/*
* Copyright 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <UniquePtr.h>
#include <gatekeeper/gatekeeper.h>
#include <endian.h>
#define DAY_IN_MS (1000 * 60 * 60 * 24)
namespace gatekeeper {
void GateKeeper::Enroll(const EnrollRequest &request, EnrollResponse *response) {
if (response == NULL) return;
if (!request.provided_password.buffer.get()) {
response->error = ERROR_INVALID;
return;
}
secure_id_t user_id = 0;// todo: rename to policy
uint32_t uid = request.user_id;
if (request.password_handle.buffer.get() == NULL) {
// Password handle does not match what is stored, generate new SecureID
GetRandom(&user_id, sizeof(secure_id_t));
} else {
password_handle_t *pw_handle =
reinterpret_cast<password_handle_t *>(request.password_handle.buffer.get());
if (pw_handle->version > HANDLE_VERSION) {
response->error = ERROR_INVALID;
return;
}
user_id = pw_handle->user_id;
uint64_t timestamp = GetMillisecondsSinceBoot();
uint32_t timeout = 0;
bool throttle = (pw_handle->version >= HANDLE_VERSION_THROTTLE);
if (throttle) {
bool throttle_secure = pw_handle->flags & HANDLE_FLAG_THROTTLE_SECURE;
failure_record_t record;
if (!GetFailureRecord(uid, user_id, &record, throttle_secure)) {
response->error = ERROR_UNKNOWN;
return;
}
if (ThrottleRequest(uid, timestamp, &record, throttle_secure, response)) return;
if (!IncrementFailureRecord(uid, user_id, timestamp, &record, throttle_secure)) {
response->error = ERROR_UNKNOWN;
return;
}
timeout = ComputeRetryTimeout(&record);
}
if (!DoVerify(pw_handle, request.enrolled_password)) {
// incorrect old password
if (throttle && timeout > 0) {
response->SetRetryTimeout(timeout);
} else {
response->error = ERROR_INVALID;
}
return;
}
}
uint64_t flags = 0;
if (ClearFailureRecord(uid, user_id, true)) {
flags |= HANDLE_FLAG_THROTTLE_SECURE;
} else {
ClearFailureRecord(uid, user_id, false);
}
salt_t salt;
GetRandom(&salt, sizeof(salt));
SizedBuffer password_handle;
if (!CreatePasswordHandle(&password_handle,
salt, user_id, flags, HANDLE_VERSION, request.provided_password.buffer.get(),
request.provided_password.length)) {
response->error = ERROR_INVALID;
return;
}
response->SetEnrolledPasswordHandle(&password_handle);
}
void GateKeeper::Verify(const VerifyRequest &request, VerifyResponse *response) {
if (response == NULL) return;
if (!request.provided_password.buffer.get() || !request.password_handle.buffer.get()) {
response->error = ERROR_INVALID;
return;
}
password_handle_t *password_handle = reinterpret_cast<password_handle_t *>(
request.password_handle.buffer.get());
if (password_handle->version > HANDLE_VERSION) {
response->error = ERROR_INVALID;
return;
}
secure_id_t user_id = password_handle->user_id;
secure_id_t authenticator_id = 0;
uint32_t uid = request.user_id;
uint64_t timestamp = GetMillisecondsSinceBoot();
uint32_t timeout = 0;
bool throttle = (password_handle->version >= HANDLE_VERSION_THROTTLE);
bool throttle_secure = password_handle->flags & HANDLE_FLAG_THROTTLE_SECURE;
if (throttle) {
failure_record_t record;
if (!GetFailureRecord(uid, user_id, &record, throttle_secure)) {
response->error = ERROR_UNKNOWN;
return;
}
if (ThrottleRequest(uid, timestamp, &record, throttle_secure, response)) return;
if (!IncrementFailureRecord(uid, user_id, timestamp, &record, throttle_secure)) {
response->error = ERROR_UNKNOWN;
return;
}
timeout = ComputeRetryTimeout(&record);
} else {
response->request_reenroll = true;
}
if (DoVerify(password_handle, request.provided_password)) {
// Signature matches
UniquePtr<uint8_t> auth_token_buffer;
uint32_t auth_token_len;
MintAuthToken(&auth_token_buffer, &auth_token_len, timestamp,
user_id, authenticator_id, request.challenge);
SizedBuffer auth_token(auth_token_len);
memcpy(auth_token.buffer.get(), auth_token_buffer.get(), auth_token_len);
response->SetVerificationToken(&auth_token);
if (throttle) ClearFailureRecord(uid, user_id, throttle_secure);
} else {
// compute the new timeout given the incremented record
if (throttle && timeout > 0) {
response->SetRetryTimeout(timeout);
} else {
response->error = ERROR_INVALID;
}
}
}
bool GateKeeper::CreatePasswordHandle(SizedBuffer *password_handle_buffer, salt_t salt,
secure_id_t user_id, uint64_t flags, uint8_t handle_version, const uint8_t *password,
uint32_t password_length) {
password_handle_buffer->buffer.reset(new uint8_t[sizeof(password_handle_t)]);
password_handle_buffer->length = sizeof(password_handle_t);
password_handle_t *password_handle = reinterpret_cast<password_handle_t *>(
password_handle_buffer->buffer.get());
password_handle->version = handle_version;
password_handle->salt = salt;
password_handle->user_id = user_id;
password_handle->flags = flags;
password_handle->hardware_backed = IsHardwareBacked();
uint32_t metadata_length = sizeof(user_id) + sizeof(flags) + sizeof(HANDLE_VERSION);
uint8_t to_sign[password_length + metadata_length];
memcpy(to_sign, password_handle, metadata_length);
memcpy(to_sign + metadata_length, password, password_length);
const uint8_t *password_key = NULL;
uint32_t password_key_length = 0;
GetPasswordKey(&password_key, &password_key_length);
if (!password_key || password_key_length == 0) {
return false;
}
ComputePasswordSignature(password_handle->signature, sizeof(password_handle->signature),
password_key, password_key_length, to_sign, sizeof(to_sign), salt);
return true;
}
bool GateKeeper::DoVerify(const password_handle_t *expected_handle, const SizedBuffer &password) {
if (!password.buffer.get()) return false;
SizedBuffer provided_handle;
if (!CreatePasswordHandle(&provided_handle, expected_handle->salt, expected_handle->user_id,
expected_handle->flags, expected_handle->version,
password.buffer.get(), password.length)) {
return false;
}
password_handle_t *generated_handle =
reinterpret_cast<password_handle_t *>(provided_handle.buffer.get());
return memcmp_s(generated_handle->signature, expected_handle->signature,
sizeof(expected_handle->signature)) == 0;
}
void GateKeeper::MintAuthToken(UniquePtr<uint8_t> *auth_token, uint32_t *length,
uint64_t timestamp, secure_id_t user_id, secure_id_t authenticator_id,
uint64_t challenge) {
if (auth_token == NULL) return;
hw_auth_token_t *token = new hw_auth_token_t;
SizedBuffer serialized_auth_token;
token->version = HW_AUTH_TOKEN_VERSION;
token->challenge = challenge;
token->user_id = user_id;
token->authenticator_id = authenticator_id;
token->authenticator_type = htonl(HW_AUTH_PASSWORD);
token->timestamp = htobe64(timestamp);
const uint8_t *auth_token_key = NULL;
uint32_t key_len = 0;
if (GetAuthTokenKey(&auth_token_key, &key_len)) {
uint32_t hash_len = (uint32_t)((uint8_t *)&token->hmac - (uint8_t *)token);
ComputeSignature(token->hmac, sizeof(token->hmac), auth_token_key, key_len,
reinterpret_cast<uint8_t *>(token), hash_len);
delete[] auth_token_key;
} else {
memset(token->hmac, 0, sizeof(token->hmac));
}
if (length != NULL) *length = sizeof(*token);
auth_token->reset(reinterpret_cast<uint8_t *>(token));
}
/*
* Calculates the timeout in milliseconds as a function of the failure
* counter 'x' as follows:
*
* [0. 5) -> 0
* 5 -> 30
* [6, 10) -> 0
* [11, 30) -> 30
* [30, 140) -> 30 * (2^((x - 30)/10))
* [140, inf) -> 1 day
*
*/
uint32_t GateKeeper::ComputeRetryTimeout(const failure_record_t *record) {
static const int failure_timeout_ms = 30000;
if (record->failure_counter == 0) return 0;
if (record->failure_counter > 0 && record->failure_counter <= 10) {
if (record->failure_counter % 5 == 0) {
return failure_timeout_ms;
} else {
return 0;
}
} else if (record->failure_counter < 30) {
return failure_timeout_ms;
} else if (record->failure_counter < 140) {
return failure_timeout_ms << ((record->failure_counter - 30) / 10);
}
return DAY_IN_MS;
}
bool GateKeeper::ThrottleRequest(uint32_t uid, uint64_t timestamp,
failure_record_t *record, bool secure, GateKeeperMessage *response) {
uint64_t last_checked = record->last_checked_timestamp;
uint32_t timeout = ComputeRetryTimeout(record);
if (timeout > 0) {
// we have a pending timeout
if (timestamp < last_checked + timeout && timestamp > last_checked) {
// attempt before timeout expired, return remaining time
response->SetRetryTimeout(timeout - (timestamp - last_checked));
return true;
} else if (timestamp <= last_checked) {
// device was rebooted or timer reset, don't count as new failure but
// reset timeout
record->last_checked_timestamp = timestamp;
if (!WriteFailureRecord(uid, record, secure)) {
response->error = ERROR_UNKNOWN;
return true;
}
response->SetRetryTimeout(timeout);
return true;
}
}
return false;
}
bool GateKeeper::IncrementFailureRecord(uint32_t uid, secure_id_t user_id, uint64_t timestamp,
failure_record_t *record, bool secure) {
record->secure_user_id = user_id;
record->failure_counter++;
record->last_checked_timestamp = timestamp;
return WriteFailureRecord(uid, record, secure);
}
} // namespace gatekeeper