blob: 1b927b84bc896f2f17d3fbe64dee5bffb79e5e58 [file] [log] [blame]
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001/*
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
Janis Danisevskis011675d2016-09-01 11:41:29 +010017#define LOG_TAG "keystore"
18
Shawn Willdenc1d1fee2016-01-26 22:44:56 -070019#include "key_store_service.h"
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -070020#include "include/keystore/KeystoreArg.h"
Shawn Willdenc1d1fee2016-01-26 22:44:56 -070021
22#include <fcntl.h>
23#include <sys/stat.h>
24
Janis Danisevskis7612fd42016-09-01 11:50:02 +010025#include <algorithm>
Shawn Willdenc1d1fee2016-01-26 22:44:56 -070026#include <sstream>
27
Pavel Grafovff311b42018-01-24 20:34:37 +000028#include <android-base/scopeguard.h>
Bartosz Fabianowskia9452d92017-01-23 22:21:11 +010029#include <binder/IInterface.h>
Shawn Willdenc1d1fee2016-01-26 22:44:56 -070030#include <binder/IPCThreadState.h>
Bartosz Fabianowskia9452d92017-01-23 22:21:11 +010031#include <binder/IPermissionController.h>
32#include <binder/IServiceManager.h>
Pavel Grafovff311b42018-01-24 20:34:37 +000033#include <log/log_event_list.h>
Shawn Willdenc1d1fee2016-01-26 22:44:56 -070034
35#include <private/android_filesystem_config.h>
Pavel Grafovff311b42018-01-24 20:34:37 +000036#include <private/android_logger.h>
Shawn Willdenc1d1fee2016-01-26 22:44:56 -070037
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +010038#include <android/hardware/keymaster/3.0/IHwKeymasterDevice.h>
Shawn Willdenc1d1fee2016-01-26 22:44:56 -070039
40#include "defaults.h"
Janis Danisevskis18f27ad2016-06-01 13:57:40 -070041#include "keystore_attestation_id.h"
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +010042#include "keystore_keymaster_enforcement.h"
Shawn Willdenc1d1fee2016-01-26 22:44:56 -070043#include "keystore_utils.h"
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +010044#include <keystore/keystore_hidl_support.h>
Shawn Willdenc1d1fee2016-01-26 22:44:56 -070045
Janis Danisevskis8f737ad2017-11-21 12:30:15 -080046#include <hardware/hw_auth_token.h>
47
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +010048namespace keystore {
Shawn Willdend5a24e62017-02-28 13:53:24 -070049
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +010050using namespace android;
Shawn Willdenc1d1fee2016-01-26 22:44:56 -070051
Shawn Willdene2a7b522017-04-11 09:27:40 -060052namespace {
53
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -070054using ::android::binder::Status;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -070055using android::security::KeystoreArg;
56using android::security::keymaster::ExportResult;
57using android::security::keymaster::KeymasterArguments;
58using android::security::keymaster::KeymasterBlob;
59using android::security::keymaster::KeymasterCertificateChain;
60using android::security::keymaster::OperationResult;
David Zeuthenc6eb7cd2017-11-27 11:33:55 -050061using ConfirmationResponseCode = android::hardware::confirmationui::V1_0::ResponseCode;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -070062
Shawn Willdene2a7b522017-04-11 09:27:40 -060063constexpr size_t kMaxOperations = 15;
64constexpr double kIdRotationPeriod = 30 * 24 * 60 * 60; /* Thirty days, in seconds */
65const char* kTimestampFilePath = "timestamp";
Shawn Willdenc1d1fee2016-01-26 22:44:56 -070066
67struct BIGNUM_Delete {
68 void operator()(BIGNUM* p) const { BN_free(p); }
69};
Janis Danisevskisccfff102017-05-01 11:02:51 -070070typedef std::unique_ptr<BIGNUM, BIGNUM_Delete> Unique_BIGNUM;
Shawn Willdenc1d1fee2016-01-26 22:44:56 -070071
Shawn Willdene2a7b522017-04-11 09:27:40 -060072bool containsTag(const hidl_vec<KeyParameter>& params, Tag tag) {
73 return params.end() != std::find_if(params.begin(), params.end(),
74 [&](auto& param) { return param.tag == tag; });
75}
76
Shawn Willdend5a24e62017-02-28 13:53:24 -070077bool isAuthenticationBound(const hidl_vec<KeyParameter>& params) {
78 return !containsTag(params, Tag::NO_AUTH_REQUIRED);
79}
80
Shawn Willdene2a7b522017-04-11 09:27:40 -060081std::pair<KeyStoreServiceReturnCode, bool> hadFactoryResetSinceIdRotation() {
82 struct stat sbuf;
83 if (stat(kTimestampFilePath, &sbuf) == 0) {
84 double diff_secs = difftime(time(NULL), sbuf.st_ctime);
85 return {ResponseCode::NO_ERROR, diff_secs < kIdRotationPeriod};
86 }
87
88 if (errno != ENOENT) {
89 ALOGE("Failed to stat \"timestamp\" file, with error %d", errno);
90 return {ResponseCode::SYSTEM_ERROR, false /* don't care */};
91 }
92
93 int fd = creat(kTimestampFilePath, 0600);
94 if (fd < 0) {
95 ALOGE("Couldn't create \"timestamp\" file, with error %d", errno);
96 return {ResponseCode::SYSTEM_ERROR, false /* don't care */};
97 }
98
99 if (close(fd)) {
100 ALOGE("Couldn't close \"timestamp\" file, with error %d", errno);
101 return {ResponseCode::SYSTEM_ERROR, false /* don't care */};
102 }
103
104 return {ResponseCode::NO_ERROR, true};
105}
106
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +0200107constexpr size_t KEY_ATTESTATION_APPLICATION_ID_MAX_SIZE = 1024;
108
109KeyStoreServiceReturnCode updateParamsForAttestation(uid_t callingUid, AuthorizationSet* params) {
110 KeyStoreServiceReturnCode responseCode;
111 bool factoryResetSinceIdRotation;
112 std::tie(responseCode, factoryResetSinceIdRotation) = hadFactoryResetSinceIdRotation();
113
114 if (!responseCode.isOk()) return responseCode;
115 if (factoryResetSinceIdRotation) params->push_back(TAG_RESET_SINCE_ID_ROTATION);
116
117 auto asn1_attestation_id_result = security::gather_attestation_application_id(callingUid);
118 if (!asn1_attestation_id_result.isOk()) {
119 ALOGE("failed to gather attestation_id");
120 return ErrorCode::ATTESTATION_APPLICATION_ID_MISSING;
121 }
122 std::vector<uint8_t>& asn1_attestation_id = asn1_attestation_id_result;
123
124 /*
125 * The attestation application ID cannot be longer than
126 * KEY_ATTESTATION_APPLICATION_ID_MAX_SIZE, so we truncate if too long.
127 */
128 if (asn1_attestation_id.size() > KEY_ATTESTATION_APPLICATION_ID_MAX_SIZE) {
129 asn1_attestation_id.resize(KEY_ATTESTATION_APPLICATION_ID_MAX_SIZE);
130 }
131
132 params->push_back(TAG_ATTESTATION_APPLICATION_ID, asn1_attestation_id);
133
134 return ResponseCode::NO_ERROR;
135}
136
Shawn Willdene2a7b522017-04-11 09:27:40 -0600137} // anonymous namespace
138
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700139void KeyStoreService::binderDied(const wp<IBinder>& who) {
140 auto operations = mOperationMap.getOperationsForToken(who.unsafe_get());
Chih-Hung Hsieh24b2a392016-07-28 10:35:24 -0700141 for (const auto& token : operations) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700142 int32_t unused_result;
143 abort(token, &unused_result);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700144 }
David Zeuthenc6eb7cd2017-11-27 11:33:55 -0500145 mConfirmationManager->binderDied(who);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700146}
147
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700148Status KeyStoreService::getState(int32_t userId, int32_t* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700149 if (!checkBinderPermission(P_GET_STATE)) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700150 *aidl_return = static_cast<int32_t>(ResponseCode::PERMISSION_DENIED);
151 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700152 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700153 *aidl_return = mKeyStore->getState(userId);
154 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700155}
156
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700157Status KeyStoreService::get(const String16& name, int32_t uid, ::std::vector<uint8_t>* item) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700158 uid_t targetUid = getEffectiveUid(uid);
159 if (!checkBinderPermission(P_GET, targetUid)) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700160 // see keystore/keystore.h
161 return Status::fromServiceSpecificError(
162 static_cast<int32_t>(ResponseCode::PERMISSION_DENIED));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700163 }
164
165 String8 name8(name);
166 Blob keyBlob;
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100167 KeyStoreServiceReturnCode rc =
168 mKeyStore->getKeyForName(&keyBlob, name8, targetUid, TYPE_GENERIC);
169 if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700170 *item = ::std::vector<uint8_t>();
171 // Return empty array if key is not found
172 // TODO: consider having returned value nullable or parse exception on the client.
173 return Status::fromServiceSpecificError(static_cast<int32_t>(rc));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700174 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100175 auto resultBlob = blob2hidlVec(keyBlob);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700176 // The static_cast here is needed to prevent a move, forcing a deep copy.
177 if (item) *item = static_cast<const hidl_vec<uint8_t>&>(blob2hidlVec(keyBlob));
178 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700179}
180
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700181Status KeyStoreService::insert(const String16& name, const ::std::vector<uint8_t>& item,
182 int targetUid, int32_t flags, int32_t* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700183 targetUid = getEffectiveUid(targetUid);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700184 KeyStoreServiceReturnCode result =
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700185 checkBinderPermissionAndKeystoreState(P_INSERT, targetUid, flags & KEYSTORE_FLAG_ENCRYPTED);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100186 if (!result.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700187 *aidl_return = static_cast<int32_t>(result);
188 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700189 }
190
191 String8 name8(name);
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -0400192 String8 filename(mKeyStore->getKeyNameForUidWithDir(name8, targetUid, ::TYPE_GENERIC));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700193
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100194 Blob keyBlob(&item[0], item.size(), NULL, 0, ::TYPE_GENERIC);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700195 keyBlob.setEncrypted(flags & KEYSTORE_FLAG_ENCRYPTED);
196
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700197 *aidl_return =
198 static_cast<int32_t>(mKeyStore->put(filename.string(), &keyBlob, get_user_id(targetUid)));
199 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700200}
201
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700202Status KeyStoreService::del(const String16& name, int targetUid, int32_t* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700203 targetUid = getEffectiveUid(targetUid);
204 if (!checkBinderPermission(P_DELETE, targetUid)) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700205 *aidl_return = static_cast<int32_t>(ResponseCode::PERMISSION_DENIED);
206 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700207 }
208 String8 name8(name);
Rubin Xu7675c9f2017-03-15 19:26:52 +0000209 ALOGI("del %s %d", name8.string(), targetUid);
Janis Danisevskisaf7783f2017-09-21 11:29:47 -0700210 auto filename = mKeyStore->getBlobFileNameIfExists(name8, targetUid, ::TYPE_ANY);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700211 if (!filename.isOk()) {
212 *aidl_return = static_cast<int32_t>(ResponseCode::KEY_NOT_FOUND);
213 return Status::ok();
214 }
Janis Danisevskisaf7783f2017-09-21 11:29:47 -0700215
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700216 ResponseCode result =
217 mKeyStore->del(filename.value().string(), ::TYPE_ANY, get_user_id(targetUid));
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100218 if (result != ResponseCode::NO_ERROR) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700219 *aidl_return = static_cast<int32_t>(result);
220 return Status::ok();
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -0400221 }
222
Janis Danisevskisaf7783f2017-09-21 11:29:47 -0700223 filename = mKeyStore->getBlobFileNameIfExists(name8, targetUid, ::TYPE_KEY_CHARACTERISTICS);
224 if (filename.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700225 *aidl_return = static_cast<int32_t>(mKeyStore->del(
226 filename.value().string(), ::TYPE_KEY_CHARACTERISTICS, get_user_id(targetUid)));
227 return Status::ok();
Janis Danisevskisaf7783f2017-09-21 11:29:47 -0700228 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700229 *aidl_return = static_cast<int32_t>(ResponseCode::NO_ERROR);
230 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700231}
232
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700233Status KeyStoreService::exist(const String16& name, int targetUid, int32_t* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700234 targetUid = getEffectiveUid(targetUid);
235 if (!checkBinderPermission(P_EXIST, targetUid)) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700236 *aidl_return = static_cast<int32_t>(ResponseCode::PERMISSION_DENIED);
237 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700238 }
239
Janis Danisevskisaf7783f2017-09-21 11:29:47 -0700240 auto filename = mKeyStore->getBlobFileNameIfExists(String8(name), targetUid, ::TYPE_ANY);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700241 *aidl_return = static_cast<int32_t>(filename.isOk() ? ResponseCode::NO_ERROR
242 : ResponseCode::KEY_NOT_FOUND);
243 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700244}
245
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700246Status KeyStoreService::list(const String16& prefix, int targetUid,
247 ::std::vector<::android::String16>* matches) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700248 targetUid = getEffectiveUid(targetUid);
249 if (!checkBinderPermission(P_LIST, targetUid)) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700250 return Status::fromServiceSpecificError(
251 static_cast<int32_t>(ResponseCode::PERMISSION_DENIED));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700252 }
253 const String8 prefix8(prefix);
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -0400254 String8 filename(mKeyStore->getKeyNameForUid(prefix8, targetUid, TYPE_ANY));
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700255 android::Vector<android::String16> matches_internal;
256 if (mKeyStore->list(filename, &matches_internal, get_user_id(targetUid)) !=
257 ResponseCode::NO_ERROR) {
258 return Status::fromServiceSpecificError(static_cast<int32_t>(ResponseCode::SYSTEM_ERROR));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700259 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700260 matches->clear();
261 for (size_t i = 0; i < matches_internal.size(); ++i) {
262 matches->push_back(matches_internal[i]);
263 }
264 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700265}
266
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700267Status KeyStoreService::reset(int32_t* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700268 if (!checkBinderPermission(P_RESET)) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700269 *aidl_return = static_cast<int32_t>(ResponseCode::PERMISSION_DENIED);
270 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700271 }
272
273 uid_t callingUid = IPCThreadState::self()->getCallingUid();
274 mKeyStore->resetUser(get_user_id(callingUid), false);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700275 *aidl_return = static_cast<int32_t>(ResponseCode::NO_ERROR);
276 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700277}
278
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700279Status KeyStoreService::onUserPasswordChanged(int32_t userId, const String16& password,
280 int32_t* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700281 if (!checkBinderPermission(P_PASSWORD)) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700282 *aidl_return = static_cast<int32_t>(ResponseCode::PERMISSION_DENIED);
283 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700284 }
285
286 const String8 password8(password);
287 // Flush the auth token table to prevent stale tokens from sticking
288 // around.
289 mAuthTokenTable.Clear();
290
291 if (password.size() == 0) {
292 ALOGI("Secure lockscreen for user %d removed, deleting encrypted entries", userId);
293 mKeyStore->resetUser(userId, true);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700294 *aidl_return = static_cast<int32_t>(ResponseCode::NO_ERROR);
295 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700296 } else {
297 switch (mKeyStore->getState(userId)) {
298 case ::STATE_UNINITIALIZED: {
299 // generate master key, encrypt with password, write to file,
300 // initialize mMasterKey*.
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700301 *aidl_return = static_cast<int32_t>(mKeyStore->initializeUser(password8, userId));
302 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700303 }
304 case ::STATE_NO_ERROR: {
305 // rewrite master key with new password.
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700306 *aidl_return = static_cast<int32_t>(mKeyStore->writeMasterKey(password8, userId));
307 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700308 }
309 case ::STATE_LOCKED: {
310 ALOGE("Changing user %d's password while locked, clearing old encryption", userId);
311 mKeyStore->resetUser(userId, true);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700312 *aidl_return = static_cast<int32_t>(mKeyStore->initializeUser(password8, userId));
313 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700314 }
315 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700316 *aidl_return = static_cast<int32_t>(ResponseCode::SYSTEM_ERROR);
317 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700318 }
319}
320
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700321Status KeyStoreService::onUserAdded(int32_t userId, int32_t parentId, int32_t* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700322 if (!checkBinderPermission(P_USER_CHANGED)) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700323 *aidl_return = static_cast<int32_t>(ResponseCode::PERMISSION_DENIED);
324 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700325 }
326
327 // Sanity check that the new user has an empty keystore.
328 if (!mKeyStore->isEmpty(userId)) {
329 ALOGW("New user %d's keystore not empty. Clearing old entries.", userId);
330 }
331 // Unconditionally clear the keystore, just to be safe.
332 mKeyStore->resetUser(userId, false);
333 if (parentId != -1) {
334 // This profile must share the same master key password as the parent profile. Because the
335 // password of the parent profile is not known here, the best we can do is copy the parent's
336 // master key and master key file. This makes this profile use the same master key as the
337 // parent profile, forever.
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700338 *aidl_return = static_cast<int32_t>(mKeyStore->copyMasterKey(parentId, userId));
339 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700340 } else {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700341 *aidl_return = static_cast<int32_t>(ResponseCode::NO_ERROR);
342 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700343 }
344}
345
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700346Status KeyStoreService::onUserRemoved(int32_t userId, int32_t* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700347 if (!checkBinderPermission(P_USER_CHANGED)) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700348 *aidl_return = static_cast<int32_t>(ResponseCode::PERMISSION_DENIED);
349 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700350 }
351
352 mKeyStore->resetUser(userId, false);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700353 *aidl_return = static_cast<int32_t>(ResponseCode::NO_ERROR);
354 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700355}
356
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700357Status KeyStoreService::lock(int32_t userId, int32_t* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700358 if (!checkBinderPermission(P_LOCK)) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700359 *aidl_return = static_cast<int32_t>(ResponseCode::PERMISSION_DENIED);
360 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700361 }
362
363 State state = mKeyStore->getState(userId);
364 if (state != ::STATE_NO_ERROR) {
365 ALOGD("calling lock in state: %d", state);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700366 *aidl_return = static_cast<int32_t>(ResponseCode(state));
367 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700368 }
369
370 mKeyStore->lock(userId);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700371 *aidl_return = static_cast<int32_t>(ResponseCode::NO_ERROR);
372 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700373}
374
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700375Status KeyStoreService::unlock(int32_t userId, const String16& pw, int32_t* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700376 if (!checkBinderPermission(P_UNLOCK)) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700377 *aidl_return = static_cast<int32_t>(ResponseCode::PERMISSION_DENIED);
378 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700379 }
380
381 State state = mKeyStore->getState(userId);
382 if (state != ::STATE_LOCKED) {
383 switch (state) {
384 case ::STATE_NO_ERROR:
385 ALOGI("calling unlock when already unlocked, ignoring.");
386 break;
387 case ::STATE_UNINITIALIZED:
388 ALOGE("unlock called on uninitialized keystore.");
389 break;
390 default:
391 ALOGE("unlock called on keystore in unknown state: %d", state);
392 break;
393 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700394 *aidl_return = static_cast<int32_t>(ResponseCode(state));
395 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700396 }
397
398 const String8 password8(pw);
399 // read master key, decrypt with password, initialize mMasterKey*.
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700400 *aidl_return = static_cast<int32_t>(mKeyStore->readMasterKey(password8, userId));
401 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700402}
403
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700404Status KeyStoreService::isEmpty(int32_t userId, int32_t* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700405 if (!checkBinderPermission(P_IS_EMPTY)) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700406 *aidl_return = static_cast<int32_t>(false);
407 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700408 }
409
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700410 *aidl_return = static_cast<int32_t>(mKeyStore->isEmpty(userId));
411 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700412}
413
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700414Status KeyStoreService::generate(const String16& name, int32_t targetUid, int32_t keyType,
415 int32_t keySize, int32_t flags,
416 const ::android::security::KeystoreArguments& keystoreArgs,
417 int32_t* aidl_return) {
418 const Vector<sp<KeystoreArg>>* args = &(keystoreArgs.getArguments());
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700419 targetUid = getEffectiveUid(targetUid);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700420 KeyStoreServiceReturnCode result =
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700421 checkBinderPermissionAndKeystoreState(P_INSERT, targetUid, flags & KEYSTORE_FLAG_ENCRYPTED);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100422 if (!result.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700423 *aidl_return = static_cast<int32_t>(result);
424 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700425 }
426
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100427 keystore::AuthorizationSet params;
428 add_legacy_key_authorizations(keyType, &params);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700429
430 switch (keyType) {
431 case EVP_PKEY_EC: {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100432 params.push_back(TAG_ALGORITHM, Algorithm::EC);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700433 if (keySize == -1) {
434 keySize = EC_DEFAULT_KEY_SIZE;
435 } else if (keySize < EC_MIN_KEY_SIZE || keySize > EC_MAX_KEY_SIZE) {
436 ALOGI("invalid key size %d", keySize);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700437 *aidl_return = static_cast<int32_t>(ResponseCode::SYSTEM_ERROR);
438 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700439 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100440 params.push_back(TAG_KEY_SIZE, keySize);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700441 break;
442 }
443 case EVP_PKEY_RSA: {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100444 params.push_back(TAG_ALGORITHM, Algorithm::RSA);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700445 if (keySize == -1) {
446 keySize = RSA_DEFAULT_KEY_SIZE;
447 } else if (keySize < RSA_MIN_KEY_SIZE || keySize > RSA_MAX_KEY_SIZE) {
448 ALOGI("invalid key size %d", keySize);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700449 *aidl_return = static_cast<int32_t>(ResponseCode::SYSTEM_ERROR);
450 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700451 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100452 params.push_back(TAG_KEY_SIZE, keySize);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700453 unsigned long exponent = RSA_DEFAULT_EXPONENT;
454 if (args->size() > 1) {
455 ALOGI("invalid number of arguments: %zu", args->size());
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700456 *aidl_return = static_cast<int32_t>(ResponseCode::SYSTEM_ERROR);
457 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700458 } else if (args->size() == 1) {
Chih-Hung Hsieh24b2a392016-07-28 10:35:24 -0700459 const sp<KeystoreArg>& expArg = args->itemAt(0);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700460 if (expArg != NULL) {
461 Unique_BIGNUM pubExpBn(BN_bin2bn(
462 reinterpret_cast<const unsigned char*>(expArg->data()), expArg->size(), NULL));
463 if (pubExpBn.get() == NULL) {
464 ALOGI("Could not convert public exponent to BN");
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700465 *aidl_return = static_cast<int32_t>(ResponseCode::SYSTEM_ERROR);
466 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700467 }
468 exponent = BN_get_word(pubExpBn.get());
469 if (exponent == 0xFFFFFFFFL) {
470 ALOGW("cannot represent public exponent as a long value");
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700471 *aidl_return = static_cast<int32_t>(ResponseCode::SYSTEM_ERROR);
472 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700473 }
474 } else {
475 ALOGW("public exponent not read");
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700476 *aidl_return = static_cast<int32_t>(ResponseCode::SYSTEM_ERROR);
477 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700478 }
479 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100480 params.push_back(TAG_RSA_PUBLIC_EXPONENT, exponent);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700481 break;
482 }
483 default: {
484 ALOGW("Unsupported key type %d", keyType);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700485 *aidl_return = static_cast<int32_t>(ResponseCode::SYSTEM_ERROR);
486 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700487 }
488 }
489
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700490 int32_t aidl_result;
491 android::security::keymaster::KeyCharacteristics unused_characteristics;
492 auto rc = generateKey(name, KeymasterArguments(params.hidl_data()), ::std::vector<uint8_t>(),
493 targetUid, flags, &unused_characteristics, &aidl_result);
494 if (!KeyStoreServiceReturnCode(aidl_result).isOk()) {
495 ALOGW("generate failed: %d", int32_t(aidl_result));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700496 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700497 *aidl_return = aidl_result;
498 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700499}
500
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700501Status KeyStoreService::import_key(const String16& name, const ::std::vector<uint8_t>& data,
502 int targetUid, int32_t flags, int32_t* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700503
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100504 const uint8_t* ptr = &data[0];
505
506 Unique_PKCS8_PRIV_KEY_INFO pkcs8(d2i_PKCS8_PRIV_KEY_INFO(NULL, &ptr, data.size()));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700507 if (!pkcs8.get()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700508 *aidl_return = static_cast<int32_t>(ResponseCode::SYSTEM_ERROR);
509 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700510 }
511 Unique_EVP_PKEY pkey(EVP_PKCS82PKEY(pkcs8.get()));
512 if (!pkey.get()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700513 *aidl_return = static_cast<int32_t>(ResponseCode::SYSTEM_ERROR);
514 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700515 }
516 int type = EVP_PKEY_type(pkey->type);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100517 AuthorizationSet params;
518 add_legacy_key_authorizations(type, &params);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700519 switch (type) {
520 case EVP_PKEY_RSA:
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100521 params.push_back(TAG_ALGORITHM, Algorithm::RSA);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700522 break;
523 case EVP_PKEY_EC:
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100524 params.push_back(TAG_ALGORITHM, Algorithm::EC);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700525 break;
526 default:
527 ALOGW("Unsupported key type %d", type);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700528 *aidl_return = static_cast<int32_t>(ResponseCode::SYSTEM_ERROR);
529 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700530 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100531
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700532 int import_result;
533 auto rc = importKey(name, KeymasterArguments(params.hidl_data()),
534 static_cast<int32_t>(KeyFormat::PKCS8), data, targetUid, flags,
535 /*outCharacteristics*/ NULL, &import_result);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100536
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700537 if (!KeyStoreServiceReturnCode(import_result).isOk()) {
538 ALOGW("importKey failed: %d", int32_t(import_result));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700539 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700540 *aidl_return = static_cast<int32_t>(ResponseCode::NO_ERROR);
541 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700542}
543
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700544Status KeyStoreService::sign(const String16& name, const ::std::vector<uint8_t>& data,
545 ::std::vector<uint8_t>* out) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700546 if (!checkBinderPermission(P_SIGN)) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700547 return Status::fromServiceSpecificError(
548 static_cast<int32_t>(ResponseCode::PERMISSION_DENIED));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700549 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700550 hidl_vec<uint8_t> legacy_out;
551 KeyStoreServiceReturnCode res =
552 doLegacySignVerify(name, data, &legacy_out, hidl_vec<uint8_t>(), KeyPurpose::SIGN);
553 *out = legacy_out;
554 return Status::fromServiceSpecificError((res));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700555}
556
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700557Status KeyStoreService::verify(const String16& name, const ::std::vector<uint8_t>& data,
558 const ::std::vector<uint8_t>& signature, int32_t* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700559 if (!checkBinderPermission(P_VERIFY)) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700560 return Status::fromServiceSpecificError(
561 static_cast<int32_t>(ResponseCode::PERMISSION_DENIED));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700562 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700563 *aidl_return = static_cast<int32_t>(
564 doLegacySignVerify(name, data, nullptr, signature, KeyPurpose::VERIFY));
565 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700566}
567
568/*
569 * TODO: The abstraction between things stored in hardware and regular blobs
570 * of data stored on the filesystem should be moved down to keystore itself.
571 * Unfortunately the Java code that calls this has naming conventions that it
572 * knows about. Ideally keystore shouldn't be used to store random blobs of
573 * data.
574 *
575 * Until that happens, it's necessary to have a separate "get_pubkey" and
576 * "del_key" since the Java code doesn't really communicate what it's
577 * intentions are.
578 */
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700579Status KeyStoreService::get_pubkey(const String16& name, ::std::vector<uint8_t>* pubKey) {
580 android::security::keymaster::ExportResult result;
581 KeymasterBlob clientId;
Janis Danisevskis64ec1fe2018-02-26 16:47:21 -0800582 KeymasterBlob appData;
583 exportKey(name, static_cast<int32_t>(KeyFormat::X509), clientId, appData, UID_SELF, &result);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100584 if (!result.resultCode.isOk()) {
585 ALOGW("export failed: %d", int32_t(result.resultCode));
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700586 return Status::fromServiceSpecificError(static_cast<int32_t>(result.resultCode));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700587 }
588
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100589 if (pubKey) *pubKey = std::move(result.exportData);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700590 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700591}
592
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700593Status KeyStoreService::grant(const String16& name, int32_t granteeUid,
594 ::android::String16* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700595 uid_t callingUid = IPCThreadState::self()->getCallingUid();
Bo Zhu91de6db2018-03-20 12:52:13 -0700596 auto result =
597 checkBinderPermissionAndKeystoreState(P_GRANT, /*targetUid=*/-1, /*checkUnlocked=*/false);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100598 if (!result.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700599 *aidl_return = String16();
600 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700601 }
602
603 String8 name8(name);
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -0400604 String8 filename(mKeyStore->getKeyNameForUidWithDir(name8, callingUid, ::TYPE_ANY));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700605
606 if (access(filename.string(), R_OK) == -1) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700607 *aidl_return = String16();
608 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700609 }
610
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700611 *aidl_return =
612 String16(mKeyStore->addGrant(String8(name).string(), callingUid, granteeUid).c_str());
613 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700614}
615
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700616Status KeyStoreService::ungrant(const String16& name, int32_t granteeUid, int32_t* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700617 uid_t callingUid = IPCThreadState::self()->getCallingUid();
Bo Zhu91de6db2018-03-20 12:52:13 -0700618 KeyStoreServiceReturnCode result =
619 checkBinderPermissionAndKeystoreState(P_GRANT, /*targetUid=*/-1, /*checkUnlocked=*/false);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100620 if (!result.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700621 *aidl_return = static_cast<int32_t>(result);
622 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700623 }
624
625 String8 name8(name);
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -0400626 String8 filename(mKeyStore->getKeyNameForUidWithDir(name8, callingUid, ::TYPE_ANY));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700627
628 if (access(filename.string(), R_OK) == -1) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700629 *aidl_return = static_cast<int32_t>((errno != ENOENT) ? ResponseCode::SYSTEM_ERROR
630 : ResponseCode::KEY_NOT_FOUND);
631 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700632 }
633
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700634 *aidl_return = static_cast<int32_t>(mKeyStore->removeGrant(name8, callingUid, granteeUid)
635 ? ResponseCode::NO_ERROR
636 : ResponseCode::KEY_NOT_FOUND);
637 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700638}
639
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700640Status KeyStoreService::getmtime(const String16& name, int32_t uid, int64_t* time) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700641 uid_t targetUid = getEffectiveUid(uid);
642 if (!checkBinderPermission(P_GET, targetUid)) {
643 ALOGW("permission denied for %d: getmtime", targetUid);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700644 *time = -1L;
645 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700646 }
647
Janis Danisevskisaf7783f2017-09-21 11:29:47 -0700648 auto filename = mKeyStore->getBlobFileNameIfExists(String8(name), targetUid, ::TYPE_ANY);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700649
Janis Danisevskisaf7783f2017-09-21 11:29:47 -0700650 if (!filename.isOk()) {
651 ALOGW("could not access %s for getmtime", filename.value().string());
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700652 *time = -1L;
653 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700654 }
655
Janis Danisevskisaf7783f2017-09-21 11:29:47 -0700656 int fd = TEMP_FAILURE_RETRY(open(filename.value().string(), O_NOFOLLOW, O_RDONLY));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700657 if (fd < 0) {
Janis Danisevskisaf7783f2017-09-21 11:29:47 -0700658 ALOGW("could not open %s for getmtime", filename.value().string());
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700659 *time = -1L;
660 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700661 }
662
663 struct stat s;
664 int ret = fstat(fd, &s);
665 close(fd);
666 if (ret == -1) {
Janis Danisevskisaf7783f2017-09-21 11:29:47 -0700667 ALOGW("could not stat %s for getmtime", filename.value().string());
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700668 *time = -1L;
669 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700670 }
671
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700672 *time = static_cast<int64_t>(s.st_mtime);
673 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700674}
675
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700676Status KeyStoreService::is_hardware_backed(const String16& keyType, int32_t* aidl_return) {
677 *aidl_return = static_cast<int32_t>(mKeyStore->isHardwareBacked(keyType) ? 1 : 0);
678 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700679}
680
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700681Status KeyStoreService::clear_uid(int64_t targetUid64, int32_t* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700682 uid_t targetUid = getEffectiveUid(targetUid64);
683 if (!checkBinderPermissionSelfOrSystem(P_CLEAR_UID, targetUid)) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700684 *aidl_return = static_cast<int32_t>(ResponseCode::PERMISSION_DENIED);
685 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700686 }
Rubin Xu7675c9f2017-03-15 19:26:52 +0000687 ALOGI("clear_uid %" PRId64, targetUid64);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700688
Janis Danisevskisaf7783f2017-09-21 11:29:47 -0700689 mKeyStore->removeAllGrantsToUid(targetUid);
690
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700691 String8 prefix = String8::format("%u_", targetUid);
692 Vector<String16> aliases;
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100693 if (mKeyStore->list(prefix, &aliases, get_user_id(targetUid)) != ResponseCode::NO_ERROR) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700694 *aidl_return = static_cast<int32_t>(ResponseCode::SYSTEM_ERROR);
695 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700696 }
697
698 for (uint32_t i = 0; i < aliases.size(); i++) {
699 String8 name8(aliases[i]);
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -0400700 String8 filename(mKeyStore->getKeyNameForUidWithDir(name8, targetUid, ::TYPE_ANY));
Rubin Xu85c85e92017-04-26 20:07:30 +0100701
702 if (get_app_id(targetUid) == AID_SYSTEM) {
703 Blob keyBlob;
704 ResponseCode responseCode =
705 mKeyStore->get(filename.string(), &keyBlob, ::TYPE_ANY, get_user_id(targetUid));
706 if (responseCode == ResponseCode::NO_ERROR && keyBlob.isCriticalToDeviceEncryption()) {
707 // Do not clear keys critical to device encryption under system uid.
708 continue;
709 }
710 }
711
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700712 mKeyStore->del(filename.string(), ::TYPE_ANY, get_user_id(targetUid));
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -0400713
714 // del() will fail silently if no cached characteristics are present for this alias.
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100715 String8 chr_filename(
716 mKeyStore->getKeyNameForUidWithDir(name8, targetUid, ::TYPE_KEY_CHARACTERISTICS));
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -0400717 mKeyStore->del(chr_filename.string(), ::TYPE_KEY_CHARACTERISTICS, get_user_id(targetUid));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700718 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700719 *aidl_return = static_cast<int32_t>(ResponseCode::NO_ERROR);
720 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700721}
722
Janis Danisevskisc1460142017-12-18 16:48:46 -0800723Status KeyStoreService::addRngEntropy(const ::std::vector<uint8_t>& entropy, int32_t flags,
724 int32_t* aidl_return) {
725 auto device = mKeyStore->getDevice(flagsToSecurityLevel(flags));
726 if (!device) {
727 *aidl_return = static_cast<int32_t>(ErrorCode::HARDWARE_TYPE_UNAVAILABLE);
728 } else {
729 *aidl_return = static_cast<int32_t>(
730 KeyStoreServiceReturnCode(KS_HANDLE_HIDL_ERROR(device->addRngEntropy(entropy))));
731 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700732 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700733}
734
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700735Status
736KeyStoreService::generateKey(const String16& name, const KeymasterArguments& params,
737 const ::std::vector<uint8_t>& entropy, int uid, int flags,
738 android::security::keymaster::KeyCharacteristics* outCharacteristics,
739 int32_t* aidl_return) {
Max Biresef4f0672017-11-29 14:38:48 -0800740 // TODO(jbires): remove this getCallingUid call upon implementation of b/25646100
741 uid_t originalUid = IPCThreadState::self()->getCallingUid();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700742 uid = getEffectiveUid(uid);
Pavel Grafovff311b42018-01-24 20:34:37 +0000743 auto logOnScopeExit = android::base::make_scope_guard([&] {
744 if (__android_log_security()) {
745 android_log_event_list(SEC_TAG_AUTH_KEY_GENERATED)
746 << int32_t(*aidl_return == static_cast<int32_t>(ResponseCode::NO_ERROR))
747 << String8(name) << int32_t(uid) << LOG_ID_SECURITY;
748 }
749 });
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100750 KeyStoreServiceReturnCode rc =
751 checkBinderPermissionAndKeystoreState(P_INSERT, uid, flags & KEYSTORE_FLAG_ENCRYPTED);
752 if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700753 *aidl_return = static_cast<int32_t>(rc);
754 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700755 }
Rubin Xu67899de2017-04-21 19:15:13 +0100756 if ((flags & KEYSTORE_FLAG_CRITICAL_TO_DEVICE_ENCRYPTION) && get_app_id(uid) != AID_SYSTEM) {
757 ALOGE("Non-system uid %d cannot set FLAG_CRITICAL_TO_DEVICE_ENCRYPTION", uid);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700758 *aidl_return = static_cast<int32_t>(ResponseCode::PERMISSION_DENIED);
759 return Status::ok();
Rubin Xu67899de2017-04-21 19:15:13 +0100760 }
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700761
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700762 if (containsTag(params.getParameters(), Tag::INCLUDE_UNIQUE_ID)) {
Shawn Willdenda6dcc32017-12-03 14:56:05 -0700763 // TODO(jbires): remove uid checking upon implementation of b/25646100
Max Bires670467d2017-12-12 11:16:43 -0800764 if (!checkBinderPermission(P_GEN_UNIQUE_ID) ||
Max Biresef4f0672017-11-29 14:38:48 -0800765 originalUid != IPCThreadState::self()->getCallingUid()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700766 *aidl_return = static_cast<int32_t>(ResponseCode::PERMISSION_DENIED);
767 return Status::ok();
768 }
Shawn Willdene2a7b522017-04-11 09:27:40 -0600769 }
770
Janis Danisevskisc1460142017-12-18 16:48:46 -0800771 SecurityLevel securityLevel = flagsToSecurityLevel(flags);
772 auto dev = mKeyStore->getDevice(securityLevel);
773 if (!dev) {
774 *aidl_return = static_cast<int32_t>(ErrorCode::HARDWARE_TYPE_UNAVAILABLE);
775 return Status::ok();
776 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700777 AuthorizationSet keyCharacteristics = params.getParameters();
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -0400778
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700779 // TODO: Seed from Linux RNG before this.
Janis Danisevskisc1460142017-12-18 16:48:46 -0800780 rc = KS_HANDLE_HIDL_ERROR(dev->addRngEntropy(entropy));
781 if (!rc.isOk()) {
782 *aidl_return = static_cast<int32_t>(rc);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700783 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700784 }
785
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100786 KeyStoreServiceReturnCode error;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700787 auto hidl_cb = [&](ErrorCode ret, const ::std::vector<uint8_t>& hidlKeyBlob,
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100788 const KeyCharacteristics& keyCharacteristics) {
789 error = ret;
790 if (!error.isOk()) {
791 return;
792 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700793 if (outCharacteristics)
794 *outCharacteristics =
795 ::android::security::keymaster::KeyCharacteristics(keyCharacteristics);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700796
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100797 // Write the key
798 String8 name8(name);
799 String8 filename(mKeyStore->getKeyNameForUidWithDir(name8, uid, ::TYPE_KEYMASTER_10));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700800
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100801 Blob keyBlob(&hidlKeyBlob[0], hidlKeyBlob.size(), NULL, 0, ::TYPE_KEYMASTER_10);
Janis Danisevskisc1460142017-12-18 16:48:46 -0800802 keyBlob.setSecurityLevel(securityLevel);
Rubin Xu67899de2017-04-21 19:15:13 +0100803 keyBlob.setCriticalToDeviceEncryption(flags & KEYSTORE_FLAG_CRITICAL_TO_DEVICE_ENCRYPTION);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700804 if (isAuthenticationBound(params.getParameters()) &&
805 !keyBlob.isCriticalToDeviceEncryption()) {
Shawn Willdend5a24e62017-02-28 13:53:24 -0700806 keyBlob.setSuperEncrypted(true);
807 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100808 keyBlob.setEncrypted(flags & KEYSTORE_FLAG_ENCRYPTED);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700809
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100810 error = mKeyStore->put(filename.string(), &keyBlob, get_user_id(uid));
811 };
812
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700813 rc = KS_HANDLE_HIDL_ERROR(dev->generateKey(params.getParameters(), hidl_cb));
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100814 if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700815 *aidl_return = static_cast<int32_t>(rc);
816 return Status::ok();
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -0400817 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100818 if (!error.isOk()) {
819 ALOGE("Failed to generate key -> falling back to software keymaster");
Janis Danisevskisc1460142017-12-18 16:48:46 -0800820 securityLevel = SecurityLevel::SOFTWARE;
Janis Danisevskise8ba1802017-01-30 10:49:51 +0000821 auto fallback = mKeyStore->getFallbackDevice();
Janis Danisevskisc1460142017-12-18 16:48:46 -0800822 if (!fallback) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700823 *aidl_return = static_cast<int32_t>(error);
824 return Status::ok();
Janis Danisevskise8ba1802017-01-30 10:49:51 +0000825 }
Janis Danisevskisc1460142017-12-18 16:48:46 -0800826 rc = KS_HANDLE_HIDL_ERROR(fallback->generateKey(params.getParameters(), hidl_cb));
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100827 if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700828 *aidl_return = static_cast<int32_t>(rc);
829 return Status::ok();
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100830 }
831 if (!error.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700832 *aidl_return = static_cast<int32_t>(error);
833 return Status::ok();
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100834 }
835 }
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -0400836
837 // Write the characteristics:
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100838 String8 name8(name);
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -0400839 String8 cFilename(mKeyStore->getKeyNameForUidWithDir(name8, uid, ::TYPE_KEY_CHARACTERISTICS));
840
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100841 std::stringstream kc_stream;
842 keyCharacteristics.Serialize(&kc_stream);
843 if (kc_stream.bad()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700844 *aidl_return = static_cast<int32_t>(ResponseCode::SYSTEM_ERROR);
845 return Status::ok();
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100846 }
847 auto kc_buf = kc_stream.str();
848 Blob charBlob(reinterpret_cast<const uint8_t*>(kc_buf.data()), kc_buf.size(), NULL, 0,
849 ::TYPE_KEY_CHARACTERISTICS);
Janis Danisevskisc1460142017-12-18 16:48:46 -0800850 charBlob.setSecurityLevel(securityLevel);
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -0400851 charBlob.setEncrypted(flags & KEYSTORE_FLAG_ENCRYPTED);
852
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700853 *aidl_return =
854 static_cast<int32_t>(mKeyStore->put(cFilename.string(), &charBlob, get_user_id(uid)));
855 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700856}
857
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700858Status KeyStoreService::getKeyCharacteristics(
859 const String16& name, const ::android::security::keymaster::KeymasterBlob& clientId,
Janis Danisevskis64ec1fe2018-02-26 16:47:21 -0800860 const ::android::security::keymaster::KeymasterBlob& appData, int32_t uid,
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700861 ::android::security::keymaster::KeyCharacteristics* outCharacteristics, int32_t* aidl_return) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700862 if (!outCharacteristics) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700863 *aidl_return =
864 static_cast<int32_t>(KeyStoreServiceReturnCode(ErrorCode::UNEXPECTED_NULL_POINTER));
865 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700866 }
867
868 uid_t targetUid = getEffectiveUid(uid);
869 uid_t callingUid = IPCThreadState::self()->getCallingUid();
870 if (!is_granted_to(callingUid, targetUid)) {
871 ALOGW("uid %d not permitted to act for uid %d in getKeyCharacteristics", callingUid,
872 targetUid);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700873 *aidl_return = static_cast<int32_t>(ResponseCode::PERMISSION_DENIED);
874 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700875 }
876
877 Blob keyBlob;
878 String8 name8(name);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700879
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100880 KeyStoreServiceReturnCode rc =
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700881 mKeyStore->getKeyForName(&keyBlob, name8, targetUid, TYPE_KEYMASTER_10);
Janis Danisevskisd714a672017-09-01 14:31:36 -0700882 if (rc == ResponseCode::UNINITIALIZED) {
883 /*
884 * If we fail reading the blob because the master key is missing we try to retrieve the
885 * key characteristics from the characteristics file. This happens when auth-bound
886 * keys are used after a screen lock has been removed by the user.
887 */
888 rc = mKeyStore->getKeyForName(&keyBlob, name8, targetUid, TYPE_KEY_CHARACTERISTICS);
889 if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700890 *aidl_return = static_cast<int32_t>(rc);
891 return Status::ok();
Janis Danisevskisd714a672017-09-01 14:31:36 -0700892 }
893 AuthorizationSet keyCharacteristics;
894 // TODO write one shot stream buffer to avoid copying (twice here)
895 std::string charBuffer(reinterpret_cast<const char*>(keyBlob.getValue()),
896 keyBlob.getLength());
897 std::stringstream charStream(charBuffer);
898 keyCharacteristics.Deserialize(&charStream);
899
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700900 outCharacteristics->softwareEnforced = KeymasterArguments(keyCharacteristics.hidl_data());
901 *aidl_return = static_cast<int32_t>(rc);
902 return Status::ok();
Janis Danisevskisd714a672017-09-01 14:31:36 -0700903 } else if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700904 *aidl_return = static_cast<int32_t>(rc);
905 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700906 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100907
908 auto hidlKeyBlob = blob2hidlVec(keyBlob);
Janis Danisevskisc1460142017-12-18 16:48:46 -0800909 auto dev = mKeyStore->getDevice(keyBlob);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100910
911 KeyStoreServiceReturnCode error;
912
913 auto hidlCb = [&](ErrorCode ret, const KeyCharacteristics& keyCharacteristics) {
914 error = ret;
915 if (!error.isOk()) {
Pavel Grafovcef39472018-02-12 18:45:02 +0000916 if (error == ErrorCode::INVALID_KEY_BLOB) {
917 log_key_integrity_violation(name8, targetUid);
918 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100919 return;
Shawn Willden98c59162016-03-20 09:10:18 -0600920 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700921 *outCharacteristics =
922 ::android::security::keymaster::KeyCharacteristics(keyCharacteristics);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100923 };
924
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700925 rc = KS_HANDLE_HIDL_ERROR(
Janis Danisevskis64ec1fe2018-02-26 16:47:21 -0800926 dev->getKeyCharacteristics(hidlKeyBlob, clientId.getData(), appData.getData(), hidlCb));
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100927 if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700928 *aidl_return = static_cast<int32_t>(rc);
929 return Status::ok();
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100930 }
931
932 if (error == ErrorCode::KEY_REQUIRES_UPGRADE) {
933 AuthorizationSet upgradeParams;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700934 if (clientId.getData().size()) {
935 upgradeParams.push_back(TAG_APPLICATION_ID, clientId.getData());
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100936 }
Janis Danisevskis64ec1fe2018-02-26 16:47:21 -0800937 if (appData.getData().size()) {
938 upgradeParams.push_back(TAG_APPLICATION_DATA, appData.getData());
Shawn Willden98c59162016-03-20 09:10:18 -0600939 }
940 rc = upgradeKeyBlob(name, targetUid, upgradeParams, &keyBlob);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100941 if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700942 *aidl_return = static_cast<int32_t>(rc);
943 return Status::ok();
Shawn Willden98c59162016-03-20 09:10:18 -0600944 }
Shawn Willden715d0232016-01-21 00:45:13 -0700945
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100946 auto upgradedHidlKeyBlob = blob2hidlVec(keyBlob);
947
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700948 rc = KS_HANDLE_HIDL_ERROR(dev->getKeyCharacteristics(
Janis Danisevskis64ec1fe2018-02-26 16:47:21 -0800949 upgradedHidlKeyBlob, clientId.getData(), appData.getData(), hidlCb));
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100950 if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700951 *aidl_return = static_cast<int32_t>(rc);
952 return Status::ok();
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100953 }
954 // Note that, on success, "error" will have been updated by the hidlCB callback.
955 // So it is fine to return "error" below.
956 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700957 *aidl_return = static_cast<int32_t>(KeyStoreServiceReturnCode(error));
958 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700959}
960
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700961Status
962KeyStoreService::importKey(const String16& name, const KeymasterArguments& params, int32_t format,
963 const ::std::vector<uint8_t>& keyData, int uid, int flags,
964 ::android::security::keymaster::KeyCharacteristics* outCharacteristics,
965 int32_t* aidl_return) {
966
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700967 uid = getEffectiveUid(uid);
Pavel Grafovff311b42018-01-24 20:34:37 +0000968 auto logOnScopeExit = android::base::make_scope_guard([&] {
969 if (__android_log_security()) {
970 android_log_event_list(SEC_TAG_KEY_IMPORTED)
971 << int32_t(*aidl_return == static_cast<int32_t>(ResponseCode::NO_ERROR))
972 << String8(name) << int32_t(uid) << LOG_ID_SECURITY;
973 }
974 });
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100975 KeyStoreServiceReturnCode rc =
976 checkBinderPermissionAndKeystoreState(P_INSERT, uid, flags & KEYSTORE_FLAG_ENCRYPTED);
977 if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700978 *aidl_return = static_cast<int32_t>(rc);
979 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700980 }
Rubin Xu67899de2017-04-21 19:15:13 +0100981 if ((flags & KEYSTORE_FLAG_CRITICAL_TO_DEVICE_ENCRYPTION) && get_app_id(uid) != AID_SYSTEM) {
982 ALOGE("Non-system uid %d cannot set FLAG_CRITICAL_TO_DEVICE_ENCRYPTION", uid);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700983 *aidl_return = static_cast<int32_t>(ResponseCode::PERMISSION_DENIED);
984 return Status::ok();
Rubin Xu67899de2017-04-21 19:15:13 +0100985 }
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700986
Janis Danisevskisc1460142017-12-18 16:48:46 -0800987 SecurityLevel securityLevel = flagsToSecurityLevel(flags);
988 auto dev = mKeyStore->getDevice(securityLevel);
989 if (!dev) {
990 *aidl_return = static_cast<int32_t>(ErrorCode::HARDWARE_TYPE_UNAVAILABLE);
991 return Status::ok();
992 }
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700993
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700994 String8 name8(name);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700995
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100996 KeyStoreServiceReturnCode error;
Shawn Willdenc1d1fee2016-01-26 22:44:56 -0700997
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -0700998 auto hidlCb = [&](ErrorCode ret, const ::std::vector<uint8_t>& keyBlob,
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +0100999 const KeyCharacteristics& keyCharacteristics) {
1000 error = ret;
1001 if (!error.isOk()) {
1002 return;
1003 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001004 if (outCharacteristics)
1005 *outCharacteristics =
1006 ::android::security::keymaster::KeyCharacteristics(keyCharacteristics);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001007
1008 // Write the key:
1009 String8 filename(mKeyStore->getKeyNameForUidWithDir(name8, uid, ::TYPE_KEYMASTER_10));
1010
1011 Blob ksBlob(&keyBlob[0], keyBlob.size(), NULL, 0, ::TYPE_KEYMASTER_10);
Janis Danisevskisc1460142017-12-18 16:48:46 -08001012 ksBlob.setSecurityLevel(securityLevel);
Rubin Xu67899de2017-04-21 19:15:13 +01001013 ksBlob.setCriticalToDeviceEncryption(flags & KEYSTORE_FLAG_CRITICAL_TO_DEVICE_ENCRYPTION);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001014 if (isAuthenticationBound(params.getParameters()) &&
1015 !ksBlob.isCriticalToDeviceEncryption()) {
Shawn Willdend5a24e62017-02-28 13:53:24 -07001016 ksBlob.setSuperEncrypted(true);
1017 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001018 ksBlob.setEncrypted(flags & KEYSTORE_FLAG_ENCRYPTED);
1019
1020 error = mKeyStore->put(filename.string(), &ksBlob, get_user_id(uid));
1021 };
1022
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001023 rc = KS_HANDLE_HIDL_ERROR(
1024 dev->importKey(params.getParameters(), KeyFormat(format), keyData, hidlCb));
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001025 // possible hidl error
1026 if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001027 *aidl_return = static_cast<int32_t>(rc);
1028 return Status::ok();
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -04001029 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001030 // now check error from callback
1031 if (!error.isOk()) {
1032 ALOGE("Failed to import key -> falling back to software keymaster");
Janis Danisevskisc1460142017-12-18 16:48:46 -08001033 securityLevel = SecurityLevel::SOFTWARE;
Janis Danisevskise8ba1802017-01-30 10:49:51 +00001034 auto fallback = mKeyStore->getFallbackDevice();
Janis Danisevskisc1460142017-12-18 16:48:46 -08001035 if (!fallback) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001036 *aidl_return = static_cast<int32_t>(error);
1037 return Status::ok();
Janis Danisevskise8ba1802017-01-30 10:49:51 +00001038 }
Janis Danisevskisc1460142017-12-18 16:48:46 -08001039 rc = KS_HANDLE_HIDL_ERROR(
1040 fallback->importKey(params.getParameters(), KeyFormat(format), keyData, hidlCb));
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001041 // possible hidl error
1042 if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001043 *aidl_return = static_cast<int32_t>(rc);
1044 return Status::ok();
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001045 }
1046 // now check error from callback
1047 if (!error.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001048 *aidl_return = static_cast<int32_t>(error);
1049 return Status::ok();
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001050 }
1051 }
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -04001052
1053 // Write the characteristics:
1054 String8 cFilename(mKeyStore->getKeyNameForUidWithDir(name8, uid, ::TYPE_KEY_CHARACTERISTICS));
1055
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001056 AuthorizationSet opParams = params.getParameters();
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001057 std::stringstream kcStream;
1058 opParams.Serialize(&kcStream);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001059 if (kcStream.bad()) {
1060 *aidl_return = static_cast<int32_t>(ResponseCode::SYSTEM_ERROR);
1061 return Status::ok();
1062 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001063 auto kcBuf = kcStream.str();
1064
1065 Blob charBlob(reinterpret_cast<const uint8_t*>(kcBuf.data()), kcBuf.size(), NULL, 0,
1066 ::TYPE_KEY_CHARACTERISTICS);
Janis Danisevskisc1460142017-12-18 16:48:46 -08001067 charBlob.setSecurityLevel(securityLevel);
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -04001068 charBlob.setEncrypted(flags & KEYSTORE_FLAG_ENCRYPTED);
1069
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001070 *aidl_return =
1071 static_cast<int32_t>(mKeyStore->put(cFilename.string(), &charBlob, get_user_id(uid)));
1072
1073 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001074}
1075
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001076Status KeyStoreService::exportKey(const String16& name, int32_t format,
1077 const ::android::security::keymaster::KeymasterBlob& clientId,
Janis Danisevskis64ec1fe2018-02-26 16:47:21 -08001078 const ::android::security::keymaster::KeymasterBlob& appData,
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001079 int32_t uid, ExportResult* result) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001080
1081 uid_t targetUid = getEffectiveUid(uid);
1082 uid_t callingUid = IPCThreadState::self()->getCallingUid();
1083 if (!is_granted_to(callingUid, targetUid)) {
1084 ALOGW("uid %d not permitted to act for uid %d in exportKey", callingUid, targetUid);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001085 result->resultCode = ResponseCode::PERMISSION_DENIED;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001086 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001087 }
1088
1089 Blob keyBlob;
1090 String8 name8(name);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001091
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001092 result->resultCode = mKeyStore->getKeyForName(&keyBlob, name8, targetUid, TYPE_KEYMASTER_10);
1093 if (!result->resultCode.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001094 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001095 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001096
1097 auto key = blob2hidlVec(keyBlob);
Janis Danisevskisc1460142017-12-18 16:48:46 -08001098 auto dev = mKeyStore->getDevice(keyBlob);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001099
1100 auto hidlCb = [&](ErrorCode ret, const ::android::hardware::hidl_vec<uint8_t>& keyMaterial) {
1101 result->resultCode = ret;
1102 if (!result->resultCode.isOk()) {
Pavel Grafovcef39472018-02-12 18:45:02 +00001103 if (result->resultCode == ErrorCode::INVALID_KEY_BLOB) {
1104 log_key_integrity_violation(name8, targetUid);
1105 }
Ji Wang2c142312016-10-14 17:21:10 +08001106 return;
1107 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001108 result->exportData = keyMaterial;
1109 };
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001110 KeyStoreServiceReturnCode rc = KS_HANDLE_HIDL_ERROR(
Janis Danisevskis64ec1fe2018-02-26 16:47:21 -08001111 dev->exportKey(KeyFormat(format), key, clientId.getData(), appData.getData(), hidlCb));
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001112 // Overwrite result->resultCode only on HIDL error. Otherwise we want the result set in the
1113 // callback hidlCb.
1114 if (!rc.isOk()) {
1115 result->resultCode = rc;
Ji Wang2c142312016-10-14 17:21:10 +08001116 }
1117
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001118 if (result->resultCode == ErrorCode::KEY_REQUIRES_UPGRADE) {
1119 AuthorizationSet upgradeParams;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001120 if (clientId.getData().size()) {
1121 upgradeParams.push_back(TAG_APPLICATION_ID, clientId.getData());
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001122 }
Janis Danisevskis64ec1fe2018-02-26 16:47:21 -08001123 if (appData.getData().size()) {
1124 upgradeParams.push_back(TAG_APPLICATION_DATA, appData.getData());
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001125 }
1126 result->resultCode = upgradeKeyBlob(name, targetUid, upgradeParams, &keyBlob);
1127 if (!result->resultCode.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001128 return Status::ok();
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001129 }
1130
1131 auto upgradedHidlKeyBlob = blob2hidlVec(keyBlob);
1132
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001133 result->resultCode = KS_HANDLE_HIDL_ERROR(dev->exportKey(
Janis Danisevskis64ec1fe2018-02-26 16:47:21 -08001134 KeyFormat(format), upgradedHidlKeyBlob, clientId.getData(), appData.getData(), hidlCb));
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001135 if (!result->resultCode.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001136 return Status::ok();
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001137 }
1138 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001139 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001140}
1141
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001142Status KeyStoreService::begin(const sp<IBinder>& appToken, const String16& name, int32_t purpose,
1143 bool pruneable, const KeymasterArguments& params,
1144 const ::std::vector<uint8_t>& entropy, int32_t uid,
1145 OperationResult* result) {
Shawn Willden0329a822017-12-04 13:55:14 -07001146 auto keyPurpose = static_cast<KeyPurpose>(purpose);
1147
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001148 uid_t callingUid = IPCThreadState::self()->getCallingUid();
1149 uid_t targetUid = getEffectiveUid(uid);
1150 if (!is_granted_to(callingUid, targetUid)) {
1151 ALOGW("uid %d not permitted to act for uid %d in begin", callingUid, targetUid);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001152 result->resultCode = ResponseCode::PERMISSION_DENIED;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001153 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001154 }
1155 if (!pruneable && get_app_id(callingUid) != AID_SYSTEM) {
1156 ALOGE("Non-system uid %d trying to start non-pruneable operation", callingUid);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001157 result->resultCode = ResponseCode::PERMISSION_DENIED;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001158 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001159 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001160 if (!checkAllowedOperationParams(params.getParameters())) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001161 result->resultCode = ErrorCode::INVALID_ARGUMENT;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001162 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001163 }
Shawn Willden0329a822017-12-04 13:55:14 -07001164
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001165 Blob keyBlob;
1166 String8 name8(name);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001167 result->resultCode = mKeyStore->getKeyForName(&keyBlob, name8, targetUid, TYPE_KEYMASTER_10);
Shawn Willdend5a24e62017-02-28 13:53:24 -07001168 if (result->resultCode == ResponseCode::LOCKED && keyBlob.isSuperEncrypted()) {
1169 result->resultCode = ErrorCode::KEY_USER_NOT_AUTHENTICATED;
1170 }
Shawn Willden0329a822017-12-04 13:55:14 -07001171 if (!result->resultCode.isOk()) return Status::ok();
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001172
1173 auto key = blob2hidlVec(keyBlob);
Janis Danisevskisc1460142017-12-18 16:48:46 -08001174 auto dev = mKeyStore->getDevice(keyBlob);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001175 AuthorizationSet opParams = params.getParameters();
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001176 KeyCharacteristics characteristics;
1177 result->resultCode = getOperationCharacteristics(key, &dev, opParams, &characteristics);
1178
1179 if (result->resultCode == ErrorCode::KEY_REQUIRES_UPGRADE) {
1180 result->resultCode = upgradeKeyBlob(name, targetUid, opParams, &keyBlob);
1181 if (!result->resultCode.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001182 return Status::ok();
Shawn Willden98c59162016-03-20 09:10:18 -06001183 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001184 key = blob2hidlVec(keyBlob);
1185 result->resultCode = getOperationCharacteristics(key, &dev, opParams, &characteristics);
Shawn Willden98c59162016-03-20 09:10:18 -06001186 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001187 if (!result->resultCode.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001188 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001189 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001190
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -04001191 // Merge these characteristics with the ones cached when the key was generated or imported
1192 Blob charBlob;
1193 AuthorizationSet persistedCharacteristics;
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001194 result->resultCode =
1195 mKeyStore->getKeyForName(&charBlob, name8, targetUid, TYPE_KEY_CHARACTERISTICS);
1196 if (result->resultCode.isOk()) {
1197 // TODO write one shot stream buffer to avoid copying (twice here)
1198 std::string charBuffer(reinterpret_cast<const char*>(charBlob.getValue()),
1199 charBlob.getLength());
1200 std::stringstream charStream(charBuffer);
1201 persistedCharacteristics.Deserialize(&charStream);
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -04001202 } else {
1203 ALOGD("Unable to read cached characteristics for key");
1204 }
1205
1206 // Replace the sw_enforced set with those persisted to disk, minus hw_enforced
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001207 AuthorizationSet softwareEnforced = characteristics.softwareEnforced;
Shawn Willden0329a822017-12-04 13:55:14 -07001208 AuthorizationSet hardwareEnforced = characteristics.hardwareEnforced;
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001209 persistedCharacteristics.Union(softwareEnforced);
Shawn Willden0329a822017-12-04 13:55:14 -07001210 persistedCharacteristics.Subtract(hardwareEnforced);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001211 characteristics.softwareEnforced = persistedCharacteristics.hidl_data();
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -04001212
Shawn Willden0329a822017-12-04 13:55:14 -07001213 KeyStoreServiceReturnCode authResult;
1214 HardwareAuthToken authToken;
1215 std::tie(authResult, authToken) =
1216 getAuthToken(characteristics, 0 /* no challenge */, keyPurpose,
1217 /*failOnTokenMissing*/ false);
1218
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001219 // If per-operation auth is needed we need to begin the operation and
1220 // the client will need to authorize that operation before calling
1221 // update. Any other auth issues stop here.
Shawn Willden827243a2017-09-12 05:41:33 -06001222 if (!authResult.isOk() && authResult != ResponseCode::OP_AUTH_NEEDED) {
1223 result->resultCode = authResult;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001224 return Status::ok();
Shawn Willden827243a2017-09-12 05:41:33 -06001225 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001226
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001227 // Add entropy to the device first.
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001228 if (entropy.size()) {
Janis Danisevskisc1460142017-12-18 16:48:46 -08001229 result->resultCode = KS_HANDLE_HIDL_ERROR(dev->addRngEntropy(entropy));
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001230 if (!result->resultCode.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001231 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001232 }
1233 }
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001234
1235 // Create a keyid for this key.
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001236 km_id_t keyid;
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001237 if (!enforcement_policy.CreateKeyId(key, &keyid)) {
1238 ALOGE("Failed to create a key ID for authorization checking.");
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001239 result->resultCode = ErrorCode::UNKNOWN_ERROR;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001240 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001241 }
1242
1243 // Check that all key authorization policy requirements are met.
Shawn Willden0329a822017-12-04 13:55:14 -07001244 AuthorizationSet key_auths = characteristics.hardwareEnforced;
1245 key_auths.append(characteristics.softwareEnforced.begin(),
1246 characteristics.softwareEnforced.end());
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001247
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001248 result->resultCode =
Shawn Willden0329a822017-12-04 13:55:14 -07001249 enforcement_policy.AuthorizeOperation(keyPurpose, keyid, key_auths, opParams, authToken,
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001250 0 /* op_handle */, true /* is_begin_operation */);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001251 if (!result->resultCode.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001252 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001253 }
1254
Shawn Willdene2a7b522017-04-11 09:27:40 -06001255 // If there are more than kMaxOperations, abort the oldest operation that was started as
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001256 // pruneable.
Shawn Willdene2a7b522017-04-11 09:27:40 -06001257 while (mOperationMap.getOperationCount() >= kMaxOperations) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001258 ALOGD("Reached or exceeded concurrent operations limit");
1259 if (!pruneOperation()) {
1260 break;
1261 }
1262 }
1263
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001264 auto hidlCb = [&](ErrorCode ret, const hidl_vec<KeyParameter>& outParams,
1265 uint64_t operationHandle) {
1266 result->resultCode = ret;
1267 if (!result->resultCode.isOk()) {
Pavel Grafovcef39472018-02-12 18:45:02 +00001268 if (result->resultCode == ErrorCode::INVALID_KEY_BLOB) {
1269 log_key_integrity_violation(name8, targetUid);
1270 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001271 return;
1272 }
1273 result->handle = operationHandle;
1274 result->outParams = outParams;
1275 };
1276
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001277 ErrorCode rc =
Shawn Willden0329a822017-12-04 13:55:14 -07001278 KS_HANDLE_HIDL_ERROR(dev->begin(keyPurpose, key, opParams.hidl_data(), authToken, hidlCb));
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001279 if (rc != ErrorCode::OK) {
1280 ALOGW("Got error %d from begin()", rc);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001281 }
1282
1283 // If there are too many operations abort the oldest operation that was
1284 // started as pruneable and try again.
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001285 while (rc == ErrorCode::TOO_MANY_OPERATIONS && mOperationMap.hasPruneableOperation()) {
1286 ALOGW("Ran out of operation handles");
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001287 if (!pruneOperation()) {
1288 break;
1289 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001290 rc = KS_HANDLE_HIDL_ERROR(
Shawn Willden0329a822017-12-04 13:55:14 -07001291 dev->begin(keyPurpose, key, opParams.hidl_data(), authToken, hidlCb));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001292 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001293 if (rc != ErrorCode::OK) {
1294 result->resultCode = rc;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001295 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001296 }
1297
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001298 // Note: The operation map takes possession of the contents of "characteristics".
1299 // It is safe to use characteristics after the following line but it will be empty.
Shawn Willden0329a822017-12-04 13:55:14 -07001300 sp<IBinder> operationToken = mOperationMap.addOperation(
1301 result->handle, keyid, keyPurpose, dev, appToken, std::move(characteristics), pruneable);
1302 assert(characteristics.hardwareEnforced.size() == 0);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001303 assert(characteristics.softwareEnforced.size() == 0);
Shawn Willdenc5e8f362017-08-31 09:23:06 -06001304 result->token = operationToken;
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001305
Shawn Willden0329a822017-12-04 13:55:14 -07001306 mOperationMap.setOperationAuthToken(operationToken, std::move(authToken));
1307
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001308 // Return the authentication lookup result. If this is a per operation
1309 // auth'd key then the resultCode will be ::OP_AUTH_NEEDED and the
1310 // application should get an auth token using the handle before the
1311 // first call to update, which will fail if keystore hasn't received the
1312 // auth token.
Shawn Willden2f96c792017-09-07 23:59:08 -06001313 if (result->resultCode == ErrorCode::OK) {
1314 result->resultCode = authResult;
1315 }
Shawn Willdenc5e8f362017-08-31 09:23:06 -06001316
1317 // Other result fields were set in the begin operation's callback.
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001318 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001319}
1320
David Zeuthenc6eb7cd2017-11-27 11:33:55 -05001321void KeyStoreService::appendConfirmationTokenIfNeeded(const KeyCharacteristics& keyCharacteristics,
1322 std::vector<KeyParameter>* params) {
1323 if (!(containsTag(keyCharacteristics.softwareEnforced, Tag::TRUSTED_CONFIRMATION_REQUIRED) ||
1324 containsTag(keyCharacteristics.hardwareEnforced, Tag::TRUSTED_CONFIRMATION_REQUIRED))) {
1325 return;
1326 }
1327
1328 hidl_vec<uint8_t> confirmationToken = mConfirmationManager->getLatestConfirmationToken();
1329 if (confirmationToken.size() == 0) {
1330 return;
1331 }
1332
1333 params->push_back(
1334 Authorization(keymaster::TAG_CONFIRMATION_TOKEN, std::move(confirmationToken)));
1335 ALOGD("Appending confirmation token\n");
1336}
1337
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001338Status KeyStoreService::update(const sp<IBinder>& token, const KeymasterArguments& params,
1339 const ::std::vector<uint8_t>& data, OperationResult* result) {
1340 if (!checkAllowedOperationParams(params.getParameters())) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001341 result->resultCode = ErrorCode::INVALID_ARGUMENT;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001342 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001343 }
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001344
1345 auto getOpResult = mOperationMap.getOperation(token);
1346 if (!getOpResult.isOk()) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001347 result->resultCode = ErrorCode::INVALID_OPERATION_HANDLE;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001348 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001349 }
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001350 const auto& op = getOpResult.value();
1351
Shawn Willden0329a822017-12-04 13:55:14 -07001352 HardwareAuthToken authToken;
1353 std::tie(result->resultCode, authToken) = getOperationAuthTokenIfNeeded(token);
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001354 if (!result->resultCode.isOk()) return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001355
1356 // Check that all key authorization policy requirements are met.
Shawn Willden0329a822017-12-04 13:55:14 -07001357 AuthorizationSet key_auths(op.characteristics.hardwareEnforced);
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001358 key_auths.append(op.characteristics.softwareEnforced.begin(),
1359 op.characteristics.softwareEnforced.end());
1360
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001361 result->resultCode = enforcement_policy.AuthorizeOperation(
Shawn Willden0329a822017-12-04 13:55:14 -07001362 op.purpose, op.keyid, key_auths, params.getParameters(), authToken, op.handle,
1363 false /* is_begin_operation */);
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001364 if (!result->resultCode.isOk()) return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001365
David Zeuthenc6eb7cd2017-11-27 11:33:55 -05001366 std::vector<KeyParameter> inParams = params.getParameters();
1367 appendConfirmationTokenIfNeeded(op.characteristics, &inParams);
1368
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001369 auto hidlCb = [&](ErrorCode ret, uint32_t inputConsumed,
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001370 const hidl_vec<KeyParameter>& outParams,
1371 const ::std::vector<uint8_t>& output) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001372 result->resultCode = ret;
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001373 if (result->resultCode.isOk()) {
1374 result->inputConsumed = inputConsumed;
1375 result->outParams = outParams;
1376 result->data = output;
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001377 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001378 };
1379
David Zeuthenc6eb7cd2017-11-27 11:33:55 -05001380 KeyStoreServiceReturnCode rc = KS_HANDLE_HIDL_ERROR(
1381 op.device->update(op.handle, inParams, data, authToken, VerificationToken(), hidlCb));
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001382
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001383 // just a reminder: on success result->resultCode was set in the callback. So we only overwrite
1384 // it if there was a communication error indicated by the ErrorCode.
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001385 if (!rc.isOk()) result->resultCode = rc;
1386
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001387 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001388}
1389
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001390Status KeyStoreService::finish(const sp<IBinder>& token, const KeymasterArguments& params,
1391 const ::std::vector<uint8_t>& signature,
1392 const ::std::vector<uint8_t>& entropy, OperationResult* result) {
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001393 auto getOpResult = mOperationMap.getOperation(token);
1394 if (!getOpResult.isOk()) {
1395 result->resultCode = ErrorCode::INVALID_OPERATION_HANDLE;
1396 return Status::ok();
1397 }
1398 const auto& op = std::move(getOpResult.value());
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001399 if (!checkAllowedOperationParams(params.getParameters())) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001400 result->resultCode = ErrorCode::INVALID_ARGUMENT;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001401 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001402 }
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001403
Shawn Willden0329a822017-12-04 13:55:14 -07001404 HardwareAuthToken authToken;
1405 std::tie(result->resultCode, authToken) = getOperationAuthTokenIfNeeded(token);
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001406 if (!result->resultCode.isOk()) return Status::ok();
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001407
1408 if (entropy.size()) {
Janis Danisevskisc1460142017-12-18 16:48:46 -08001409 result->resultCode = KS_HANDLE_HIDL_ERROR(op.device->addRngEntropy(entropy));
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001410 if (!result->resultCode.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001411 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001412 }
1413 }
1414
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001415 // Check that all key authorization policy requirements are met.
Shawn Willden0329a822017-12-04 13:55:14 -07001416 AuthorizationSet key_auths(op.characteristics.hardwareEnforced);
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001417 key_auths.append(op.characteristics.softwareEnforced.begin(),
1418 op.characteristics.softwareEnforced.end());
1419
David Zeuthenc6eb7cd2017-11-27 11:33:55 -05001420 std::vector<KeyParameter> inParams = params.getParameters();
1421 appendConfirmationTokenIfNeeded(op.characteristics, &inParams);
1422
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001423 result->resultCode = enforcement_policy.AuthorizeOperation(
Shawn Willden0329a822017-12-04 13:55:14 -07001424 op.purpose, op.keyid, key_auths, params.getParameters(), authToken, op.handle,
1425 false /* is_begin_operation */);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001426 if (!result->resultCode.isOk()) return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001427
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001428 auto hidlCb = [&](ErrorCode ret, const hidl_vec<KeyParameter>& outParams,
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001429 const ::std::vector<uint8_t>& output) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001430 result->resultCode = ret;
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001431 if (result->resultCode.isOk()) {
1432 result->outParams = outParams;
1433 result->data = output;
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001434 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001435 };
1436
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001437 KeyStoreServiceReturnCode rc = KS_HANDLE_HIDL_ERROR(
David Zeuthenc6eb7cd2017-11-27 11:33:55 -05001438 op.device->finish(op.handle, inParams,
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001439 ::std::vector<uint8_t>() /* TODO(swillden): wire up input to finish() */,
Shawn Willden0329a822017-12-04 13:55:14 -07001440 signature, authToken, VerificationToken(), hidlCb));
Wolloh Choucb61d0c2018-03-20 15:28:00 +08001441 // removeOperation() will free the memory 'op' used, so the order is important
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001442 mAuthTokenTable.MarkCompleted(op.handle);
Wolloh Choucb61d0c2018-03-20 15:28:00 +08001443 mOperationMap.removeOperation(token);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001444
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001445 // just a reminder: on success result->resultCode was set in the callback. So we only overwrite
1446 // it if there was a communication error indicated by the ErrorCode.
1447 if (!rc.isOk()) {
1448 result->resultCode = rc;
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001449 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001450 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001451}
1452
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001453Status KeyStoreService::abort(const sp<IBinder>& token, int32_t* aidl_return) {
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001454 auto getOpResult = mOperationMap.removeOperation(token);
1455 if (!getOpResult.isOk()) {
1456 *aidl_return = static_cast<int32_t>(ErrorCode::INVALID_OPERATION_HANDLE);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001457 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001458 }
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001459 auto op = std::move(getOpResult.value());
1460 mAuthTokenTable.MarkCompleted(op.handle);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001461
Shawn Willdenda6dcc32017-12-03 14:56:05 -07001462 ErrorCode error_code = KS_HANDLE_HIDL_ERROR(op.device->abort(op.handle));
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001463 *aidl_return = static_cast<int32_t>(KeyStoreServiceReturnCode(error_code));
1464 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001465}
1466
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001467Status KeyStoreService::isOperationAuthorized(const sp<IBinder>& token, bool* aidl_return) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001468 AuthorizationSet ignored;
Shawn Willden0329a822017-12-04 13:55:14 -07001469 KeyStoreServiceReturnCode rc;
1470 std::tie(rc, std::ignore) = getOperationAuthTokenIfNeeded(token);
1471 *aidl_return = rc.isOk();
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001472 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001473}
1474
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001475Status KeyStoreService::addAuthToken(const ::std::vector<uint8_t>& authTokenAsVector,
Brian Youngccb492d2018-02-22 23:36:01 +00001476 int32_t* aidl_return) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001477
Shawn Willdend3ed3a22017-03-28 00:39:16 +00001478 // TODO(swillden): When gatekeeper and fingerprint are ready, this should be updated to
1479 // receive a HardwareAuthToken, rather than an opaque byte array.
1480
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001481 if (!checkBinderPermission(P_ADD_AUTH)) {
1482 ALOGW("addAuthToken: permission denied for %d", IPCThreadState::self()->getCallingUid());
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001483 *aidl_return = static_cast<int32_t>(ResponseCode::PERMISSION_DENIED);
1484 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001485 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001486 if (authTokenAsVector.size() != sizeof(hw_auth_token_t)) {
1487 *aidl_return = static_cast<int32_t>(KeyStoreServiceReturnCode(ErrorCode::INVALID_ARGUMENT));
1488 return Status::ok();
Shawn Willdend3ed3a22017-03-28 00:39:16 +00001489 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001490
Shawn Willdend3ed3a22017-03-28 00:39:16 +00001491 hw_auth_token_t authToken;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001492 memcpy(reinterpret_cast<void*>(&authToken), authTokenAsVector.data(), sizeof(hw_auth_token_t));
Shawn Willdend3ed3a22017-03-28 00:39:16 +00001493 if (authToken.version != 0) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001494 *aidl_return = static_cast<int32_t>(KeyStoreServiceReturnCode(ErrorCode::INVALID_ARGUMENT));
1495 return Status::ok();
Shawn Willdend3ed3a22017-03-28 00:39:16 +00001496 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001497
Shawn Willden0329a822017-12-04 13:55:14 -07001498 mAuthTokenTable.AddAuthenticationToken(hidlVec2AuthToken(hidl_vec<uint8_t>(authTokenAsVector)));
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001499 *aidl_return = static_cast<int32_t>(ResponseCode::NO_ERROR);
1500 return Status::ok();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001501}
1502
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001503bool isDeviceIdAttestationRequested(const KeymasterArguments& params) {
1504 const hardware::hidl_vec<KeyParameter> paramsVec = params.getParameters();
1505 for (size_t i = 0; i < paramsVec.size(); ++i) {
1506 switch (paramsVec[i].tag) {
Shawn Willdene2a7b522017-04-11 09:27:40 -06001507 case Tag::ATTESTATION_ID_BRAND:
1508 case Tag::ATTESTATION_ID_DEVICE:
1509 case Tag::ATTESTATION_ID_IMEI:
1510 case Tag::ATTESTATION_ID_MANUFACTURER:
1511 case Tag::ATTESTATION_ID_MEID:
1512 case Tag::ATTESTATION_ID_MODEL:
1513 case Tag::ATTESTATION_ID_PRODUCT:
1514 case Tag::ATTESTATION_ID_SERIAL:
1515 return true;
1516 default:
1517 break;
Bartosz Fabianowskia9452d92017-01-23 22:21:11 +01001518 }
1519 }
1520 return false;
1521}
1522
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001523Status KeyStoreService::attestKey(const String16& name, const KeymasterArguments& params,
1524 ::android::security::keymaster::KeymasterCertificateChain* chain,
1525 int32_t* aidl_return) {
1526 // check null output if method signature is updated and return ErrorCode::OUTPUT_PARAMETER_NULL
1527 if (!checkAllowedOperationParams(params.getParameters())) {
1528 *aidl_return = static_cast<int32_t>(KeyStoreServiceReturnCode(ErrorCode::INVALID_ARGUMENT));
1529 return Status::ok();
Shawn Willden50eb1b22016-01-21 12:41:23 -07001530 }
1531
Eran Messerie2c34152017-12-21 21:01:22 +00001532 uid_t callingUid = IPCThreadState::self()->getCallingUid();
1533
1534 if (isDeviceIdAttestationRequested(params) && (callingUid != AID_SYSTEM)) {
1535 // Only the system context may request Device ID attestation combined with key attestation.
1536 // Otherwise, There is a dedicated attestDeviceIds() method for device ID attestation.
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001537 *aidl_return = static_cast<int32_t>(KeyStoreServiceReturnCode(ErrorCode::INVALID_ARGUMENT));
1538 return Status::ok();
Bartosz Fabianowskia9452d92017-01-23 22:21:11 +01001539 }
1540
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001541 AuthorizationSet mutableParams = params.getParameters();
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001542 KeyStoreServiceReturnCode rc = updateParamsForAttestation(callingUid, &mutableParams);
1543 if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001544 *aidl_return = static_cast<int32_t>(rc);
1545 return Status::ok();
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001546 }
Shawn Willdene2a7b522017-04-11 09:27:40 -06001547
Shawn Willden50eb1b22016-01-21 12:41:23 -07001548 Blob keyBlob;
1549 String8 name8(name);
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001550 rc = mKeyStore->getKeyForName(&keyBlob, name8, callingUid, TYPE_KEYMASTER_10);
1551 if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001552 *aidl_return = static_cast<int32_t>(rc);
1553 return Status::ok();
Shawn Willden50eb1b22016-01-21 12:41:23 -07001554 }
1555
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001556 KeyStoreServiceReturnCode error;
1557 auto hidlCb = [&](ErrorCode ret, const hidl_vec<hidl_vec<uint8_t>>& certChain) {
1558 error = ret;
1559 if (!error.isOk()) {
1560 return;
1561 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001562 if (chain) {
1563 *chain = KeymasterCertificateChain(certChain);
1564 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001565 };
1566
1567 auto hidlKey = blob2hidlVec(keyBlob);
Janis Danisevskisc1460142017-12-18 16:48:46 -08001568 auto dev = mKeyStore->getDevice(keyBlob);
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001569 rc = KS_HANDLE_HIDL_ERROR(dev->attestKey(hidlKey, mutableParams.hidl_data(), hidlCb));
1570 if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001571 *aidl_return = static_cast<int32_t>(rc);
1572 return Status::ok();
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001573 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001574 *aidl_return = static_cast<int32_t>(error);
1575 return Status::ok();
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001576}
1577
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001578Status
1579KeyStoreService::attestDeviceIds(const KeymasterArguments& params,
1580 ::android::security::keymaster::KeymasterCertificateChain* chain,
1581 int32_t* aidl_return) {
1582 // check null output if method signature is updated and return ErrorCode::OUTPUT_PARAMETER_NULL
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001583
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001584 if (!checkAllowedOperationParams(params.getParameters())) {
1585 *aidl_return = static_cast<int32_t>(KeyStoreServiceReturnCode(ErrorCode::INVALID_ARGUMENT));
1586 return Status::ok();
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001587 }
1588
1589 if (!isDeviceIdAttestationRequested(params)) {
1590 // There is an attestKey() method for attesting keys without device ID attestation.
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001591 *aidl_return = static_cast<int32_t>(KeyStoreServiceReturnCode(ErrorCode::INVALID_ARGUMENT));
1592 return Status::ok();
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001593 }
1594
1595 uid_t callingUid = IPCThreadState::self()->getCallingUid();
1596 sp<IBinder> binder = defaultServiceManager()->getService(String16("permission"));
1597 if (binder == 0) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001598 *aidl_return =
1599 static_cast<int32_t>(KeyStoreServiceReturnCode(ErrorCode::CANNOT_ATTEST_IDS));
1600 return Status::ok();
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001601 }
1602 if (!interface_cast<IPermissionController>(binder)->checkPermission(
1603 String16("android.permission.READ_PRIVILEGED_PHONE_STATE"),
1604 IPCThreadState::self()->getCallingPid(), callingUid)) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001605 *aidl_return =
1606 static_cast<int32_t>(KeyStoreServiceReturnCode(ErrorCode::CANNOT_ATTEST_IDS));
1607 return Status::ok();
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001608 }
1609
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001610 AuthorizationSet mutableParams = params.getParameters();
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001611 KeyStoreServiceReturnCode rc = updateParamsForAttestation(callingUid, &mutableParams);
1612 if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001613 *aidl_return = static_cast<int32_t>(rc);
1614 return Status::ok();
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001615 }
1616
1617 // Generate temporary key.
Janis Danisevskisc1460142017-12-18 16:48:46 -08001618 sp<Keymaster> dev;
1619 SecurityLevel securityLevel;
1620 std::tie(dev, securityLevel) = mKeyStore->getMostSecureDevice();
1621
1622 if (securityLevel == SecurityLevel::SOFTWARE) {
1623 *aidl_return = static_cast<int32_t>(ResponseCode::SYSTEM_ERROR);
1624 return Status::ok();
1625 }
1626
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001627 KeyStoreServiceReturnCode error;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001628 ::std::vector<uint8_t> hidlKey;
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001629
1630 AuthorizationSet keyCharacteristics;
1631 keyCharacteristics.push_back(TAG_PURPOSE, KeyPurpose::VERIFY);
1632 keyCharacteristics.push_back(TAG_ALGORITHM, Algorithm::EC);
1633 keyCharacteristics.push_back(TAG_DIGEST, Digest::SHA_2_256);
1634 keyCharacteristics.push_back(TAG_NO_AUTH_REQUIRED);
1635 keyCharacteristics.push_back(TAG_EC_CURVE, EcCurve::P_256);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001636 auto generateHidlCb = [&](ErrorCode ret, const ::std::vector<uint8_t>& hidlKeyBlob,
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001637 const KeyCharacteristics&) {
1638 error = ret;
1639 if (!error.isOk()) {
1640 return;
1641 }
1642 hidlKey = hidlKeyBlob;
1643 };
1644
1645 rc = KS_HANDLE_HIDL_ERROR(dev->generateKey(keyCharacteristics.hidl_data(), generateHidlCb));
1646 if (!rc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001647 *aidl_return = static_cast<int32_t>(rc);
1648 return Status::ok();
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001649 }
1650 if (!error.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001651 *aidl_return = static_cast<int32_t>(error);
1652 return Status::ok();
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001653 }
1654
1655 // Attest key and device IDs.
1656 auto attestHidlCb = [&](ErrorCode ret, const hidl_vec<hidl_vec<uint8_t>>& certChain) {
1657 error = ret;
1658 if (!error.isOk()) {
1659 return;
1660 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001661 *chain = ::android::security::keymaster::KeymasterCertificateChain(certChain);
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001662 };
1663 KeyStoreServiceReturnCode attestationRc =
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001664 KS_HANDLE_HIDL_ERROR(dev->attestKey(hidlKey, mutableParams.hidl_data(), attestHidlCb));
Bartosz Fabianowski5aa93e02017-04-24 13:54:49 +02001665
1666 // Delete temporary key.
1667 KeyStoreServiceReturnCode deletionRc = KS_HANDLE_HIDL_ERROR(dev->deleteKey(hidlKey));
Bartosz Fabianowskia9452d92017-01-23 22:21:11 +01001668
1669 if (!attestationRc.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001670 *aidl_return = static_cast<int32_t>(attestationRc);
1671 return Status::ok();
Bartosz Fabianowskia9452d92017-01-23 22:21:11 +01001672 }
1673 if (!error.isOk()) {
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001674 *aidl_return = static_cast<int32_t>(error);
1675 return Status::ok();
Bartosz Fabianowskia9452d92017-01-23 22:21:11 +01001676 }
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001677 *aidl_return = static_cast<int32_t>(deletionRc);
1678 return Status::ok();
Shawn Willden50eb1b22016-01-21 12:41:23 -07001679}
1680
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001681Status KeyStoreService::onDeviceOffBody(int32_t* aidl_return) {
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -04001682 // TODO(tuckeris): add permission check. This should be callable from ClockworkHome only.
1683 mAuthTokenTable.onDeviceOffBody();
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001684 *aidl_return = static_cast<int32_t>(ResponseCode::NO_ERROR);
1685 return Status::ok();
Tucker Sylvestro0ab28b72016-08-05 18:02:47 -04001686}
1687
Janis Danisevskiscb9267d2017-12-19 16:27:52 -08001688#define AIDL_RETURN(rc) \
1689 (*_aidl_return = static_cast<int32_t>(KeyStoreServiceReturnCode(rc)), Status::ok())
1690
1691Status KeyStoreService::importWrappedKey(
1692 const ::android::String16& wrappedKeyAlias, const ::std::vector<uint8_t>& wrappedKey,
1693 const ::android::String16& wrappingKeyAlias, const ::std::vector<uint8_t>& maskingKey,
1694 const KeymasterArguments& params, int64_t rootSid, int64_t fingerprintSid,
1695 ::android::security::keymaster::KeyCharacteristics* outCharacteristics, int32_t* _aidl_return) {
1696
1697 uid_t callingUid = IPCThreadState::self()->getCallingUid();
1698
1699 if (!checkBinderPermission(P_INSERT, callingUid)) {
1700 return AIDL_RETURN(ResponseCode::PERMISSION_DENIED);
1701 }
1702
1703 Blob wrappingKeyBlob;
1704 String8 wrappingKeyName8(wrappingKeyAlias);
1705 KeyStoreServiceReturnCode rc =
1706 mKeyStore->getKeyForName(&wrappingKeyBlob, wrappingKeyName8, callingUid, TYPE_KEYMASTER_10);
1707 if (!rc.isOk()) {
1708 return AIDL_RETURN(rc);
1709 }
1710
1711 SecurityLevel securityLevel = wrappingKeyBlob.getSecurityLevel();
1712 auto dev = mKeyStore->getDevice(securityLevel);
1713 if (!dev) {
1714 return AIDL_RETURN(ErrorCode::HARDWARE_TYPE_UNAVAILABLE);
1715 }
1716
1717 auto hidlWrappingKey = blob2hidlVec(wrappingKeyBlob);
1718 String8 wrappedKeyAlias8(wrappedKeyAlias);
1719
1720 KeyStoreServiceReturnCode error;
1721
1722 auto hidlCb = [&](ErrorCode ret, const ::std::vector<uint8_t>& keyBlob,
1723 const KeyCharacteristics& keyCharacteristics) {
1724 error = ret;
1725 if (!error.isOk()) {
1726 return;
1727 }
1728 if (outCharacteristics) {
1729 *outCharacteristics =
1730 ::android::security::keymaster::KeyCharacteristics(keyCharacteristics);
1731 }
1732
1733 // Write the key:
1734 String8 filename(
1735 mKeyStore->getKeyNameForUidWithDir(wrappedKeyAlias8, callingUid, ::TYPE_KEYMASTER_10));
1736
1737 Blob ksBlob(&keyBlob[0], keyBlob.size(), NULL, 0, ::TYPE_KEYMASTER_10);
1738 ksBlob.setSecurityLevel(securityLevel);
1739
1740 if (containsTag(keyCharacteristics.hardwareEnforced, Tag::USER_SECURE_ID)) {
1741 ksBlob.setSuperEncrypted(true);
1742 }
1743
1744 error = mKeyStore->put(filename.string(), &ksBlob, get_user_id(callingUid));
1745 };
1746
Shawn Willden0a198a02018-01-19 13:36:31 -07001747 rc = KS_HANDLE_HIDL_ERROR(dev->importWrappedKey(wrappedKey, hidlWrappingKey, maskingKey,
1748 params.getParameters(), rootSid, fingerprintSid,
1749 hidlCb));
1750
Janis Danisevskiscb9267d2017-12-19 16:27:52 -08001751 // possible hidl error
1752 if (!rc.isOk()) {
1753 return AIDL_RETURN(rc);
1754 }
1755 // now check error from callback
1756 if (!error.isOk()) {
1757 return AIDL_RETURN(error);
1758 }
1759
1760 // Write the characteristics:
1761 String8 cFilename(mKeyStore->getKeyNameForUidWithDir(wrappedKeyAlias8, callingUid,
1762 ::TYPE_KEY_CHARACTERISTICS));
1763
1764 AuthorizationSet opParams = params.getParameters();
1765 std::stringstream kcStream;
1766 opParams.Serialize(&kcStream);
1767 if (kcStream.bad()) {
1768 return AIDL_RETURN(ResponseCode::SYSTEM_ERROR);
1769 }
1770 auto kcBuf = kcStream.str();
1771
1772 Blob charBlob(reinterpret_cast<const uint8_t*>(kcBuf.data()), kcBuf.size(), NULL, 0,
1773 ::TYPE_KEY_CHARACTERISTICS);
1774 charBlob.setSecurityLevel(securityLevel);
1775
1776 return AIDL_RETURN(mKeyStore->put(cFilename.string(), &charBlob, get_user_id(callingUid)));
1777}
1778
David Zeuthenc6eb7cd2017-11-27 11:33:55 -05001779Status KeyStoreService::presentConfirmationPrompt(const sp<IBinder>& listener,
1780 const String16& promptText,
1781 const ::std::vector<uint8_t>& extraData,
1782 const String16& locale, int32_t uiOptionsAsFlags,
1783 int32_t* aidl_return) {
1784 return mConfirmationManager->presentConfirmationPrompt(listener, promptText, extraData, locale,
1785 uiOptionsAsFlags, aidl_return);
1786}
1787
1788Status KeyStoreService::cancelConfirmationPrompt(const sp<IBinder>& listener,
1789 int32_t* aidl_return) {
1790 return mConfirmationManager->cancelConfirmationPrompt(listener, aidl_return);
1791}
1792
David Zeuthen1a492312018-02-26 11:00:30 -05001793Status KeyStoreService::isConfirmationPromptSupported(bool* aidl_return) {
1794 return mConfirmationManager->isConfirmationPromptSupported(aidl_return);
1795}
1796
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001797/**
1798 * Prune the oldest pruneable operation.
1799 */
1800bool KeyStoreService::pruneOperation() {
1801 sp<IBinder> oldest = mOperationMap.getOldestPruneableOperation();
1802 ALOGD("Trying to prune operation %p", oldest.get());
1803 size_t op_count_before_abort = mOperationMap.getOperationCount();
1804 // We mostly ignore errors from abort() because all we care about is whether at least
1805 // one operation has been removed.
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001806 int32_t abort_error;
1807 abort(oldest, &abort_error);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001808 if (mOperationMap.getOperationCount() >= op_count_before_abort) {
1809 ALOGE("Failed to abort pruneable operation %p, error: %d", oldest.get(), abort_error);
1810 return false;
1811 }
1812 return true;
1813}
1814
1815/**
1816 * Get the effective target uid for a binder operation that takes an
1817 * optional uid as the target.
1818 */
1819uid_t KeyStoreService::getEffectiveUid(int32_t targetUid) {
1820 if (targetUid == UID_SELF) {
1821 return IPCThreadState::self()->getCallingUid();
1822 }
1823 return static_cast<uid_t>(targetUid);
1824}
1825
1826/**
1827 * Check if the caller of the current binder method has the required
1828 * permission and if acting on other uids the grants to do so.
1829 */
1830bool KeyStoreService::checkBinderPermission(perm_t permission, int32_t targetUid) {
1831 uid_t callingUid = IPCThreadState::self()->getCallingUid();
1832 pid_t spid = IPCThreadState::self()->getCallingPid();
1833 if (!has_permission(callingUid, permission, spid)) {
1834 ALOGW("permission %s denied for %d", get_perm_label(permission), callingUid);
1835 return false;
1836 }
1837 if (!is_granted_to(callingUid, getEffectiveUid(targetUid))) {
1838 ALOGW("uid %d not granted to act for %d", callingUid, targetUid);
1839 return false;
1840 }
1841 return true;
1842}
1843
1844/**
1845 * Check if the caller of the current binder method has the required
1846 * permission and the target uid is the caller or the caller is system.
1847 */
1848bool KeyStoreService::checkBinderPermissionSelfOrSystem(perm_t permission, int32_t targetUid) {
1849 uid_t callingUid = IPCThreadState::self()->getCallingUid();
1850 pid_t spid = IPCThreadState::self()->getCallingPid();
1851 if (!has_permission(callingUid, permission, spid)) {
1852 ALOGW("permission %s denied for %d", get_perm_label(permission), callingUid);
1853 return false;
1854 }
1855 return getEffectiveUid(targetUid) == callingUid || callingUid == AID_SYSTEM;
1856}
1857
1858/**
1859 * Check if the caller of the current binder method has the required
1860 * permission or the target of the operation is the caller's uid. This is
1861 * for operation where the permission is only for cross-uid activity and all
1862 * uids are allowed to act on their own (ie: clearing all entries for a
1863 * given uid).
1864 */
1865bool KeyStoreService::checkBinderPermissionOrSelfTarget(perm_t permission, int32_t targetUid) {
1866 uid_t callingUid = IPCThreadState::self()->getCallingUid();
1867 if (getEffectiveUid(targetUid) == callingUid) {
1868 return true;
1869 } else {
1870 return checkBinderPermission(permission, targetUid);
1871 }
1872}
1873
1874/**
1875 * Helper method to check that the caller has the required permission as
1876 * well as the keystore is in the unlocked state if checkUnlocked is true.
1877 *
1878 * Returns NO_ERROR on success, PERMISSION_DENIED on a permission error and
1879 * otherwise the state of keystore when not unlocked and checkUnlocked is
1880 * true.
1881 */
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001882KeyStoreServiceReturnCode
1883KeyStoreService::checkBinderPermissionAndKeystoreState(perm_t permission, int32_t targetUid,
1884 bool checkUnlocked) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001885 if (!checkBinderPermission(permission, targetUid)) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001886 return ResponseCode::PERMISSION_DENIED;
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001887 }
1888 State state = mKeyStore->getState(get_user_id(getEffectiveUid(targetUid)));
1889 if (checkUnlocked && !isKeystoreUnlocked(state)) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001890 // All State values coincide with ResponseCodes
1891 return static_cast<ResponseCode>(state);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001892 }
1893
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001894 return ResponseCode::NO_ERROR;
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001895}
1896
1897bool KeyStoreService::isKeystoreUnlocked(State state) {
1898 switch (state) {
1899 case ::STATE_NO_ERROR:
1900 return true;
1901 case ::STATE_UNINITIALIZED:
1902 case ::STATE_LOCKED:
1903 return false;
1904 }
1905 return false;
1906}
1907
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001908/**
Shawn Willden0329a822017-12-04 13:55:14 -07001909 * Check that all KeyParameters provided by the application are allowed. Any parameter that keystore
1910 * adds itself should be disallowed here.
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001911 */
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001912bool KeyStoreService::checkAllowedOperationParams(const hidl_vec<KeyParameter>& params) {
1913 for (size_t i = 0; i < params.size(); ++i) {
1914 switch (params[i].tag) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001915 case Tag::ATTESTATION_APPLICATION_ID:
Shawn Willdene2a7b522017-04-11 09:27:40 -06001916 case Tag::RESET_SINCE_ID_ROTATION:
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001917 return false;
1918 default:
1919 break;
1920 }
1921 }
1922 return true;
1923}
1924
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001925ErrorCode KeyStoreService::getOperationCharacteristics(const hidl_vec<uint8_t>& key,
Shawn Willdenc67a8aa2017-12-03 17:51:29 -07001926 sp<Keymaster>* dev,
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001927 const AuthorizationSet& params,
1928 KeyCharacteristics* out) {
Janis Danisevskis64ec1fe2018-02-26 16:47:21 -08001929 ::std::vector<uint8_t> clientId;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001930 ::std::vector<uint8_t> appData;
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001931 for (auto param : params) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001932 if (param.tag == Tag::APPLICATION_ID) {
Janis Danisevskis64ec1fe2018-02-26 16:47:21 -08001933 clientId = authorizationValue(TAG_APPLICATION_ID, param).value();
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001934 } else if (param.tag == Tag::APPLICATION_DATA) {
Janis Danisevskis64ec1fe2018-02-26 16:47:21 -08001935 appData = authorizationValue(TAG_APPLICATION_DATA, param).value();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001936 }
1937 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001938 ErrorCode error = ErrorCode::OK;
1939
1940 auto hidlCb = [&](ErrorCode ret, const KeyCharacteristics& keyCharacteristics) {
1941 error = ret;
1942 if (error != ErrorCode::OK) {
1943 return;
1944 }
1945 if (out) *out = keyCharacteristics;
1946 };
1947
Janis Danisevskis64ec1fe2018-02-26 16:47:21 -08001948 ErrorCode rc =
1949 KS_HANDLE_HIDL_ERROR((*dev)->getKeyCharacteristics(key, clientId, appData, hidlCb));
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001950 if (rc != ErrorCode::OK) {
1951 return rc;
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001952 }
1953 return error;
1954}
1955
1956/**
Shawn Willdend3ed3a22017-03-28 00:39:16 +00001957 * Get the auth token for this operation from the auth token table.
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001958 *
Shawn Willdend3ed3a22017-03-28 00:39:16 +00001959 * Returns ResponseCode::NO_ERROR if the auth token was set or none was required.
1960 * ::OP_AUTH_NEEDED if it is a per op authorization, no
1961 * authorization token exists for that operation and
1962 * failOnTokenMissing is false.
1963 * KM_ERROR_KEY_USER_NOT_AUTHENTICATED if there is no valid auth
1964 * token for the operation
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001965 */
Shawn Willden0329a822017-12-04 13:55:14 -07001966std::pair<KeyStoreServiceReturnCode, HardwareAuthToken>
1967KeyStoreService::getAuthToken(const KeyCharacteristics& characteristics, uint64_t handle,
1968 KeyPurpose purpose, bool failOnTokenMissing) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001969
Shawn Willden0329a822017-12-04 13:55:14 -07001970 AuthorizationSet allCharacteristics(characteristics.softwareEnforced);
1971 allCharacteristics.append(characteristics.hardwareEnforced.begin(),
1972 characteristics.hardwareEnforced.end());
1973
1974 const HardwareAuthToken* authToken = nullptr;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001975 AuthTokenTable::Error err = mAuthTokenTable.FindAuthorization(
Shawn Willden0329a822017-12-04 13:55:14 -07001976 allCharacteristics, static_cast<KeyPurpose>(purpose), handle, &authToken);
1977
1978 KeyStoreServiceReturnCode rc;
1979
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001980 switch (err) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001981 case AuthTokenTable::OK:
1982 case AuthTokenTable::AUTH_NOT_REQUIRED:
Shawn Willden0329a822017-12-04 13:55:14 -07001983 rc = ResponseCode::NO_ERROR;
1984 break;
1985
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001986 case AuthTokenTable::AUTH_TOKEN_NOT_FOUND:
1987 case AuthTokenTable::AUTH_TOKEN_EXPIRED:
1988 case AuthTokenTable::AUTH_TOKEN_WRONG_SID:
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07001989 ALOGE("getAuthToken failed: %d", err); // STOPSHIP: debug only, to be removed
Shawn Willden0329a822017-12-04 13:55:14 -07001990 rc = ErrorCode::KEY_USER_NOT_AUTHENTICATED;
1991 break;
1992
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01001993 case AuthTokenTable::OP_HANDLE_REQUIRED:
Shawn Willden0329a822017-12-04 13:55:14 -07001994 rc = failOnTokenMissing ? KeyStoreServiceReturnCode(ErrorCode::KEY_USER_NOT_AUTHENTICATED)
1995 : KeyStoreServiceReturnCode(ResponseCode::OP_AUTH_NEEDED);
1996 break;
1997
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07001998 default:
1999 ALOGE("Unexpected FindAuthorization return value %d", err);
Shawn Willden0329a822017-12-04 13:55:14 -07002000 rc = ErrorCode::INVALID_ARGUMENT;
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002001 }
Shawn Willden0329a822017-12-04 13:55:14 -07002002
2003 return {rc, authToken ? std::move(*authToken) : HardwareAuthToken()};
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002004}
2005
2006/**
2007 * Add the auth token for the operation to the param list if the operation
2008 * requires authorization. Uses the cached result in the OperationMap if available
2009 * otherwise gets the token from the AuthTokenTable and caches the result.
2010 *
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002011 * Returns ResponseCode::NO_ERROR if the auth token was added or not needed.
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002012 * KM_ERROR_KEY_USER_NOT_AUTHENTICATED if the operation is not
2013 * authenticated.
2014 * KM_ERROR_INVALID_OPERATION_HANDLE if token is not a valid
2015 * operation token.
2016 */
Shawn Willden0329a822017-12-04 13:55:14 -07002017std::pair<KeyStoreServiceReturnCode, const HardwareAuthToken&>
2018KeyStoreService::getOperationAuthTokenIfNeeded(const sp<IBinder>& token) {
2019 static HardwareAuthToken emptyToken = {};
2020
Shawn Willdenda6dcc32017-12-03 14:56:05 -07002021 auto getOpResult = mOperationMap.getOperation(token);
Shawn Willden0329a822017-12-04 13:55:14 -07002022 if (!getOpResult.isOk()) return {ErrorCode::INVALID_OPERATION_HANDLE, emptyToken};
Shawn Willdenda6dcc32017-12-03 14:56:05 -07002023 const auto& op = getOpResult.value();
2024
Shawn Willden0329a822017-12-04 13:55:14 -07002025 if (!op.hasAuthToken()) {
2026 KeyStoreServiceReturnCode rc;
2027 HardwareAuthToken found;
2028 std::tie(rc, found) = getAuthToken(op.characteristics, op.handle, op.purpose);
2029 if (!rc.isOk()) return {rc, emptyToken};
2030 mOperationMap.setOperationAuthToken(token, std::move(found));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002031 }
Shawn Willden0329a822017-12-04 13:55:14 -07002032
2033 return {ResponseCode::NO_ERROR, op.authToken};
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002034}
2035
2036/**
2037 * Translate a result value to a legacy return value. All keystore errors are
2038 * preserved and keymaster errors become SYSTEM_ERRORs
2039 */
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002040KeyStoreServiceReturnCode KeyStoreService::translateResultToLegacyResult(int32_t result) {
Shawn Willden0329a822017-12-04 13:55:14 -07002041 if (result > 0) return static_cast<ResponseCode>(result);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002042 return ResponseCode::SYSTEM_ERROR;
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002043}
2044
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07002045static NullOr<const Algorithm&> getKeyAlgoritmFromKeyCharacteristics(
2046 const ::android::security::keymaster::KeyCharacteristics& characteristics) {
Shawn Willden0329a822017-12-04 13:55:14 -07002047 for (const auto& param : characteristics.hardwareEnforced.getParameters()) {
2048 auto algo = authorizationValue(TAG_ALGORITHM, param);
2049 if (algo.isOk()) return algo;
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002050 }
Shawn Willden0329a822017-12-04 13:55:14 -07002051 for (const auto& param : characteristics.softwareEnforced.getParameters()) {
2052 auto algo = authorizationValue(TAG_ALGORITHM, param);
2053 if (algo.isOk()) return algo;
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002054 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002055 return {};
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002056}
2057
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002058void KeyStoreService::addLegacyBeginParams(const String16& name, AuthorizationSet* params) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002059 // All legacy keys are DIGEST_NONE/PAD_NONE.
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002060 params->push_back(TAG_DIGEST, Digest::NONE);
2061 params->push_back(TAG_PADDING, PaddingMode::NONE);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002062
2063 // Look up the algorithm of the key.
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07002064 ::android::security::keymaster::KeyCharacteristics characteristics;
2065 int32_t result;
2066 auto rc = getKeyCharacteristics(name, ::android::security::keymaster::KeymasterBlob(),
2067 ::android::security::keymaster::KeymasterBlob(), UID_SELF,
2068 &characteristics, &result);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002069 if (!rc.isOk()) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002070 ALOGE("Failed to get key characteristics");
2071 return;
2072 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002073 auto algorithm = getKeyAlgoritmFromKeyCharacteristics(characteristics);
2074 if (!algorithm.isOk()) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002075 ALOGE("getKeyCharacteristics did not include KM_TAG_ALGORITHM");
2076 return;
2077 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002078 params->push_back(TAG_ALGORITHM, algorithm.value());
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002079}
2080
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002081KeyStoreServiceReturnCode KeyStoreService::doLegacySignVerify(const String16& name,
2082 const hidl_vec<uint8_t>& data,
2083 hidl_vec<uint8_t>* out,
2084 const hidl_vec<uint8_t>& signature,
2085 KeyPurpose purpose) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002086
2087 std::basic_stringstream<uint8_t> outBuffer;
2088 OperationResult result;
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002089 AuthorizationSet inArgs;
2090 addLegacyBeginParams(name, &inArgs);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002091 sp<IBinder> appToken(new BBinder);
2092 sp<IBinder> token;
2093
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07002094 begin(appToken, name, static_cast<int32_t>(purpose), true,
2095 KeymasterArguments(inArgs.hidl_data()), ::std::vector<uint8_t>(), UID_SELF, &result);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002096 if (!result.resultCode.isOk()) {
2097 if (result.resultCode == ResponseCode::KEY_NOT_FOUND) {
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002098 ALOGW("Key not found");
2099 } else {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002100 ALOGW("Error in begin: %d", int32_t(result.resultCode));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002101 }
2102 return translateResultToLegacyResult(result.resultCode);
2103 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002104 inArgs.Clear();
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002105 token = result.token;
2106 size_t consumed = 0;
2107 size_t lastConsumed = 0;
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002108 hidl_vec<uint8_t> data_view;
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002109 do {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002110 data_view.setToExternal(const_cast<uint8_t*>(&data[consumed]), data.size() - consumed);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07002111 update(token, KeymasterArguments(inArgs.hidl_data()), data_view, &result);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002112 if (result.resultCode != ResponseCode::NO_ERROR) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002113 ALOGW("Error in update: %d", int32_t(result.resultCode));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002114 return translateResultToLegacyResult(result.resultCode);
2115 }
2116 if (out) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002117 outBuffer.write(&result.data[0], result.data.size());
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002118 }
2119 lastConsumed = result.inputConsumed;
2120 consumed += lastConsumed;
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002121 } while (consumed < data.size() && lastConsumed > 0);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002122
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002123 if (consumed != data.size()) {
2124 ALOGW("Not all data consumed. Consumed %zu of %zu", consumed, data.size());
2125 return ResponseCode::SYSTEM_ERROR;
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002126 }
2127
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07002128 finish(token, KeymasterArguments(inArgs.hidl_data()), signature, ::std::vector<uint8_t>(),
2129 &result);
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002130 if (result.resultCode != ResponseCode::NO_ERROR) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002131 ALOGW("Error in finish: %d", int32_t(result.resultCode));
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002132 return translateResultToLegacyResult(result.resultCode);
2133 }
2134 if (out) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002135 outBuffer.write(&result.data[0], result.data.size());
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002136 }
2137
2138 if (out) {
2139 auto buf = outBuffer.str();
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002140 out->resize(buf.size());
2141 memcpy(&(*out)[0], buf.data(), out->size());
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002142 }
2143
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002144 return ResponseCode::NO_ERROR;
Shawn Willdenc1d1fee2016-01-26 22:44:56 -07002145}
2146
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002147KeyStoreServiceReturnCode KeyStoreService::upgradeKeyBlob(const String16& name, uid_t uid,
2148 const AuthorizationSet& params,
2149 Blob* blob) {
Shawn Willden98c59162016-03-20 09:10:18 -06002150 // Read the blob rather than assuming the caller provided the right name/uid/blob triplet.
2151 String8 name8(name);
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07002152 KeyStoreServiceReturnCode responseCode =
2153 mKeyStore->getKeyForName(blob, name8, uid, TYPE_KEYMASTER_10);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002154 if (responseCode != ResponseCode::NO_ERROR) {
Shawn Willden98c59162016-03-20 09:10:18 -06002155 return responseCode;
2156 }
Rubin Xu7675c9f2017-03-15 19:26:52 +00002157 ALOGI("upgradeKeyBlob %s %d", name8.string(), uid);
Shawn Willden98c59162016-03-20 09:10:18 -06002158
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002159 auto hidlKey = blob2hidlVec(*blob);
Janis Danisevskisc1460142017-12-18 16:48:46 -08002160 auto dev = mKeyStore->getDevice(*blob);
Shawn Willden98c59162016-03-20 09:10:18 -06002161
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002162 KeyStoreServiceReturnCode error;
Dmitry Dementyeva447b3c2017-10-27 23:09:53 -07002163 auto hidlCb = [&](ErrorCode ret, const ::std::vector<uint8_t>& upgradedKeyBlob) {
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002164 error = ret;
2165 if (!error.isOk()) {
Pavel Grafovcef39472018-02-12 18:45:02 +00002166 if (error == ErrorCode::INVALID_KEY_BLOB) {
2167 log_key_integrity_violation(name8, uid);
2168 }
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002169 return;
2170 }
2171
Janis Danisevskisaf7783f2017-09-21 11:29:47 -07002172 auto filename = mKeyStore->getBlobFileNameIfExists(name8, uid, ::TYPE_KEYMASTER_10);
2173 if (!filename.isOk()) {
2174 ALOGI("trying to upgrade a non existing blob");
2175 return;
2176 }
2177 error = mKeyStore->del(filename.value().string(), ::TYPE_ANY, get_user_id(uid));
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002178 if (!error.isOk()) {
Rubin Xu7675c9f2017-03-15 19:26:52 +00002179 ALOGI("upgradeKeyBlob keystore->del failed %d", (int)error);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002180 return;
2181 }
2182
2183 Blob newBlob(&upgradedKeyBlob[0], upgradedKeyBlob.size(), nullptr /* info */,
2184 0 /* infoLength */, ::TYPE_KEYMASTER_10);
Janis Danisevskisc1460142017-12-18 16:48:46 -08002185 newBlob.setSecurityLevel(blob->getSecurityLevel());
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002186 newBlob.setEncrypted(blob->isEncrypted());
Rubin Xu67899de2017-04-21 19:15:13 +01002187 newBlob.setSuperEncrypted(blob->isSuperEncrypted());
2188 newBlob.setCriticalToDeviceEncryption(blob->isCriticalToDeviceEncryption());
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002189
Janis Danisevskisaf7783f2017-09-21 11:29:47 -07002190 error = mKeyStore->put(filename.value().string(), &newBlob, get_user_id(uid));
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002191 if (!error.isOk()) {
Rubin Xu7675c9f2017-03-15 19:26:52 +00002192 ALOGI("upgradeKeyBlob keystore->put failed %d", (int)error);
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002193 return;
2194 }
2195
2196 // Re-read blob for caller. We can't use newBlob because writing it modified it.
2197 error = mKeyStore->getKeyForName(blob, name8, uid, TYPE_KEYMASTER_10);
2198 };
2199
2200 KeyStoreServiceReturnCode rc =
2201 KS_HANDLE_HIDL_ERROR(dev->upgradeKey(hidlKey, params.hidl_data(), hidlCb));
2202 if (!rc.isOk()) {
Shawn Willden98c59162016-03-20 09:10:18 -06002203 return rc;
2204 }
2205
Janis Danisevskisc7a9fa22016-10-13 18:43:45 +01002206 return error;
Shawn Willden98c59162016-03-20 09:10:18 -06002207}
2208
Shawn Willdene2a7b522017-04-11 09:27:40 -06002209} // namespace keystore