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 "Keystore.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 
~KeystoreOperation()46 KeystoreOperation::~KeystoreOperation() {
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_explicit(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 KeystoreOperation::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 KeystoreOperation::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 
Keystore()106 Keystore::Keystore() {
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 Keystore::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 & ksKey,std::string * key)153 bool Keystore::exportKey(const KeyBuffer& ksKey, 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>>(ksKey.begin(), ksKey.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     // vold intentionally ignores ephemeral_key_response.upgradedBlob, since the
170     // concept of "upgrading" doesn't make sense for TAG_STORAGE_KEY keys
171     // (hardware-wrapped inline encryption keys).  These keys are only meant as
172     // a substitute for raw keys; they still go through vold's usual layer of
173     // key wrapping, which already handles version binding.  So, vold just keeps
174     // using the original blobs for TAG_STORAGE_KEY keys.  If KeyMint "upgrades"
175     // them anyway, then they'll just get re-upgraded before each use.
176 
177     ret = true;
178 out:
179     zeroize_vector(ephemeral_key_response.ephemeralKey);
180     zeroize_vector(storageKey.blob.value());
181     return ret;
182 }
183 
deleteKey(const std::string & key)184 bool Keystore::deleteKey(const std::string& key) {
185     ks2::KeyDescriptor keyDesc = {
186             .domain = ks2::Domain::BLOB,
187             .alias = std::nullopt,
188             .nspace = VOLD_NAMESPACE,
189     };
190     keyDesc.blob =
191             std::optional<std::vector<uint8_t>>(std::vector<uint8_t>(key.begin(), key.end()));
192 
193     auto rc = securityLevel->deleteKey(keyDesc);
194     return !logKeystore2ExceptionIfPresent(rc, "deleteKey");
195 }
196 
begin(const std::string & key,const km::AuthorizationSet & inParams,km::AuthorizationSet * outParams)197 KeystoreOperation Keystore::begin(const std::string& key, const km::AuthorizationSet& inParams,
198                                   km::AuthorizationSet* outParams) {
199     ks2::KeyDescriptor keyDesc = {
200             .domain = ks2::Domain::BLOB,
201             .alias = std::nullopt,
202             .nspace = VOLD_NAMESPACE,
203     };
204     keyDesc.blob =
205             std::optional<std::vector<uint8_t>>(std::vector<uint8_t>(key.begin(), key.end()));
206 
207     ks2::CreateOperationResponse cor;
208     auto rc = securityLevel->createOperation(keyDesc, inParams.vector_data(), true, &cor);
209     if (logKeystore2ExceptionIfPresent(rc, "createOperation")) {
210         if (rc.getExceptionCode() == EX_SERVICE_SPECIFIC)
211             return KeystoreOperation((km::ErrorCode)rc.getServiceSpecificError());
212         else
213             return KeystoreOperation();
214     }
215 
216     if (!cor.iOperation) {
217         LOG(ERROR) << "keystore2 createOperation didn't return an operation";
218         return KeystoreOperation();
219     }
220 
221     if (outParams && cor.parameters) *outParams = cor.parameters->keyParameter;
222 
223     return KeystoreOperation(cor.iOperation, cor.upgradedBlob);
224 }
225 
earlyBootEnded()226 void Keystore::earlyBootEnded() {
227     ::ndk::SpAIBinder binder(AServiceManager_getService(maintenance_service_name));
228     auto maint_service = ks2_maint::IKeystoreMaintenance::fromBinder(binder);
229 
230     if (!maint_service) {
231         LOG(ERROR) << "Unable to connect to keystore2 maintenance service for earlyBootEnded";
232         return;
233     }
234 
235     auto rc = maint_service->earlyBootEnded();
236     logKeystore2ExceptionIfPresent(rc, "earlyBootEnded");
237 }
238 
deleteAllKeys()239 void Keystore::deleteAllKeys() {
240     ::ndk::SpAIBinder binder(AServiceManager_getService(maintenance_service_name));
241     auto maint_service = ks2_maint::IKeystoreMaintenance::fromBinder(binder);
242 
243     if (!maint_service) {
244         LOG(ERROR) << "Unable to connect to keystore2 maintenance service for deleteAllKeys";
245         return;
246     }
247 
248     auto rc = maint_service->deleteAllKeys();
249     logKeystore2ExceptionIfPresent(rc, "deleteAllKeys");
250 }
251 
252 }  // namespace vold
253 }  // namespace android
254