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 #ifndef CRYPTO_RSA_PRIVATE_KEY_H_
6 #define CRYPTO_RSA_PRIVATE_KEY_H_
8 #include "build/build_config.h"
10 #if defined(USE_OPENSSL)
11 // Forward declaration for openssl/*.h
12 typedef struct evp_pkey_st EVP_PKEY
;
13 #elif defined(USE_NSS)
14 // Forward declaration.
15 struct SECKEYPrivateKeyStr
;
16 struct SECKEYPublicKeyStr
;
17 #elif defined(OS_MACOSX)
18 #include <Security/cssm.h>
24 #include "base/basictypes.h"
25 #include "crypto/crypto_export.h"
28 #include "crypto/scoped_capi_types.h"
31 #include "base/gtest_prod_util.h"
36 // Used internally by RSAPrivateKey for serializing and deserializing
37 // PKCS #8 PrivateKeyInfo and PublicKeyInfo.
38 class PrivateKeyInfoCodec
{
41 // ASN.1 encoding of the AlgorithmIdentifier from PKCS #8.
42 static const uint8 kRsaAlgorithmIdentifier
[];
44 // ASN.1 tags for some types we use.
45 static const uint8 kBitStringTag
= 0x03;
46 static const uint8 kIntegerTag
= 0x02;
47 static const uint8 kNullTag
= 0x05;
48 static const uint8 kOctetStringTag
= 0x04;
49 static const uint8 kSequenceTag
= 0x30;
51 // |big_endian| here specifies the byte-significance of the integer components
52 // that will be parsed & serialized (modulus(), etc...) during Import(),
53 // Export() and ExportPublicKeyInfo() -- not the ASN.1 DER encoding of the
54 // PrivateKeyInfo/PublicKeyInfo (which is always big-endian).
55 explicit PrivateKeyInfoCodec(bool big_endian
);
57 ~PrivateKeyInfoCodec();
59 // Exports the contents of the integer components to the ASN.1 DER encoding
60 // of the PrivateKeyInfo structure to |output|.
61 bool Export(std::vector
<uint8
>* output
);
63 // Exports the contents of the integer components to the ASN.1 DER encoding
64 // of the PublicKeyInfo structure to |output|.
65 bool ExportPublicKeyInfo(std::vector
<uint8
>* output
);
67 // Exports the contents of the integer components to the ASN.1 DER encoding
68 // of the RSAPublicKey structure to |output|.
69 bool ExportPublicKey(std::vector
<uint8
>* output
);
71 // Parses the ASN.1 DER encoding of the PrivateKeyInfo structure in |input|
72 // and populates the integer components with |big_endian_| byte-significance.
73 // IMPORTANT NOTE: This is currently *not* security-approved for importing
74 // keys from unstrusted sources.
75 bool Import(const std::vector
<uint8
>& input
);
77 // Accessors to the contents of the integer components of the PrivateKeyInfo
79 std::vector
<uint8
>* modulus() { return &modulus_
; };
80 std::vector
<uint8
>* public_exponent() { return &public_exponent_
; };
81 std::vector
<uint8
>* private_exponent() { return &private_exponent_
; };
82 std::vector
<uint8
>* prime1() { return &prime1_
; };
83 std::vector
<uint8
>* prime2() { return &prime2_
; };
84 std::vector
<uint8
>* exponent1() { return &exponent1_
; };
85 std::vector
<uint8
>* exponent2() { return &exponent2_
; };
86 std::vector
<uint8
>* coefficient() { return &coefficient_
; };
89 // Utility wrappers for PrependIntegerImpl that use the class's |big_endian_|
91 void PrependInteger(const std::vector
<uint8
>& in
, std::list
<uint8
>* out
);
92 void PrependInteger(uint8
* val
, int num_bytes
, std::list
<uint8
>* data
);
94 // Prepends the integer stored in |val| - |val + num_bytes| with |big_endian|
95 // byte-significance into |data| as an ASN.1 integer.
96 void PrependIntegerImpl(uint8
* val
,
98 std::list
<uint8
>* data
,
101 // Utility wrappers for ReadIntegerImpl that use the class's |big_endian_|
103 bool ReadInteger(uint8
** pos
, uint8
* end
, std::vector
<uint8
>* out
);
104 bool ReadIntegerWithExpectedSize(uint8
** pos
,
106 size_t expected_size
,
107 std::vector
<uint8
>* out
);
109 // Reads an ASN.1 integer from |pos|, and stores the result into |out| with
110 // |big_endian| byte-significance.
111 bool ReadIntegerImpl(uint8
** pos
,
113 std::vector
<uint8
>* out
,
116 // Prepends the integer stored in |val|, starting a index |start|, for
117 // |num_bytes| bytes onto |data|.
118 void PrependBytes(uint8
* val
,
121 std::list
<uint8
>* data
);
123 // Helper to prepend an ASN.1 length field.
124 void PrependLength(size_t size
, std::list
<uint8
>* data
);
126 // Helper to prepend an ASN.1 type header.
127 void PrependTypeHeaderAndLength(uint8 type
,
129 std::list
<uint8
>* output
);
131 // Helper to prepend an ASN.1 bit string
132 void PrependBitString(uint8
* val
, int num_bytes
, std::list
<uint8
>* output
);
134 // Read an ASN.1 length field. This also checks that the length does not
135 // extend beyond |end|.
136 bool ReadLength(uint8
** pos
, uint8
* end
, uint32
* result
);
138 // Read an ASN.1 type header and its length.
139 bool ReadTypeHeaderAndLength(uint8
** pos
,
144 // Read an ASN.1 sequence declaration. This consumes the type header and
145 // length field, but not the contents of the sequence.
146 bool ReadSequence(uint8
** pos
, uint8
* end
);
148 // Read the RSA AlgorithmIdentifier.
149 bool ReadAlgorithmIdentifier(uint8
** pos
, uint8
* end
);
151 // Read one of the two version fields in PrivateKeyInfo.
152 bool ReadVersion(uint8
** pos
, uint8
* end
);
154 // The byte-significance of the stored components (modulus, etc..).
157 // Component integers of the PrivateKeyInfo
158 std::vector
<uint8
> modulus_
;
159 std::vector
<uint8
> public_exponent_
;
160 std::vector
<uint8
> private_exponent_
;
161 std::vector
<uint8
> prime1_
;
162 std::vector
<uint8
> prime2_
;
163 std::vector
<uint8
> exponent1_
;
164 std::vector
<uint8
> exponent2_
;
165 std::vector
<uint8
> coefficient_
;
167 DISALLOW_COPY_AND_ASSIGN(PrivateKeyInfoCodec
);
170 // Encapsulates an RSA private key. Can be used to generate new keys, export
171 // keys to other formats, or to extract a public key.
172 // TODO(hclam): This class should be ref-counted so it can be reused easily.
173 class CRYPTO_EXPORT RSAPrivateKey
{
177 // Create a new random instance. Can return NULL if initialization fails.
178 static RSAPrivateKey
* Create(uint16 num_bits
);
180 // Create a new random instance. Can return NULL if initialization fails.
181 // The created key is permanent and is not exportable in plaintext form.
183 // NOTE: Currently only available if USE_NSS is defined.
184 static RSAPrivateKey
* CreateSensitive(uint16 num_bits
);
186 // Create a new instance by importing an existing private key. The format is
187 // an ASN.1-encoded PrivateKeyInfo block from PKCS #8. This can return NULL if
188 // initialization fails.
189 static RSAPrivateKey
* CreateFromPrivateKeyInfo(
190 const std::vector
<uint8
>& input
);
192 // Create a new instance by importing an existing private key. The format is
193 // an ASN.1-encoded PrivateKeyInfo block from PKCS #8. This can return NULL if
194 // initialization fails.
195 // The created key is permanent and is not exportable in plaintext form.
197 // NOTE: Currently only available if USE_NSS is defined.
198 static RSAPrivateKey
* CreateSensitiveFromPrivateKeyInfo(
199 const std::vector
<uint8
>& input
);
201 // Import an existing public key, and then search for the private
202 // half in the key database. The format of the public key blob is is
203 // an X509 SubjectPublicKeyInfo block. This can return NULL if
204 // initialization fails or the private key cannot be found. The
205 // caller takes ownership of the returned object, but nothing new is
206 // created in the key database.
208 // NOTE: Currently only available if USE_NSS is defined.
209 static RSAPrivateKey
* FindFromPublicKeyInfo(
210 const std::vector
<uint8
>& input
);
212 #if defined(USE_OPENSSL)
213 EVP_PKEY
* key() { return key_
; }
214 #elif defined(USE_NSS)
215 SECKEYPrivateKeyStr
* key() { return key_
; }
216 SECKEYPublicKeyStr
* public_key() { return public_key_
; }
217 #elif defined(OS_WIN)
218 HCRYPTPROV
provider() { return provider_
; }
219 HCRYPTKEY
key() { return key_
; }
220 #elif defined(OS_MACOSX)
221 CSSM_KEY_PTR
key() { return &key_
; }
222 CSSM_KEY_PTR
public_key() { return &public_key_
; }
225 // Creates a copy of the object.
226 RSAPrivateKey
* Copy() const;
228 // Exports the private key to a PKCS #1 PrivateKey block.
229 bool ExportPrivateKey(std::vector
<uint8
>* output
) const;
231 // Exports the public key to an X509 SubjectPublicKeyInfo block.
232 bool ExportPublicKey(std::vector
<uint8
>* output
) const;
236 FRIEND_TEST_ALL_PREFIXES(RSAPrivateKeyNSSTest
, FindFromPublicKey
);
237 FRIEND_TEST_ALL_PREFIXES(RSAPrivateKeyNSSTest
, FailedFindFromPublicKey
);
240 // Constructor is private. Use one of the Create*() or Find*()
241 // methods above instead.
244 // Shared helper for Create() and CreateSensitive().
245 // TODO(cmasone): consider replacing |permanent| and |sensitive| with a
246 // flags arg created by ORing together some enumerated values.
247 static RSAPrivateKey
* CreateWithParams(uint16 num_bits
,
251 // Shared helper for CreateFromPrivateKeyInfo() and
252 // CreateSensitiveFromPrivateKeyInfo().
253 static RSAPrivateKey
* CreateFromPrivateKeyInfoWithParams(
254 const std::vector
<uint8
>& input
, bool permanent
, bool sensitive
);
256 #if defined(USE_OPENSSL)
258 #elif defined(USE_NSS)
259 SECKEYPrivateKeyStr
* key_
;
260 SECKEYPublicKeyStr
* public_key_
;
261 #elif defined(OS_WIN)
264 ScopedHCRYPTPROV provider_
;
265 ScopedHCRYPTKEY key_
;
266 #elif defined(OS_MACOSX)
268 CSSM_KEY public_key_
;
271 DISALLOW_COPY_AND_ASSIGN(RSAPrivateKey
);
274 } // namespace crypto
276 #endif // CRYPTO_RSA_PRIVATE_KEY_H_