logger: fix file open issue if crypto algorithm is disabled

Store keydata into memory buffer in init phase. If keydata exists,
write it into the beginning of the file when file is opened in
LogFileBuffer::start_log()

src/modules/logger/log_writer_file.cpp

@@ -85,7 +85,7 @@ LogWriterFile::~LogWriterFile()
 }
 
 #if defined(PX4_CRYPTO)
-bool LogWriterFile::init_logfile_encryption(const char *filename)
+bool LogWriterFile::init_logfile_encryption(uint8_t **keydata, size_t *keydatasize)
 {
 	if (_algorithm == CRYPTO_NONE) {
 		_min_blocksize = 1;
@@ -129,34 +129,6 @@ bool LogWriterFile::init_logfile_encryption(const char *filename)
 		return false;
 	}
 
-	/* Allocate space and get key + nonce */
-	uint8_t *key = (uint8_t *)malloc(key_size + nonce_size);
-
-	if (!key ||
-	    !rsa_crypto.get_encrypted_key(
-		    _key_idx,
-		    key,
-		    &key_size,
-		    _exchange_key_idx) ||
-	    !_crypto.get_nonce(
-		    key + key_size, &nonce_size)) {
-		PX4_ERR("Can't get & encrypt the key");
-		free(key);
-		rsa_crypto.close();
-		return false;
-	}
-
-	rsa_crypto.close();
-
-	// Write the encrypted key to the disk
-	int key_fd = ::open((const char *)filename, O_CREAT | O_WRONLY | O_DIRECT | O_SYNC, PX4_O_MODE_666);
-
-	if (key_fd < 0) {
-		PX4_ERR("Can't open key file, errno: %d", errno);
-		free(key);
-		return false;
-	}
-
 	// write the header to the combined key exchange & cipherdata file
 	struct ulog_key_header_s keyfile_header = {
 		.magic = {'U', 'L', 'o', 'g', 'E', 'n', 'c'},
@@ -168,24 +140,33 @@ bool LogWriterFile::init_logfile_encryption(const char *filename)
 		.initdata_size = (uint16_t)nonce_size
 	};
 
-	size_t hdr_sz = ::write(key_fd, (uint8_t *)&keyfile_header, sizeof(keyfile_header));
-	size_t written = 0;
+	// Store keydata into buffers
+	*keydatasize = sizeof(keyfile_header) + key_size + nonce_size;
+	*keydata = (uint8_t *)malloc(*keydatasize);
 
-	if (hdr_sz == sizeof(keyfile_header)) {
-		// Header write succeeded, write the  key
-		written = ::write(key_fd, key, key_size + nonce_size);
+	if (!*keydata) {
+		PX4_ERR("Can't allocate keydata");
+		rsa_crypto.close();
+		return false;
 	}
 
-	// Free temporary memory allocations
-	free(key);
-	::close(key_fd);
+	uint8_t *key = *keydata;
+	memcpy(key, (uint8_t *)&keyfile_header, sizeof(keyfile_header));
+	key += sizeof(keyfile_header);
 
-	// Check that writing to the disk succeeded
-	if (written != key_size + nonce_size) {
-		PX4_ERR("Writing the encryption key to disk fail");
+	if (!rsa_crypto.get_encrypted_key(
+		    _key_idx,
+		    key,
+		    &key_size,
+		    _exchange_key_idx) ||
+	    !_crypto.get_nonce(
+		    key + key_size, &nonce_size)) {
+		PX4_ERR("Can't get & encrypt the key");
+		rsa_crypto.close();
 		return false;
 	}
 
+	rsa_crypto.close();
 	return true;
 }
 #endif // PX4_CRYPTO
@@ -218,20 +199,32 @@ void LogWriterFile::start_log(LogType type, const char *filename)
 	}
 
 #if PX4_CRYPTO
-	bool enc_init = init_logfile_encryption(filename);
+	uint8_t *keydata;
+	size_t keydatasize;
+	bool enc_init = init_logfile_encryption(&keydata, &keydatasize);
 
 	if (!enc_init) {
 		PX4_ERR("Failed to start encrypted logging");
 		_crypto.close();
+		if (keydata) {
+			free(keydata);
+		}
 		return;
 	}
 
-#endif
-
+	if (_buffers[(int)type].start_log(filename, keydata, keydatasize)) {
+#else
 	if (_buffers[(int)type].start_log(filename)) {
+#endif
 		PX4_INFO("Opened %s log file: %s", log_type_str(type), filename);
 		notify();
 	}
+
+#if PX4_CRYPTO
+	if (keydata) {
+		free(keydata);
+	}
+#endif
 }
 
 int LogWriterFile::hardfault_store_filename(const char *log_file)
@@ -628,19 +621,32 @@ size_t LogWriterFile::LogFileBuffer::get_read_ptr(void **ptr, bool *is_part)
 	}
 }
 
-bool LogWriterFile::LogFileBuffer::start_log(const char *filename)
-{
 #if defined(PX4_CRYPTO)
-	_fd = ::open(filename, O_APPEND | O_WRONLY, PX4_O_MODE_666);
+bool LogWriterFile::LogFileBuffer::start_log(const char *filename, uint8_t *keydata, size_t keydatasize)
 #else
-	_fd = ::open(filename, O_CREAT | O_WRONLY, PX4_O_MODE_666);
+bool LogWriterFile::LogFileBuffer::start_log(const char *filename)
 #endif
+{
+	_fd = ::open(filename, O_CREAT | O_WRONLY, PX4_O_MODE_666);
 
 	if (_fd < 0) {
 		PX4_ERR("Can't open log file %s, errno: %d", filename, errno);
 		return false;
 	}
 
+#if defined(PX4_CRYPTO)
+	if (keydata) {
+		size_t keydata_sz = ::write(_fd, keydata, keydatasize);
+		// Check that writing to the disk succeeded
+		if (keydata_sz != keydatasize) {
+			PX4_ERR("Writing the encryption key to disk fail");
+			::close(_fd);
+			_fd = -1;
+			return false;
+		}
+	}
+#endif
+
 	if (_buffer == nullptr) {
 		_buffer = (uint8_t *) px4_cache_aligned_alloc(_buffer_size);
 

src/modules/logger/log_writer_file.h

@@ -170,9 +170,11 @@ class LogWriterFile
 		LogFileBuffer(size_t log_buffer_size, perf_counter_t perf_write, perf_counter_t perf_fsync);
 
 		~LogFileBuffer();
-
+#if defined(PX4_CRYPTO)
+		bool start_log(const char *filename, uint8_t *keydata, size_t keydatasize);
+#else
 		bool start_log(const char *filename);
-
+#endif
 		void close_file();
 
 		void reset();
@@ -219,7 +221,7 @@ class LogWriterFile
 	pthread_cond_t		_cv;
 	pthread_t _thread = 0;
 #if defined(PX4_CRYPTO)
-	bool init_logfile_encryption(const char *filename);
+	bool init_logfile_encryption(uint8_t **keydata, size_t *keydatasize);
 	PX4Crypto _crypto;
 	int _min_blocksize;
 	px4_crypto_algorithm_t _algorithm;