Convert iOS to use X509CertificateBytes.

net/cert/cert_verify_proc_ios.cc

 // Copyright (c) 2016 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/cert/cert_verify_proc_ios.h"
 
 #include <CommonCrypto/CommonDigest.h>
 
 #include "base/logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "crypto/sha2.h"
 #include "net/base/net_errors.h"
 #include "net/cert/asn1_util.h"
 #include "net/cert/cert_verify_result.h"
 #include "net/cert/test_root_certs.h"
 #include "net/cert/x509_certificate.h"
+#include "net/cert/x509_util_ios.h"
+#include "net/cert/x509_util_ios_and_mac.h"
 #include "net/ssl/openssl_ssl_util.h"
 
 using base::ScopedCFTypeRef;
 
 namespace net {
 
 namespace {
 
 int NetErrorFromOSStatus(OSStatus status) {
   switch (status) {
@@ skipping 81 matching lines @@
   std::vector<SecCertificateRef> verified_chain;
   for (CFIndex i = 0, count = CFArrayGetCount(cert_chain); i < count; ++i) {
     SecCertificateRef chain_cert = reinterpret_cast<SecCertificateRef>(
         const_cast<void*>(CFArrayGetValueAtIndex(cert_chain, i)));
     if (i == 0) {
       verified_cert = chain_cert;
     } else {
       verified_chain.push_back(chain_cert);
     }
 
-    std::string der_bytes;
-    if (!X509Certificate::GetDEREncoded(chain_cert, &der_bytes)) {
+    base::ScopedCFTypeRef<CFDataRef> der_data(
+        SecCertificateCopyData(chain_cert));
+    if (!der_data) {
       verify_result->cert_status |= CERT_STATUS_INVALID;
       return;
     }
 
     base::StringPiece spki_bytes;
-    if (!asn1::ExtractSPKIFromDERCert(der_bytes, &spki_bytes)) {
+    if (!asn1::ExtractSPKIFromDERCert(
+            base::StringPiece(
+                reinterpret_cast<const char*>(CFDataGetBytePtr(der_data)),
+                CFDataGetLength(der_data)),
+            &spki_bytes)) {
       verify_result->cert_status |= CERT_STATUS_INVALID;
       return;
     }
 
     HashValue sha1(HASH_VALUE_SHA1);
     CC_SHA1(spki_bytes.data(), spki_bytes.size(), sha1.data());
     verify_result->public_key_hashes.push_back(sha1);
 
     HashValue sha256(HASH_VALUE_SHA256);
     CC_SHA256(spki_bytes.data(), spki_bytes.size(), sha256.data());
     verify_result->public_key_hashes.push_back(sha256);
 
     // Ignore the signature algorithm for the trust anchor.
     if ((verify_result->cert_status & CERT_STATUS_AUTHORITY_INVALID) == 0 &&
         i == count - 1) {
       continue;
     }
   }
   if (!verified_cert) {
     NOTREACHED();
     verify_result->cert_status |= CERT_STATUS_INVALID;
     return;
   }
 
   scoped_refptr<X509Certificate> verified_cert_with_chain =
-      X509Certificate::CreateFromHandle(verified_cert, verified_chain);
+      x509_util::CreateX509CertificateFromSecCertificate(verified_cert,
+                                                         verified_chain);
   if (verified_cert_with_chain)
     verify_result->verified_cert = std::move(verified_cert_with_chain);
   else
     verify_result->cert_status |= CERT_STATUS_INVALID;
 }
 
 }  // namespace
 
 CertVerifyProcIOS::CertVerifyProcIOS() {}
 
@@ skipping 79 matching lines @@
     int flags,
     CRLSet* crl_set,
     const CertificateList& additional_trust_anchors,
     CertVerifyResult* verify_result) {
   ScopedCFTypeRef<CFArrayRef> trust_policies;
   OSStatus status = CreateTrustPolicies(&trust_policies);
   if (status)
     return NetErrorFromOSStatus(status);
 
   ScopedCFTypeRef<CFMutableArrayRef> cert_array(
-      cert->CreateOSCertChainForCert());
+      x509_util::CreateSecCertificateArrayForX509Certificate(cert));
   ScopedCFTypeRef<SecTrustRef> trust_ref;
   SecTrustResultType trust_result = kSecTrustResultDeny;
   ScopedCFTypeRef<CFArrayRef> final_chain;
 
   status = BuildAndEvaluateSecTrustRef(cert_array, trust_policies, &trust_ref,
                                        &final_chain, &trust_result);
   if (status)
     return NetErrorFromOSStatus(status);
 
   if (CFArrayGetCount(final_chain) == 0)
@@ skipping 18 matching lines @@
   // roots.
   verify_result->is_issued_by_known_root = false;
 
   if (IsCertStatusError(verify_result->cert_status))
     return MapCertStatusToNetError(verify_result->cert_status);
 
   return OK;
 }
 
 }  // namespace net