1 // Copyright (c) 2012 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.
5 #include "crypto/ec_private_key.h"
7 #include <openssl/ec.h>
8 #include <openssl/evp.h>
9 #include <openssl/pkcs12.h>
10 #include <openssl/x509.h>
12 #include "base/logging.h"
13 #include "base/memory/scoped_ptr.h"
14 #include "crypto/openssl_util.h"
20 // Function pointer definition, for injecting the required key export function
21 // into ExportKeyWithBio, below. |bio| is a temporary memory BIO object, and
22 // |key| is a handle to the input key object. Return 1 on success, 0 otherwise.
23 // NOTE: Used with OpenSSL functions, which do not comply with the Chromium
24 // style guide, hence the unusual parameter placement / types.
25 typedef int (*ExportBioFunction
)(BIO
* bio
, const void* key
);
27 // Helper to export |key| into |output| via the specified ExportBioFunction.
28 bool ExportKeyWithBio(const void* key
,
29 ExportBioFunction export_fn
,
30 std::vector
<uint8
>* output
) {
34 ScopedOpenSSL
<BIO
, BIO_free_all
> bio(BIO_new(BIO_s_mem()));
38 if (!export_fn(bio
.get(), key
))
42 long len
= BIO_get_mem_data(bio
.get(), &data
);
46 output
->assign(data
, data
+ len
);
50 // Function pointer definition, for injecting the required key export function
51 // into ExportKey below. |key| is a pointer to the input key object,
52 // and |data| is either NULL, or the address of an 'unsigned char*' pointer
53 // that points to the start of the output buffer. The function must return
54 // the number of bytes required to export the data, or -1 in case of error.
55 typedef int (*ExportDataFunction
)(const void* key
, unsigned char** data
);
57 // Helper to export |key| into |output| via the specified export function.
58 bool ExportKey(const void* key
,
59 ExportDataFunction export_fn
,
60 std::vector
<uint8
>* output
) {
64 int data_len
= export_fn(key
, NULL
);
68 output
->resize(static_cast<size_t>(data_len
));
69 unsigned char* data
= &(*output
)[0];
70 if (export_fn(key
, &data
) < 0)
78 ECPrivateKey::~ECPrivateKey() {
84 bool ECPrivateKey::IsSupported() { return true; }
87 ECPrivateKey
* ECPrivateKey::Create() {
88 OpenSSLErrStackTracer
err_tracer(FROM_HERE
);
90 ScopedOpenSSL
<EC_KEY
, EC_KEY_free
> ec_key(
91 EC_KEY_new_by_curve_name(NID_X9_62_prime256v1
));
92 if (!ec_key
.get() || !EC_KEY_generate_key(ec_key
.get()))
95 scoped_ptr
<ECPrivateKey
> result(new ECPrivateKey());
96 result
->key_
= EVP_PKEY_new();
97 if (!result
->key_
|| !EVP_PKEY_set1_EC_KEY(result
->key_
, ec_key
.get()))
100 return result
.release();
104 ECPrivateKey
* ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
105 const std::string
& password
,
106 const std::vector
<uint8
>& encrypted_private_key_info
,
107 const std::vector
<uint8
>& subject_public_key_info
) {
108 // NOTE: The |subject_public_key_info| can be ignored here, it is only
109 // useful for the NSS implementation (which uses the public key's SHA1
110 // as a lookup key when storing the private one in its store).
111 if (encrypted_private_key_info
.empty())
114 OpenSSLErrStackTracer
err_tracer(FROM_HERE
);
115 // Write the encrypted private key into a memory BIO.
116 char* private_key_data
= reinterpret_cast<char*>(
117 const_cast<uint8
*>(&encrypted_private_key_info
[0]));
118 int private_key_data_len
=
119 static_cast<int>(encrypted_private_key_info
.size());
120 ScopedOpenSSL
<BIO
, BIO_free_all
> bio(
121 BIO_new_mem_buf(private_key_data
, private_key_data_len
));
125 // Convert it, then decrypt it into a PKCS#8 object.
126 ScopedOpenSSL
<X509_SIG
, X509_SIG_free
> p8_encrypted(
127 d2i_PKCS8_bio(bio
.get(), NULL
));
128 if (!p8_encrypted
.get())
131 ScopedOpenSSL
<PKCS8_PRIV_KEY_INFO
, PKCS8_PRIV_KEY_INFO_free
> p8_decrypted(
132 PKCS8_decrypt(p8_encrypted
.get(),
134 static_cast<int>(password
.size())));
135 if (!p8_decrypted
.get() && password
.empty()) {
136 // Hack for reading keys generated by ec_private_key_nss. Passing NULL
137 // causes OpenSSL to use an empty password instead of "\0\0".
138 p8_decrypted
.reset(PKCS8_decrypt(p8_encrypted
.get(), NULL
, 0));
140 if (!p8_decrypted
.get())
143 // Create a new EVP_PKEY for it.
144 scoped_ptr
<ECPrivateKey
> result(new ECPrivateKey
);
145 result
->key_
= EVP_PKCS82PKEY(p8_decrypted
.get());
149 return result
.release();
152 bool ECPrivateKey::ExportEncryptedPrivateKey(
153 const std::string
& password
,
155 std::vector
<uint8
>* output
) {
156 OpenSSLErrStackTracer
err_tracer(FROM_HERE
);
157 // Convert into a PKCS#8 object.
158 ScopedOpenSSL
<PKCS8_PRIV_KEY_INFO
, PKCS8_PRIV_KEY_INFO_free
> pkcs8(
159 EVP_PKEY2PKCS8(key_
));
163 // Encrypt the object.
164 // NOTE: NSS uses SEC_OID_PKCS12_V2_PBE_WITH_SHA1_AND_3KEY_TRIPLE_DES_CBC
165 // so use NID_pbe_WithSHA1And3_Key_TripleDES_CBC which should be the OpenSSL
167 ScopedOpenSSL
<X509_SIG
, X509_SIG_free
> encrypted(
168 PKCS8_encrypt(NID_pbe_WithSHA1And3_Key_TripleDES_CBC
,
171 static_cast<int>(password
.size()),
176 if (!encrypted
.get())
179 // Write it into |*output|
180 return ExportKeyWithBio(encrypted
.get(),
181 reinterpret_cast<ExportBioFunction
>(i2d_PKCS8_bio
),
185 bool ECPrivateKey::ExportPublicKey(std::vector
<uint8
>* output
) {
186 OpenSSLErrStackTracer
err_tracer(FROM_HERE
);
187 return ExportKeyWithBio(
188 key_
, reinterpret_cast<ExportBioFunction
>(i2d_PUBKEY_bio
), output
);
191 bool ECPrivateKey::ExportValue(std::vector
<uint8
>* output
) {
192 OpenSSLErrStackTracer
err_tracer(FROM_HERE
);
193 ScopedOpenSSL
<EC_KEY
, EC_KEY_free
> ec_key(EVP_PKEY_get1_EC_KEY(key_
));
194 return ExportKey(ec_key
.get(),
195 reinterpret_cast<ExportDataFunction
>(i2d_ECPrivateKey
),
199 bool ECPrivateKey::ExportECParams(std::vector
<uint8
>* output
) {
200 OpenSSLErrStackTracer
err_tracer(FROM_HERE
);
201 ScopedOpenSSL
<EC_KEY
, EC_KEY_free
> ec_key(EVP_PKEY_get1_EC_KEY(key_
));
202 return ExportKey(ec_key
.get(),
203 reinterpret_cast<ExportDataFunction
>(i2d_ECParameters
),
207 ECPrivateKey::ECPrivateKey() : key_(NULL
) {}
209 } // namespace crypto