lib: Switch to std::vector<std::uint8_t> for fingerprint data

src/lib/base/String.cpp

@@ -221,12 +221,12 @@ removeFileExt(std::string filename)
     return filename.substr(0, dot);
 }
 
-std::string to_hex(const std::string& subject, int width, const char fill)
+std::string to_hex(const std::vector<std::uint8_t>& subject, int width, const char fill)
 {
     std::stringstream ss;
     ss << std::hex;
-    for (unsigned int i = 0; i < subject.length(); i++) {
+    for (unsigned int i = 0; i < subject.size(); i++) {
-        ss << std::setw(width) << std::setfill(fill) << (int)(unsigned char)subject[i];
+        ss << std::setw(width) << std::setfill(fill) << static_cast<int>(subject[i]);
     }
 
     return ss.str();

src/lib/base/String.h

@@ -75,7 +75,7 @@ std::string removeFileExt(std::string filename);
 /*!
 Convert each character in \c subject into hexdecimal form with \c width
 */
-std::string to_hex(const std::string& subject, int width, const char fill = '0');
+std::string to_hex(const std::vector<std::uint8_t>& subject, int width, const char fill = '0');
 
 /// Convert binary data from hexadecimal
 std::vector<std::uint8_t> from_hex(const std::string& data);

src/lib/net/SecureSocket.cpp

@@ -674,8 +674,10 @@ SecureSocket::verifyCertFingerprint()
     }
 
     // format fingerprint into hexdecimal format with colon separator
-    std::string fingerprint(reinterpret_cast<char*>(tempFingerprint), tempFingerprintLen);
+    std::vector<std::uint8_t> fingerprint_raw;
-    fingerprint = barrier::format_ssl_fingerprint(fingerprint);
+    fingerprint_raw.assign(reinterpret_cast<std::uint8_t*>(tempFingerprint),
+                           reinterpret_cast<std::uint8_t*>(tempFingerprint) + tempFingerprintLen);
+    auto fingerprint = barrier::format_ssl_fingerprint(fingerprint_raw);
     LOG((CLOG_NOTE "server fingerprint: %s", fingerprint.c_str()));
 
     std::string trustedServersFilename;

src/lib/net/SecureUtils.cpp

@@ -20,13 +20,9 @@
 
 namespace barrier {
 
-std::string format_ssl_fingerprint(const std::string& fingerprint, bool hex, bool separator)
+std::string format_ssl_fingerprint(const std::vector<uint8_t>& fingerprint, bool separator)
 {
-    std::string result = fingerprint;
+    std::string result = barrier::string::to_hex(fingerprint, 2);
-    if (hex) {
-        // to hexadecimal
-        result = barrier::string::to_hex(result, 2);
-    }
 
     // all uppercase
     barrier::string::uppercase(result);

src/lib/net/SecureUtils.h

@@ -19,11 +19,12 @@
 #define BARRIER_LIB_NET_SECUREUTILS_H
 
 #include <string>
+#include <vector>
 
 namespace barrier {
 
-std::string format_ssl_fingerprint(const std::string& fingerprint,
+std::string format_ssl_fingerprint(const std::vector<std::uint8_t>& fingerprint,
-                                   bool hex = true, bool separator = true);
+                                   bool separator = true);
 
 } // namespace barrier
 

src/test/global/TestUtils.cpp

@@ -20,18 +20,18 @@
 
 namespace barrier {
 
-std::string generate_pseudo_random_bytes(std::size_t seed, std::size_t size)
+std::vector<std::uint8_t> generate_pseudo_random_bytes(std::size_t seed, std::size_t size)
 {
     std::mt19937_64 engine{seed};
     std::uniform_int_distribution<int> dist{0, 255};
-    std::vector<char> bytes;
+    std::vector<std::uint8_t> bytes;
 
     bytes.reserve(size);
     for (std::size_t i = 0; i < size; ++i) {
         bytes.push_back(dist(engine));
     }
 
-    return std::string{bytes.data(), bytes.size()};
+    return bytes;
 }
 
 } // namespace barrier

src/test/global/TestUtils.h

@@ -19,11 +19,11 @@
 #define BARRIER_TEST_GLOBAL_TEST_UTILS_H
 
 #include <cstdint>
-#include <string>
+#include <vector>
 
 namespace barrier {
 
-std::string generate_pseudo_random_bytes(std::size_t seed, std::size_t size);
+std::vector<std::uint8_t> generate_pseudo_random_bytes(std::size_t seed, std::size_t size);
 
 } // namespace barrier
 

src/test/unittests/base/StringTests.cpp

@@ -56,7 +56,7 @@ TEST(StringTests, sprintf_formatWithArgument_formatedString)
 
 TEST(StringTests, toHex_plaintext_hexString)
 {
-    String subject = "foobar";
+    std::vector<std::uint8_t> subject{'f', 'o', 'o', 'b', 'a', 'r'};
     int width = 2;
 
     EXPECT_EQ("666f6f626172", string::to_hex(subject, width));

src/test/unittests/net/SecureUtilsTests.cpp

@@ -24,8 +24,8 @@ namespace barrier {
 
 TEST(SecureUtilsTest, FormatSslFingerprintHexWithSeparators)
 {
-    std::string fingerprint = generate_pseudo_random_bytes(0, 32);
+    auto fingerprint = generate_pseudo_random_bytes(0, 32);
-    ASSERT_EQ(format_ssl_fingerprint(fingerprint, true, true),
+    ASSERT_EQ(format_ssl_fingerprint(fingerprint, true),
               "28:FD:0A:98:8A:0E:A1:6C:D7:E8:6C:A7:EE:58:41:71:"
               "CA:B2:8E:49:25:94:90:25:26:05:8D:AF:63:ED:2E:30");
 }