1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
|
// Copyright (c) 2012 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.
#ifndef CRYPTO_RSA_PRIVATE_KEY_H_
#define CRYPTO_RSA_PRIVATE_KEY_H_
#include <list>
#include <vector>
#include "base/basictypes.h"
#include "build/build_config.h"
#include "crypto/crypto_export.h"
#if defined(USE_OPENSSL)
// Forward declaration for openssl/*.h
typedef struct evp_pkey_st EVP_PKEY;
#else
// Forward declaration.
typedef struct PK11SlotInfoStr PK11SlotInfo;
typedef struct SECKEYPrivateKeyStr SECKEYPrivateKey;
typedef struct SECKEYPublicKeyStr SECKEYPublicKey;
#endif
namespace crypto {
// Used internally by RSAPrivateKey for serializing and deserializing
// PKCS #8 PrivateKeyInfo and PublicKeyInfo.
class PrivateKeyInfoCodec {
public:
// ASN.1 encoding of the AlgorithmIdentifier from PKCS #8.
static const uint8 kRsaAlgorithmIdentifier[];
// ASN.1 tags for some types we use.
static const uint8 kBitStringTag = 0x03;
static const uint8 kIntegerTag = 0x02;
static const uint8 kNullTag = 0x05;
static const uint8 kOctetStringTag = 0x04;
static const uint8 kSequenceTag = 0x30;
// |big_endian| here specifies the byte-significance of the integer components
// that will be parsed & serialized (modulus(), etc...) during Import(),
// Export() and ExportPublicKeyInfo() -- not the ASN.1 DER encoding of the
// PrivateKeyInfo/PublicKeyInfo (which is always big-endian).
explicit PrivateKeyInfoCodec(bool big_endian);
~PrivateKeyInfoCodec();
// Exports the contents of the integer components to the ASN.1 DER encoding
// of the PrivateKeyInfo structure to |output|.
bool Export(std::vector<uint8>* output);
// Exports the contents of the integer components to the ASN.1 DER encoding
// of the PublicKeyInfo structure to |output|.
bool ExportPublicKeyInfo(std::vector<uint8>* output);
// Exports the contents of the integer components to the ASN.1 DER encoding
// of the RSAPublicKey structure to |output|.
bool ExportPublicKey(std::vector<uint8>* output);
// Parses the ASN.1 DER encoding of the PrivateKeyInfo structure in |input|
// and populates the integer components with |big_endian_| byte-significance.
// IMPORTANT NOTE: This is currently *not* security-approved for importing
// keys from unstrusted sources.
bool Import(const std::vector<uint8>& input);
// Accessors to the contents of the integer components of the PrivateKeyInfo
// structure.
std::vector<uint8>* modulus() { return &modulus_; }
std::vector<uint8>* public_exponent() { return &public_exponent_; }
std::vector<uint8>* private_exponent() { return &private_exponent_; }
std::vector<uint8>* prime1() { return &prime1_; }
std::vector<uint8>* prime2() { return &prime2_; }
std::vector<uint8>* exponent1() { return &exponent1_; }
std::vector<uint8>* exponent2() { return &exponent2_; }
std::vector<uint8>* coefficient() { return &coefficient_; }
private:
// Utility wrappers for PrependIntegerImpl that use the class's |big_endian_|
// value.
void PrependInteger(const std::vector<uint8>& in, std::list<uint8>* out);
void PrependInteger(uint8* val, int num_bytes, std::list<uint8>* data);
// Prepends the integer stored in |val| - |val + num_bytes| with |big_endian|
// byte-significance into |data| as an ASN.1 integer.
void PrependIntegerImpl(uint8* val,
int num_bytes,
std::list<uint8>* data,
bool big_endian);
// Utility wrappers for ReadIntegerImpl that use the class's |big_endian_|
// value.
bool ReadInteger(uint8** pos, uint8* end, std::vector<uint8>* out);
bool ReadIntegerWithExpectedSize(uint8** pos,
uint8* end,
size_t expected_size,
std::vector<uint8>* out);
// Reads an ASN.1 integer from |pos|, and stores the result into |out| with
// |big_endian| byte-significance.
bool ReadIntegerImpl(uint8** pos,
uint8* end,
std::vector<uint8>* out,
bool big_endian);
// Prepends the integer stored in |val|, starting a index |start|, for
// |num_bytes| bytes onto |data|.
void PrependBytes(uint8* val,
int start,
int num_bytes,
std::list<uint8>* data);
// Helper to prepend an ASN.1 length field.
void PrependLength(size_t size, std::list<uint8>* data);
// Helper to prepend an ASN.1 type header.
void PrependTypeHeaderAndLength(uint8 type,
uint32 length,
std::list<uint8>* output);
// Helper to prepend an ASN.1 bit string
void PrependBitString(uint8* val, int num_bytes, std::list<uint8>* output);
// Read an ASN.1 length field. This also checks that the length does not
// extend beyond |end|.
bool ReadLength(uint8** pos, uint8* end, uint32* result);
// Read an ASN.1 type header and its length.
bool ReadTypeHeaderAndLength(uint8** pos,
uint8* end,
uint8 expected_tag,
uint32* length);
// Read an ASN.1 sequence declaration. This consumes the type header and
// length field, but not the contents of the sequence.
bool ReadSequence(uint8** pos, uint8* end);
// Read the RSA AlgorithmIdentifier.
bool ReadAlgorithmIdentifier(uint8** pos, uint8* end);
// Read one of the two version fields in PrivateKeyInfo.
bool ReadVersion(uint8** pos, uint8* end);
// The byte-significance of the stored components (modulus, etc..).
bool big_endian_;
// Component integers of the PrivateKeyInfo
std::vector<uint8> modulus_;
std::vector<uint8> public_exponent_;
std::vector<uint8> private_exponent_;
std::vector<uint8> prime1_;
std::vector<uint8> prime2_;
std::vector<uint8> exponent1_;
std::vector<uint8> exponent2_;
std::vector<uint8> coefficient_;
DISALLOW_COPY_AND_ASSIGN(PrivateKeyInfoCodec);
};
// Encapsulates an RSA private key. Can be used to generate new keys, export
// keys to other formats, or to extract a public key.
// TODO(hclam): This class should be ref-counted so it can be reused easily.
class CRYPTO_EXPORT RSAPrivateKey {
public:
~RSAPrivateKey();
// Create a new random instance. Can return NULL if initialization fails.
static RSAPrivateKey* Create(uint16 num_bits);
// Create a new instance by importing an existing private key. The format is
// an ASN.1-encoded PrivateKeyInfo block from PKCS #8. This can return NULL if
// initialization fails.
static RSAPrivateKey* CreateFromPrivateKeyInfo(
const std::vector<uint8>& input);
#if defined(USE_OPENSSL)
// Create a new instance from an existing EVP_PKEY, taking a
// reference to it. |key| must be an RSA key. Returns NULL on
// failure.
static RSAPrivateKey* CreateFromKey(EVP_PKEY* key);
#else
// Create a new instance by referencing an existing private key
// structure. Does not import the key.
static RSAPrivateKey* CreateFromKey(SECKEYPrivateKey* key);
#endif
#if defined(USE_OPENSSL)
EVP_PKEY* key() { return key_; }
#else
SECKEYPrivateKey* key() { return key_; }
SECKEYPublicKey* public_key() { return public_key_; }
#endif
// Creates a copy of the object.
RSAPrivateKey* Copy() const;
// Exports the private key to a PKCS #1 PrivateKey block.
bool ExportPrivateKey(std::vector<uint8>* output) const;
// Exports the public key to an X509 SubjectPublicKeyInfo block.
bool ExportPublicKey(std::vector<uint8>* output) const;
private:
// Constructor is private. Use one of the Create*() methods above instead.
RSAPrivateKey();
#if defined(USE_OPENSSL)
EVP_PKEY* key_;
#else
SECKEYPrivateKey* key_;
SECKEYPublicKey* public_key_;
#endif
DISALLOW_COPY_AND_ASSIGN(RSAPrivateKey);
};
} // namespace crypto
#endif // CRYPTO_RSA_PRIVATE_KEY_H_
|
