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

net/base/x509_certificate_mac.cc

 // 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/x509_certificate.h"
 
 #include <CommonCrypto/CommonDigest.h>
 #include <Security/Security.h>
 #include <time.h>
 
 #include <vector>
 
-#include "base/crypto/cssm_init.h"
-#include "base/crypto/rsa_private_key.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/singleton.h"
-#include "base/nss_util.h"
 #include "base/pickle.h"
 #include "base/sha1.h"
 #include "base/sys_string_conversions.h"
+#include "crypto/cssm_init.h"
+#include "crypto/nss_util.h"
+#include "crypto/rsa_private_key.h"
 #include "net/base/asn1_util.h"
 #include "net/base/cert_status_flags.h"
 #include "net/base/cert_verify_result.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_root_certs.h"
 #include "net/base/x509_certificate_known_roots_mac.h"
 #include "third_party/nss/mozilla/security/nss/lib/certdb/cert.h"
 
 using base::mac::ScopedCFTypeRef;
 using base::Time;
@@ skipping 445 matching lines @@
 
 class ScopedEncodedCertResults {
  public:
   explicit ScopedEncodedCertResults(CSSM_TP_RESULT_SET* results)
       : results_(results) { }
   ~ScopedEncodedCertResults() {
     if (results_) {
       CSSM_ENCODED_CERT* encCert =
           reinterpret_cast<CSSM_ENCODED_CERT*>(results_->Results);
       for (uint32 i = 0; i < results_->NumberOfResults; i++) {
-        base::CSSMFree(encCert[i].CertBlob.Data);
+        crypto::CSSMFree(encCert[i].CertBlob.Data);
       }
     }
-    base::CSSMFree(results_->Results);
-    base::CSSMFree(results_);
+    crypto::CSSMFree(results_->Results);
+    crypto::CSSMFree(results_);
   }
 
 private:
   CSSM_TP_RESULT_SET* results_;
 };
 
 void AppendPublicKeyHashes(CFArrayRef chain,
                            std::vector<SHA1Fingerprint>* hashes) {
   const CFIndex n = CFArrayGetCount(chain);
   for (CFIndex i = 0; i < n; i++) {
@@ skipping 56 matching lines @@
   const char* data;
   int length;
   if (!pickle.ReadData(pickle_iter, &data, &length))
     return NULL;
 
   return CreateFromBytes(data, length);
 }
 
 // static
 X509Certificate* X509Certificate::CreateSelfSigned(
-    base::RSAPrivateKey* key,
+    crypto::RSAPrivateKey* key,
     const std::string& subject,
     uint32 serial_number,
     base::TimeDelta valid_duration) {
   DCHECK(key);
   DCHECK(!subject.empty());
 
   if (valid_duration.InSeconds() > UINT32_MAX) {
      LOG(ERROR) << "valid_duration too big" << valid_duration.InSeconds();
      valid_duration = base::TimeDelta::FromSeconds(UINT32_MAX);
   }
 
   // There is a comment in
   // http://www.opensource.apple.com/source/security_certtool/security_certtool-31828/src/CertTool.cpp
   // that serial_numbers being passed into CSSM_TP_SubmitCredRequest can't have
   // their high bit set. We will continue though and mask it out below.
   if (serial_number & 0x80000000)
     LOG(ERROR) << "serial_number has high bit set " << serial_number;
 
   // NSS is used to parse the subject string into a set of
   // CSSM_OID/string pairs. There doesn't appear to be a system routine for
   // parsing Distinguished Name strings.
-  base::EnsureNSSInit();
+  crypto::EnsureNSSInit();
 
   CSSMOIDStringVector subject_name_oids;
   ScopedCertName subject_name(
       CERT_AsciiToName(const_cast<char*>(subject.c_str())));
   if (!CERTNameToCSSMOIDVector(subject_name, &subject_name_oids)) {
     DLOG(ERROR) << "Unable to generate CSSMOIDMap from " << subject;
     return NULL;
   }
 
   // Convert the map of oid/string pairs into an array of
   // CSSM_APPLE_TP_NAME_OIDs.
   std::vector<CSSM_APPLE_TP_NAME_OID> cssm_subject_names;
   for(CSSMOIDStringVector::iterator iter = subject_name_oids.begin();
       iter != subject_name_oids.end(); ++iter) {
     CSSM_APPLE_TP_NAME_OID cssm_subject_name;
     cssm_subject_name.oid = iter->oid_;
     cssm_subject_name.string = iter->string_.c_str();
     cssm_subject_names.push_back(cssm_subject_name);
   }
 
   if (cssm_subject_names.empty()) {
     DLOG(ERROR) << "cssm_subject_names.size() == 0. Input: " << subject;
     return NULL;
   }
 
   // Set up a certificate request.
   CSSM_APPLE_TP_CERT_REQUEST certReq;
   memset(&certReq, 0, sizeof(certReq));
-  certReq.cspHand = base::GetSharedCSPHandle();
-  certReq.clHand = base::GetSharedCLHandle();
+  certReq.cspHand = crypto::GetSharedCSPHandle();
+  certReq.clHand = crypto::GetSharedCLHandle();
     // See comment about serial numbers above.
   certReq.serialNumber = serial_number & 0x7fffffff;
   certReq.numSubjectNames = cssm_subject_names.size();
   certReq.subjectNames = &cssm_subject_names[0];
   certReq.numIssuerNames = 0; // Root.
   certReq.issuerNames = NULL;
   certReq.issuerNameX509 = NULL;
   certReq.certPublicKey = key->public_key();
   certReq.issuerPrivateKey = key->key();
   // These are the Apple defaults.
@@ skipping 11 matching lines @@
 
   CSSM_FIELD policyId;
   memset(&policyId, 0, sizeof(policyId));
   policyId.FieldOid = CSSMOID_APPLE_TP_LOCAL_CERT_GEN;
 
   CSSM_TP_CALLERAUTH_CONTEXT callerAuthContext;
   memset(&callerAuthContext, 0, sizeof(callerAuthContext));
   callerAuthContext.Policy.NumberOfPolicyIds = 1;
   callerAuthContext.Policy.PolicyIds = &policyId;
 
-  CSSM_TP_HANDLE tp_handle = base::GetSharedTPHandle();
+  CSSM_TP_HANDLE tp_handle = crypto::GetSharedTPHandle();
   CSSM_DATA refId;
   memset(&refId, 0, sizeof(refId));
   sint32 estTime;
   CSSM_RETURN crtn = CSSM_TP_SubmitCredRequest(tp_handle, NULL,
       CSSM_TP_AUTHORITY_REQUEST_CERTISSUE, &reqSet, &callerAuthContext,
        &estTime, &refId);
   if(crtn) {
     DLOG(ERROR) << "CSSM_TP_SubmitCredRequest failed " << crtn;
     return NULL;
   }
 
   CSSM_BOOL confirmRequired;
   CSSM_TP_RESULT_SET *resultSet = NULL;
   crtn = CSSM_TP_RetrieveCredResult(tp_handle, &refId, NULL, &estTime,
                                     &confirmRequired, &resultSet);
   ScopedEncodedCertResults scopedResults(resultSet);
-  base::CSSMFree(refId.Data);
+  crypto::CSSMFree(refId.Data);
   if (crtn) {
     DLOG(ERROR) << "CSSM_TP_RetrieveCredResult failed " << crtn;
     return NULL;
   }
 
   if (confirmRequired) {
     // Potential leak here of resultSet. |confirmRequired| should never be
     // true.
     DLOG(ERROR) << "CSSM_TP_RetrieveCredResult required confirmation";
     return NULL;
@@ skipping 568 matching lines @@
       CFArrayAppendArray(chain,
                          cert_chain,
                          CFRangeMake(1, chain_count - 1));
     }
   }
 
   return chain.release();
 }
 
 }  // namespace net