ocsp support other hash algos

Author: julek-wolfssl

scripts/ocsp-responder-openssl-interop.test

@@ -338,26 +338,29 @@ echo
 
 echo "=== Negative tests: unsupported features ==="
 
-# Test 1: Non-SHA-1 hash algorithms (should fail with OCSP error)
+# Test 1: Non-SHA-1 hash algorithms (should be supported)
 tests_run=$((tests_run+1))
-printf "  TEST %2d: %-55s " "$tests_run" "SHA-256 hash (should return OCSP error)"
+printf "  TEST %2d: %-55s " "$tests_run" "SHA-384 hash -> good"
 
 output=$($OPENSSL ocsp \
-    -sha256 \
+    -sha384 \
     -issuer "$OCSP_DIR/intermediate1-ca-cert.pem" \
     -cert "$OCSP_DIR/server1-cert.pem" \
     -url "http://127.0.0.1:$port1/" \
     -noverify \
     -resp_text 2>&1)
 rc=$?
 
-# Expect OCSP error response: internalerror (2)
-# OpenSSL shows "Responder Error: internalerror (2)"
-if echo "$output" | grep -q "Responder Error: internalerror"; then
-    printf "PASSED (OCSP internalerror)\n"
+# Extract the cert status line
+status=$(echo "$output" | grep "Cert Status:" | head -1 | \
+         sed 's/.*Cert Status: *//')
+
+# Expect "good" status (feature should be supported)
+if [ "$status" = "good" ]; then
+    printf "PASSED (status: %s)\n" "$status"
     tests_passed=$((tests_passed+1))
 else
-    printf "FAILED (expected OCSP internalerror, got rc: %d)\n" "$rc"
+    printf "FAILED (expected: good, got: %s, rc: %d)\n" "$status" "$rc"
     tests_failed=$((tests_failed+1))
     echo "--- openssl output ---"
     echo "$output"

src/ocsp.c

@@ -1376,8 +1376,9 @@ WOLFSSL_OCSP_ONEREQ* wolfSSL_OCSP_request_add0_id(OcspRequest *req,
     /* Keep to free */
     req->cid = (void*)cid;
 
-    XMEMCPY(req->issuerHash, cid->issuerHash, KEYID_SIZE);
-    XMEMCPY(req->issuerKeyHash, cid->issuerKeyHash, KEYID_SIZE);
+    XMEMCPY(req->issuerHash, cid->issuerHash, WC_MAX_DIGEST_SIZE);
+    XMEMCPY(req->issuerKeyHash, cid->issuerKeyHash, WC_MAX_DIGEST_SIZE);
+    req->hashAlg = (int)cid->hashAlgoOID;
     if (cid->status->serialSz > req->serialSz) {
         XFREE(req->serial, req->heap, DYNAMIC_TYPE_OCSP);
         req->serial = (byte*)XMALLOC((size_t)cid->status->serialSz,
@@ -2293,8 +2294,23 @@ int wc_OcspResponder_AddCA(OcspResponder* responder,
 
     /* Extract necessary info from decoded cert */
     XMEMCPY(ca->subject, decoded->subject, WC_ASN_NAME_MAX);
-    XMEMCPY(ca->issuerHash, decoded->subjectHash, KEYID_SIZE);
-    XMEMCPY(ca->issuerKeyHash, decoded->subjectKeyHash, KEYID_SIZE);
+    if (decoded->subjectRawForHash == NULL ||
+            decoded->subjectRawForHashLen <= 0) {
+        ret = BAD_FUNC_ARG;
+        goto out;
+    }
+    ret = AsnHashesHash(&ca->issuerHashes, decoded->subjectRawForHash,
+            (word32)decoded->subjectRawForHashLen);
+    if (ret != 0)
+        goto out;
+    if (decoded->publicKeyForHash == NULL || decoded->pubKeyForHashSize == 0) {
+        ret = BAD_FUNC_ARG;
+        goto out;
+    }
+    ret = AsnHashesHash(&ca->issuerKeyHash, decoded->publicKeyForHash,
+            decoded->pubKeyForHashSize);
+    if (ret != 0)
+        goto out;
     keyOID = decoded->keyOID;
 
     /* Store raw certificate DER if sendCerts is enabled */
@@ -2359,13 +2375,20 @@ int wc_OcspResponder_AddCA(OcspResponder* responder,
 /* Find CA by comparing cert DER */
 /* Find CA by issuer hashes from request */
 static OcspResponderCa* FindCaByHashes(OcspResponder* responder,
-    const byte* issuerHash, const byte* issuerKeyHash)
+    const byte* issuerHash, const byte* issuerKeyHash, int hashAlg)
 {
     OcspResponderCa* ca = responder->caList;
 
     while (ca != NULL) {
-        if (XMEMCMP(ca->issuerHash, issuerHash, KEYID_SIZE) == 0 &&
-            XMEMCMP(ca->issuerKeyHash, issuerKeyHash, KEYID_SIZE) == 0) {
+        int hashSz = 0;
+        const byte* caIssuerHash = AsnHashesGetHash(&ca->issuerHashes,
+            hashAlg, &hashSz);
+        const byte* caKeyHash = AsnHashesGetHash(&ca->issuerKeyHash,
+            hashAlg, &hashSz);
+
+        if (caIssuerHash != NULL && caKeyHash != NULL && hashSz > 0 &&
+            XMEMCMP(caIssuerHash, issuerHash, (size_t)hashSz) == 0 &&
+            XMEMCMP(caKeyHash, issuerKeyHash, (size_t)hashSz) == 0) {
             return ca;
         }
         ca = ca->next;
@@ -2514,8 +2537,10 @@ static int OcspResponse_WriteResponse(OcspResponder* responder, byte* response,
     RsaKey* rsaKey = NULL;
     ecc_key* eccKey = NULL;
     int respInited = 0;
-
-    wc_static_assert((int)KEYID_SIZE == (int)WC_SHA_DIGEST_SIZE);
+    int hashSz = 0;
+    const byte* caIssuerHash = NULL;
+    const byte* caKeyHash = NULL;
+    int hashAlg = -1;
 
     WOLFSSL_ENTER("OcspResponse_WriteResponse");
 
@@ -2579,13 +2604,25 @@ static int OcspResponse_WriteResponse(OcspResponder* responder, byte* response,
         resp.nonceSz = req->nonceSz;
     }
 
-    /* Only support sha-1 hashes for now */
-    entry.hashAlgoOID = SHAh;
-    XMEMCPY(entry.issuerHash, ca->issuerHash, KEYID_SIZE);
-    XMEMCPY(entry.issuerKeyHash, ca->issuerKeyHash, KEYID_SIZE);
+    /* Echo the hash algorithm from the request */
+    if (req == NULL) {
+        hashAlg = SHAh; /* Fall back to SHA-1 as its required for OCSP */
+    }
+    else {
+        hashAlg = req->hashAlg;
+    }
+    caIssuerHash = AsnHashesGetHash(&ca->issuerHashes, hashAlg, &hashSz);
+    caKeyHash = AsnHashesGetHash(&ca->issuerKeyHash, hashAlg, &hashSz);
+    if (caIssuerHash == NULL || caKeyHash == NULL || hashSz <= 0) {
+        ret = ASN_SIG_HASH_E;
+        goto out;
+    }
+    entry.hashAlgoOID = (word32)hashAlg;
+    XMEMCPY(entry.issuerHash, caIssuerHash, (size_t)hashSz);
+    XMEMCPY(entry.issuerKeyHash, caKeyHash, (size_t)hashSz);
 
     resp.responderIdType = OCSP_RESPONDER_ID_KEY;
-    XMEMCPY(resp.responderId.keyHash, ca->issuerKeyHash, KEYID_SIZE);
+    XMEMCPY(resp.responderId.keyHash, ca->issuerKeyHash.sha, KEYID_SIZE);
 
     /* TODO allow user to set algo */
     if (ca->keyType == RSAk) {
@@ -2640,7 +2677,8 @@ int wc_OcspResponder_WriteResponse(OcspResponder* responder,
     reqInited = 1;
 
     /* Find the CA by issuer hashes */
-    ca = FindCaByHashes(responder, req.issuerHash, req.issuerKeyHash);
+    ca = FindCaByHashes(responder, req.issuerHash, req.issuerKeyHash,
+                        req.hashAlg);
     if (ca == NULL) {
         WOLFSSL_MSG("No matching CA found for request");
         ret = ASN_NO_SIGNER_E;