1 /*
2 * Copyright (C) 2016 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 "Keymaster.h"
18
19 #include <android-base/logging.h>
20
21 #include <aidl/android/hardware/security/keymint/SecurityLevel.h>
22 #include <aidl/android/security/maintenance/IKeystoreMaintenance.h>
23 #include <aidl/android/system/keystore2/Domain.h>
24 #include <aidl/android/system/keystore2/EphemeralStorageKeyResponse.h>
25 #include <aidl/android/system/keystore2/KeyDescriptor.h>
26
27 // Keep these in sync with system/security/keystore2/src/keystore2_main.rs
28 static constexpr const char keystore2_service_name[] =
29 "android.system.keystore2.IKeystoreService/default";
30 static constexpr const char maintenance_service_name[] = "android.security.maintenance";
31
32 /*
33 * Keep this in sync with the description for update() in
34 * system/hardware/interfaces/keystore2/aidl/android/system/keystore2/IKeystoreOperation.aidl
35 */
36 static constexpr const size_t UPDATE_INPUT_MAX_SIZE = 32 * 1024; // 32 KiB
37
38 // Keep this in sync with system/sepolicy/private/keystore2_key_contexts
39 static constexpr const int VOLD_NAMESPACE = 100;
40
41 namespace android {
42 namespace vold {
43
44 namespace ks2_maint = ::aidl::android::security::maintenance;
45
~KeymasterOperation()46 KeymasterOperation::~KeymasterOperation() {
47 if (ks2Operation) ks2Operation->abort();
48 }
49
zeroize_vector(std::vector<uint8_t> & vec)50 static void zeroize_vector(std::vector<uint8_t>& vec) {
51 memset_s(vec.data(), 0, vec.size());
52 }
53
logKeystore2ExceptionIfPresent(::ndk::ScopedAStatus & rc,const std::string & func_name)54 static bool logKeystore2ExceptionIfPresent(::ndk::ScopedAStatus& rc, const std::string& func_name) {
55 if (rc.isOk()) return false;
56
57 auto exception_code = rc.getExceptionCode();
58 if (exception_code == EX_SERVICE_SPECIFIC) {
59 LOG(ERROR) << "keystore2 Keystore " << func_name
60 << " returned service specific error: " << rc.getServiceSpecificError();
61 } else {
62 LOG(ERROR) << "keystore2 Communication with Keystore " << func_name
63 << " failed error: " << exception_code;
64 }
65 return true;
66 }
67
updateCompletely(const char * input,size_t inputLen,const std::function<void (const char *,size_t)> consumer)68 bool KeymasterOperation::updateCompletely(const char* input, size_t inputLen,
69 const std::function<void(const char*, size_t)> consumer) {
70 if (!ks2Operation) return false;
71
72 while (inputLen != 0) {
73 size_t currLen = std::min(inputLen, UPDATE_INPUT_MAX_SIZE);
74 std::vector<uint8_t> input_vec(input, input + currLen);
75 inputLen -= currLen;
76 input += currLen;
77
78 std::optional<std::vector<uint8_t>> output;
79 auto rc = ks2Operation->update(input_vec, &output);
80 zeroize_vector(input_vec);
81 if (logKeystore2ExceptionIfPresent(rc, "update")) {
82 ks2Operation = nullptr;
83 return false;
84 }
85 if (output) consumer((const char*)output->data(), output->size());
86 }
87 return true;
88 }
89
finish(std::string * output)90 bool KeymasterOperation::finish(std::string* output) {
91 std::optional<std::vector<uint8_t>> out_vec;
92
93 if (!ks2Operation) return false;
94
95 auto rc = ks2Operation->finish(std::nullopt, std::nullopt, &out_vec);
96 if (logKeystore2ExceptionIfPresent(rc, "finish")) {
97 ks2Operation = nullptr;
98 return false;
99 }
100
101 if (output) *output = std::string(out_vec->begin(), out_vec->end());
102
103 return true;
104 }
105
Keymaster()106 Keymaster::Keymaster() {
107 ::ndk::SpAIBinder binder(AServiceManager_waitForService(keystore2_service_name));
108 auto keystore2Service = ks2::IKeystoreService::fromBinder(binder);
109
110 if (!keystore2Service) {
111 LOG(ERROR) << "Vold unable to connect to keystore2.";
112 return;
113 }
114
115 /*
116 * There are only two options available to vold for the SecurityLevel: TRUSTED_ENVIRONMENT (TEE)
117 * and STRONGBOX. We don't use STRONGBOX because if a TEE is present it will have Weaver, which
118 * already strengthens CE, so there's no additional benefit from using StrongBox.
119 *
120 * The picture is slightly more complicated because Keystore2 reports a SOFTWARE instance as
121 * a TEE instance when there isn't a TEE instance available, but in that case, a STRONGBOX
122 * instance won't be available either, so we'll still be doing the best we can.
123 */
124 auto rc = keystore2Service->getSecurityLevel(km::SecurityLevel::TRUSTED_ENVIRONMENT,
125 &securityLevel);
126 if (logKeystore2ExceptionIfPresent(rc, "getSecurityLevel"))
127 LOG(ERROR) << "Vold unable to get security level from keystore2.";
128 }
129
generateKey(const km::AuthorizationSet & inParams,std::string * key)130 bool Keymaster::generateKey(const km::AuthorizationSet& inParams, std::string* key) {
131 ks2::KeyDescriptor in_key = {
132 .domain = ks2::Domain::BLOB,
133 .alias = std::nullopt,
134 .nspace = VOLD_NAMESPACE,
135 .blob = std::nullopt,
136 };
137 ks2::KeyMetadata keyMetadata;
138 auto rc = securityLevel->generateKey(in_key, std::nullopt, inParams.vector_data(), 0, {},
139 &keyMetadata);
140
141 if (logKeystore2ExceptionIfPresent(rc, "generateKey")) return false;
142
143 if (keyMetadata.key.blob == std::nullopt) {
144 LOG(ERROR) << "keystore2 generated key blob was null";
145 return false;
146 }
147 if (key) *key = std::string(keyMetadata.key.blob->begin(), keyMetadata.key.blob->end());
148
149 zeroize_vector(keyMetadata.key.blob.value());
150 return true;
151 }
152
exportKey(const KeyBuffer & kmKey,std::string * key)153 bool Keymaster::exportKey(const KeyBuffer& kmKey, std::string* key) {
154 bool ret = false;
155 ks2::KeyDescriptor storageKey = {
156 .domain = ks2::Domain::BLOB,
157 .alias = std::nullopt,
158 .nspace = VOLD_NAMESPACE,
159 };
160 storageKey.blob = std::make_optional<std::vector<uint8_t>>(kmKey.begin(), kmKey.end());
161 ks2::EphemeralStorageKeyResponse ephemeral_key_response;
162 auto rc = securityLevel->convertStorageKeyToEphemeral(storageKey, &ephemeral_key_response);
163
164 if (logKeystore2ExceptionIfPresent(rc, "exportKey")) goto out;
165 if (key)
166 *key = std::string(ephemeral_key_response.ephemeralKey.begin(),
167 ephemeral_key_response.ephemeralKey.end());
168
169 // TODO b/185811713 store the upgraded key blob if provided and delete the old key blob.
170
171 ret = true;
172 out:
173 zeroize_vector(ephemeral_key_response.ephemeralKey);
174 zeroize_vector(storageKey.blob.value());
175 return ret;
176 }
177
deleteKey(const std::string & key)178 bool Keymaster::deleteKey(const std::string& key) {
179 ks2::KeyDescriptor keyDesc = {
180 .domain = ks2::Domain::BLOB,
181 .alias = std::nullopt,
182 .nspace = VOLD_NAMESPACE,
183 };
184 keyDesc.blob =
185 std::optional<std::vector<uint8_t>>(std::vector<uint8_t>(key.begin(), key.end()));
186
187 auto rc = securityLevel->deleteKey(keyDesc);
188 return !logKeystore2ExceptionIfPresent(rc, "deleteKey");
189 }
190
begin(const std::string & key,const km::AuthorizationSet & inParams,km::AuthorizationSet * outParams)191 KeymasterOperation Keymaster::begin(const std::string& key, const km::AuthorizationSet& inParams,
192 km::AuthorizationSet* outParams) {
193 ks2::KeyDescriptor keyDesc = {
194 .domain = ks2::Domain::BLOB,
195 .alias = std::nullopt,
196 .nspace = VOLD_NAMESPACE,
197 };
198 keyDesc.blob =
199 std::optional<std::vector<uint8_t>>(std::vector<uint8_t>(key.begin(), key.end()));
200
201 ks2::CreateOperationResponse cor;
202 auto rc = securityLevel->createOperation(keyDesc, inParams.vector_data(), true, &cor);
203 if (logKeystore2ExceptionIfPresent(rc, "createOperation")) {
204 if (rc.getExceptionCode() == EX_SERVICE_SPECIFIC)
205 return KeymasterOperation((km::ErrorCode)rc.getServiceSpecificError());
206 else
207 return KeymasterOperation();
208 }
209
210 if (!cor.iOperation) {
211 LOG(ERROR) << "keystore2 createOperation didn't return an operation";
212 return KeymasterOperation();
213 }
214
215 if (outParams && cor.parameters) *outParams = cor.parameters->keyParameter;
216
217 return KeymasterOperation(cor.iOperation, cor.upgradedBlob);
218 }
219
earlyBootEnded()220 void Keymaster::earlyBootEnded() {
221 ::ndk::SpAIBinder binder(AServiceManager_getService(maintenance_service_name));
222 auto maint_service = ks2_maint::IKeystoreMaintenance::fromBinder(binder);
223
224 if (!maint_service) {
225 LOG(ERROR) << "Unable to connect to keystore2 maintenance service for earlyBootEnded";
226 return;
227 }
228
229 auto rc = maint_service->earlyBootEnded();
230 logKeystore2ExceptionIfPresent(rc, "earlyBootEnded");
231 }
232
deleteAllKeys()233 void Keymaster::deleteAllKeys() {
234 ::ndk::SpAIBinder binder(AServiceManager_getService(maintenance_service_name));
235 auto maint_service = ks2_maint::IKeystoreMaintenance::fromBinder(binder);
236
237 if (!maint_service) {
238 LOG(ERROR) << "Unable to connect to keystore2 maintenance service for deleteAllKeys";
239 return;
240 }
241
242 auto rc = maint_service->deleteAllKeys();
243 logKeystore2ExceptionIfPresent(rc, "deleteAllKeys");
244 }
245
246 } // namespace vold
247 } // namespace android
248