| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master