Simplify the Windows <keygen> implementation by making better use of CryptoAP...

net/base/keygen_handler_win.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/keygen_handler.h"
 
 #include <windows.h>
 #include <wincrypt.h>
 #pragma comment(lib, "crypt32.lib")
 #include <rpc.h>
 #pragma comment(lib, "rpcrt4.lib")
 
 #include <list>
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/string_piece.h"
+#include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 
 namespace net {
 
-// TODO(rsleevi): The following encoding functions are adapted from
-// base/crypto/rsa_private_key.h and can/should probably be refactored.
-static const uint8 kSequenceTag = 0x30;
-
-void PrependLength(size_t size, std::list<BYTE>* data) {
-  // The high bit is used to indicate whether additional octets are needed to
-  // represent the length.
-  if (size < 0x80) {
-    data->push_front(static_cast<BYTE>(size));
-  } else {
-    uint8 num_bytes = 0;
-    while (size > 0) {
-      data->push_front(static_cast<BYTE>(size & 0xFF));
-      size >>= 8;
-      num_bytes++;
-    }
-    CHECK_LE(num_bytes, 4);
-    data->push_front(0x80 | num_bytes);
-  }
-}
-
-void PrependTypeHeaderAndLength(uint8 type, uint32 length,
-                                std::vector<BYTE>* output) {
-  std::list<BYTE> type_and_length;
-
-  PrependLength(length, &type_and_length);
-  type_and_length.push_front(type);
-
-  output->insert(output->begin(), type_and_length.begin(),
-                 type_and_length.end());
-}
-
 bool EncodeAndAppendType(LPCSTR type, const void* to_encode,
                          std::vector<BYTE>* output) {
   BOOL ok;
   DWORD size = 0;
   ok = CryptEncodeObject(X509_ASN_ENCODING, type, to_encode, NULL, &size);
   DCHECK(ok);
   if (!ok)
     return false;
 
   std::vector<BYTE>::size_type old_size = output->size();
   output->resize(old_size + size);
 
   ok = CryptEncodeObject(X509_ASN_ENCODING, type, to_encode,
                          &(*output)[old_size], &size);
   DCHECK(ok);
   if (!ok)
     return false;
 
   // Sometimes the initial call to CryptEncodeObject gave a generous estimate
   // of the size, so shrink back to what was actually used.
   output->resize(old_size + size);
 
   return true;
 }
 
-// Appends a DER IA5String containing |challenge| to |output|.
-// Returns true if encoding was successful.
-bool EncodeChallenge(const std::string& challenge, std::vector<BYTE>* output) {
-  CERT_NAME_VALUE challenge_nv;
-  challenge_nv.dwValueType = CERT_RDN_IA5_STRING;
-  challenge_nv.Value.pbData = const_cast<BYTE*>(
-      reinterpret_cast<const BYTE*>(challenge.data()));
-  challenge_nv.Value.cbData = challenge.size();
-
-  return EncodeAndAppendType(X509_ANY_STRING, &challenge_nv, output);
-}
-
-// Appends a DER SubjectPublicKeyInfo structure for the signing key in |prov|
-// to |output|.
-// Returns true if encoding was successful.
-bool EncodeSubjectPublicKeyInfo(HCRYPTPROV prov, std::vector<BYTE>* output) {
+// Assigns the contents of a CERT_PUBLIC_KEY_INFO structure for the signing
+// key in |prov| to |output|. Returns true if encoding was successful.
+bool GetSubjectPublicKeyInfo(HCRYPTPROV prov, std::vector<BYTE>* output) {
   BOOL ok;
   DWORD size = 0;
 
   // From the private key stored in HCRYPTPROV, obtain the public key, stored
   // as a CERT_PUBLIC_KEY_INFO structure. Currently, only RSA public keys are
   // supported.
   ok = CryptExportPublicKeyInfoEx(prov, AT_KEYEXCHANGE, X509_ASN_ENCODING,
                                   szOID_RSA_RSA, 0, NULL, NULL, &size);
   DCHECK(ok);
   if (!ok)
     return false;
 
-  std::vector<BYTE> public_key_info(size);
+  output->resize(size);
+
   PCERT_PUBLIC_KEY_INFO public_key_casted =
-      reinterpret_cast<PCERT_PUBLIC_KEY_INFO>(&public_key_info[0]);
+      reinterpret_cast<PCERT_PUBLIC_KEY_INFO>(&(*output)[0]);
   ok = CryptExportPublicKeyInfoEx(prov, AT_KEYEXCHANGE, X509_ASN_ENCODING,
                                   szOID_RSA_RSA, 0, NULL, public_key_casted,
                                   &size);
   DCHECK(ok);
   if (!ok)
     return false;
 
-  public_key_info.resize(size);
+  output->resize(size);
+
+  return true;
+}
+
+// Appends a DER SubjectPublicKeyInfo structure for the signing key in |prov|
+// to |output|.
+// Returns true if encoding was successful.
+bool EncodeSubjectPublicKeyInfo(HCRYPTPROV prov, std::vector<BYTE>* output) {
+  std::vector<BYTE> public_key_info;
+  if (!GetSubjectPublicKeyInfo(prov, &public_key_info))
+    return false;
 
   return EncodeAndAppendType(X509_PUBLIC_KEY_INFO, &public_key_info[0],
                              output);
 }
 
-// Generates an ASN.1 DER representation of the PublicKeyAndChallenge structure
-// from the signing key of |prov| and the specified |challenge| and appends it
-// to |output|.
-// True if the the encoding was successfully generated.
-bool GetPublicKeyAndChallenge(HCRYPTPROV prov, const std::string& challenge,
-                              std::vector<BYTE>* output) {
-  if (!EncodeSubjectPublicKeyInfo(prov, output) ||
-      !EncodeChallenge(challenge, output)) {
-    return false;
-  }
-
-  PrependTypeHeaderAndLength(kSequenceTag, output->size(), output);
-  return true;
-}
-
 // Generates a DER encoded SignedPublicKeyAndChallenge structure from the
-// signing key of |prov| and the specified |challenge| string and appends it
-// to |output|.
+// signing key of |prov| and the specified ASCII |challenge| string and
+// appends it to |output|.
 // True if the encoding was successfully generated.
 bool GetSignedPublicKeyAndChallenge(HCRYPTPROV prov,
                                     const std::string& challenge,
                                     std::string* output) {
-  std::vector<BYTE> pkac;
-  if (!GetPublicKeyAndChallenge(prov, challenge, &pkac))
+  std::wstring wide_challenge = ASCIIToWide(challenge);
+  std::vector<BYTE> spki;
+
+  if (!GetSubjectPublicKeyInfo(prov, &spki))
     return false;
 
-  std::vector<BYTE> signature;
+  CERT_KEYGEN_REQUEST_INFO request;
+  request.dwVersion = CERT_KEYGEN_REQUEST_V1;
+  request.SubjectPublicKeyInfo =
+      *reinterpret_cast<PCERT_PUBLIC_KEY_INFO>(&spki[0]);
+  request.pwszChallengeString = const_cast<wchar_t*>(wide_challenge.c_str());
+
+  CRYPT_ALGORITHM_IDENTIFIER sig_alg;
+  memset(&sig_alg, 0, sizeof(sig_alg));
+  sig_alg.pszObjId = szOID_RSA_MD5RSA;
+
+  BOOL ok;
+  DWORD size = 0;
   std::vector<BYTE> signed_pkac;
-  DWORD size = 0;
-  BOOL ok;
-
-  // While the MSDN documentation states that CERT_SIGNED_CONTENT_INFO should
-  // be an X.509 certificate type, for encoding this is not necessary. The
-  // result of encoding this structure will be a DER-encoded structure with
-  // the ASN.1 equivalent of
-  //  ::= SEQUENCE {
-  //    ToBeSigned IMPLICIT OCTET STRING,
-  //    SignatureAlgorithm AlgorithmIdentifier,
-  //    Signature BIT STRING
-  //  }
-  //
-  // This happens to be the same naive type as an SPKAC, so this works.
-  CERT_SIGNED_CONTENT_INFO info;
-  info.ToBeSigned.cbData = pkac.size();
-  info.ToBeSigned.pbData = &pkac[0];
-  info.SignatureAlgorithm.pszObjId = szOID_RSA_MD5RSA;
-  info.SignatureAlgorithm.Parameters.cbData = 0;
-  info.SignatureAlgorithm.Parameters.pbData = NULL;
-
-  ok = CryptSignCertificate(prov, AT_KEYEXCHANGE, X509_ASN_ENCODING,
-                            info.ToBeSigned.pbData, info.ToBeSigned.cbData,
-                            &info.SignatureAlgorithm, NULL, NULL, &size);
+  ok = CryptSignAndEncodeCertificate(prov, AT_KEYEXCHANGE, X509_ASN_ENCODING,
+                                     X509_KEYGEN_REQUEST_TO_BE_SIGNED,
+                                     &request, &sig_alg, NULL,
+                                     NULL, &size);
   DCHECK(ok);
   if (!ok)
     return false;
 
-  signature.resize(size);
-  info.Signature.cbData = signature.size();
-  info.Signature.pbData = &signature[0];
-  info.Signature.cUnusedBits = 0;
-
-  ok = CryptSignCertificate(prov, AT_KEYEXCHANGE, X509_ASN_ENCODING,
-                            info.ToBeSigned.pbData, info.ToBeSigned.cbData,
-                            &info.SignatureAlgorithm, NULL,
-                            info.Signature.pbData, &info.Signature.cbData);
+  signed_pkac.resize(size);
+  ok = CryptSignAndEncodeCertificate(prov, AT_KEYEXCHANGE, X509_ASN_ENCODING,
+                                     X509_KEYGEN_REQUEST_TO_BE_SIGNED,
+                                     &request, &sig_alg, NULL,
+                                     &signed_pkac[0], &size);
   DCHECK(ok);
-  if (!ok || !EncodeAndAppendType(X509_CERT, &info, &signed_pkac))
+  if (!ok)
     return false;
 
-  output->assign(reinterpret_cast<char*>(&signed_pkac[0]),
-                 signed_pkac.size());
-
+  output->assign(reinterpret_cast<char*>(&signed_pkac[0]), size);
   return true;
 }
 
 // Generates a unique name for the container which will store the key that is
 // generated. The traditional Windows approach is to use a GUID here.
 std::wstring GetNewKeyContainerId() {
   RPC_STATUS status = RPC_S_OK;
   std::wstring result;
 
   UUID id = { 0 };
@@ skipping 151 matching lines @@
       // Fully destroys any of the keys that were created and releases prov.
       CryptAcquireContext(&prov, new_key_id.c_str(), NULL, PROV_RSA_FULL,
                           CRYPT_SILENT | CRYPT_DELETEKEYSET);
     }
   }
 
   return result;
 }
 
 }  // namespace net