| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 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 "crypto/rsa_private_key.h" | |
| 6 | |
| 7 #include <openssl/bio.h> | |
| 8 #include <openssl/bn.h> | |
| 9 #include <openssl/evp.h> | |
| 10 #include <openssl/pkcs12.h> | |
| 11 #include <openssl/rsa.h> | |
| 12 | |
| 13 #include "base/logging.h" | |
| 14 #include "base/memory/scoped_ptr.h" | |
| 15 #include "crypto/openssl_util.h" | |
| 16 #include "crypto/scoped_openssl_types.h" | |
| 17 | |
| 18 namespace crypto { | |
| 19 | |
| 20 namespace { | |
| 21 | |
| 22 typedef ScopedOpenSSL<PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_free>::Type | |
| 23 ScopedPKCS8_PRIV_KEY_INFO; | |
| 24 | |
| 25 // Function pointer definition, for injecting the required key export function | |
| 26 // into ExportKey, below. The supplied function should export EVP_PKEY into | |
| 27 // the supplied BIO, returning 1 on success or 0 on failure. | |
| 28 typedef int (ExportFunction)(BIO*, EVP_PKEY*); | |
| 29 | |
| 30 // Helper to export |key| into |output| via the specified ExportFunction. | |
| 31 bool ExportKey(EVP_PKEY* key, | |
| 32 ExportFunction export_fn, | |
| 33 std::vector<uint8>* output) { | |
| 34 if (!key) | |
| 35 return false; | |
| 36 | |
| 37 OpenSSLErrStackTracer err_tracer(FROM_HERE); | |
| 38 ScopedBIO bio(BIO_new(BIO_s_mem())); | |
| 39 | |
| 40 int res = export_fn(bio.get(), key); | |
| 41 if (!res) | |
| 42 return false; | |
| 43 | |
| 44 char* data = NULL; | |
| 45 long len = BIO_get_mem_data(bio.get(), &data); | |
| 46 if (!data || len < 0) | |
| 47 return false; | |
| 48 | |
| 49 output->assign(data, data + len); | |
| 50 return true; | |
| 51 } | |
| 52 | |
| 53 } // namespace | |
| 54 | |
| 55 // static | |
| 56 RSAPrivateKey* RSAPrivateKey::Create(uint16 num_bits) { | |
| 57 OpenSSLErrStackTracer err_tracer(FROM_HERE); | |
| 58 | |
| 59 ScopedRSA rsa_key(RSA_new()); | |
| 60 ScopedBIGNUM bn(BN_new()); | |
| 61 if (!rsa_key.get() || !bn.get() || !BN_set_word(bn.get(), 65537L)) | |
| 62 return NULL; | |
| 63 | |
| 64 if (!RSA_generate_key_ex(rsa_key.get(), num_bits, bn.get(), NULL)) | |
| 65 return NULL; | |
| 66 | |
| 67 scoped_ptr<RSAPrivateKey> result(new RSAPrivateKey); | |
| 68 result->key_ = EVP_PKEY_new(); | |
| 69 if (!result->key_ || !EVP_PKEY_set1_RSA(result->key_, rsa_key.get())) | |
| 70 return NULL; | |
| 71 | |
| 72 return result.release(); | |
| 73 } | |
| 74 | |
| 75 // static | |
| 76 RSAPrivateKey* RSAPrivateKey::CreateFromPrivateKeyInfo( | |
| 77 const std::vector<uint8>& input) { | |
| 78 if (input.empty()) | |
| 79 return NULL; | |
| 80 | |
| 81 OpenSSLErrStackTracer err_tracer(FROM_HERE); | |
| 82 | |
| 83 // Importing is a little more involved than exporting, as we must first | |
| 84 // PKCS#8 decode the input, and then import the EVP_PKEY from Private Key | |
| 85 // Info structure returned. | |
| 86 const uint8_t* ptr = &input[0]; | |
| 87 ScopedPKCS8_PRIV_KEY_INFO p8inf( | |
| 88 d2i_PKCS8_PRIV_KEY_INFO(nullptr, &ptr, input.size())); | |
| 89 if (!p8inf.get() || ptr != &input[0] + input.size()) | |
| 90 return NULL; | |
| 91 | |
| 92 scoped_ptr<RSAPrivateKey> result(new RSAPrivateKey); | |
| 93 result->key_ = EVP_PKCS82PKEY(p8inf.get()); | |
| 94 if (!result->key_ || EVP_PKEY_id(result->key_) != EVP_PKEY_RSA) | |
| 95 return NULL; | |
| 96 | |
| 97 return result.release(); | |
| 98 } | |
| 99 | |
| 100 // static | |
| 101 RSAPrivateKey* RSAPrivateKey::CreateFromKey(EVP_PKEY* key) { | |
| 102 DCHECK(key); | |
| 103 if (EVP_PKEY_type(key->type) != EVP_PKEY_RSA) | |
| 104 return NULL; | |
| 105 RSAPrivateKey* copy = new RSAPrivateKey(); | |
| 106 copy->key_ = EVP_PKEY_dup(key); | |
| 107 return copy; | |
| 108 } | |
| 109 | |
| 110 RSAPrivateKey::RSAPrivateKey() | |
| 111 : key_(NULL) { | |
| 112 } | |
| 113 | |
| 114 RSAPrivateKey::~RSAPrivateKey() { | |
| 115 if (key_) | |
| 116 EVP_PKEY_free(key_); | |
| 117 } | |
| 118 | |
| 119 RSAPrivateKey* RSAPrivateKey::Copy() const { | |
| 120 scoped_ptr<RSAPrivateKey> copy(new RSAPrivateKey()); | |
| 121 ScopedRSA rsa(EVP_PKEY_get1_RSA(key_)); | |
| 122 if (!rsa) | |
| 123 return NULL; | |
| 124 copy->key_ = EVP_PKEY_new(); | |
| 125 if (!EVP_PKEY_set1_RSA(copy->key_, rsa.get())) | |
| 126 return NULL; | |
| 127 return copy.release(); | |
| 128 } | |
| 129 | |
| 130 bool RSAPrivateKey::ExportPrivateKey(std::vector<uint8>* output) const { | |
| 131 return ExportKey(key_, i2d_PKCS8PrivateKeyInfo_bio, output); | |
| 132 } | |
| 133 | |
| 134 bool RSAPrivateKey::ExportPublicKey(std::vector<uint8>* output) const { | |
| 135 return ExportKey(key_, i2d_PUBKEY_bio, output); | |
| 136 } | |
| 137 | |
| 138 } // namespace crypto | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 956613002:
Reland "Cut down /crypto and switch what is left of it to boringssl". (Closed)
Base URL: git@github.com:domokit/mojo.git@master