Added verifying for ECDSA with hashing

Author: Antoine Lochet

src/lib/SoftHSM.cpp

@@ -1247,6 +1247,11 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_
 			pInfo->flags = CKF_GENERATE_KEY_PAIR | CKF_EC_COMMOM;
 			break;
 		case CKM_ECDSA:
+		case CKM_ECDSA_SHA1:
+		case CKM_ECDSA_SHA224:
+		case CKM_ECDSA_SHA256:
+		case CKM_ECDSA_SHA384:
+		case CKM_ECDSA_SHA512:
 			pInfo->ulMinKeySize = ecdsaMinSize;
 			pInfo->ulMaxKeySize = ecdsaMaxSize;
 			pInfo->flags = CKF_SIGN | CKF_VERIFY | CKF_EC_COMMOM;
@@ -5366,6 +5371,31 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech
 			bAllowMultiPartOp = false;
 			isECDSA = true;
 			break;
+		case CKM_ECDSA_SHA1:
+			mechanism = AsymMech::ECDSA_SHA1;
+			bAllowMultiPartOp = false;
+			isECDSA = true;
+			break;
+		case CKM_ECDSA_SHA224:
+			mechanism = AsymMech::ECDSA_SHA224;
+			bAllowMultiPartOp = false;
+			isECDSA = true;
+			break;
+		case CKM_ECDSA_SHA256:
+			mechanism = AsymMech::ECDSA_SHA256;
+			bAllowMultiPartOp = false;
+			isECDSA = true;
+			break;
+		case CKM_ECDSA_SHA384:
+			mechanism = AsymMech::ECDSA_SHA384;
+			bAllowMultiPartOp = false;
+			isECDSA = true;
+			break;
+		case CKM_ECDSA_SHA512:
+			mechanism = AsymMech::ECDSA_SHA512;
+			bAllowMultiPartOp = false;
+			isECDSA = true;
+			break;
 #endif
 #ifdef WITH_GOST
 		case CKM_GOSTR3410:

src/lib/crypto/BotanECDSA.cpp

@@ -196,18 +196,33 @@ bool BotanECDSA::verify(PublicKey* publicKey, const ByteString& originalData,
 			const ByteString& signature, const AsymMech::Type mechanism,
 			const void* /* param = NULL */, const size_t /* paramLen = 0 */)
 {
-	std::string emsa;
+	std::string emsa = "Raw";
 
-	if (mechanism == AsymMech::ECDSA)
-	{
-		emsa = "Raw";
-	}
-        else
+	HashAlgo::Type hash = HashAlgo::Unknown;
+    if (mechanism != AsymMech::ECDSA)
+    {
+        switch (mechanism)
         {
-		ERROR_MSG("Invalid mechanism supplied (%i)", mechanism);
-
-		return false;
-	}
+            case AsymMech::ECDSA_SHA1:
+                hash = HashAlgo::SHA1;
+                break;
+            case AsymMech::ECDSA_SHA224:
+                hash = HashAlgo::SHA224;
+                break;
+            case AsymMech::ECDSA_SHA256:
+                hash = HashAlgo::SHA256;
+                break;
+            case AsymMech::ECDSA_SHA384:
+                hash = HashAlgo::SHA384;
+                break;
+            case AsymMech::ECDSA_SHA512:
+                hash = HashAlgo::SHA512;
+                break;
+            default:
+                ERROR_MSG("Invalid mechanism supplied (%i)", mechanism);
+                return false;
+        }
+    }
 
 	// Check if the public key is the right type
 	if (!publicKey->isOfType(BotanECDSAPublicKey::type))
@@ -238,12 +253,30 @@ bool BotanECDSA::verify(PublicKey* publicKey, const ByteString& originalData,
 		return false;
 	}
 
+	// Pre-hash the data if necessary
+    ByteString prepDataToSign;
+
+    if (hash == HashAlgo::Unknown) {
+        prepDataToSign = originalData;
+    } else {
+        HashAlgorithm* digest = BotanCryptoFactory::i()->getHashAlgorithm(hash);
+
+        if (!digest->hashInit()
+                || !digest->hashUpdate(originalData)
+                || !digest->hashFinal(prepDataToSign))
+        {
+            delete digest;
+            return false;
+        }
+        delete digest;
+    }
+
 	// Perform the verify operation
 	bool verResult;
 	try
 	{
-		verResult = verifier->verify_message(originalData.const_byte_str(),
-							originalData.size(),
+		verResult = verifier->verify_message(prepDataToSign.const_byte_str(),
+							prepDataToSign.size(),
 							signature.const_byte_str(),
 							signature.size());
 	}

src/lib/crypto/OSSLECDSA.cpp

@@ -185,11 +185,33 @@ bool OSSLECDSA::verify(PublicKey* publicKey, const ByteString& originalData,
 		       const ByteString& signature, const AsymMech::Type mechanism,
 		       const void* /* param = NULL */, const size_t /* paramLen = 0 */)
 {
+
+	HashAlgo::Type hash = HashAlgo::Unknown;
+
 	if (mechanism != AsymMech::ECDSA)
-	{
-		ERROR_MSG("Invalid mechanism supplied (%i)", mechanism);
-		return false;
-	}
+    {
+        switch (mechanism)
+        {
+            case AsymMech::ECDSA_SHA1:
+                hash = HashAlgo::SHA1;
+                break;
+            case AsymMech::ECDSA_SHA224:
+                hash = HashAlgo::SHA224;
+                break;
+            case AsymMech::ECDSA_SHA256:
+                hash = HashAlgo::SHA256;
+                break;
+            case AsymMech::ECDSA_SHA384:
+                hash = HashAlgo::SHA384;
+                break;
+            case AsymMech::ECDSA_SHA512:
+                hash = HashAlgo::SHA512;
+                break;
+            default:
+                ERROR_MSG("Invalid mechanism supplied (%i)", mechanism);
+                return false;
+        }
+    }
 
 	// Check if the private key is the right type
 	if (!publicKey->isOfType(OSSLECPublicKey::type))
@@ -253,7 +275,25 @@ bool OSSLECDSA::verify(PublicKey* publicKey, const ByteString& originalData,
 		ECDSA_SIG_free(sig);
 		return false;
 	}
-	int ret = ECDSA_do_verify(originalData.const_byte_str(), originalData.size(), sig, eckey);
+
+	// Pre-hash the data if necessary
+    ByteString prepDataToSign;
+    if (hash == HashAlgo::Unknown) {
+        prepDataToSign = originalData;
+    } else {
+        HashAlgorithm* digest = CryptoFactory::i()->getHashAlgorithm(hash);
+
+        if (!digest->hashInit()
+                || !digest->hashUpdate(originalData)
+                || !digest->hashFinal(prepDataToSign))
+        {
+            delete digest;
+            return false;
+        }
+        delete digest;
+    }
+
+	int ret = ECDSA_do_verify(prepDataToSign.const_byte_str(), prepDataToSign.size(), sig, eckey);
 	if (ret != 1)
 	{
 		if (ret < 0)