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#ifndef CRYPTO_RSA_PRIVATE_KEY_H_
6#define CRYPTO_RSA_PRIVATE_KEY_H_
7#pragma once
8
9#include "build/build_config.h"
10
11#if defined(USE_OPENSSL)
12// Forward declaration for openssl/*.h
13typedef struct evp_pkey_st EVP_PKEY;
14#elif defined(USE_NSS)
15// Forward declaration.
16struct SECKEYPrivateKeyStr;
17struct SECKEYPublicKeyStr;
18#elif defined(OS_MACOSX)
19#include <Security/cssm.h>
20#endif
21
22#include <list>
23#include <vector>
24
25#include "base/basictypes.h"
26
27#if defined(OS_WIN)
28#include "crypto/scoped_capi_types.h"
29#endif
30#if defined(USE_NSS)
31#include "base/gtest_prod_util.h"
32#endif
33
34namespace crypto {
35
36// Used internally by RSAPrivateKey for serializing and deserializing
37// PKCS #8 PrivateKeyInfo and PublicKeyInfo.
38class PrivateKeyInfoCodec {
39 public:
40
41  // ASN.1 encoding of the AlgorithmIdentifier from PKCS #8.
42  static const uint8 kRsaAlgorithmIdentifier[];
43
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;
50
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);
56
57  ~PrivateKeyInfoCodec();
58
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);
62
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);
66
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);
70
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);
76
77  // Accessors to the contents of the integer components of the PrivateKeyInfo
78  // structure.
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_; };
87
88 private:
89  // Utility wrappers for PrependIntegerImpl that use the class's |big_endian_|
90  // value.
91  void PrependInteger(const std::vector<uint8>& in, std::list<uint8>* out);
92  void PrependInteger(uint8* val, int num_bytes, std::list<uint8>* data);
93
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,
97                          int num_bytes,
98                          std::list<uint8>* data,
99                          bool big_endian);
100
101  // Utility wrappers for ReadIntegerImpl that use the class's |big_endian_|
102  // value.
103  bool ReadInteger(uint8** pos, uint8* end, std::vector<uint8>* out);
104  bool ReadIntegerWithExpectedSize(uint8** pos,
105                                   uint8* end,
106                                   size_t expected_size,
107                                   std::vector<uint8>* out);
108
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,
112                       uint8* end,
113                       std::vector<uint8>* out,
114                       bool big_endian);
115
116  // Prepends the integer stored in |val|, starting a index |start|, for
117  // |num_bytes| bytes onto |data|.
118  void PrependBytes(uint8* val,
119                    int start,
120                    int num_bytes,
121                    std::list<uint8>* data);
122
123  // Helper to prepend an ASN.1 length field.
124  void PrependLength(size_t size, std::list<uint8>* data);
125
126  // Helper to prepend an ASN.1 type header.
127  void PrependTypeHeaderAndLength(uint8 type,
128                                  uint32 length,
129                                  std::list<uint8>* output);
130
131  // Helper to prepend an ASN.1 bit string
132  void PrependBitString(uint8* val, int num_bytes, std::list<uint8>* output);
133
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);
137
138  // Read an ASN.1 type header and its length.
139  bool ReadTypeHeaderAndLength(uint8** pos,
140                               uint8* end,
141                               uint8 expected_tag,
142                               uint32* length);
143
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);
147
148  // Read the RSA AlgorithmIdentifier.
149  bool ReadAlgorithmIdentifier(uint8** pos, uint8* end);
150
151  // Read one of the two version fields in PrivateKeyInfo.
152  bool ReadVersion(uint8** pos, uint8* end);
153
154  // The byte-significance of the stored components (modulus, etc..).
155  bool big_endian_;
156
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_;
166
167  DISALLOW_COPY_AND_ASSIGN(PrivateKeyInfoCodec);
168};
169
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.
173class RSAPrivateKey {
174 public:
175  ~RSAPrivateKey();
176
177  // Create a new random instance. Can return NULL if initialization fails.
178  static RSAPrivateKey* Create(uint16 num_bits);
179
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.
182  //
183  // NOTE: Currently only available if USE_NSS is defined.
184  static RSAPrivateKey* CreateSensitive(uint16 num_bits);
185
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);
191
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.
196  //
197  // NOTE: Currently only available if USE_NSS is defined.
198  static RSAPrivateKey* CreateSensitiveFromPrivateKeyInfo(
199      const std::vector<uint8>& input);
200
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.
207  //
208  // NOTE: Currently only available if USE_NSS is defined.
209  static RSAPrivateKey* FindFromPublicKeyInfo(
210      const std::vector<uint8>& input);
211
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_; }
223#endif
224
225  // Exports the private key to a PKCS #1 PrivateKey block.
226  bool ExportPrivateKey(std::vector<uint8>* output);
227
228  // Exports the public key to an X509 SubjectPublicKeyInfo block.
229  bool ExportPublicKey(std::vector<uint8>* output);
230
231 private:
232#if defined(USE_NSS)
233  FRIEND_TEST_ALL_PREFIXES(RSAPrivateKeyNSSTest, FindFromPublicKey);
234  FRIEND_TEST_ALL_PREFIXES(RSAPrivateKeyNSSTest, FailedFindFromPublicKey);
235#endif
236
237  // Constructor is private. Use one of the Create*() or Find*()
238  // methods above instead.
239  RSAPrivateKey();
240
241  // Shared helper for Create() and CreateSensitive().
242  // TODO(cmasone): consider replacing |permanent| and |sensitive| with a
243  //                flags arg created by ORing together some enumerated values.
244  static RSAPrivateKey* CreateWithParams(uint16 num_bits,
245                                         bool permanent,
246                                         bool sensitive);
247
248  // Shared helper for CreateFromPrivateKeyInfo() and
249  // CreateSensitiveFromPrivateKeyInfo().
250  static RSAPrivateKey* CreateFromPrivateKeyInfoWithParams(
251      const std::vector<uint8>& input, bool permanent, bool sensitive);
252
253#if defined(USE_OPENSSL)
254  EVP_PKEY* key_;
255#elif defined(USE_NSS)
256  SECKEYPrivateKeyStr* key_;
257  SECKEYPublicKeyStr* public_key_;
258#elif defined(OS_WIN)
259  bool InitProvider();
260
261  ScopedHCRYPTPROV provider_;
262  ScopedHCRYPTKEY key_;
263#elif defined(OS_MACOSX)
264  CSSM_KEY key_;
265  CSSM_KEY public_key_;
266#endif
267
268  DISALLOW_COPY_AND_ASSIGN(RSAPrivateKey);
269};
270
271}  // namespace crypto
272
273#endif  // CRYPTO_RSA_PRIVATE_KEY_H_
274