Fix hmac sha256 crypto and test.

Author: linuscu

packages/crypto/include/crypto/Crypto.h

@@ -3,6 +3,7 @@
 #include <string>
 
 #include "logging/LoggingAll.h"
+#include "serialization/Base16.h"
 #include "serialization/Base64.h"
 
 #include "cryptopp/xed25519.h"
@@ -18,8 +19,11 @@ namespace l::crypto {
 		CryptoSigner() = default;
 		virtual ~CryptoSigner() = default;
 
+		virtual std::string_view GetAssociatedKey() = 0;
 		virtual void AccumulateMessage(std::string_view message) = 0;
 		virtual std::string SignMessageB64() = 0;
+		virtual std::string SignMessageHex() = 0;
+
 	};
 
 	std::string ToPublicKeyFormat(std::string_view pkcsFormat);
@@ -30,14 +34,19 @@ namespace l::crypto {
 		CryptoHMacSha256() = default;
 		~CryptoHMacSha256() = default;
 
+		void SetAssociatedKey(std::string_view associatedKey) {
+			mAssociatedKey = associatedKey;
+		}
+
 		bool LoadSecretKeyAscii(std::string_view privateKeyAscii) {
-			CryptoPP::SHA256 sha256;
 			auto keyBytes = reinterpret_cast<const CryptoPP::byte*>(privateKeyAscii.data());
-			sha256.CalculateDigest(mSecret, keyBytes, privateKeyAscii.size());
-			mHmac.SetKey(mSecret, 32);
+			mHmac.SetKey(keyBytes, privateKeyAscii.size());
 			return true;
 		}
 
+		std::string_view GetAssociatedKey() override {
+			return mAssociatedKey;
+		}
 		virtual void AccumulateMessage(std::string_view message) override {
 			auto p = reinterpret_cast<const CryptoPP::byte*>(message.data());
 			mHmac.Update(p, message.size());
@@ -48,6 +57,11 @@ namespace l::crypto {
 			return l::serialization::base64_encode(mSignature, 32);
 		}
 
+		virtual std::string SignMessageHex() override {
+			SignMessage();
+			return l::serialization::base16_encode(mSignature, 32);
+		}
+
 	protected:
 		void SignMessage() {
 			mHmac.Final(mSignature);
@@ -56,6 +70,8 @@ namespace l::crypto {
 		CryptoPP::HMAC<CryptoPP::SHA256> mHmac;
 		CryptoPP::byte mSecret[32];
 		CryptoPP::byte mSignature[32];
+
+		std::string mAssociatedKey;
 	};
 
 	class CryptoXED25519 : public CryptoSigner {
@@ -65,17 +81,24 @@ namespace l::crypto {
 
 		void CreateNewKeys();
 
+		void SetAssociatedKey(std::string_view associatedKey) {
+			mAssociatedKey = associatedKey;
+		}
+
 		bool LoadPrivateKeyB64(std::string_view privateKeyB64);
 		bool LoadPrivateKeyHex(std::string_view privateKeyHex);
 		bool LoadPublicKeyB64(std::string_view publicKeyB64);
 		bool LoadPublicKeyHex(std::string_view publicKeyHex);
 
 		CryptoPP::byte* SignMessage();
-		std::string SignMessageHex();
 		std::string SignMessagePem();
 
 		virtual void AccumulateMessage(std::string_view message) override;
 		virtual std::string SignMessageB64() override;
+		virtual std::string SignMessageHex() override;
+		std::string_view GetAssociatedKey() override {
+			return "";
+		}
 
 		bool VerifyB64(std::string_view signatureB64);
 		bool VerifyHex(std::string_view signatureHex);
@@ -114,6 +137,8 @@ namespace l::crypto {
 		CryptoPP::byte mPrivateKey[32];
 		CryptoPP::byte mPublicKey[32];
 		CryptoPP::byte mSignature[64];
+
+		std::string mAssociatedKey;
 	};
 
 

packages/crypto/tests/common/CryptoppTest.cpp

@@ -14,14 +14,14 @@
 
 using namespace l;
 
+
 TEST(CryptoPP, hmacsha256) {
 
 	CryptoPP::HMAC<CryptoPP::SHA256> mHmac;
 	CryptoPP::byte mSecret[32];
 	CryptoPP::byte mSignature[32];
 	CryptoPP::SHA256 sha256;
 
-
 	std::string_view privateKeyAscii = "Ab0z9aZvAb0z9aZvAb0z9aZvAb0z9aZvAb0z9aZvAb0z9aZvAb0z9aZvAb0z9aZv";
 	std::string_view message = "test";
 
@@ -40,6 +40,36 @@ TEST(CryptoPP, hmacsha256) {
 	return 0;
 }
 
+TEST(CryptoPP, verifydigest) {
+
+	CryptoPP::HMAC<CryptoPP::SHA256> mHmac;
+	CryptoPP::byte mSecret[32];
+	CryptoPP::byte mSignature[32];
+
+	std::string_view privateKeyAscii = "NhqPtmdSJYdKjVHjA7PZj4Mge3R5YNiP1e3UZjInClVN65XAbvqqM6A7H5fATj0j";
+	std::string_view message = "apiKey=test";
+
+	auto keyBytes = reinterpret_cast<const CryptoPP::byte*>(privateKeyAscii.data());
+	mHmac.SetKey(keyBytes, privateKeyAscii.size());
+	const CryptoPP::byte* p = reinterpret_cast<const CryptoPP::byte*>(message.data());
+	mHmac.Update(p, message.size());
+	mHmac.Final(mSignature);
+	auto sign = l::serialization::base16_encode(mSignature, 32);
+	LOG(LogTest) << sign;
+
+	/*
+		echo -n 'apiKey=test' | openssl dgst -hex -sha256 -hmac 'NhqPtmdSJYdKjVHjA7PZj4Mge3R5YNiP1e3UZjInClVN65XAbvqqM6A7H5fATj0j'                   
+		> SHA2-256(stdin)= ffc10e6024b05c27e03e7515b976ac1a0f73cb6797fed05cd1e5f01a00a84e45
+	*/
+	auto correctSign = "ffc10e6024b05c27e03e7515b976ac1a0f73cb6797fed05cd1e5f01a00a84e45";
+	TEST_TRUE(sign == correctSign, "");
+
+	auto verify = mHmac.VerifyDigest(mSignature, p, message.size());
+	TEST_TRUE(verify, "");
+
+	return 0;
+}
+
 #ifdef CRYPTOPP_TEST_1
 TEST(Cryptopp, printPemKeys) {
 	auto messageHex = "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f";

packages/network/source/common/NetworkConnection.cpp

@@ -244,6 +244,9 @@ namespace l::network {
 		if (res == CURLE_OK) {
 			return static_cast<int32_t>(sentBytes);
 		}
+		else if (res == CURLE_GOT_NOTHING) {
+			mWebSocketReceivingData = false;
+		}
 		LOG(LogError) << "Failed wss write, error: " << res;
 		return -res;
 	}
@@ -266,6 +269,10 @@ namespace l::network {
 			}
 			return static_cast<int32_t>(readBytes);
 		}
+		else if (res == CURLE_GOT_NOTHING) {
+			mWebSocketReceivingData = false;
+			LOG(LogError) << "Failed wss read, connection closed, error: " << res;
+		}
 		//LOG(LogError) << "Failed wss read, error: " << res;
 		return -res;
 	}