net/base/keygen_handler_mac.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/base/keygen_handler.h"
   6
   7 #include <Security/SecAsn1Coder.h>
   8 #include <Security/SecAsn1Templates.h>
   9 #include <Security/Security.h>
  10
  11 #include "base/base64.h"
  12 #include "base/logging.h"
  13 #include "base/mac/mac_logging.h"
  14 #include "base/mac/scoped_cftyperef.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/strings/sys_string_conversions.h"
  17 #include "base/synchronization/lock.h"
  18 #include "crypto/cssm_init.h"
  19 #include "crypto/mac_security_services_lock.h"
  20
  21 // These are in Security.framework but not declared in a public header.
  22 extern const SecAsn1Template kSecAsn1AlgorithmIDTemplate[];
  23 extern const SecAsn1Template kSecAsn1SubjectPublicKeyInfoTemplate[];
  24
  25 namespace net {
  26
  27 // Declarations of Netscape keygen cert structures for ASN.1 encoding:
  28
  29 struct PublicKeyAndChallenge {
  30   CSSM_X509_SUBJECT_PUBLIC_KEY_INFO spki;
  31   CSSM_DATA challenge_string;
  32 };
  33
  34 // This is a copy of the built-in kSecAsn1IA5StringTemplate, but without the
  35 // 'streamable' flag, which was causing bogus data to be written.
  36 const SecAsn1Template kIA5StringTemplate[] = {
  37     { SEC_ASN1_IA5_STRING, 0, NULL, sizeof(CSSM_DATA) }
  38 };
  39
  40 static const SecAsn1Template kPublicKeyAndChallengeTemplate[] = {
  41   {
  42     SEC_ASN1_SEQUENCE,
  43     0,
  44     NULL,
  45     sizeof(PublicKeyAndChallenge)
  46   },
  47   {
  48     SEC_ASN1_INLINE,
  49     offsetof(PublicKeyAndChallenge, spki),
  50     kSecAsn1SubjectPublicKeyInfoTemplate
  51   },
  52   {
  53     SEC_ASN1_INLINE,
  54     offsetof(PublicKeyAndChallenge, challenge_string),
  55     kIA5StringTemplate
  56   },
  57   {
  58     0
  59   }
  60 };
  61
  62 struct SignedPublicKeyAndChallenge {
  63   PublicKeyAndChallenge pkac;
  64   CSSM_X509_ALGORITHM_IDENTIFIER signature_algorithm;
  65   CSSM_DATA signature;
  66 };
  67
  68 static const SecAsn1Template kSignedPublicKeyAndChallengeTemplate[] = {
  69   {
  70     SEC_ASN1_SEQUENCE,
  71     0,
  72     NULL,
  73     sizeof(SignedPublicKeyAndChallenge)
  74   },
  75   {
  76     SEC_ASN1_INLINE,
  77     offsetof(SignedPublicKeyAndChallenge, pkac),
  78     kPublicKeyAndChallengeTemplate
  79   },
  80   {
  81     SEC_ASN1_INLINE,
  82     offsetof(SignedPublicKeyAndChallenge, signature_algorithm),
  83     kSecAsn1AlgorithmIDTemplate
  84   },
  85   {
  86     SEC_ASN1_BIT_STRING,
  87     offsetof(SignedPublicKeyAndChallenge, signature)
  88   },
  89   {
  90     0
  91   }
  92 };
  93
  94
  95 static OSStatus CreateRSAKeyPair(int size_in_bits,
  96                                  SecAccessRef initial_access,
  97                                  SecKeyRef* out_pub_key,
  98                                  SecKeyRef* out_priv_key);
  99 static OSStatus SignData(CSSM_DATA data,
 100                          SecKeyRef private_key,
 101                          CSSM_DATA* signature);
 102
 103 std::string KeygenHandler::GenKeyAndSignChallenge() {
 104   std::string result;
 105   OSStatus err;
 106   SecAccessRef initial_access = NULL;
 107   SecKeyRef public_key = NULL;
 108   SecKeyRef private_key = NULL;
 109   SecAsn1CoderRef coder = NULL;
 110   CSSM_DATA signature = {0, NULL};
 111
 112   {
 113     if (url_.has_host()) {
 114       // TODO(davidben): Use something like "Key generated for
 115       // example.com", but localize it.
 116       base::ScopedCFTypeRef<CFStringRef> label(
 117           base::SysUTF8ToCFStringRef(url_.host()));
 118       // Create an initial access object to set the SecAccessRef. This
 119       // sets a label on the Keychain dialogs. Pass NULL as the second
 120       // argument to use the default trusted list; only allow the
 121       // current application to access without user confirmation.
 122       err = SecAccessCreate(label, NULL, &initial_access);
 123       // If we fail, just continue without a label.
 124       if (err)
 125         crypto::LogCSSMError("SecAccessCreate", err);
 126     }
 127
 128     // Create the key-pair.
 129     err = CreateRSAKeyPair(key_size_in_bits_, initial_access,
 130                            &public_key, &private_key);
 131     if (err)
 132       goto failure;
 133
 134     // Get the public key data (DER sequence of modulus, exponent).
 135     CFDataRef key_data = NULL;
 136     err = SecKeychainItemExport(public_key, kSecFormatBSAFE, 0, NULL,
 137                                 &key_data);
 138     if (err) {
 139       crypto::LogCSSMError("SecKeychainItemExpor", err);
 140       goto failure;
 141     }
 142     base::ScopedCFTypeRef<CFDataRef> scoped_key_data(key_data);
 143
 144     // Create an ASN.1 encoder.
 145     err = SecAsn1CoderCreate(&coder);
 146     if (err) {
 147       crypto::LogCSSMError("SecAsn1CoderCreate", err);
 148       goto failure;
 149     }
 150
 151     // Fill in and DER-encode the PublicKeyAndChallenge:
 152     SignedPublicKeyAndChallenge spkac;
 153     memset(&spkac, 0, sizeof(spkac));
 154     spkac.pkac.spki.algorithm.algorithm = CSSMOID_RSA;
 155     spkac.pkac.spki.subjectPublicKey.Length =
 156         CFDataGetLength(key_data) * 8;  // interpreted as a _bit_ count
 157     spkac.pkac.spki.subjectPublicKey.Data =
 158         const_cast<uint8_t*>(CFDataGetBytePtr(key_data));
 159     spkac.pkac.challenge_string.Length = challenge_.length();
 160     spkac.pkac.challenge_string.Data =
 161         reinterpret_cast<uint8_t*>(const_cast<char*>(challenge_.data()));
 162
 163     CSSM_DATA encoded;
 164     err = SecAsn1EncodeItem(coder, &spkac.pkac,
 165                             kPublicKeyAndChallengeTemplate, &encoded);
 166     if (err) {
 167       crypto::LogCSSMError("SecAsn1EncodeItem", err);
 168       goto failure;
 169     }
 170
 171     // Compute a signature of the result:
 172     err = SignData(encoded, private_key, &signature);
 173     if (err)
 174       goto failure;
 175     spkac.signature.Data = signature.Data;
 176     spkac.signature.Length = signature.Length * 8;  // a _bit_ count
 177     spkac.signature_algorithm.algorithm = CSSMOID_MD5WithRSA;
 178     // TODO(snej): MD5 is weak. Can we use SHA1 instead?
 179     // See <https://bugzilla.mozilla.org/show_bug.cgi?id=549460>
 180
 181     // DER-encode the entire SignedPublicKeyAndChallenge:
 182     err = SecAsn1EncodeItem(coder, &spkac,
 183                             kSignedPublicKeyAndChallengeTemplate, &encoded);
 184     if (err) {
 185       crypto::LogCSSMError("SecAsn1EncodeItem", err);
 186       goto failure;
 187     }
 188
 189     // Base64 encode the result.
 190     std::string input(reinterpret_cast<char*>(encoded.Data), encoded.Length);
 191     base::Base64Encode(input, &result);
 192   }
 193
 194  failure:
 195   if (err)
 196     OSSTATUS_LOG(ERROR, err) << "SSL Keygen failed!";
 197   else
 198     VLOG(1) << "SSL Keygen succeeded! Output is: " << result;
 199
 200   // Remove keys from keychain if asked to during unit testing:
 201   if (!stores_key_) {
 202     if (public_key)
 203       SecKeychainItemDelete(reinterpret_cast<SecKeychainItemRef>(public_key));
 204     if (private_key)
 205       SecKeychainItemDelete(reinterpret_cast<SecKeychainItemRef>(private_key));
 206   }
 207
 208   // Clean up:
 209   free(signature.Data);
 210   if (coder)
 211     SecAsn1CoderRelease(coder);
 212   if (initial_access)
 213     CFRelease(initial_access);
 214   if (public_key)
 215     CFRelease(public_key);
 216   if (private_key)
 217     CFRelease(private_key);
 218   return result;
 219 }
 220
 221
 222 // Create an RSA key pair with size |size_in_bits|. |initial_access|
 223 // is passed as the initial access control list in Keychain. The
 224 // public and private keys are placed in |out_pub_key| and
 225 // |out_priv_key|, respectively.
 226 static OSStatus CreateRSAKeyPair(int size_in_bits,
 227                                  SecAccessRef initial_access,
 228                                  SecKeyRef* out_pub_key,
 229                                  SecKeyRef* out_priv_key) {
 230   OSStatus err;
 231   SecKeychainRef keychain;
 232   err = SecKeychainCopyDefault(&keychain);
 233   if (err) {
 234     crypto::LogCSSMError("SecKeychainCopyDefault", err);
 235     return err;
 236   }
 237   base::ScopedCFTypeRef<SecKeychainRef> scoped_keychain(keychain);
 238   {
 239     base::AutoLock locked(crypto::GetMacSecurityServicesLock());
 240     err = SecKeyCreatePair(
 241         keychain,
 242         CSSM_ALGID_RSA,
 243         size_in_bits,
 244         0LL,
 245         // public key usage and attributes:
 246         CSSM_KEYUSE_ENCRYPT | CSSM_KEYUSE_VERIFY | CSSM_KEYUSE_WRAP,
 247         CSSM_KEYATTR_EXTRACTABLE | CSSM_KEYATTR_PERMANENT,
 248         // private key usage and attributes:
 249         CSSM_KEYUSE_DECRYPT | CSSM_KEYUSE_SIGN | CSSM_KEYUSE_UNWRAP,
 250         CSSM_KEYATTR_EXTRACTABLE | CSSM_KEYATTR_PERMANENT |
 251             CSSM_KEYATTR_SENSITIVE,
 252         initial_access,
 253         out_pub_key, out_priv_key);
 254   }
 255   if (err)
 256     crypto::LogCSSMError("SecKeyCreatePair", err);
 257   return err;
 258 }
 259
 260 static OSStatus CreateSignatureContext(SecKeyRef key,
 261                                        CSSM_ALGORITHMS algorithm,
 262                                        CSSM_CC_HANDLE* out_cc_handle) {
 263   OSStatus err;
 264   const CSSM_ACCESS_CREDENTIALS* credentials = NULL;
 265   {
 266     base::AutoLock locked(crypto::GetMacSecurityServicesLock());
 267     err = SecKeyGetCredentials(key,
 268                                CSSM_ACL_AUTHORIZATION_SIGN,
 269                                kSecCredentialTypeDefault,
 270                                &credentials);
 271   }
 272   if (err) {
 273     crypto::LogCSSMError("SecKeyGetCredentials", err);
 274     return err;
 275   }
 276
 277   CSSM_CSP_HANDLE csp_handle = 0;
 278   {
 279     base::AutoLock locked(crypto::GetMacSecurityServicesLock());
 280     err = SecKeyGetCSPHandle(key, &csp_handle);
 281   }
 282   if (err) {
 283     crypto::LogCSSMError("SecKeyGetCSPHandle", err);
 284     return err;
 285   }
 286
 287   const CSSM_KEY* cssm_key = NULL;
 288   {
 289     base::AutoLock locked(crypto::GetMacSecurityServicesLock());
 290     err = SecKeyGetCSSMKey(key, &cssm_key);
 291   }
 292   if (err) {
 293     crypto::LogCSSMError("SecKeyGetCSSMKey", err);
 294     return err;
 295   }
 296
 297   err = CSSM_CSP_CreateSignatureContext(csp_handle,
 298                                         algorithm,
 299                                         credentials,
 300                                         cssm_key,
 301                                         out_cc_handle);
 302   if (err)
 303     crypto::LogCSSMError("CSSM_CSP_CreateSignatureContext", err);
 304   return err;
 305 }
 306
 307 static OSStatus SignData(CSSM_DATA data,
 308                          SecKeyRef private_key,
 309                          CSSM_DATA* signature) {
 310   CSSM_CC_HANDLE cc_handle;
 311   OSStatus err = CreateSignatureContext(private_key,
 312                                         CSSM_ALGID_MD5WithRSA,
 313                                         &cc_handle);
 314   if (err) {
 315     crypto::LogCSSMError("CreateSignatureContext", err);
 316     return err;
 317   }
 318   err = CSSM_SignData(cc_handle, &data, 1, CSSM_ALGID_NONE, signature);
 319   if (err)
 320     crypto::LogCSSMError("CSSM_SignData", err);
 321   CSSM_DeleteContext(cc_handle);
 322   return err;
 323 }
 324
 325 }  // namespace net