1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
/* Copyright 2019 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "common.h"
#include "ec_commands.h"
#include "fpsensor.h"
#include "fpsensor_private.h"
#include "fpsensor_state.h"
#include "host_command.h"
#include "system.h"
#include "task.h"
#include "util.h"
/* Last acquired frame (aligned as it is used by arbitrary binary libraries) */
uint8_t fp_buffer[FP_SENSOR_IMAGE_SIZE] FP_FRAME_SECTION __aligned(4);
/* Fingers templates for the current user */
uint8_t fp_template[FP_MAX_FINGER_COUNT][FP_ALGORITHM_TEMPLATE_SIZE]
FP_TEMPLATE_SECTION;
/* Encryption/decryption buffer */
/* TODO: On-the-fly encryption/decryption without a dedicated buffer */
/*
* Store the encryption metadata at the beginning of the buffer containing the
* ciphered data.
*/
uint8_t fp_enc_buffer[FP_ALGORITHM_ENCRYPTED_TEMPLATE_SIZE]
FP_TEMPLATE_SECTION;
/* Number of used templates */
uint32_t templ_valid;
/* Bitmap of the templates with local modifications */
uint32_t templ_dirty;
/* Current user ID */
uint32_t user_id[FP_CONTEXT_USERID_WORDS];
/* Part of the IKM used to derive encryption keys received from the TPM. */
uint8_t tpm_seed[FP_CONTEXT_TPM_BYTES];
/* Status of the FP encryption engine. */
static uint32_t fp_encryption_status;
uint32_t fp_events;
uint32_t sensor_mode;
void fp_task_simulate(void)
{
int timeout_us = -1;
while (1)
task_wait_event(timeout_us);
}
void fp_clear_finger_context(int idx)
{
memset(fp_template[idx], 0, sizeof(fp_template[0]));
}
void fp_clear_context(void)
{
int idx;
templ_valid = 0;
templ_dirty = 0;
memset(fp_buffer, 0, sizeof(fp_buffer));
memset(fp_enc_buffer, 0, sizeof(fp_enc_buffer));
memset(user_id, 0, sizeof(user_id));
for (idx = 0; idx < FP_MAX_FINGER_COUNT; idx++)
fp_clear_finger_context(idx);
/* TODO maybe shutdown and re-init the private libraries ? */
}
int fp_get_next_event(uint8_t *out)
{
uint32_t event_out = atomic_read_clear(&fp_events);
memcpy(out, &event_out, sizeof(event_out));
return sizeof(event_out);
}
DECLARE_EVENT_SOURCE(EC_MKBP_EVENT_FINGERPRINT, fp_get_next_event);
static int fp_command_tpm_seed(struct host_cmd_handler_args *args)
{
const struct ec_params_fp_seed *params = args->params;
if (params->struct_version != FP_TEMPLATE_FORMAT_VERSION) {
CPRINTS("Invalid seed format %d", params->struct_version);
return EC_RES_INVALID_PARAM;
}
if (fp_encryption_status & FP_ENC_STATUS_SEED_SET) {
CPRINTS("Seed has already been set.");
return EC_RES_ACCESS_DENIED;
}
memcpy(tpm_seed, params->seed, sizeof(tpm_seed));
fp_encryption_status |= FP_ENC_STATUS_SEED_SET;
return EC_RES_SUCCESS;
}
DECLARE_HOST_COMMAND(EC_CMD_FP_SEED, fp_command_tpm_seed, EC_VER_MASK(0));
int fp_tpm_seed_is_set(void)
{
return fp_encryption_status & FP_ENC_STATUS_SEED_SET;
}
static int fp_command_encryption_status(struct host_cmd_handler_args *args)
{
struct ec_response_fp_encryption_status *r = args->response;
r->valid_flags = FP_ENC_STATUS_SEED_SET;
r->status = fp_encryption_status;
args->response_size = sizeof(*r);
return EC_RES_SUCCESS;
}
DECLARE_HOST_COMMAND(EC_CMD_FP_ENC_STATUS, fp_command_encryption_status,
EC_VER_MASK(0));
static int validate_fp_mode(const uint32_t mode)
{
uint32_t capture_type = FP_CAPTURE_TYPE(mode);
uint32_t algo_mode = mode & ~FP_MODE_CAPTURE_TYPE_MASK;
uint32_t cur_mode = sensor_mode;
if (capture_type >= FP_CAPTURE_TYPE_MAX)
return EC_ERROR_INVAL;
if (algo_mode & ~FP_VALID_MODES)
return EC_ERROR_INVAL;
if ((mode & FP_MODE_ENROLL_SESSION) &&
templ_valid >= FP_MAX_FINGER_COUNT) {
CPRINTS("Maximum number of fingers already enrolled: %d",
FP_MAX_FINGER_COUNT);
return EC_ERROR_INVAL;
}
/* Don't allow sensor reset if any other mode is
* set (including FP_MODE_RESET_SENSOR itself).
*/
if (mode & FP_MODE_RESET_SENSOR) {
if (cur_mode & FP_VALID_MODES)
return EC_ERROR_INVAL;
}
return EC_SUCCESS;
}
int fp_set_sensor_mode(uint32_t mode, uint32_t *mode_output)
{
int ret;
if (mode_output == NULL)
return EC_RES_INVALID_PARAM;
ret = validate_fp_mode(mode);
if (ret != EC_SUCCESS) {
CPRINTS("Invalid FP mode 0x%x", mode);
return EC_RES_INVALID_PARAM;
}
if (!(mode & FP_MODE_DONT_CHANGE)) {
sensor_mode = mode;
task_set_event(TASK_ID_FPSENSOR, TASK_EVENT_UPDATE_CONFIG, 0);
}
*mode_output = sensor_mode;
return EC_RES_SUCCESS;
}
static int fp_command_mode(struct host_cmd_handler_args *args)
{
const struct ec_params_fp_mode *p = args->params;
struct ec_response_fp_mode *r = args->response;
int ret = fp_set_sensor_mode(p->mode, &r->mode);
if (ret == EC_RES_SUCCESS)
args->response_size = sizeof(*r);
return ret;
}
DECLARE_HOST_COMMAND(EC_CMD_FP_MODE, fp_command_mode, EC_VER_MASK(0));
static int fp_command_context(struct host_cmd_handler_args *args)
{
const struct ec_params_fp_context *params = args->params;
fp_clear_context();
memcpy(user_id, params->userid, sizeof(user_id));
return EC_RES_SUCCESS;
}
DECLARE_HOST_COMMAND(EC_CMD_FP_CONTEXT, fp_command_context, EC_VER_MASK(0));
|
