Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 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 | */ |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 16 | #include <UniquePtr.h> |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 17 | #include <gatekeeper/gatekeeper.h> |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 18 | |
Andres Morales | ec9fd1d | 2015-04-20 07:45:50 -0700 | [diff] [blame] | 19 | #include <endian.h> |
| 20 | |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 21 | namespace gatekeeper { |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 22 | |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 23 | void GateKeeper::Enroll(const EnrollRequest &request, EnrollResponse *response) { |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 24 | if (response == NULL) return; |
| 25 | |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 26 | if (!request.provided_password.buffer.get()) { |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 27 | response->error = ERROR_INVALID; |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 28 | return; |
| 29 | } |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 30 | |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 31 | secure_id_t user_id = 0;// todo: rename to policy |
| 32 | uint32_t uid = request.user_id; |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 33 | |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 34 | if (request.password_handle.buffer.get() == NULL) { |
| 35 | // Password handle does not match what is stored, generate new SecureID |
| 36 | GetRandom(&user_id, sizeof(secure_id_t)); |
| 37 | } else { |
Andres Morales | 426fcfb | 2015-04-01 13:33:45 -0700 | [diff] [blame] | 38 | password_handle_t *pw_handle = |
| 39 | reinterpret_cast<password_handle_t *>(request.password_handle.buffer.get()); |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 40 | |
| 41 | user_id = pw_handle->user_id; |
| 42 | |
| 43 | uint64_t timestamp = GetMillisecondsSinceBoot(); |
| 44 | |
Andres Morales | ea08ace | 2015-05-28 18:30:14 -0700 | [diff] [blame^] | 45 | // disabled |
| 46 | bool throttle = false; |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 47 | if (pw_handle->version == 0) { |
| 48 | // handle version is pre-throttling |
| 49 | throttle = false; |
| 50 | } else if (pw_handle->version != HANDLE_VERSION) { |
Andres Morales | 426fcfb | 2015-04-01 13:33:45 -0700 | [diff] [blame] | 51 | response->error = ERROR_INVALID; |
| 52 | return; |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 53 | } |
Andres Morales | 426fcfb | 2015-04-01 13:33:45 -0700 | [diff] [blame] | 54 | |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 55 | uint32_t timeout = 0; |
| 56 | if (throttle) { |
| 57 | failure_record_t record; |
| 58 | if (!GetFailureRecord(uid, user_id, &record)) { |
| 59 | response->error = ERROR_UNKNOWN; |
| 60 | return; |
| 61 | } |
| 62 | |
Andres Morales | a623e45 | 2015-05-27 12:26:59 -0700 | [diff] [blame] | 63 | if (ThrottleRequest(uid, timestamp, &record, response)) return; |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 64 | |
| 65 | if (!IncrementFailureRecord(uid, user_id, timestamp, &record)) { |
| 66 | response->error = ERROR_UNKNOWN; |
| 67 | return; |
| 68 | } |
| 69 | |
| 70 | timeout = ComputeRetryTimeout(&record); |
| 71 | } |
| 72 | |
| 73 | if (!DoVerify(pw_handle, request.enrolled_password)) { |
| 74 | // incorrect old password |
| 75 | if (throttle && timeout > 0) { |
| 76 | response->SetRetryTimeout(timeout); |
| 77 | } else { |
| 78 | response->error = ERROR_INVALID; |
| 79 | } |
| 80 | return; |
| 81 | } |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 82 | } |
| 83 | |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 84 | ClearFailureRecord(uid, user_id); |
| 85 | |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 86 | salt_t salt; |
| 87 | GetRandom(&salt, sizeof(salt)); |
| 88 | |
| 89 | secure_id_t authenticator_id; |
| 90 | GetRandom(&authenticator_id, sizeof(authenticator_id)); |
| 91 | |
| 92 | |
| 93 | SizedBuffer password_handle; |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 94 | if (!CreatePasswordHandle(&password_handle, |
| 95 | salt, user_id, authenticator_id, HANDLE_VERSION, request.provided_password.buffer.get(), |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 96 | request.provided_password.length)) { |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 97 | response->error = ERROR_INVALID; |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 98 | return; |
| 99 | } |
| 100 | |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 101 | response->SetEnrolledPasswordHandle(&password_handle); |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 102 | } |
| 103 | |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 104 | void GateKeeper::Verify(const VerifyRequest &request, VerifyResponse *response) { |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 105 | if (response == NULL) return; |
| 106 | |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 107 | if (!request.provided_password.buffer.get() || !request.password_handle.buffer.get()) { |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 108 | response->error = ERROR_INVALID; |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 109 | return; |
| 110 | } |
| 111 | |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 112 | password_handle_t *password_handle = reinterpret_cast<password_handle_t *>( |
| 113 | request.password_handle.buffer.get()); |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 114 | |
Andres Morales | ea08ace | 2015-05-28 18:30:14 -0700 | [diff] [blame^] | 115 | // disabled |
| 116 | bool throttle = false; |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 117 | if (password_handle->version == 0) { |
| 118 | // handle version is pre-throttling |
| 119 | throttle = false; |
| 120 | response->request_reenroll = true; |
| 121 | } else if (password_handle->version != HANDLE_VERSION) { |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 122 | response->error = ERROR_INVALID; |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 123 | return; |
| 124 | } |
| 125 | |
Andres Morales | 426fcfb | 2015-04-01 13:33:45 -0700 | [diff] [blame] | 126 | secure_id_t user_id = password_handle->user_id; |
| 127 | secure_id_t authenticator_id = password_handle->authenticator_id; |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 128 | uint32_t uid = request.user_id; |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 129 | |
Andres Morales | ec9fd1d | 2015-04-20 07:45:50 -0700 | [diff] [blame] | 130 | uint64_t timestamp = GetMillisecondsSinceBoot(); |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 131 | |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 132 | uint32_t timeout = 0; |
| 133 | if (throttle) { |
| 134 | failure_record_t record; |
| 135 | if (!GetFailureRecord(uid, user_id, &record)) { |
| 136 | response->error = ERROR_UNKNOWN; |
| 137 | return; |
| 138 | } |
| 139 | |
Andres Morales | a623e45 | 2015-05-27 12:26:59 -0700 | [diff] [blame] | 140 | if (ThrottleRequest(uid, timestamp, &record, response)) return; |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 141 | |
| 142 | if (!IncrementFailureRecord(uid, user_id, timestamp, &record)) { |
| 143 | response->error = ERROR_UNKNOWN; |
| 144 | return; |
| 145 | } |
| 146 | |
| 147 | timeout = ComputeRetryTimeout(&record); |
| 148 | } |
| 149 | |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 150 | if (DoVerify(password_handle, request.provided_password)) { |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 151 | // Signature matches |
| 152 | SizedBuffer auth_token; |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 153 | MintAuthToken(&auth_token.buffer, &auth_token.length, timestamp, |
Andres Morales | 6034309 | 2015-04-09 19:01:10 -0700 | [diff] [blame] | 154 | user_id, authenticator_id, request.challenge); |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 155 | response->SetVerificationToken(&auth_token); |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 156 | if (throttle) ClearFailureRecord(uid, user_id); |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 157 | } else { |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 158 | // compute the new timeout given the incremented record |
| 159 | if (throttle && timeout > 0) { |
| 160 | response->SetRetryTimeout(timeout); |
| 161 | } else { |
| 162 | response->error = ERROR_INVALID; |
| 163 | } |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 164 | } |
| 165 | } |
| 166 | |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 167 | bool GateKeeper::CreatePasswordHandle(SizedBuffer *password_handle_buffer, salt_t salt, |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 168 | secure_id_t user_id, secure_id_t authenticator_id, uint8_t handle_version, const uint8_t *password, |
Andres Morales | 11ed52a | 2015-03-30 16:47:47 -0700 | [diff] [blame] | 169 | uint32_t password_length) { |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 170 | password_handle_buffer->buffer.reset(new uint8_t[sizeof(password_handle_t)]); |
| 171 | password_handle_buffer->length = sizeof(password_handle_t); |
| 172 | |
| 173 | password_handle_t *password_handle = reinterpret_cast<password_handle_t *>( |
| 174 | password_handle_buffer->buffer.get()); |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 175 | password_handle->version = handle_version; |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 176 | password_handle->salt = salt; |
| 177 | password_handle->user_id = user_id; |
| 178 | password_handle->authenticator_id = authenticator_id; |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 179 | password_handle->hardware_backed = IsHardwareBacked(); |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 180 | |
Andres Morales | 11ed52a | 2015-03-30 16:47:47 -0700 | [diff] [blame] | 181 | uint32_t metadata_length = sizeof(user_id) /* user id */ |
Andres Morales | 94b201e | 2015-04-16 13:47:47 -0700 | [diff] [blame] | 182 | + sizeof(authenticator_id) /* auth id */ + sizeof(HANDLE_VERSION) /* version */; |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 183 | uint8_t to_sign[password_length + metadata_length]; |
Andres Morales | 94b201e | 2015-04-16 13:47:47 -0700 | [diff] [blame] | 184 | memcpy(to_sign, password_handle, metadata_length); |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 185 | memcpy(to_sign + metadata_length, password, password_length); |
| 186 | |
Andres Morales | f10e289 | 2015-03-23 12:03:56 -0700 | [diff] [blame] | 187 | const uint8_t *password_key = NULL; |
Andres Morales | 11ed52a | 2015-03-30 16:47:47 -0700 | [diff] [blame] | 188 | uint32_t password_key_length = 0; |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 189 | GetPasswordKey(&password_key, &password_key_length); |
| 190 | |
Andres Morales | f10e289 | 2015-03-23 12:03:56 -0700 | [diff] [blame] | 191 | if (!password_key || password_key_length == 0) { |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 192 | return false; |
| 193 | } |
| 194 | |
| 195 | ComputePasswordSignature(password_handle->signature, sizeof(password_handle->signature), |
Andres Morales | f10e289 | 2015-03-23 12:03:56 -0700 | [diff] [blame] | 196 | password_key, password_key_length, to_sign, sizeof(to_sign), salt); |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 197 | return true; |
| 198 | } |
| 199 | |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 200 | bool GateKeeper::DoVerify(const password_handle_t *expected_handle, const SizedBuffer &password) { |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 201 | if (!password.buffer.get()) return false; |
| 202 | |
| 203 | SizedBuffer provided_handle; |
| 204 | if (!CreatePasswordHandle(&provided_handle, expected_handle->salt, expected_handle->user_id, |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 205 | expected_handle->authenticator_id, expected_handle->version, |
| 206 | password.buffer.get(), password.length)) { |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 207 | return false; |
| 208 | } |
| 209 | |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 210 | password_handle_t *generated_handle = |
| 211 | reinterpret_cast<password_handle_t *>(provided_handle.buffer.get()); |
| 212 | return memcmp_s(generated_handle->signature, expected_handle->signature, |
| 213 | sizeof(expected_handle->signature)) == 0; |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 214 | } |
| 215 | |
Andres Morales | 11ed52a | 2015-03-30 16:47:47 -0700 | [diff] [blame] | 216 | void GateKeeper::MintAuthToken(UniquePtr<uint8_t> *auth_token, uint32_t *length, |
Andres Morales | 652f076 | 2015-04-13 10:23:20 -0700 | [diff] [blame] | 217 | uint64_t timestamp, secure_id_t user_id, secure_id_t authenticator_id, |
Andres Morales | 6034309 | 2015-04-09 19:01:10 -0700 | [diff] [blame] | 218 | uint64_t challenge) { |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 219 | if (auth_token == NULL) return; |
| 220 | |
Andres Morales | fa104e1 | 2015-04-08 12:36:44 -0700 | [diff] [blame] | 221 | hw_auth_token_t *token = new hw_auth_token_t; |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 222 | SizedBuffer serialized_auth_token; |
| 223 | |
Andres Morales | fa104e1 | 2015-04-08 12:36:44 -0700 | [diff] [blame] | 224 | token->version = HW_AUTH_TOKEN_VERSION; |
Andres Morales | 6034309 | 2015-04-09 19:01:10 -0700 | [diff] [blame] | 225 | token->challenge = challenge; |
Andres Morales | fa104e1 | 2015-04-08 12:36:44 -0700 | [diff] [blame] | 226 | token->user_id = user_id; |
| 227 | token->authenticator_id = authenticator_id; |
| 228 | token->authenticator_type = htonl(HW_AUTH_PASSWORD); |
Andres Morales | ec9fd1d | 2015-04-20 07:45:50 -0700 | [diff] [blame] | 229 | token->timestamp = htobe64(timestamp); |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 230 | |
Andres Morales | f10e289 | 2015-03-23 12:03:56 -0700 | [diff] [blame] | 231 | const uint8_t *auth_token_key = NULL; |
Andres Morales | 11ed52a | 2015-03-30 16:47:47 -0700 | [diff] [blame] | 232 | uint32_t key_len = 0; |
Andres Morales | 58bb246 | 2015-04-10 18:27:50 -0700 | [diff] [blame] | 233 | if (GetAuthTokenKey(&auth_token_key, &key_len)) { |
| 234 | uint32_t hash_len = (uint32_t)((uint8_t *)&token->hmac - (uint8_t *)token); |
| 235 | ComputeSignature(token->hmac, sizeof(token->hmac), auth_token_key, key_len, |
| 236 | reinterpret_cast<uint8_t *>(token), hash_len); |
| 237 | } else { |
| 238 | memset(token->hmac, 0, sizeof(token->hmac)); |
| 239 | } |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 240 | |
Andres Morales | fa104e1 | 2015-04-08 12:36:44 -0700 | [diff] [blame] | 241 | if (length != NULL) *length = sizeof(*token); |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 242 | auth_token->reset(reinterpret_cast<uint8_t *>(token)); |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 243 | } |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 244 | |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 245 | uint32_t GateKeeper::ComputeRetryTimeout(const failure_record_t *record) { |
| 246 | if (record->failure_counter > 0 && record->failure_counter <= 10) { |
| 247 | if (record->failure_counter % 5 == 0) { |
| 248 | return 30000; |
| 249 | } |
| 250 | } else { |
| 251 | return 30000; |
| 252 | } |
| 253 | return 0; |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 254 | } |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 255 | |
Andres Morales | a623e45 | 2015-05-27 12:26:59 -0700 | [diff] [blame] | 256 | bool GateKeeper::ThrottleRequest(uint32_t uid, uint64_t timestamp, |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 257 | failure_record_t *record, GateKeeperMessage *response) { |
| 258 | |
| 259 | uint64_t last_checked = record->last_checked_timestamp; |
| 260 | uint32_t timeout = ComputeRetryTimeout(record); |
| 261 | |
| 262 | if (timeout > 0) { |
| 263 | // we have a pending timeout |
| 264 | if (timestamp < last_checked + timeout && timestamp > last_checked) { |
| 265 | // attempt before timeout expired, return remaining time |
| 266 | response->SetRetryTimeout(timeout - (timestamp - last_checked)); |
| 267 | return true; |
| 268 | } else if (timestamp <= last_checked) { |
| 269 | // device was rebooted or timer reset, don't count as new failure but |
| 270 | // reset timeout |
| 271 | record->last_checked_timestamp = timestamp; |
| 272 | if (!WriteFailureRecord(uid, record)) { |
| 273 | response->error = ERROR_UNKNOWN; |
| 274 | return true; |
| 275 | } |
| 276 | response->SetRetryTimeout(timeout); |
| 277 | return true; |
| 278 | } |
| 279 | } |
| 280 | |
| 281 | return false; |
| 282 | } |
| 283 | |
| 284 | bool GateKeeper::IncrementFailureRecord(uint32_t uid, secure_id_t user_id, uint64_t timestamp, |
| 285 | failure_record_t *record) { |
| 286 | record->secure_user_id = user_id; |
| 287 | record->failure_counter++; |
| 288 | record->last_checked_timestamp = timestamp; |
| 289 | |
| 290 | return WriteFailureRecord(uid, record); |
| 291 | } |
| 292 | } // namespace gatekeeper |
| 293 | |