• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 TRUSTY_KEYMASTER_TRUSTY_KEYMASTER_DEVICE_H_
18 #define TRUSTY_KEYMASTER_TRUSTY_KEYMASTER_DEVICE_H_
19 
20 #include <hardware/keymaster2.h>
21 #include <keymaster/android_keymaster_messages.h>
22 
23 namespace keymaster {
24 
25 /**
26  * Trusty Keymaster device.
27  *
28  * IMPORTANT MAINTAINER NOTE: Pointers to instances of this class must be castable to hw_device_t
29  * and keymaster_device. This means it must remain a standard layout class (no virtual functions and
30  * no data members which aren't standard layout), and device_ must be the first data member.
31  * Assertions in the constructor validate compliance with those constraints.
32  */
33 class TrustyKeymasterDevice {
34   public:
35     /*
36      * These are the only symbols that will be exported by libtrustykeymaster.  All functionality
37      * can be reached via the function pointers in device_.
38      */
39     __attribute__((visibility("default"))) explicit TrustyKeymasterDevice(const hw_module_t* module);
40     __attribute__((visibility("default"))) hw_device_t* hw_device();
41 
42     ~TrustyKeymasterDevice();
43 
session_error()44     keymaster_error_t session_error() { return error_; }
45 
46     keymaster_error_t configure(const keymaster_key_param_set_t* params);
47     keymaster_error_t add_rng_entropy(const uint8_t* data, size_t data_length);
48     keymaster_error_t generate_key(const keymaster_key_param_set_t* params,
49                                    keymaster_key_blob_t* key_blob,
50                                    keymaster_key_characteristics_t* characteristics);
51     keymaster_error_t get_key_characteristics(const keymaster_key_blob_t* key_blob,
52                                               const keymaster_blob_t* client_id,
53                                               const keymaster_blob_t* app_data,
54                                               keymaster_key_characteristics_t* character);
55     keymaster_error_t import_key(const keymaster_key_param_set_t* params,
56                                  keymaster_key_format_t key_format,
57                                  const keymaster_blob_t* key_data, keymaster_key_blob_t* key_blob,
58                                  keymaster_key_characteristics_t* characteristics);
59     keymaster_error_t export_key(keymaster_key_format_t export_format,
60                                  const keymaster_key_blob_t* key_to_export,
61                                  const keymaster_blob_t* client_id,
62                                  const keymaster_blob_t* app_data, keymaster_blob_t* export_data);
63     keymaster_error_t attest_key(const keymaster_key_blob_t* key_to_attest,
64                                  const keymaster_key_param_set_t* attest_params,
65                                  keymaster_cert_chain_t* cert_chain);
66     keymaster_error_t upgrade_key(const keymaster_key_blob_t* key_to_upgrade,
67                                   const keymaster_key_param_set_t* upgrade_params,
68                                   keymaster_key_blob_t* upgraded_key);
69     keymaster_error_t begin(keymaster_purpose_t purpose, const keymaster_key_blob_t* key,
70                             const keymaster_key_param_set_t* in_params,
71                             keymaster_key_param_set_t* out_params,
72                             keymaster_operation_handle_t* operation_handle);
73     keymaster_error_t update(keymaster_operation_handle_t operation_handle,
74                              const keymaster_key_param_set_t* in_params,
75                              const keymaster_blob_t* input, size_t* input_consumed,
76                              keymaster_key_param_set_t* out_params, keymaster_blob_t* output);
77     keymaster_error_t finish(keymaster_operation_handle_t operation_handle,
78                              const keymaster_key_param_set_t* in_params,
79                              const keymaster_blob_t* input, const keymaster_blob_t* signature,
80                              keymaster_key_param_set_t* out_params, keymaster_blob_t* output);
81     keymaster_error_t abort(keymaster_operation_handle_t operation_handle);
82 
83   private:
84     keymaster_error_t Send(uint32_t command, const Serializable& request,
85                            KeymasterResponse* response);
86 
87     /*
88      * These static methods are the functions referenced through the function pointers in
89      * keymaster_device.  They're all trivial wrappers.
90      */
91     static int close_device(hw_device_t* dev);
92     static keymaster_error_t configure(const keymaster2_device_t* dev,
93                                        const keymaster_key_param_set_t* params);
94     static keymaster_error_t add_rng_entropy(const keymaster2_device_t* dev, const uint8_t* data,
95                                              size_t data_length);
96     static keymaster_error_t generate_key(const keymaster2_device_t* dev,
97                                           const keymaster_key_param_set_t* params,
98                                           keymaster_key_blob_t* key_blob,
99                                           keymaster_key_characteristics_t* characteristics);
100     static keymaster_error_t get_key_characteristics(const keymaster2_device_t* dev,
101                                                      const keymaster_key_blob_t* key_blob,
102                                                      const keymaster_blob_t* client_id,
103                                                      const keymaster_blob_t* app_data,
104                                                      keymaster_key_characteristics_t* character);
105     static keymaster_error_t import_key(const keymaster2_device_t* dev,
106                                         const keymaster_key_param_set_t* params,
107                                         keymaster_key_format_t key_format,
108                                         const keymaster_blob_t* key_data,
109                                         keymaster_key_blob_t* key_blob,
110                                         keymaster_key_characteristics_t* characteristics);
111     static keymaster_error_t export_key(const keymaster2_device_t* dev,
112                                         keymaster_key_format_t export_format,
113                                         const keymaster_key_blob_t* key_to_export,
114                                         const keymaster_blob_t* client_id,
115                                         const keymaster_blob_t* app_data,
116                                         keymaster_blob_t* export_data);
117     static keymaster_error_t attest_key(const keymaster2_device_t* dev,
118                                         const keymaster_key_blob_t* key_to_attest,
119                                         const keymaster_key_param_set_t* attest_params,
120                                         keymaster_cert_chain_t* cert_chain);
121     static keymaster_error_t upgrade_key(const keymaster2_device_t* dev,
122                                          const keymaster_key_blob_t* key_to_upgrade,
123                                          const keymaster_key_param_set_t* upgrade_params,
124                                          keymaster_key_blob_t* upgraded_key);
125     static keymaster_error_t delete_key(const keymaster2_device_t* dev,
126                                         const keymaster_key_blob_t* key);
127     static keymaster_error_t delete_all_keys(const keymaster2_device_t* dev);
128     static keymaster_error_t begin(const keymaster2_device_t* dev, keymaster_purpose_t purpose,
129                                    const keymaster_key_blob_t* key,
130                                    const keymaster_key_param_set_t* in_params,
131                                    keymaster_key_param_set_t* out_params,
132                                    keymaster_operation_handle_t* operation_handle);
133     static keymaster_error_t update(const keymaster2_device_t* dev,
134                                     keymaster_operation_handle_t operation_handle,
135                                     const keymaster_key_param_set_t* in_params,
136                                     const keymaster_blob_t* input, size_t* input_consumed,
137                                     keymaster_key_param_set_t* out_params, keymaster_blob_t* output);
138     static keymaster_error_t finish(const keymaster2_device_t* dev,
139                                     keymaster_operation_handle_t operation_handle,
140                                     const keymaster_key_param_set_t* in_params,
141                                     const keymaster_blob_t* input, const keymaster_blob_t* signature,
142                                     keymaster_key_param_set_t* out_params, keymaster_blob_t* output);
143     static keymaster_error_t abort(const keymaster2_device_t* dev,
144                                    keymaster_operation_handle_t operation_handle);
145 
146     keymaster2_device_t device_;
147     keymaster_error_t error_;
148     int32_t message_version_;
149 };
150 
151 }  // namespace keymaster
152 
153 #endif  // TRUSTY_KEYMASTER_TRUSTY_KEYMASTER_DEVICE_H_
154