Merge pull request #12 from tectrolabs/fixing_sonarqube_findings

Addressing C/C++ source code issues found with SonarQube scanner

Author: tectrolabs

linux-and-macOS/swrng/Makefile

@@ -16,7 +16,7 @@ endif
 CFLAGS = -O2 -I$(IDIR) $(IDIR_MACOS) -Wall -Wextra
 CFLAGS_THREAD = -lpthread
 CPPFLAGS = $(CFLAGS) -std=c++11
-#CLANGSTD = -std=c89
+#CLANGSTD = -std=c99
 LDFLAGS = -lusb-1.0 $(LDIR_MACOS)
 LDCPPFLAGS = $(LDFLAGS) -lstdc++
 

linux-and-macOS/swrng/api-inc/ApiStructs.h

@@ -12,9 +12,9 @@
 
 /**
  *    @file ApiStructs.h
- *    @date 7/8/2023
+ *    @date 9/17/2023
  *    @Author: Andrian Belinski
- *    @version 1.0
+ *    @version 1.1
  *
  *    @brief Data structures used in the API implementation.
  */
@@ -36,7 +36,9 @@ typedef struct {
 	int64_t totalRetries;
 
 	/* Used for measuring performance */
-	time_t beginTime, endTime, totalTime;
+	time_t beginTime;
+	time_t endTime;
+	time_t totalTime;
 
 	/* Measured download speed in KB/sec */
 	int downloadSpeedKBsec;

linux-and-macOS/swrng/api-inc/RandomSeqGenerator.h

@@ -1,6 +1,6 @@
 /*
  * RandomSeqGenerator.h
- * Ver 2.2
+ * Ver 2.3
  */
 
 /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@@ -23,15 +23,13 @@
 #include <cstring>
 #include <sstream>
 
-using namespace std;
-
 namespace swiftrng {
 
 class RandomSeqGenerator {
 public:
 	RandomSeqGenerator(int deviceNumber, uint32_t range);
 	int generateSequence(uint32_t *dest, uint32_t size);
-	string getLastErrorMessage() const {return m_error_log_oss.str();}
+	std::string getLastErrorMessage() const {return m_error_log_oss.str();}
 	virtual ~RandomSeqGenerator();
 
 private:
@@ -42,7 +40,7 @@ class RandomSeqGenerator {
 	int open_device();
 
 private:
-	ostringstream m_error_log_oss;
+	std::ostringstream m_error_log_oss;
 
 	int32_t *m_number_buffer_1;
 

linux-and-macOS/swrng/api-inc/SwiftRngApi.h

@@ -12,9 +12,9 @@
 
 /**
  *    @file SwiftRngApi.h
- *    @date 7/8/2022
+ *    @date 9/17/2023
  *    @Author: Andrian Belinski
- *    @version 1.0
+ *    @version 1.1
  *
  *    @brief Implements the API for interacting with the SwiftRNG device.
  */
@@ -41,8 +41,6 @@
 	#include <USBSerialDevice.h>
 #endif
 
-using namespace std;
-
 namespace swiftrng {
 
 class SwiftRngApi {
@@ -51,7 +49,7 @@ class SwiftRngApi {
 	SwiftRngApi();
 	int open(int devNum);
 	int close();
-	int is_open();
+	int is_open() const;
 	int get_entropy(unsigned char *buffer, long length);
 	int get_entropy_ex(unsigned char *buffer, long length);
 	int get_raw_data_block(NoiseSourceRawData *noise_source_raw_data, int noise_source_num);
@@ -74,17 +72,17 @@ class SwiftRngApi {
 	int enable_statistical_tests();
 	DeviceStatistics* generate_device_statistics();
 	const char* get_last_error_message();
-	string get_last_error_log() {return m_last_error_log_oss.str();}
+	std::string get_last_error_log() const {return m_last_error_log_oss.str();}
 	void enable_printing_error_messages();
-	int get_max_apt_failures_per_block(uint16_t *max_apt_failures_per_block);
-	int get_max_rct_failures_per_block(uint16_t *max_rct_failures_per_block);
+	int get_max_apt_failures_per_block(uint16_t *max_apt_failures_per_block) const;
+	int get_max_rct_failures_per_block(uint16_t *max_rct_failures_per_block) const;
 
 
 	virtual	~SwiftRngApi();
 
 
 private:
-	bool is_context_initialized() { return m_is_initialized; }
+	bool is_context_initialized() const { return m_is_initialized; }
 	void initialize();
 	void clear_last_error_msg();
 	void close_USB_lib();
@@ -95,42 +93,42 @@ class SwiftRngApi {
 
 	void sha256_initialize();
 	void sha512_initialize();
-	void sha256_stampSerialNumber(void *input_block);
+	void sha256_stampSerialNumber(uint32_t *input_block);
 	void sha256_initializeSerialNumber(uint32_t init_value);
-	int sha512_generateHash(uint64_t *src, int16_t len, uint64_t *dst);
+	int sha512_generateHash(const uint64_t *src, int16_t len, uint64_t *dst);
 	void sha512_hashCurrentBlock();
-	uint64_t sha512_sigma1(uint64_t *x);
+	uint64_t sha512_sigma1(const uint64_t *x);
 	int sha256_selfTest();
 	int sha512_selfTest();
 	int xorshift64_selfTest();
 	uint32_t sha256_ch(uint32_t *x, uint32_t *y, uint32_t *z);
-	uint32_t sha256_maj(uint32_t *x, uint32_t *y, uint32_t *z);
-	uint32_t sha256_sum0(uint32_t *x);
-	uint32_t sha256_sum1(uint32_t *x);
-	uint32_t sha256_sigma0(uint32_t *x);
-	uint32_t sha256_sigma1(uint32_t *x);
-	uint64_t sha512_ch(uint64_t *x, uint64_t *y, uint64_t *z);
-	uint64_t sha512_maj(uint64_t *x, uint64_t *y, uint64_t *z);
-	uint64_t sha512_sum0(uint64_t *x);
-	uint64_t sha512_sum1(uint64_t *x);
-	uint64_t sha512_sigma0(uint64_t *x);
+	uint32_t sha256_maj(const uint32_t *x, const uint32_t *y, const uint32_t *z);
+	uint32_t sha256_sum0(const uint32_t *x);
+	uint32_t sha256_sum1(const uint32_t *x);
+	uint32_t sha256_sigma0(const uint32_t *x);
+	uint32_t sha256_sigma1(const uint32_t *x);
+	uint64_t sha512_ch(const uint64_t *x, const uint64_t *y, const uint64_t *z);
+	uint64_t sha512_maj(const uint64_t *x, const uint64_t *y, const uint64_t *z);
+	uint64_t sha512_sum0(const uint64_t *x);
+	uint64_t sha512_sum1(const uint64_t *x);
+	uint64_t sha512_sigma0(const uint64_t *x);
 	void sha256_hashCurrentBlock();
-	int sha256_generateHash(uint32_t *src, int16_t len, uint32_t *dst);
-	void swrng_printErrorMessage(const string &err_msg);
+	int sha256_generateHash(const uint32_t *src, int16_t len, uint32_t *dst);
+	void swrng_printErrorMessage(const std::string &err_msg);
 	int swrng_handleDeviceVersion();
 	void swrng_clearReceiverBuffer();
-	uint64_t xorshift64_postProcessWord(uint64_t raw_word);
+	uint64_t xorshift64_postProcessWord(uint64_t raw_word) const;
 	void xorshift64_postProcessWords(uint64_t *buffer, int num_elements);
 	void xorshift64_postProcess(uint8_t *buffer, int num_elements);
-	int swrng_snd_rcv_usb_data(char *snd, int size_snd, char *rcv, int size_rcv, int op_timeout_secs);
+	int swrng_snd_rcv_usb_data(const char *snd, int size_snd, char *rcv, int size_rcv, int op_timeout_secs);
 	int swrng_chip_read_data(char *buff, int length, int op_timeout_secs);
 	void swrng_contextReset();
 	int swrng_getEntropyBytes();
 	int swrng_rcv_rnd_bytes();
 	void test_samples();
-	void swrng_updateDevInfoList(DeviceInfoList* dev_info_list, int *curt_found_dev_num);
-	uint32_t rotr32(uint32_t sb, uint32_t w) { return (((w) >> (sb)) | ((w) << (32-(sb)))); }
-	uint64_t rotr64(uint64_t sb, uint64_t w) { return (((w) >> (sb)) | ((w) << (64-(sb)))); }
+	void swrng_updateDevInfoList(DeviceInfoList* dev_info_list, int *curt_found_dev_num) const;
+	uint32_t rotr32(uint32_t sb, uint32_t w) const { return ((w) >> (sb)) | ((w) << (32-(sb))); }
+	uint64_t rotr64(uint64_t sb, uint64_t w) const { return ((w) >> (sb)) | ((w) << (64-(sb))); }
 
 private:
 
@@ -145,14 +143,14 @@ class SwiftRngApi {
 	static const int c_max_cdc_com_ports {80};
 
 	// USB device hardware ID string used in windows
-	static const wstring c_hardware_id;
+	static const std::wstring c_hardware_id;
 #endif
 
 	// Device specific USB bulk end point number for OUT operation
-	const int SWRNG_BULK_EP_OUT {0x01};
+	const unsigned char c_bulk_ep_out {0x01};
 
 	// Device specific USB bulk end point number for IN operation
-	const int SWRNG_BULK_EP_IN {0x81};
+	const unsigned char c_bulk_ep_in {0x81};
 
 	// Method id for using SHA-256 for post processing
 	const int c_sha256_pp_method_id {0};
@@ -191,18 +189,48 @@ class SwiftRngApi {
 
 	// A structure used for generating SHA-256 hash
 	struct {
-		uint32_t a, b, c, d, e, f, g, h;
-		uint32_t h0, h1, h2, h3, h4, h5, h6, h7;
-		uint32_t tmp1, tmp2;
+		uint32_t a;
+		uint32_t b;
+		uint32_t c;
+		uint32_t d;
+		uint32_t e;
+		uint32_t f;
+		uint32_t g;
+		uint32_t h;
+		uint32_t h0;
+		uint32_t h1;
+		uint32_t h2;
+		uint32_t h3;
+		uint32_t h4;
+		uint32_t h5;
+		uint32_t h6;
+		uint32_t h7;
+		uint32_t tmp1;
+		uint32_t tmp2;
 		uint32_t w[64];
 		uint32_t blockSerialNumber;
 	} m_sha256_ctxt;
 
 	// A structure used for generating SHA-512 hash
 	struct {
-		uint64_t a,b,c,d,e,f,g,h;
-		uint64_t h0,h1,h2,h3,h4,h5,h6,h7;
-		uint64_t tmp1, tmp2;
+		uint64_t a;
+		uint64_t b;
+		uint64_t c;
+		uint64_t d;
+		uint64_t e;
+		uint64_t f;
+		uint64_t g;
+		uint64_t h;
+		uint64_t h0;
+		uint64_t h1;
+		uint64_t h2;
+		uint64_t h3;
+		uint64_t h4;
+		uint64_t h5;
+		uint64_t h6;
+		uint64_t h7;
+		uint64_t tmp1;
+		uint64_t tmp2;
 		uint64_t w[80];
 	} m_sha512_ctxt;
 
@@ -292,7 +320,7 @@ class SwiftRngApi {
 
 	// A storage for holding the last error message. Many operations, when failed, will store the error message in this buffer.
 	// The error text message can be retrieved with `get_last_error_message()` method.
-	ostringstream m_last_error_log_oss;
+	std::ostringstream m_last_error_log_oss;
 
 	// Number of bytes to allocate for `m_last_error_log_char`;
 	const int c_max_last_error_log_size {256};
@@ -338,16 +366,16 @@ class SwiftRngApi {
 	//
 	// Text constants
 	//
-	static const string c_dev_not_open_msg;
-	static const string c_freq_table_invalid_msg;
-	static const string c_cannot_disable_pp_msg;
-	static const string c_pp_op_not_supported_msg;
-	static const string c_diag_op_not_supported_msg;
-	static const string c_pp_method_not_supported_msg;
-	static const string c_cannot_get_freq_table_for_device_msg;
-	static const string c_too_many_devices_msg;
-	static const string c_cannot_read_device_descriptor_msg;
-	static const string c_libusb_init_failure_msg;
+	static const std::string c_dev_not_open_msg;
+	static const std::string c_freq_table_invalid_msg;
+	static const std::string c_cannot_disable_pp_msg;
+	static const std::string c_pp_op_not_supported_msg;
+	static const std::string c_diag_op_not_supported_msg;
+	static const std::string c_pp_method_not_supported_msg;
+	static const std::string c_cannot_get_freq_table_for_device_msg;
+	static const std::string c_too_many_devices_msg;
+	static const std::string c_cannot_read_device_descriptor_msg;
+	static const std::string c_libusb_init_failure_msg;
 
 };
 

linux-and-macOS/swrng/api-inc/USBSerialDevice.h

@@ -1,11 +1,11 @@
 /*
  * USBSerialDevice.h
- * Ver 1.1
+ * Ver 1.2
  */
 
 /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
- Copyright (C) 2014-2020 TectroLabs, https://tectrolabs.com
+ Copyright (C) 2014-2023 TectroLabs, https://tectrolabs.com
 
  THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
  INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
@@ -28,34 +28,37 @@
 #include <sys/types.h>
 #include <sys/file.h>
 #include <ctype.h>
-
-#define MAX_DEVICE_COUNT (25)
-#define MAX_SIZE_DEVICE_NAME (128)
+#include <sstream>
 
 class USBSerialDevice {
-private:
-	int fd;
-	int lock;
-	char devNames[MAX_DEVICE_COUNT][MAX_SIZE_DEVICE_NAME];
-	int activeDevCount;
-	bool deviceConnected;
-	char lastError[512];
-	void setErrMsg(const char *errMessage);
-	void clearErrMsg();
-	void purgeComm();
 public:
 	USBSerialDevice();
 	virtual ~USBSerialDevice();
 	void initialize();
-	bool isConnected();
+	bool is_connected() const;
 	bool connect(const char *devicePath);
 	bool disconnect();
-	const char* getLastErrMsg();
-	int sendCommand(unsigned char *snd, int sizeSnd, int *bytesSent);
-	int receiveDeviceData(unsigned char *rcv, int sizeRcv, int *bytesReceived);
-	int getConnectedDeviceCount();
-	void scanForConnectedDevices();
-	bool retrieveConnectedDevice(char *devName, int devNum);
+	void clear_error_log();
+	std::string get_error_log() const;
+	int send_command(const unsigned char *snd, int sizeSnd, int *bytesSent);
+	int receive_data(unsigned char *rcv, int sizeRcv, int *bytesReceived);
+	int get_device_count() const;
+	void scan_available_devices();
+	bool retrieve_device_path(char *devName, int devNum) const;
+
+private:
+	void set_error_message(const char *error_message);
+	void purge_comm_data() const;
+
+private:
+	static const int c_max_devices = 25;
+	static const int c_max_size_device_name = 128;
+	int m_fd {-1};
+	int m_lock;
+	char c_device_names[c_max_devices][c_max_size_device_name];
+	int m_active_device_count {0};
+	bool m_device_connected {false};
+	std::ostringstream m_error_log_oss;
 
 };