1/*
2 * Copyright 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef SYSTEM_KEYMASTER_ASYMMETRIC_KEY_H
18#define SYSTEM_KEYMASTER_ASYMMETRIC_KEY_H
19
20#include <openssl/rsa.h>
21#include <openssl/dsa.h>
22#include <openssl/ecdsa.h>
23#include <openssl/evp.h>
24
25#include "key.h"
26
27namespace keymaster {
28
29class AsymmetricKey : public Key {
30  public:
31  protected:
32    AsymmetricKey(const KeyBlob& blob, const Logger& logger) : Key(blob, logger) {}
33    keymaster_error_t LoadKey(const KeyBlob& blob);
34
35    /**
36     * Return a copy of raw key material, in the key's preferred binary format.
37     */
38    virtual keymaster_error_t key_material(UniquePtr<uint8_t[]>* material, size_t* size) const;
39
40    /**
41     * Return a copy of raw key material, in the specified format.
42     */
43    virtual keymaster_error_t formatted_key_material(keymaster_key_format_t format,
44                                                     UniquePtr<uint8_t[]>* material,
45                                                     size_t* size) const;
46
47    virtual Operation* CreateOperation(keymaster_purpose_t purpose, keymaster_error_t* error);
48
49  protected:
50    AsymmetricKey(const AuthorizationSet& auths, const Logger& logger) : Key(auths, logger) {}
51
52  private:
53    virtual int evp_key_type() = 0;
54    virtual bool InternalToEvp(EVP_PKEY* pkey) const = 0;
55    virtual bool EvpToInternal(const EVP_PKEY* pkey) = 0;
56    virtual Operation* CreateOperation(keymaster_purpose_t purpose, keymaster_digest_t digest,
57                                       keymaster_padding_t padding, keymaster_error_t* error) = 0;
58};
59
60class RsaKey : public AsymmetricKey {
61  public:
62    static RsaKey* GenerateKey(const AuthorizationSet& key_description, const Logger& logger,
63                               keymaster_error_t* error);
64    static RsaKey* ImportKey(const AuthorizationSet& key_description, EVP_PKEY* pkey,
65                             const Logger& logger, keymaster_error_t* error);
66    RsaKey(const KeyBlob& blob, const Logger& logger, keymaster_error_t* error);
67
68    virtual Operation* CreateOperation(keymaster_purpose_t purpose, keymaster_digest_t digest,
69                                       keymaster_padding_t padding, keymaster_error_t* error);
70
71  private:
72    RsaKey(RSA* rsa_key, const AuthorizationSet& auths, const Logger& logger)
73        : AsymmetricKey(auths, logger), rsa_key_(rsa_key) {}
74
75    virtual int evp_key_type() { return EVP_PKEY_RSA; }
76    virtual bool InternalToEvp(EVP_PKEY* pkey) const;
77    virtual bool EvpToInternal(const EVP_PKEY* pkey);
78
79    struct RSA_Delete {
80        void operator()(RSA* p) { RSA_free(p); }
81    };
82
83    UniquePtr<RSA, RSA_Delete> rsa_key_;
84};
85
86class DsaKey : public AsymmetricKey {
87  public:
88    static DsaKey* GenerateKey(const AuthorizationSet& key_description, const Logger& logger,
89                               keymaster_error_t* error);
90    static DsaKey* ImportKey(const AuthorizationSet& key_description, EVP_PKEY* pkey,
91                             const Logger& logger, keymaster_error_t* error);
92    DsaKey(const KeyBlob& blob, const Logger& logger, keymaster_error_t* error);
93
94    virtual Operation* CreateOperation(keymaster_purpose_t purpose, keymaster_digest_t digest,
95                                       keymaster_padding_t padding, keymaster_error_t* error);
96    static size_t key_size_bits(DSA* dsa_key);
97
98  private:
99
100    DsaKey(DSA* dsa_key, const AuthorizationSet auths, const Logger& logger)
101        : AsymmetricKey(auths, logger), dsa_key_(dsa_key) {}
102
103    virtual int evp_key_type() { return EVP_PKEY_DSA; }
104    virtual bool InternalToEvp(EVP_PKEY* pkey) const;
105    virtual bool EvpToInternal(const EVP_PKEY* pkey);
106
107    struct DSA_Delete {
108        void operator()(DSA* p) { DSA_free(p); }
109    };
110
111    UniquePtr<DSA, DSA_Delete> dsa_key_;
112};
113
114class EcdsaKey : public AsymmetricKey {
115  public:
116    static EcdsaKey* GenerateKey(const AuthorizationSet& key_description, const Logger& logger,
117                                 keymaster_error_t* error);
118    static EcdsaKey* ImportKey(const AuthorizationSet& key_description, EVP_PKEY* pkey,
119                             const Logger& logger, keymaster_error_t* error);
120    EcdsaKey(const KeyBlob& blob, const Logger& logger, keymaster_error_t* error);
121
122    virtual Operation* CreateOperation(keymaster_purpose_t purpose, keymaster_digest_t digest,
123                                       keymaster_padding_t padding, keymaster_error_t* error);
124
125  private:
126    EcdsaKey(EC_KEY* ecdsa_key, const AuthorizationSet auths, const Logger& logger)
127        : AsymmetricKey(auths, logger), ecdsa_key_(ecdsa_key) {}
128
129    static EC_GROUP* choose_group(size_t key_size_bits);
130    static keymaster_error_t get_group_size(const EC_GROUP& group, size_t* key_size_bits);
131
132    virtual int evp_key_type() { return EVP_PKEY_EC; }
133    virtual bool InternalToEvp(EVP_PKEY* pkey) const;
134    virtual bool EvpToInternal(const EVP_PKEY* pkey);
135
136    struct ECDSA_Delete {
137        void operator()(EC_KEY* p) { EC_KEY_free(p); }
138    };
139
140    struct EC_GROUP_Delete {
141        void operator()(EC_GROUP* p) { EC_GROUP_free(p); }
142    };
143
144    UniquePtr<EC_KEY, ECDSA_Delete> ecdsa_key_;
145};
146
147}  // namespace keymaster
148
149#endif  // SYSTEM_KEYMASTER_ASYMMETRIC_KEY_H
150