Move crypto files out of base, to a top level directory.

net/base/keygen_handler_mac.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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 <Security/SecAsn1Coder.h>
 #include <Security/SecAsn1Templates.h>
 #include <Security/Security.h>
 
 #include "base/base64.h"
-#include "base/crypto/cssm_init.h"
-#include "base/crypto/mac_security_services_lock.h"
 #include "base/logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/string_util.h"
 #include "base/synchronization/lock.h"
 #include "base/sys_string_conversions.h"
+#include "crypto/cssm_init.h"
+#include "crypto/mac_security_services_lock.h"
 
 // These are in Security.framework but not declared in a public header.
 extern const SecAsn1Template kSecAsn1AlgorithmIDTemplate[];
 extern const SecAsn1Template kSecAsn1SubjectPublicKeyInfoTemplate[];
 
 namespace net {
 
 // Declarations of Netscape keygen cert structures for ASN.1 encoding:
 
 struct PublicKeyAndChallenge {
@@ skipping 85 matching lines @@
       // example.com", but localize it.
       base::mac::ScopedCFTypeRef<CFStringRef> label(
           base::SysUTF8ToCFStringRef(url_.host()));
       // Create an initial access object to set the SecAccessRef. This
       // sets a label on the Keychain dialogs. Pass NULL as the second
       // argument to use the default trusted list; only allow the
       // current application to access without user confirmation.
       err = SecAccessCreate(label, NULL, &initial_access);
       // If we fail, just continue without a label.
       if (err)
-        base::LogCSSMError("SecAccessCreate", err);
+        crypto::LogCSSMError("SecAccessCreate", err);
     }
 
     // Create the key-pair.
     err = CreateRSAKeyPair(key_size_in_bits_, initial_access,
                            &public_key, &private_key);
     if (err)
       goto failure;
 
     // Get the public key data (DER sequence of modulus, exponent).
     CFDataRef key_data = NULL;
     err = SecKeychainItemExport(public_key, kSecFormatBSAFE, 0, NULL,
                                 &key_data);
     if (err) {
-      base::LogCSSMError("SecKeychainItemExpor", err);
+      crypto::LogCSSMError("SecKeychainItemExpor", err);
       goto failure;
     }
     base::mac::ScopedCFTypeRef<CFDataRef> scoped_key_data(key_data);
 
     // Create an ASN.1 encoder.
     err = SecAsn1CoderCreate(&coder);
     if (err) {
-      base::LogCSSMError("SecAsn1CoderCreate", err);
+      crypto::LogCSSMError("SecAsn1CoderCreate", err);
       goto failure;
     }
 
     // Fill in and DER-encode the PublicKeyAndChallenge:
     SignedPublicKeyAndChallenge spkac;
     memset(&spkac, 0, sizeof(spkac));
     spkac.pkac.spki.algorithm.algorithm = CSSMOID_RSA;
     spkac.pkac.spki.subjectPublicKey.Length =
         CFDataGetLength(key_data) * 8;  // interpreted as a _bit_ count
     spkac.pkac.spki.subjectPublicKey.Data =
         const_cast<uint8_t*>(CFDataGetBytePtr(key_data));
     spkac.pkac.challenge_string.Length = challenge_.length();
     spkac.pkac.challenge_string.Data =
         reinterpret_cast<uint8_t*>(const_cast<char*>(challenge_.data()));
 
     CSSM_DATA encoded;
     err = SecAsn1EncodeItem(coder, &spkac.pkac,
                             kPublicKeyAndChallengeTemplate, &encoded);
     if (err) {
-      base::LogCSSMError("SecAsn1EncodeItem", err);
+      crypto::LogCSSMError("SecAsn1EncodeItem", err);
       goto failure;
     }
 
     // Compute a signature of the result:
     err = SignData(encoded, private_key, &signature);
     if (err)
       goto failure;
     spkac.signature.Data = signature.Data;
     spkac.signature.Length = signature.Length * 8;  // a _bit_ count
     spkac.signature_algorithm.algorithm = CSSMOID_MD5WithRSA;
     // TODO(snej): MD5 is weak. Can we use SHA1 instead?
     // See <https://bugzilla.mozilla.org/show_bug.cgi?id=549460>
 
     // DER-encode the entire SignedPublicKeyAndChallenge:
     err = SecAsn1EncodeItem(coder, &spkac,
                             kSignedPublicKeyAndChallengeTemplate, &encoded);
     if (err) {
-      base::LogCSSMError("SecAsn1EncodeItem", err);
+      crypto::LogCSSMError("SecAsn1EncodeItem", err);
       goto failure;
     }
 
     // Base64 encode the result.
     std::string input(reinterpret_cast<char*>(encoded.Data), encoded.Length);
     base::Base64Encode(input, &result);
   }
 
  failure:
   if (err)
@@ skipping 28 matching lines @@
 // public and private keys are placed in |out_pub_key| and
 // |out_priv_key|, respectively.
 static OSStatus CreateRSAKeyPair(int size_in_bits,
                                  SecAccessRef initial_access,
                                  SecKeyRef* out_pub_key,
                                  SecKeyRef* out_priv_key) {
   OSStatus err;
   SecKeychainRef keychain;
   err = SecKeychainCopyDefault(&keychain);
   if (err) {
-    base::LogCSSMError("SecKeychainCopyDefault", err);
+    crypto::LogCSSMError("SecKeychainCopyDefault", err);
     return err;
   }
   base::mac::ScopedCFTypeRef<SecKeychainRef> scoped_keychain(keychain);
   {
-    base::AutoLock locked(base::GetMacSecurityServicesLock());
+    base::AutoLock locked(crypto::GetMacSecurityServicesLock());
     err = SecKeyCreatePair(
         keychain,
         CSSM_ALGID_RSA,
         size_in_bits,
         0LL,
         // public key usage and attributes:
         CSSM_KEYUSE_ENCRYPT | CSSM_KEYUSE_VERIFY | CSSM_KEYUSE_WRAP,
         CSSM_KEYATTR_EXTRACTABLE | CSSM_KEYATTR_PERMANENT,
         // private key usage and attributes:
         CSSM_KEYUSE_DECRYPT | CSSM_KEYUSE_SIGN | CSSM_KEYUSE_UNWRAP,
         CSSM_KEYATTR_EXTRACTABLE | CSSM_KEYATTR_PERMANENT |
             CSSM_KEYATTR_SENSITIVE,
         initial_access,
         out_pub_key, out_priv_key);
   }
   if (err)
-    base::LogCSSMError("SecKeyCreatePair", err);
+    crypto::LogCSSMError("SecKeyCreatePair", err);
   return err;
 }
 
 static OSStatus CreateSignatureContext(SecKeyRef key,
                                        CSSM_ALGORITHMS algorithm,
                                        CSSM_CC_HANDLE* out_cc_handle) {
   OSStatus err;
   const CSSM_ACCESS_CREDENTIALS* credentials = NULL;
   {
-    base::AutoLock locked(base::GetMacSecurityServicesLock());
+    base::AutoLock locked(crypto::GetMacSecurityServicesLock());
     err = SecKeyGetCredentials(key,
                                CSSM_ACL_AUTHORIZATION_SIGN,
                                kSecCredentialTypeDefault,
                                &credentials);
   }
   if (err) {
-    base::LogCSSMError("SecKeyGetCredentials", err);
+    crypto::LogCSSMError("SecKeyGetCredentials", err);
     return err;
   }
 
   CSSM_CSP_HANDLE csp_handle = 0;
   {
-    base::AutoLock locked(base::GetMacSecurityServicesLock());
+    base::AutoLock locked(crypto::GetMacSecurityServicesLock());
     err = SecKeyGetCSPHandle(key, &csp_handle);
   }
   if (err) {
-    base::LogCSSMError("SecKeyGetCSPHandle", err);
+    crypto::LogCSSMError("SecKeyGetCSPHandle", err);
     return err;
   }
 
   const CSSM_KEY* cssm_key = NULL;
   {
-    base::AutoLock locked(base::GetMacSecurityServicesLock());
+    base::AutoLock locked(crypto::GetMacSecurityServicesLock());
     err = SecKeyGetCSSMKey(key, &cssm_key);
   }
   if (err) {
-    base::LogCSSMError("SecKeyGetCSSMKey", err);
+    crypto::LogCSSMError("SecKeyGetCSSMKey", err);
     return err;
   }
 
   err = CSSM_CSP_CreateSignatureContext(csp_handle,
                                         algorithm,
                                         credentials,
                                         cssm_key,
                                         out_cc_handle);
   if (err)
-    base::LogCSSMError("CSSM_CSP_CreateSignatureContext", err);
+    crypto::LogCSSMError("CSSM_CSP_CreateSignatureContext", err);
   return err;
 }
 
 static OSStatus SignData(CSSM_DATA data,
                          SecKeyRef private_key,
                          CSSM_DATA* signature) {
   CSSM_CC_HANDLE cc_handle;
   OSStatus err = CreateSignatureContext(private_key,
                                         CSSM_ALGID_MD5WithRSA,
                                         &cc_handle);
   if (err) {
-    base::LogCSSMError("CreateSignatureContext", err);
+    crypto::LogCSSMError("CreateSignatureContext", err);
     return err;
   }
   err = CSSM_SignData(cc_handle, &data, 1, CSSM_ALGID_NONE, signature);
   if (err)
-    base::LogCSSMError("CSSM_SignData", err);
+    crypto::LogCSSMError("CSSM_SignData", err);
   CSSM_DeleteContext(cc_handle);
   return err;
 }
 
 }  // namespace net