x509_certificate_model_openssl: implement ProcessSubjectPublicKeyInfo

chrome/common/net/x509_certificate_model_openssl.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 "chrome/common/net/x509_certificate_model.h"
 
 #include <openssl/bio.h>
 #include <openssl/obj_mac.h>
 #include <openssl/sha.h>
 #include <openssl/x509v3.h>
@@ skipping 27 matching lines @@
     return std::string();
 
   scoped_ptr<unsigned char[]> buf(new unsigned char[len]);
   unsigned char* bufp = buf.get();
 
   len = i2d_ASN1_TYPE(data, &bufp);
 
   return ProcessRawBytes(buf.get(), len);
 }
 
+std::string ProcessRawBignum(BIGNUM* n) {
+  int len = BN_num_bytes(n);
+  scoped_ptr<unsigned char[]> buf(new unsigned char[len]);
+  BN_bn2bin(n, buf.get());

[Ryan Sleevi, 2014/07/07 19:53:42]

nit: A bit of a code-smell to ignore a result. Though the implementation always
returns BN_num_bytes, it's not guaranteed by the API contract (just implied)

[mattm, 2014/07/07 21:32:55]

Done.

+  return ProcessRawBytes(buf.get(), len);
+}
+
 std::string Asn1StringToUTF8(ASN1_STRING* asn1_string) {
   std::string rv;
   unsigned char* buf = NULL;
   int len = ASN1_STRING_to_UTF8(&buf, asn1_string);
   if (len < 0)
     return rv;
   rv = std::string(reinterpret_cast<const char*>(buf), len);
   OPENSSL_free(buf);
   return rv;
 }
@@ skipping 1119 matching lines @@
       X509_get_X509_PUBKEY(cert_handle)->algor->algorithm);
 }
 
 std::string ProcessSecAlgorithmSignatureWrap(
     net::X509Certificate::OSCertHandle cert_handle) {
   return Asn1ObjectToString(cert_handle->sig_alg->algorithm);
 }
 
 std::string ProcessSubjectPublicKeyInfo(
     net::X509Certificate::OSCertHandle cert_handle) {
-  // TODO(bulach): implement me.
-  return "";
+  std::string rv;
+  crypto::ScopedOpenSSL<EVP_PKEY, EVP_PKEY_free> public_key(
+      X509_get_pubkey(cert_handle));
+  if (!public_key.get())
+    return rv;
+  switch (EVP_PKEY_type(public_key.get()->type)) {
+    case EVP_PKEY_RSA: {
+      crypto::ScopedOpenSSL<RSA, RSA_free> rsa_key(
+          EVP_PKEY_get1_RSA(public_key.get()));
+      if (!rsa_key.get())
+        return rv;
+      rv = l10n_util::GetStringFUTF8(
+          IDS_CERT_RSA_PUBLIC_KEY_DUMP_FORMAT,
+          base::UintToString16(BN_num_bits(rsa_key.get()->n)),
+          base::UTF8ToUTF16(ProcessRawBignum(rsa_key.get()->n)),
+          base::UintToString16(BN_num_bits(rsa_key.get()->e)),
+          base::UTF8ToUTF16(ProcessRawBignum(rsa_key.get()->e)));
+      return rv;
+    }
+    default:
+      rv = ProcessRawAsn1String(X509_get_X509_PUBKEY(cert_handle)->public_key);
+      return rv;
+  }
 }
 
 std::string ProcessRawBitsSignatureWrap(
     net::X509Certificate::OSCertHandle cert_handle) {
   // TODO(bulach): implement me.
   return "";
 }
 
 }  // namespace x509_certificate_model