1 /*
2  * Copyright (C) 2020 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 #include "JavacardKeyMintUtils.h"
18 
19 #include <cppbor.h>
20 
21 #include <android-base/logging.h>
22 
23 namespace aidl::android::hardware::security::keymint::km_utils {
24 
25 keymaster_key_param_t kInvalidTag{.tag = KM_TAG_INVALID, .integer = 0};
26 
kmEnumParam2Aidl(const keymaster_key_param_t & param)27 KeyParameter kmEnumParam2Aidl(const keymaster_key_param_t& param) {
28     switch (param.tag) {
29     case KM_TAG_PURPOSE:
30         return KeyParameter{Tag::PURPOSE, KeyParameterValue::make<KeyParameterValue::keyPurpose>(
31                                               static_cast<KeyPurpose>(param.enumerated))};
32     case KM_TAG_ALGORITHM:
33         return KeyParameter{Tag::ALGORITHM, KeyParameterValue::make<KeyParameterValue::algorithm>(
34                                                 static_cast<Algorithm>(param.enumerated))};
35     case KM_TAG_BLOCK_MODE:
36         return KeyParameter{Tag::BLOCK_MODE, KeyParameterValue::make<KeyParameterValue::blockMode>(
37                                                  static_cast<BlockMode>(param.enumerated))};
38     case KM_TAG_DIGEST:
39         return KeyParameter{Tag::DIGEST, KeyParameterValue::make<KeyParameterValue::digest>(
40                                              static_cast<Digest>(param.enumerated))};
41     case KM_TAG_PADDING:
42         return KeyParameter{Tag::PADDING, KeyParameterValue::make<KeyParameterValue::paddingMode>(
43                                               static_cast<PaddingMode>(param.enumerated))};
44     case KM_TAG_EC_CURVE:
45         return KeyParameter{Tag::EC_CURVE, KeyParameterValue::make<KeyParameterValue::ecCurve>(
46                                                static_cast<EcCurve>(param.enumerated))};
47     case KM_TAG_USER_AUTH_TYPE:
48         return KeyParameter{Tag::USER_AUTH_TYPE,
49                             KeyParameterValue::make<KeyParameterValue::hardwareAuthenticatorType>(
50                                 static_cast<HardwareAuthenticatorType>(param.enumerated))};
51     case KM_TAG_ORIGIN:
52         return KeyParameter{Tag::ORIGIN, KeyParameterValue::make<KeyParameterValue::origin>(
53                                              static_cast<KeyOrigin>(param.enumerated))};
54     case KM_TAG_BLOB_USAGE_REQUIREMENTS:
55     case KM_TAG_KDF:
56     default:
57         return KeyParameter{Tag::INVALID, false};
58     }
59 }
60 
kmParam2Aidl(const keymaster_key_param_t & param)61 KeyParameter kmParam2Aidl(const keymaster_key_param_t& param) {
62     auto tag = legacy_enum_conversion(param.tag);
63     switch (typeFromTag(param.tag)) {
64     case KM_ENUM:
65     case KM_ENUM_REP:
66         return kmEnumParam2Aidl(param);
67         break;
68 
69     case KM_UINT:
70     case KM_UINT_REP:
71         return KeyParameter{tag,
72                             KeyParameterValue::make<KeyParameterValue::integer>(param.integer)};
73 
74     case KM_ULONG:
75     case KM_ULONG_REP:
76         return KeyParameter{
77             tag, KeyParameterValue::make<KeyParameterValue::longInteger>(param.long_integer)};
78         break;
79 
80     case KM_DATE:
81         return KeyParameter{tag,
82                             KeyParameterValue::make<KeyParameterValue::dateTime>(param.date_time)};
83         break;
84 
85     case KM_BOOL:
86         return KeyParameter{tag, param.boolean};
87         break;
88 
89     case KM_BIGNUM:
90     case KM_BYTES:
91         return {tag, KeyParameterValue::make<KeyParameterValue::blob>(
92                          std::vector(param.blob.data, param.blob.data + param.blob.data_length))};
93         break;
94 
95     case KM_INVALID:
96     default:
97         LOG(FATAL) << "Unknown or unused tag type: Something is broken";
98         return KeyParameter{Tag::INVALID, false};
99         break;
100     }
101 }
102 
kmParamSet2Aidl(const keymaster_key_param_set_t & set)103 vector<KeyParameter> kmParamSet2Aidl(const keymaster_key_param_set_t& set) {
104     vector<KeyParameter> result;
105     if (set.length == 0 || set.params == nullptr) return result;
106 
107     result.reserve(set.length);
108     for (size_t i = 0; i < set.length; ++i) {
109         result.push_back(kmParam2Aidl(set.params[i]));
110     }
111     return result;
112 }
113 
114 template <KeyParameterValue::Tag aidl_tag>
aidlEnumVal2Km(keymaster_tag_t km_tag,const KeyParameterValue & value)115 keymaster_key_param_t aidlEnumVal2Km(keymaster_tag_t km_tag, const KeyParameterValue& value) {
116     return value.getTag() == aidl_tag
117                ? keymaster_param_enum(km_tag, static_cast<uint32_t>(value.get<aidl_tag>()))
118                : kInvalidTag;
119 }
120 
aidlEnumParam2Km(const KeyParameter & param)121 keymaster_key_param_t aidlEnumParam2Km(const KeyParameter& param) {
122     auto tag = legacy_enum_conversion(param.tag);
123     switch (tag) {
124     case KM_TAG_PURPOSE:
125         return aidlEnumVal2Km<KeyParameterValue::keyPurpose>(tag, param.value);
126     case KM_TAG_ALGORITHM:
127         return aidlEnumVal2Km<KeyParameterValue::algorithm>(tag, param.value);
128     case KM_TAG_BLOCK_MODE:
129         return aidlEnumVal2Km<KeyParameterValue::blockMode>(tag, param.value);
130     case KM_TAG_DIGEST:
131     case KM_TAG_RSA_OAEP_MGF_DIGEST:
132         return aidlEnumVal2Km<KeyParameterValue::digest>(tag, param.value);
133     case KM_TAG_PADDING:
134         return aidlEnumVal2Km<KeyParameterValue::paddingMode>(tag, param.value);
135     case KM_TAG_EC_CURVE:
136         return aidlEnumVal2Km<KeyParameterValue::ecCurve>(tag, param.value);
137     case KM_TAG_USER_AUTH_TYPE:
138         return aidlEnumVal2Km<KeyParameterValue::hardwareAuthenticatorType>(tag, param.value);
139     case KM_TAG_ORIGIN:
140         return aidlEnumVal2Km<KeyParameterValue::origin>(tag, param.value);
141     case KM_TAG_BLOB_USAGE_REQUIREMENTS:
142     case KM_TAG_KDF:
143     default:
144         LOG(FATAL) << "Unknown or unused enum tag: Something is broken";
145         return keymaster_param_enum(tag, false);
146     }
147 }
148 
legacyHardwareAuthToken(const HardwareAuthToken & aidlToken,LegacyHardwareAuthToken * legacyToken)149 keymaster_error_t legacyHardwareAuthToken(const HardwareAuthToken& aidlToken,
150                                           LegacyHardwareAuthToken* legacyToken) {
151     legacyToken->challenge = aidlToken.challenge;
152     legacyToken->user_id = aidlToken.userId;
153     legacyToken->authenticator_id = aidlToken.authenticatorId;
154     legacyToken->authenticator_type =
155         static_cast<hw_authenticator_type_t>(aidlToken.authenticatorType);
156     legacyToken->timestamp = aidlToken.timestamp.milliSeconds;
157     Vec2KmBlob(aidlToken.mac, &legacyToken->mac);
158     return KM_ERROR_OK;
159 }
160 
encodeTimestampToken(const TimeStampToken & timestampToken,vector<uint8_t> * encodedToken)161 keymaster_error_t encodeTimestampToken(const TimeStampToken& timestampToken,
162                                        vector<uint8_t>* encodedToken) {
163     cppbor::Array array;
164     ::keymaster::TimestampToken token;
165     array.add(static_cast<uint64_t>(timestampToken.challenge));
166     array.add(static_cast<uint64_t>(timestampToken.timestamp.milliSeconds));
167     array.add(timestampToken.mac);
168     *encodedToken = array.encode();
169     return KM_ERROR_OK;
170 }
171 
aidlKeyParams2Km(const vector<KeyParameter> & keyParams)172 keymaster_key_param_set_t aidlKeyParams2Km(const vector<KeyParameter>& keyParams) {
173     keymaster_key_param_set_t set;
174 
175     set.params = static_cast<keymaster_key_param_t*>(
176         malloc(keyParams.size() * sizeof(keymaster_key_param_t)));
177     set.length = keyParams.size();
178 
179     for (size_t i = 0; i < keyParams.size(); ++i) {
180         const auto& param = keyParams[i];
181         auto tag = legacy_enum_conversion(param.tag);
182         switch (typeFromTag(tag)) {
183         case KM_ENUM:
184         case KM_ENUM_REP:
185             set.params[i] = aidlEnumParam2Km(param);
186             break;
187 
188         case KM_UINT:
189         case KM_UINT_REP:
190             set.params[i] =
191                 param.value.getTag() == KeyParameterValue::integer
192                     ? keymaster_param_int(tag, param.value.get<KeyParameterValue::integer>())
193                     : kInvalidTag;
194             break;
195 
196         case KM_ULONG:
197         case KM_ULONG_REP:
198             set.params[i] =
199                 param.value.getTag() == KeyParameterValue::longInteger
200                     ? keymaster_param_long(tag, param.value.get<KeyParameterValue::longInteger>())
201                     : kInvalidTag;
202             break;
203 
204         case KM_DATE:
205             set.params[i] =
206                 param.value.getTag() == KeyParameterValue::dateTime
207                     ? keymaster_param_date(tag, param.value.get<KeyParameterValue::dateTime>())
208                     : kInvalidTag;
209             break;
210 
211         case KM_BOOL:
212             set.params[i] = keymaster_param_bool(tag);
213             break;
214 
215         case KM_BIGNUM:
216         case KM_BYTES:
217             if (param.value.getTag() == KeyParameterValue::blob) {
218                 const auto& value = param.value.get<KeyParameterValue::blob>();
219                 uint8_t* copy = static_cast<uint8_t*>(malloc(value.size()));
220                 std::copy(value.begin(), value.end(), copy);
221                 set.params[i] = keymaster_param_blob(tag, copy, value.size());
222             } else {
223                 set.params[i] = kInvalidTag;
224             }
225             break;
226 
227         case KM_INVALID:
228         default:
229             LOG(FATAL) << "Invalid tag: Something is broken";
230             set.params[i].tag = KM_TAG_INVALID;
231             /* just skip */
232             break;
233         }
234     }
235 
236     return set;
237 }
238 
239 }  // namespace aidl::android::hardware::security::keymint::km_utils
240