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 | */ |
Jiyong Park | 9414ec0 | 2017-08-09 21:10:16 +0900 | [diff] [blame] | 16 | #include <gatekeeper/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> |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 20 | #include <stddef.h> |
Andres Morales | ec9fd1d | 2015-04-20 07:45:50 -0700 | [diff] [blame] | 21 | |
Andres Morales | f436c80 | 2015-10-08 12:21:25 -0700 | [diff] [blame] | 22 | #define DAY_IN_MS (1000 * 60 * 60 * 24) |
| 23 | |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 24 | namespace gatekeeper { |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 25 | |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 26 | void GateKeeper::Enroll(const EnrollRequest &request, EnrollResponse *response) { |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 27 | if (response == nullptr) return; |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 28 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 29 | if (!request.provided_password) { |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 30 | response->error = ERROR_INVALID; |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 31 | return; |
| 32 | } |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 33 | |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 34 | secure_id_t user_id = 0;// todo: rename to policy |
| 35 | uint32_t uid = request.user_id; |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 36 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 37 | if (!request.password_handle) { |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 38 | // Password handle does not match what is stored, generate new SecureID |
| 39 | GetRandom(&user_id, sizeof(secure_id_t)); |
| 40 | } else { |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 41 | const password_handle_t *pw_handle = request.password_handle.Data<password_handle_t>(); |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 42 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 43 | if (!pw_handle || pw_handle->version > HANDLE_VERSION) { |
Andres Morales | 426fcfb | 2015-04-01 13:33:45 -0700 | [diff] [blame] | 44 | response->error = ERROR_INVALID; |
| 45 | return; |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 46 | } |
Andres Morales | 426fcfb | 2015-04-01 13:33:45 -0700 | [diff] [blame] | 47 | |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 48 | user_id = pw_handle->user_id; |
| 49 | |
| 50 | uint64_t timestamp = GetMillisecondsSinceBoot(); |
| 51 | |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 52 | uint32_t timeout = 0; |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 53 | bool throttle = (pw_handle->version >= HANDLE_VERSION_THROTTLE); |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 54 | if (throttle) { |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 55 | bool throttle_secure = pw_handle->flags & HANDLE_FLAG_THROTTLE_SECURE; |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 56 | failure_record_t record; |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 57 | if (!GetFailureRecord(uid, user_id, &record, throttle_secure)) { |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 58 | response->error = ERROR_UNKNOWN; |
| 59 | return; |
| 60 | } |
| 61 | |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 62 | if (ThrottleRequest(uid, timestamp, &record, throttle_secure, response)) return; |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 63 | |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 64 | if (!IncrementFailureRecord(uid, user_id, timestamp, &record, throttle_secure)) { |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 65 | response->error = ERROR_UNKNOWN; |
| 66 | return; |
| 67 | } |
| 68 | |
| 69 | timeout = ComputeRetryTimeout(&record); |
| 70 | } |
| 71 | |
| 72 | if (!DoVerify(pw_handle, request.enrolled_password)) { |
| 73 | // incorrect old password |
| 74 | if (throttle && timeout > 0) { |
| 75 | response->SetRetryTimeout(timeout); |
| 76 | } else { |
| 77 | response->error = ERROR_INVALID; |
| 78 | } |
| 79 | return; |
| 80 | } |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 81 | } |
| 82 | |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 83 | uint64_t flags = 0; |
| 84 | if (ClearFailureRecord(uid, user_id, true)) { |
| 85 | flags |= HANDLE_FLAG_THROTTLE_SECURE; |
| 86 | } else { |
| 87 | ClearFailureRecord(uid, user_id, false); |
| 88 | } |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 89 | |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 90 | salt_t salt; |
| 91 | GetRandom(&salt, sizeof(salt)); |
| 92 | |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 93 | SizedBuffer password_handle; |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 94 | if (!CreatePasswordHandle(&password_handle, |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 95 | salt, user_id, flags, HANDLE_VERSION, request.provided_password)) { |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 96 | response->error = ERROR_INVALID; |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 97 | return; |
| 98 | } |
| 99 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 100 | response->SetEnrolledPasswordHandle(move(password_handle)); |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 101 | } |
| 102 | |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 103 | void GateKeeper::Verify(const VerifyRequest &request, VerifyResponse *response) { |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 104 | if (response == nullptr) return; |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 105 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 106 | if (!request.provided_password || !request.password_handle) { |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 107 | response->error = ERROR_INVALID; |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 108 | return; |
| 109 | } |
| 110 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 111 | const password_handle_t *password_handle = request.password_handle.Data<password_handle_t>(); |
Matthew Maurer | a8f9709 | 2019-03-28 13:43:44 -0700 | [diff] [blame] | 112 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 113 | if (!password_handle || password_handle->version > HANDLE_VERSION) { |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 114 | response->error = ERROR_INVALID; |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 115 | return; |
| 116 | } |
| 117 | |
Andres Morales | 426fcfb | 2015-04-01 13:33:45 -0700 | [diff] [blame] | 118 | secure_id_t user_id = password_handle->user_id; |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 119 | secure_id_t authenticator_id = 0; |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 120 | uint32_t uid = request.user_id; |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 121 | |
Andres Morales | ec9fd1d | 2015-04-20 07:45:50 -0700 | [diff] [blame] | 122 | uint64_t timestamp = GetMillisecondsSinceBoot(); |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 123 | |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 124 | uint32_t timeout = 0; |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 125 | bool throttle = (password_handle->version >= HANDLE_VERSION_THROTTLE); |
| 126 | bool throttle_secure = password_handle->flags & HANDLE_FLAG_THROTTLE_SECURE; |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 127 | if (throttle) { |
| 128 | failure_record_t record; |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 129 | if (!GetFailureRecord(uid, user_id, &record, throttle_secure)) { |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 130 | response->error = ERROR_UNKNOWN; |
| 131 | return; |
| 132 | } |
| 133 | |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 134 | if (ThrottleRequest(uid, timestamp, &record, throttle_secure, response)) return; |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 135 | |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 136 | if (!IncrementFailureRecord(uid, user_id, timestamp, &record, throttle_secure)) { |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 137 | response->error = ERROR_UNKNOWN; |
| 138 | return; |
| 139 | } |
| 140 | |
| 141 | timeout = ComputeRetryTimeout(&record); |
Andres Morales | 893fa7f | 2015-06-02 19:00:03 -0700 | [diff] [blame] | 142 | } else { |
| 143 | response->request_reenroll = true; |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 144 | } |
| 145 | |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 146 | if (DoVerify(password_handle, request.provided_password)) { |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 147 | // Signature matches |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 148 | SizedBuffer auth_token; |
| 149 | response->error = MintAuthToken(&auth_token, timestamp, |
Andres Morales | 6034309 | 2015-04-09 19:01:10 -0700 | [diff] [blame] | 150 | user_id, authenticator_id, request.challenge); |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 151 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 152 | if (response->error != ERROR_NONE) return; |
| 153 | |
| 154 | response->SetVerificationToken(move(auth_token)); |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 155 | if (throttle) ClearFailureRecord(uid, user_id, throttle_secure); |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 156 | } else { |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 157 | // compute the new timeout given the incremented record |
| 158 | if (throttle && timeout > 0) { |
| 159 | response->SetRetryTimeout(timeout); |
| 160 | } else { |
| 161 | response->error = ERROR_INVALID; |
| 162 | } |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 163 | } |
| 164 | } |
| 165 | |
Marco Nelissen | 8d7cafe | 2021-01-28 09:20:03 -0800 | [diff] [blame] | 166 | void GateKeeper::DeleteUser(const DeleteUserRequest &request, DeleteUserResponse *response) { |
| 167 | if (response == nullptr) return; |
| 168 | |
| 169 | uint32_t uid = request.user_id; |
| 170 | response->error = RemoveUser(uid); |
Marco Nelissen | 76b743e | 2021-01-25 13:46:42 -0800 | [diff] [blame] | 171 | } |
| 172 | |
| 173 | void GateKeeper::DeleteAllUsers(const DeleteAllUsersRequest &/*request*/, |
| 174 | DeleteAllUsersResponse *response) { |
Marco Nelissen | 8d7cafe | 2021-01-28 09:20:03 -0800 | [diff] [blame] | 175 | if (response == nullptr) return; |
| 176 | |
| 177 | response->error = RemoveAllUsers(); |
Marco Nelissen | 76b743e | 2021-01-25 13:46:42 -0800 | [diff] [blame] | 178 | } |
| 179 | |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 180 | bool GateKeeper::CreatePasswordHandle(SizedBuffer *password_handle_buffer, salt_t salt, |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 181 | secure_id_t user_id, uint64_t flags, uint8_t handle_version, const SizedBuffer & password) { |
| 182 | if (password_handle_buffer == nullptr) return false; |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 183 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 184 | password_handle_t password_handle; |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 185 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 186 | password_handle.version = handle_version; |
| 187 | password_handle.salt = salt; |
| 188 | password_handle.user_id = user_id; |
| 189 | password_handle.flags = flags; |
| 190 | password_handle.hardware_backed = IsHardwareBacked(); |
Alexey Polyudov | 84f8f9f | 2016-08-18 13:48:50 -0700 | [diff] [blame] | 191 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 192 | constexpr uint32_t metadata_length = sizeof(password_handle.version) + |
| 193 | sizeof(password_handle.user_id) + |
| 194 | sizeof(password_handle.flags); |
| 195 | static_assert(offsetof(password_handle_t, salt) == metadata_length, |
| 196 | "password_handle_t does not appear to be packed"); |
Alexey Polyudov | 84f8f9f | 2016-08-18 13:48:50 -0700 | [diff] [blame] | 197 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 198 | const size_t to_sign_size = password.size() + metadata_length; |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 199 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 200 | UniquePtr<uint8_t[]> to_sign(new(std::nothrow) uint8_t[to_sign_size]); |
| 201 | if (!to_sign) return false; |
| 202 | |
| 203 | memcpy(to_sign.get(), &password_handle, metadata_length); |
| 204 | memcpy(to_sign.get() + metadata_length, password.Data<uint8_t>(), password.size()); |
| 205 | |
| 206 | const uint8_t *password_key = nullptr; |
Andres Morales | 11ed52a | 2015-03-30 16:47:47 -0700 | [diff] [blame] | 207 | uint32_t password_key_length = 0; |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 208 | GetPasswordKey(&password_key, &password_key_length); |
| 209 | |
Andres Morales | f10e289 | 2015-03-23 12:03:56 -0700 | [diff] [blame] | 210 | if (!password_key || password_key_length == 0) { |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 211 | return false; |
| 212 | } |
| 213 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 214 | ComputePasswordSignature(password_handle.signature, sizeof(password_handle.signature), |
Alexey Polyudov | 84f8f9f | 2016-08-18 13:48:50 -0700 | [diff] [blame] | 215 | password_key, password_key_length, to_sign.get(), to_sign_size, salt); |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 216 | |
| 217 | uint8_t *ph_buffer = new(std::nothrow) uint8_t[sizeof(password_handle_t)]; |
| 218 | if (ph_buffer == nullptr) return false; |
| 219 | |
| 220 | *password_handle_buffer = { ph_buffer, sizeof(password_handle_t) }; |
| 221 | memcpy(ph_buffer, &password_handle, sizeof(password_handle_t)); |
| 222 | |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 223 | return true; |
| 224 | } |
| 225 | |
Andres Morales | 7d0f040 | 2015-03-19 18:02:55 -0700 | [diff] [blame] | 226 | bool GateKeeper::DoVerify(const password_handle_t *expected_handle, const SizedBuffer &password) { |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 227 | if (!password) return false; |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 228 | |
| 229 | SizedBuffer provided_handle; |
| 230 | if (!CreatePasswordHandle(&provided_handle, expected_handle->salt, expected_handle->user_id, |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 231 | expected_handle->flags, expected_handle->version, password)) { |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 232 | return false; |
| 233 | } |
| 234 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 235 | const password_handle_t *generated_handle = provided_handle.Data<password_handle_t>(); |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 236 | return memcmp_s(generated_handle->signature, expected_handle->signature, |
| 237 | sizeof(expected_handle->signature)) == 0; |
Andres Morales | edd3e3d | 2015-03-12 13:30:15 -0700 | [diff] [blame] | 238 | } |
| 239 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 240 | gatekeeper_error_t GateKeeper::MintAuthToken(SizedBuffer *auth_token, |
Andres Morales | 652f076 | 2015-04-13 10:23:20 -0700 | [diff] [blame] | 241 | 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] | 242 | uint64_t challenge) { |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 243 | if (auth_token == nullptr) return ERROR_INVALID; |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 244 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 245 | hw_auth_token_t token; |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 246 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 247 | token.version = HW_AUTH_TOKEN_VERSION; |
| 248 | token.challenge = challenge; |
| 249 | token.user_id = user_id; |
| 250 | token.authenticator_id = authenticator_id; |
| 251 | token.authenticator_type = htobe32(HW_AUTH_PASSWORD); |
| 252 | token.timestamp = htobe64(timestamp); |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 253 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 254 | constexpr uint32_t hashable_length = sizeof(token.version) + |
| 255 | sizeof(token.challenge) + |
| 256 | sizeof(token.user_id) + |
| 257 | sizeof(token.authenticator_id) + |
| 258 | sizeof(token.authenticator_type) + |
| 259 | sizeof(token.timestamp); |
| 260 | |
| 261 | static_assert(offsetof(hw_auth_token_t, hmac) == hashable_length, |
| 262 | "hw_auth_token_t does not appear to be packed"); |
| 263 | |
| 264 | const uint8_t *auth_token_key = nullptr; |
Andres Morales | 11ed52a | 2015-03-30 16:47:47 -0700 | [diff] [blame] | 265 | uint32_t key_len = 0; |
Andres Morales | 58bb246 | 2015-04-10 18:27:50 -0700 | [diff] [blame] | 266 | if (GetAuthTokenKey(&auth_token_key, &key_len)) { |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 267 | ComputeSignature(token.hmac, sizeof(token.hmac), auth_token_key, key_len, |
| 268 | reinterpret_cast<uint8_t *>(&token), hashable_length); |
Andres Morales | 58bb246 | 2015-04-10 18:27:50 -0700 | [diff] [blame] | 269 | } else { |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 270 | memset(token.hmac, 0, sizeof(token.hmac)); |
Andres Morales | 58bb246 | 2015-04-10 18:27:50 -0700 | [diff] [blame] | 271 | } |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 272 | |
Janis Danisevskis | f122af3 | 2019-03-26 16:06:53 -0700 | [diff] [blame] | 273 | uint8_t *token_buffer = new(std::nothrow) uint8_t[sizeof(hw_auth_token_t)]; |
| 274 | if (token_buffer == nullptr) return ERROR_MEMORY_ALLOCATION_FAILED; |
| 275 | |
| 276 | *reinterpret_cast<hw_auth_token_t*>(token_buffer) = token; |
| 277 | |
| 278 | *auth_token = { token_buffer, sizeof(hw_auth_token_t) }; |
| 279 | return ERROR_NONE; |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 280 | } |
Andres Morales | b2abaa8 | 2015-03-03 09:09:18 -0800 | [diff] [blame] | 281 | |
Andres Morales | f436c80 | 2015-10-08 12:21:25 -0700 | [diff] [blame] | 282 | /* |
| 283 | * Calculates the timeout in milliseconds as a function of the failure |
| 284 | * counter 'x' as follows: |
| 285 | * |
Paul Crowley | 8fbcf80 | 2018-06-15 15:03:33 -0700 | [diff] [blame] | 286 | * [0, 4] -> 0 |
Andres Morales | f436c80 | 2015-10-08 12:21:25 -0700 | [diff] [blame] | 287 | * 5 -> 30 |
Paul Crowley | 8fbcf80 | 2018-06-15 15:03:33 -0700 | [diff] [blame] | 288 | * [6, 10] -> 0 |
| 289 | * [11, 29] -> 30 |
| 290 | * [30, 139] -> 30 * (2^((x - 30)/10)) |
Andres Morales | f436c80 | 2015-10-08 12:21:25 -0700 | [diff] [blame] | 291 | * [140, inf) -> 1 day |
| 292 | * |
| 293 | */ |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 294 | uint32_t GateKeeper::ComputeRetryTimeout(const failure_record_t *record) { |
Andres Morales | b6a5cd7 | 2015-06-03 17:59:17 -0700 | [diff] [blame] | 295 | static const int failure_timeout_ms = 30000; |
| 296 | if (record->failure_counter == 0) return 0; |
| 297 | |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 298 | if (record->failure_counter > 0 && record->failure_counter <= 10) { |
| 299 | if (record->failure_counter % 5 == 0) { |
Andres Morales | b6a5cd7 | 2015-06-03 17:59:17 -0700 | [diff] [blame] | 300 | return failure_timeout_ms; |
Andres Morales | d14f472 | 2015-12-18 11:57:34 -0800 | [diff] [blame] | 301 | } else { |
| 302 | return 0; |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 303 | } |
Andres Morales | f436c80 | 2015-10-08 12:21:25 -0700 | [diff] [blame] | 304 | } else if (record->failure_counter < 30) { |
Andres Morales | b6a5cd7 | 2015-06-03 17:59:17 -0700 | [diff] [blame] | 305 | return failure_timeout_ms; |
Andres Morales | f436c80 | 2015-10-08 12:21:25 -0700 | [diff] [blame] | 306 | } else if (record->failure_counter < 140) { |
| 307 | return failure_timeout_ms << ((record->failure_counter - 30) / 10); |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 308 | } |
Andres Morales | f436c80 | 2015-10-08 12:21:25 -0700 | [diff] [blame] | 309 | |
| 310 | return DAY_IN_MS; |
Andres Morales | ac80818 | 2015-02-26 14:11:04 -0800 | [diff] [blame] | 311 | } |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 312 | |
Andres Morales | a623e45 | 2015-05-27 12:26:59 -0700 | [diff] [blame] | 313 | bool GateKeeper::ThrottleRequest(uint32_t uid, uint64_t timestamp, |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 314 | failure_record_t *record, bool secure, GateKeeperMessage *response) { |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 315 | |
| 316 | uint64_t last_checked = record->last_checked_timestamp; |
| 317 | uint32_t timeout = ComputeRetryTimeout(record); |
| 318 | |
| 319 | if (timeout > 0) { |
| 320 | // we have a pending timeout |
| 321 | if (timestamp < last_checked + timeout && timestamp > last_checked) { |
| 322 | // attempt before timeout expired, return remaining time |
| 323 | response->SetRetryTimeout(timeout - (timestamp - last_checked)); |
| 324 | return true; |
| 325 | } else if (timestamp <= last_checked) { |
| 326 | // device was rebooted or timer reset, don't count as new failure but |
| 327 | // reset timeout |
| 328 | record->last_checked_timestamp = timestamp; |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 329 | if (!WriteFailureRecord(uid, record, secure)) { |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 330 | response->error = ERROR_UNKNOWN; |
| 331 | return true; |
| 332 | } |
| 333 | response->SetRetryTimeout(timeout); |
| 334 | return true; |
| 335 | } |
| 336 | } |
| 337 | |
| 338 | return false; |
| 339 | } |
| 340 | |
| 341 | bool GateKeeper::IncrementFailureRecord(uint32_t uid, secure_id_t user_id, uint64_t timestamp, |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 342 | failure_record_t *record, bool secure) { |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 343 | record->secure_user_id = user_id; |
| 344 | record->failure_counter++; |
| 345 | record->last_checked_timestamp = timestamp; |
| 346 | |
Andres Morales | 48a4f83 | 2015-05-29 10:13:31 -0700 | [diff] [blame] | 347 | return WriteFailureRecord(uid, record, secure); |
Andres Morales | aedf605 | 2015-05-14 13:10:30 -0700 | [diff] [blame] | 348 | } |
| 349 | } // namespace gatekeeper |
| 350 | |