Implement TLS 1.2.

net/third_party/nss/ssl/sslplatf.c

 /*
  * Platform specific crypto wrappers
  *
  * ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
@@ skipping 194 matching lines @@
                            PRBool isTLS, KeyType keyType)
 {
     SECStatus       rv                = SECFailure;
     SECURITY_STATUS ncrypt_status;
     PRBool          doDerEncode       = PR_FALSE;
     SECItem         hashItem;
     DWORD           signatureLen      = 0;
     DWORD           dwFlags           = 0;
     VOID           *pPaddingInfo      = NULL;
 
-    /* Always encode using PKCS#1 block type, with no OID/encoded DigestInfo */
+    /* Always encode using PKCS#1 block type. */
     BCRYPT_PKCS1_PADDING_INFO rsaPaddingInfo;
-    rsaPaddingInfo.pszAlgId = NULL;
 
     if (key->dwKeySpec != CERT_NCRYPT_KEY_SPEC) {
         PR_SetError(SEC_ERROR_LIBRARY_FAILURE, 0);
         return SECFailure;
     }
     if (ssl_InitCng() != SECSuccess) {
         PR_SetError(SEC_ERROR_LIBRARY_FAILURE, 0);
         return SECFailure;
     }
 
     switch (keyType) {
         case rsaKey:
-            hashItem.data = hash->md5;
-            hashItem.len  = sizeof(SSL3Hashes);
+            switch (hash->hashAlg) {
+                case SEC_OID_UNKNOWN:
+                    /* No OID/encoded DigestInfo. */
+                    rsaPaddingInfo.pszAlgId = NULL;
+                    break;
+                case SEC_OID_SHA1:
+                    rsaPaddingInfo.pszAlgId = BCRYPT_SHA1_ALGORITHM;
+                    break;
+                case SEC_OID_SHA256:
+                    rsaPaddingInfo.pszAlgId = BCRYPT_SHA256_ALGORITHM;
+                    break;
+                case SEC_OID_SHA384:
+                    rsaPaddingInfo.pszAlgId = BCRYPT_SHA384_ALGORITHM;
+                    break;
+                case SEC_OID_SHA512:
+                    rsaPaddingInfo.pszAlgId = BCRYPT_SHA512_ALGORITHM;
+                    break;
+                default:
+                    PORT_SetError(SSL_ERROR_UNSUPPORTED_HASH_ALGORITHM);
+                    return SECFailure;
+            }
+            hashItem.data = hash->u.raw;
+            hashItem.len  = hash->len;
             dwFlags       = BCRYPT_PAD_PKCS1;
             pPaddingInfo  = &rsaPaddingInfo;
             break;
         case dsaKey:
         case ecKey:
             if (keyType == ecKey) {
                 doDerEncode = PR_TRUE;
             } else {
                 doDerEncode = isTLS;
             }
-            hashItem.data = hash->sha;
-            hashItem.len  = sizeof(hash->sha);
+            if (hash->hashAlg == SEC_OID_UNKNOWN) {
+                hashItem.data = hash->u.s.sha;
+                hashItem.len  = sizeof(hash->u.s.sha);
+            } else {
+                hashItem.data = hash->u.raw;
+                hashItem.len  = hash->len;
+            }
             break;
         default:
             PORT_SetError(SEC_ERROR_INVALID_KEY);
             goto done;
     }
     PRINT_BUF(60, (NULL, "hash(es) to be signed", hashItem.data, hashItem.len));
 
     ncrypt_status = (*pNCryptSignHash)(key->hNCryptKey, pPaddingInfo,
                                        (PBYTE)hashItem.data, hashItem.len,
                                        NULL, 0, &signatureLen, dwFlags);
@@ skipping 54 matching lines @@
     SECItem      hashItem;
     DWORD        argLen         = 0;
     DWORD        signatureLen   = 0;
     ALG_ID       hashAlg        = 0;
     HCRYPTHASH   hHash          = 0;
     DWORD        hashLen        = 0;
     unsigned int i              = 0;
 
     buf->data = NULL;
 
+    switch (hash->hashAlg) {
+        case SEC_OID_UNKNOWN:
+            hashAlg = 0;
+            break;
+        case SEC_OID_SHA1:
+            hashAlg = CALG_SHA1;
+            break;
+        case SEC_OID_SHA256:
+            hashAlg = CALG_SHA_256;
+            break;
+        case SEC_OID_SHA384:
+            hashAlg = CALG_SHA_384;
+            break;
+        case SEC_OID_SHA512:
+            hashAlg = CALG_SHA_512;
+            break;
+        default:
+            PORT_SetError(SSL_ERROR_UNSUPPORTED_HASH_ALGORITHM);
+            return SECFailure;
+    }
+
     switch (keyType) {
         case rsaKey:
-            hashAlg       = CALG_SSL3_SHAMD5;
-            hashItem.data = hash->md5;
-            hashItem.len  = sizeof(SSL3Hashes);
+            if (hashAlg == 0) {
+                hashAlg = CALG_SSL3_SHAMD5;
+            }
+            hashItem.data = hash->u.raw;
+            hashItem.len = hash->len;
             break;
         case dsaKey:
         case ecKey:
             if (keyType == ecKey) {
                 doDerEncode = PR_TRUE;
             } else {
                 doDerEncode = isTLS;
             }
-            hashAlg       = CALG_SHA1;
-            hashItem.data = hash->sha;
-            hashItem.len  = sizeof(hash->sha);
+            if (hashAlg == 0) {
+                hashAlg = CALG_SHA1;
+                hashItem.data = hash->u.s.sha;
+                hashItem.len = sizeof(hash->u.s.sha);
+            } else {
+                hashItem.data = hash->u.raw;
+                hashItem.len = hash->len;
+            }
             break;
         default:
             PORT_SetError(SEC_ERROR_INVALID_KEY);
             goto done;
     }
     PRINT_BUF(60, (NULL, "hash(es) to be signed", hashItem.data, hashItem.len));
 
     if (!CryptCreateHash(key->hCryptProv, hashAlg, 0, 0, &hHash)) {
         PR_SetError(SSL_ERROR_SIGN_HASHES_FAILURE, GetLastError());
         goto done;
@@ skipping 117 matching lines @@
     if (signatureLen == 0) {
         PORT_SetError(SEC_ERROR_INVALID_KEY);
         goto done;
     }
 
     buf->data = (unsigned char *)PORT_Alloc(signatureLen);
     if (!buf->data)
         goto done;    /* error code was set. */
 
     sigAlg = cssmKey->KeyHeader.AlgorithmId;
+    if (keyType == rsaKey) {
+        PORT_Assert(sigAlg == CSSM_ALGID_RSA);
+        switch (hash->hashAlg) {
+            case SEC_OID_UNKNOWN:
+                break;
+            case SEC_OID_SHA1:
+                sigAlg = CSSM_ALGID_SHA1WithRSA;
+                break;
+            case SEC_OID_SHA224:
+                sigAlg = CSSM_ALGID_SHA224WithRSA;
+                break;
+            case SEC_OID_SHA256:
+                sigAlg = CSSM_ALGID_SHA256WithRSA;
+                break;
+            case SEC_OID_SHA384:
+                sigAlg = CSSM_ALGID_SHA384WithRSA;
+                break;
+            case SEC_OID_SHA512:
+                sigAlg = CSSM_ALGID_SHA512WithRSA;
+                break;
+            default:
+                PORT_SetError(SSL_ERROR_UNSUPPORTED_HASH_ALGORITHM);
+                goto done;
+        }
+    }
+
     switch (keyType) {
         case rsaKey:
-            PORT_Assert(sigAlg == CSSM_ALGID_RSA);
-            hashData.Data   = hash->md5;
-            hashData.Length = sizeof(SSL3Hashes);
+            hashData.Data   = hash->u.raw;
+            hashData.Length = hash->len;
             break;
         case dsaKey:
         case ecKey:
             if (keyType == ecKey) {
                 PORT_Assert(sigAlg == CSSM_ALGID_ECDSA);
                 doDerEncode = PR_TRUE;
             } else {
                 PORT_Assert(sigAlg == CSSM_ALGID_DSA);
                 doDerEncode = isTLS;
             }
-            hashData.Data   = hash->sha;
-            hashData.Length = sizeof(hash->sha);
+            if (hash->hashAlg == SEC_OID_UNKNOWN) {
+                hashData.Data   = hash->u.s.sha;
+                hashData.Length = sizeof(hash->u.s.sha);
+            } else {
+                hashData.Data   = hash->u.raw;
+                hashData.Length = hash->len;
+            }
             break;
         default:
             PORT_SetError(SEC_ERROR_INVALID_KEY);
             goto done;
     }
     PRINT_BUF(60, (NULL, "hash(es) to be signed", hashData.Data, hashData.Length));
 
     /* TODO(rsleevi): Should it be kSecCredentialTypeNoUI? In Win32, at least,
      * you can prevent the UI by setting the provider handle on the
      * certificate to be opened with CRYPT_SILENT, but is there an equivalent?
@@ skipping 76 matching lines @@
 SECStatus
 ssl3_PlatformSignHashes(SSL3Hashes *hash, PlatformKey key, SECItem *buf,
                         PRBool isTLS, KeyType keyType)
 {
     PORT_SetError(PR_NOT_IMPLEMENTED_ERROR);
     return SECFailure;
 }
 #endif
 
 #endif /* NSS_PLATFORM_CLIENT_AUTH */