1 /*
2 * X.509 Public Key
3 * (C) 1999-2010 Jack Lloyd
4 *
5 * Botan is released under the Simplified BSD License (see license.txt)
6 */
7 
8 #include <botan/x509_key.h>
9 #include <botan/data_src.h>
10 #include <botan/ber_dec.h>
11 #include <botan/pem.h>
12 #include <botan/asn1_obj.h>
13 #include <botan/pk_algs.h>
14 
15 namespace Botan {
16 
17 namespace X509 {
18 
BER_encode(const Public_Key & key)19 std::vector<uint8_t> BER_encode(const Public_Key& key)
20    {
21    // keeping it around for compat
22    return key.subject_public_key();
23    }
24 
25 /*
26 * PEM encode a X.509 public key
27 */
PEM_encode(const Public_Key & key)28 std::string PEM_encode(const Public_Key& key)
29    {
30    return PEM_Code::encode(key.subject_public_key(),
31                            "PUBLIC KEY");
32    }
33 
34 /*
35 * Extract a public key and return it
36 */
load_key(DataSource & source)37 Public_Key* load_key(DataSource& source)
38    {
39    try {
40       AlgorithmIdentifier alg_id;
41       std::vector<uint8_t> key_bits;
42 
43       if(ASN1::maybe_BER(source) && !PEM_Code::matches(source))
44          {
45          BER_Decoder(source)
46             .start_cons(SEQUENCE)
47             .decode(alg_id)
48             .decode(key_bits, BIT_STRING)
49          .end_cons();
50          }
51       else
52          {
53          DataSource_Memory ber(
54             PEM_Code::decode_check_label(source, "PUBLIC KEY")
55             );
56 
57          BER_Decoder(ber)
58             .start_cons(SEQUENCE)
59             .decode(alg_id)
60             .decode(key_bits, BIT_STRING)
61          .end_cons();
62          }
63 
64       if(key_bits.empty())
65          throw Decoding_Error("X.509 public key decoding");
66 
67       return load_public_key(alg_id, key_bits).release();
68       }
69    catch(Decoding_Error& e)
70       {
71       throw Decoding_Error("X.509 public key decoding", e);
72       }
73    }
74 
75 #if defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)
76 /*
77 * Extract a public key and return it
78 */
load_key(const std::string & fsname)79 Public_Key* load_key(const std::string& fsname)
80    {
81    DataSource_Stream source(fsname, true);
82    return X509::load_key(source);
83    }
84 #endif
85 
86 /*
87 * Extract a public key and return it
88 */
load_key(const std::vector<uint8_t> & mem)89 Public_Key* load_key(const std::vector<uint8_t>& mem)
90    {
91    DataSource_Memory source(mem);
92    return X509::load_key(source);
93    }
94 
95 /*
96 * Make a copy of this public key
97 */
copy_key(const Public_Key & key)98 Public_Key* copy_key(const Public_Key& key)
99    {
100    DataSource_Memory source(PEM_encode(key));
101    return X509::load_key(source);
102    }
103 
104 }
105 
106 }
107