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 13 typedef struct evp_pkey_st EVP_PKEY; 14 #elif defined(USE_NSS) 15 // Forward declaration. 16 struct SECKEYPrivateKeyStr; 17 struct 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 34 namespace crypto { 35 36 // Used internally by RSAPrivateKey for serializing and deserializing 37 // PKCS #8 PrivateKeyInfo and PublicKeyInfo. 38 class 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. 173 class 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
