1 /*
2 *
3 * Copyright 2023 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 */
18
19 #pragma once
20
21 #include <bluetooth/log.h>
22
23 #include <cstdint>
24 #include <string>
25
26 #include "macros.h"
27 #include "stack/include/bt_dev_class.h"
28 #include "stack/include/bt_name.h"
29 #include "stack/include/bt_octets.h"
30 #include "stack/include/hcidefs.h"
31 #include "stack/include/smp_api_types.h"
32 #include "stack/include/smp_status.h"
33 #include "types/bt_transport.h"
34 #include "types/raw_address.h"
35
36 typedef enum : uint8_t {
37 BTM_BLE_SEC_NONE = 0,
38 /* encrypt the link using current key */
39 BTM_BLE_SEC_ENCRYPT = 1,
40 BTM_BLE_SEC_ENCRYPT_NO_MITM = 2,
41 BTM_BLE_SEC_ENCRYPT_MITM = 3,
42 } tBTM_BLE_SEC_ACT;
43
44 /*****************************************************************************
45 * SECURITY MANAGEMENT
46 ****************************************************************************/
47 /*******************************
48 * Security Manager Constants
49 *******************************/
50
51 typedef enum : uint8_t {
52 BTM_SEC_MODE_SERVICE = 2,
53 BTM_SEC_MODE_SP = 4,
54 BTM_SEC_MODE_SC = 6,
55 } tSECURITY_MODE;
56
security_mode_text(const tSECURITY_MODE & security_mode)57 inline std::string security_mode_text(const tSECURITY_MODE& security_mode) {
58 switch (security_mode) {
59 case BTM_SEC_MODE_SERVICE:
60 return std::string("service");
61 case BTM_SEC_MODE_SP:
62 return std::string("simple pairing");
63 case BTM_SEC_MODE_SC:
64 return std::string("secure connections only");
65 default:
66 return std::format("UNKNOWN[{}]", static_cast<uint8_t>(security_mode));
67 }
68 }
69
70 /* BTM_SEC security masks */
71 enum : uint16_t {
72 /* Nothing required */
73 BTM_SEC_NONE = 0x0000,
74 /* Inbound call requires authentication */
75 BTM_SEC_IN_AUTHENTICATE = 0x0002,
76 /* Inbound call requires encryption */
77 BTM_SEC_IN_ENCRYPT = 0x0004,
78 /* Outbound call requires authentication */
79 BTM_SEC_OUT_AUTHENTICATE = 0x0010,
80 /* Outbound call requires encryption */
81 BTM_SEC_OUT_ENCRYPT = 0x0020,
82 /* Secure Connections Only Mode */
83 BTM_SEC_MODE4_LEVEL4 = 0x0040,
84 /* Need to switch connection to be central */
85 BTM_SEC_FORCE_CENTRAL = 0x0100,
86 /* Need to switch connection to be central */
87 BTM_SEC_ATTEMPT_CENTRAL = 0x0200,
88 /* Need to switch connection to be peripheral */
89 BTM_SEC_FORCE_PERIPHERAL = 0x0400,
90 /* Try to switch connection to be peripheral */
91 BTM_SEC_ATTEMPT_PERIPHERAL = 0x0800,
92 /* inbound Do man in the middle protection */
93 BTM_SEC_IN_MITM = 0x1000,
94 /* outbound Do man in the middle protection */
95 BTM_SEC_OUT_MITM = 0x2000,
96 /* enforce a minimum of 16 digit for sec mode 2 */
97 BTM_SEC_IN_MIN_16_DIGIT_PIN = 0x4000,
98 };
99
100 /* Security Flags [bit mask] (BTM_GetSecurityFlags)
101 */
102 #define BTM_SEC_FLAG_AUTHENTICATED 0x02
103 #define BTM_SEC_FLAG_ENCRYPTED 0x04
104 #define BTM_SEC_FLAG_LKEY_KNOWN 0x10
105 #define BTM_SEC_FLAG_LKEY_AUTHED 0x20
106
107 /* Link Key types used to generate the new link key.
108 * returned in link key notification callback function
109 */
110 #define BTM_LKEY_TYPE_COMBINATION HCI_LKEY_TYPE_COMBINATION
111 #define BTM_LKEY_TYPE_REMOTE_UNIT HCI_LKEY_TYPE_REMOTE_UNIT
112 #define BTM_LKEY_TYPE_DEBUG_COMB HCI_LKEY_TYPE_DEBUG_COMB
113 #define BTM_LKEY_TYPE_UNAUTH_COMB HCI_LKEY_TYPE_UNAUTH_COMB
114 #define BTM_LKEY_TYPE_AUTH_COMB HCI_LKEY_TYPE_AUTH_COMB
115 #define BTM_LKEY_TYPE_CHANGED_COMB HCI_LKEY_TYPE_CHANGED_COMB
116
117 #define BTM_LKEY_TYPE_UNAUTH_COMB_P_256 HCI_LKEY_TYPE_UNAUTH_COMB_P_256
118 #define BTM_LKEY_TYPE_AUTH_COMB_P_256 HCI_LKEY_TYPE_AUTH_COMB_P_256
119
linkkey_type_text(const int linkkey_type)120 inline std::string linkkey_type_text(const int linkkey_type) {
121 switch (linkkey_type) {
122 case BTM_LKEY_TYPE_COMBINATION:
123 return std::string("COMBINATION");
124 case BTM_LKEY_TYPE_REMOTE_UNIT:
125 return std::string("REMOTE_UNIT");
126 case BTM_LKEY_TYPE_DEBUG_COMB:
127 return std::string("DEBUG_COMB");
128 case BTM_LKEY_TYPE_UNAUTH_COMB:
129 return std::string("UNAUTH_COMB");
130 case BTM_LKEY_TYPE_AUTH_COMB:
131 return std::string("AUTH_COMB");
132 case BTM_LKEY_TYPE_CHANGED_COMB:
133 return std::string("CHANGED_COMB");
134 case BTM_LKEY_TYPE_UNAUTH_COMB_P_256:
135 return std::string("UNAUTH_COMB_P_256");
136 case BTM_LKEY_TYPE_AUTH_COMB_P_256:
137 return std::string("AUTH_COMB_P_256");
138 default:
139 return std::format("UNKNOWN[0x{:02x}]", linkkey_type);
140 }
141 }
142
143 /* "easy" requirements for LK derived from LTK */
144 #define BTM_LTK_DERIVED_LKEY_OFFSET 0x20
145 #define BTM_LKEY_TYPE_IGNORE \
146 0xff /* used when event is response from \
147 hci return link keys request */
148
149 typedef uint8_t tBTM_LINK_KEY_TYPE;
150
151 /* Protocol level security (BTM_SetSecurityLevel) */
152 #define BTM_SEC_PROTO_RFCOMM 3
153 #define BTM_SEC_PROTO_BNEP 5
154 #define BTM_SEC_PROTO_HID 6 /* HID */
155 #define BTM_SEC_PROTO_AVDT 7
156
157 #define BTM_SEC_SERVICE_HEADSET 8
158 #define BTM_SEC_SERVICE_HEADSET_AG 12
159 #define BTM_SEC_SERVICE_AG_HANDSFREE 29
160 #define BTM_SEC_SERVICE_RFC_MUX 42
161 #define BTM_SEC_SERVICE_HEARING_AID_LEFT 54
162 #define BTM_SEC_SERVICE_HEARING_AID_RIGHT 55
163 #define BTM_SEC_SERVICE_EATT 56
164
165 /* Update these as services are added */
166 #define BTM_SEC_SERVICE_FIRST_EMPTY 57
167
168 #ifndef BTM_SEC_MAX_SERVICES
169 #define BTM_SEC_MAX_SERVICES 75
170 #endif
171
172 /*******************************************************************************
173 * Security Services MACROS handle array of uint32_t bits for more than 32
174 * trusted services
175 ******************************************************************************/
176
177 typedef enum : uint8_t {
178 BTM_SP_IO_REQ_EVT, /* received IO_CAPABILITY_REQUEST event */
179 BTM_SP_IO_RSP_EVT, /* received IO_CAPABILITY_RESPONSE event */
180 BTM_SP_CFM_REQ_EVT, /* received USER_CONFIRMATION_REQUEST event */
181 BTM_SP_KEY_NOTIF_EVT, /* received USER_PASSKEY_NOTIFY event */
182 BTM_SP_KEY_REQ_EVT, /* received USER_PASSKEY_REQUEST event */
183 BTM_SP_LOC_OOB_EVT, /* received result for READ_LOCAL_OOB_DATA command */
184 BTM_SP_RMT_OOB_EVT, /* received REMOTE_OOB_DATA_REQUEST event */
185 } tBTM_SP_EVT;
186
sp_evt_to_text(const tBTM_SP_EVT evt)187 inline std::string sp_evt_to_text(const tBTM_SP_EVT evt) {
188 switch (evt) {
189 CASE_RETURN_TEXT(BTM_SP_IO_REQ_EVT);
190 CASE_RETURN_TEXT(BTM_SP_IO_RSP_EVT);
191 CASE_RETURN_TEXT(BTM_SP_CFM_REQ_EVT);
192 CASE_RETURN_TEXT(BTM_SP_KEY_NOTIF_EVT);
193 CASE_RETURN_TEXT(BTM_SP_KEY_REQ_EVT);
194 CASE_RETURN_TEXT(BTM_SP_LOC_OOB_EVT);
195 CASE_RETURN_TEXT(BTM_SP_RMT_OOB_EVT);
196 }
197
198 return std::format("UNKNOWN[{}]", static_cast<uint8_t>(evt));
199 }
200
201 enum : uint8_t {
202 BTM_IO_CAP_OUT = 0, /* DisplayOnly */
203 BTM_IO_CAP_IO = 1, /* DisplayYesNo */
204 BTM_IO_CAP_IN = 2, /* KeyboardOnly */
205 BTM_IO_CAP_NONE = 3, /* NoInputNoOutput */
206 BTM_IO_CAP_KBDISP = 4, /* Keyboard display */
207 BTM_IO_CAP_MAX = 5,
208 BTM_IO_CAP_UNKNOWN = 0xFF /* Unknown value */
209 };
210 typedef uint8_t tBTM_IO_CAP;
211
io_capabilities_text(const tBTM_IO_CAP & io_caps)212 inline std::string io_capabilities_text(const tBTM_IO_CAP& io_caps) {
213 switch (io_caps) {
214 case BTM_IO_CAP_OUT:
215 return std::string("Display only");
216 case BTM_IO_CAP_IO:
217 return std::string("Display yes-no");
218 case BTM_IO_CAP_IN:
219 return std::string("Keyboard Only");
220 case BTM_IO_CAP_NONE:
221 return std::string("No input or output");
222 case BTM_IO_CAP_KBDISP:
223 return std::string("Keyboard-Display");
224 default:
225 return std::format("UNKNOWN[{}]", io_caps);
226 }
227 }
228
229 #define BTM_MAX_PASSKEY_VAL (999999)
230
231 typedef enum : uint8_t {
232 /* MITM Protection Not Required - Single Profile/non-bonding Numeric
233 * comparison with automatic accept allowed */
234 // NO_BONDING
235 BTM_AUTH_SP_NO = 0,
236 /* MITM Protection Required - Single Profile/non-bonding. Use IO Capabilities
237 * to determine authentication procedure */
238 // NO_BONDING_MITM_PROTECTION
239 BTM_AUTH_SP_YES = 1,
240 /* MITM Protection Not Required - All Profiles/dedicated bonding Numeric
241 * comparison with automatic accept allowed */
242 // DEDICATED_BONDING
243 BTM_AUTH_AP_NO = 2,
244 /* MITM Protection Required - All Profiles/dedicated bonding Use IO
245 * Capabilities to determine authentication procedure */
246 // DEDICATED_BONDING_MITM_PROTECTION
247 BTM_AUTH_AP_YES = 3,
248 /* MITM Protection Not Required - Single Profiles/general bonding Numeric
249 * comparison with automatic accept allowed */
250 // GENERAL_BONDING
251 BTM_AUTH_SPGB_NO = 4,
252 /* MITM Protection Required - Single Profiles/general bonding Use IO
253 * Capabilities to determine authentication procedure */
254 // GENERAL_BONDING_MITM_PROTECTION
255 BTM_AUTH_SPGB_YES = 5,
256 } tBTM_AUTH;
257
258 /* this bit is ORed with BTM_AUTH_SP_* when IO exchange for dedicated bonding */
259 #define BTM_AUTH_DD_BOND 2
260 #define BTM_AUTH_BONDS 6 /* the general/dedicated bonding bits */
261 #define BTM_AUTH_YN_BIT 1 /* this is the Yes or No bit */
262
263 #define BTM_BLE_INITIATOR_KEY_SIZE 15
264 #define BTM_BLE_RESPONDER_KEY_SIZE 15
265 #define BTM_BLE_MAX_KEY_SIZE 16
266
267 typedef uint8_t tBTM_AUTH_REQ;
268
269 enum {
270 BTM_OOB_NONE,
271 BTM_OOB_PRESENT_192,
272 BTM_OOB_PRESENT_256,
273 BTM_OOB_PRESENT_192_AND_256,
274 BTM_OOB_UNKNOWN
275 };
276
277 typedef uint8_t tBTM_OOB_DATA;
278
btm_oob_data_text(const tBTM_OOB_DATA & data)279 inline std::string btm_oob_data_text(const tBTM_OOB_DATA& data) {
280 switch (data) {
281 CASE_RETURN_TEXT(BTM_OOB_NONE);
282 CASE_RETURN_TEXT(BTM_OOB_PRESENT_192);
283 CASE_RETURN_TEXT(BTM_OOB_PRESENT_256);
284 CASE_RETURN_TEXT(BTM_OOB_PRESENT_192_AND_256);
285 CASE_RETURN_TEXT(BTM_OOB_UNKNOWN);
286 default:
287 return std::string("UNKNOWN[") + std::to_string(data) + std::string("]");
288 }
289 }
290
291 /* data type for BTM_SP_IO_REQ_EVT */
292 typedef struct {
293 RawAddress bd_addr; /* peer address */
294 tBTM_IO_CAP io_cap; /* local IO capabilities */
295 tBTM_OOB_DATA oob_data; /* OOB data present (locally) for the peer device */
296 tBTM_AUTH_REQ auth_req; /* Authentication required (for local device) */
297 bool is_orig; /* true, if local device initiated the SP process */
298 } tBTM_SP_IO_REQ;
299
300 /* data type for BTM_SP_IO_RSP_EVT */
301 typedef struct {
302 RawAddress bd_addr; /* peer address */
303 tBTM_IO_CAP io_cap; /* peer IO capabilities */
304 tBTM_OOB_DATA oob_data; /* OOB data present at peer device for the local device */
305 tBTM_AUTH_REQ auth_req; /* Authentication required for peer device */
306 } tBTM_SP_IO_RSP;
307
308 /* data type for BTM_SP_CFM_REQ_EVT */
309 typedef struct {
310 RawAddress bd_addr; /* peer address */
311 DEV_CLASS dev_class; /* peer CoD */
312 BD_NAME bd_name; /* peer device name */
313 uint32_t num_val; /* the numeric value for comparison. If just_works, do not
314 show this number to UI */
315 bool just_works; /* true, if "Just Works" association model */
316 tBTM_AUTH_REQ loc_auth_req; /* Authentication required for local device */
317 tBTM_AUTH_REQ rmt_auth_req; /* Authentication required for peer device */
318 tBTM_IO_CAP loc_io_caps; /* IO Capabilities of the local device */
319 tBTM_IO_CAP rmt_io_caps; /* IO Capabilities of the remot device */
320 } tBTM_SP_CFM_REQ;
321
322 /* data type for BTM_SP_KEY_REQ_EVT */
323 typedef struct {
324 RawAddress bd_addr; /* peer address */
325 DEV_CLASS dev_class; /* peer CoD */
326 BD_NAME bd_name; /* peer device name */
327 } tBTM_SP_KEY_REQ;
328
329 /* data type for BTM_SP_KEY_NOTIF_EVT */
330 typedef struct {
331 RawAddress bd_addr; /* peer address */
332 DEV_CLASS dev_class; /* peer CoD */
333 BD_NAME bd_name; /* peer device name */
334 uint32_t passkey; /* passkey */
335 } tBTM_SP_KEY_NOTIF;
336
337 /* data type for BTM_SP_LOC_OOB_EVT */
338 typedef struct {
339 tBTM_STATUS status; /* */
340 Octet16 c_192; /* Simple Pairing Hash C from P-192 public key */
341 Octet16 r_192; /* Simple Pairing Randomnizer R from P-192 public key */
342 Octet16 c_256; /* Simple Pairing Hash C from P-256 public key */
343 Octet16 r_256; /* Simple Pairing Randomnizer R from P-256 public key */
344 } tBTM_SP_LOC_OOB;
345
346 /* data type for BTM_SP_RMT_OOB_EVT */
347 typedef struct {
348 RawAddress bd_addr; /* peer address */
349 DEV_CLASS dev_class; /* peer CoD */
350 BD_NAME bd_name; /* peer device name */
351 } tBTM_SP_RMT_OOB;
352
353 typedef union {
354 tBTM_SP_IO_REQ io_req; /* BTM_SP_IO_REQ_EVT */
355 tBTM_SP_IO_RSP io_rsp; /* BTM_SP_IO_RSP_EVT */
356 tBTM_SP_CFM_REQ cfm_req; /* BTM_SP_CFM_REQ_EVT */
357 tBTM_SP_KEY_NOTIF key_notif; /* BTM_SP_KEY_NOTIF_EVT */
358 tBTM_SP_KEY_REQ key_req; /* BTM_SP_KEY_REQ_EVT */
359 tBTM_SP_LOC_OOB loc_oob; /* BTM_SP_LOC_OOB_EVT */
360 tBTM_SP_RMT_OOB rmt_oob; /* BTM_SP_RMT_OOB_EVT */
361 } tBTM_SP_EVT_DATA;
362
363 /* Simple Pairing Events. Called by the stack when Simple Pairing related
364 * events occur.
365 */
366 typedef tBTM_STATUS(tBTM_SP_CALLBACK)(tBTM_SP_EVT event, tBTM_SP_EVT_DATA* p_data);
367
368 typedef void(tBTM_MKEY_CALLBACK)(const RawAddress& bd_addr, uint8_t status, uint8_t key_flag);
369
370 /* Encryption enabled/disabled complete: Optionally passed with
371 * BTM_SetEncryption.
372 * Parameters are
373 * BD Address of remote
374 * optional data passed in by BTM_SetEncryption
375 * tBTM_STATUS - result of the operation
376 */
377 typedef void(tBTM_SEC_CALLBACK)(RawAddress bd_addr, tBT_TRANSPORT transport, void* p_ref_data,
378 tBTM_STATUS result);
379 typedef tBTM_SEC_CALLBACK tBTM_SEC_CALLBACK;
380
381 /* Bond Cancel complete. Parameters are
382 * Result of the cancel operation
383 *
384 */
385 typedef void(tBTM_BOND_CANCEL_CMPL_CALLBACK)(tBTM_STATUS result);
386
387 typedef enum : uint8_t {
388 /* LE related event and data structure */
389 /* received IO_CAPABILITY_REQUEST event */
390 BTM_LE_IO_REQ_EVT = SMP_IO_CAP_REQ_EVT,
391 /* security request event */
392 BTM_LE_SEC_REQUEST_EVT = SMP_SEC_REQUEST_EVT,
393
394 /* received USER_PASSKEY_NOTIFY event */
395 BTM_LE_KEY_NOTIF_EVT = SMP_PASSKEY_NOTIF_EVT,
396
397 /* received USER_PASSKEY_REQUEST event */
398 BTM_LE_KEY_REQ_EVT = SMP_PASSKEY_REQ_EVT,
399
400 /* OOB data request event */
401 BTM_LE_OOB_REQ_EVT = SMP_OOB_REQ_EVT,
402
403 /* Numeric Comparison request event */
404 BTM_LE_NC_REQ_EVT = SMP_NC_REQ_EVT,
405
406 /* Peer keypress notification recd event */
407 BTM_LE_PR_KEYPR_NOT_EVT = SMP_PEER_KEYPR_NOT_EVT,
408
409 /* SC OOB request event (both local and peer OOB data) can be expected in
410 * response */
411 BTM_LE_SC_OOB_REQ_EVT = SMP_SC_OOB_REQ_EVT,
412
413 /* SC OOB local data set is created (as result of SMP_CrLocScOobData(...)) */
414 BTM_LE_SC_LOC_OOB_EVT = SMP_SC_LOC_OOB_DATA_UP_EVT,
415 /* SMP complete event */
416 BTM_LE_COMPLT_EVT = SMP_COMPLT_EVT,
417 BTM_LE_LAST_FROM_SMP = SMP_BR_KEYS_REQ_EVT,
418 /* KEY update event */
419 BTM_LE_KEY_EVT = (BTM_LE_LAST_FROM_SMP + 1),
420 BTM_LE_CONSENT_REQ_EVT = SMP_CONSENT_REQ_EVT,
421
422 /* Identity address associate event */
423 BTM_LE_ADDR_ASSOC_EVT = SMP_LE_ADDR_ASSOC_EVT,
424 } tBTM_LE_EVT;
425
ble_evt_to_text(const tBTM_LE_EVT evt)426 inline std::string ble_evt_to_text(const tBTM_LE_EVT evt) {
427 switch (evt) {
428 CASE_RETURN_TEXT(BTM_LE_IO_REQ_EVT);
429 CASE_RETURN_TEXT(BTM_LE_SEC_REQUEST_EVT);
430 CASE_RETURN_TEXT(BTM_LE_KEY_NOTIF_EVT);
431 CASE_RETURN_TEXT(BTM_LE_KEY_REQ_EVT);
432 CASE_RETURN_TEXT(BTM_LE_OOB_REQ_EVT);
433 CASE_RETURN_TEXT(BTM_LE_NC_REQ_EVT);
434 CASE_RETURN_TEXT(BTM_LE_PR_KEYPR_NOT_EVT);
435 CASE_RETURN_TEXT(BTM_LE_SC_OOB_REQ_EVT);
436 CASE_RETURN_TEXT(BTM_LE_SC_LOC_OOB_EVT);
437 CASE_RETURN_TEXT(BTM_LE_COMPLT_EVT);
438 CASE_RETURN_TEXT(BTM_LE_LAST_FROM_SMP);
439 CASE_RETURN_TEXT(BTM_LE_KEY_EVT);
440 CASE_RETURN_TEXT(BTM_LE_CONSENT_REQ_EVT);
441 CASE_RETURN_TEXT(BTM_LE_ADDR_ASSOC_EVT);
442 }
443
444 return std::format("UNKNOWN[{}]", static_cast<uint8_t>(evt));
445 }
446
447 enum : uint8_t {
448 BTM_LE_KEY_NONE = 0,
449 BTM_LE_KEY_PENC = SMP_SEC_KEY_TYPE_ENC,
450 /* identity key of the peer device */
451 BTM_LE_KEY_PID = SMP_SEC_KEY_TYPE_ID,
452 /* peer SRK */
453 BTM_LE_KEY_PCSRK = SMP_SEC_KEY_TYPE_CSRK,
454 BTM_LE_KEY_PLK = SMP_SEC_KEY_TYPE_LK,
455 BTM_LE_KEY_LLK = (SMP_SEC_KEY_TYPE_LK << 4),
456 /* master role security information:div */
457 BTM_LE_KEY_LENC = (SMP_SEC_KEY_TYPE_ENC << 4),
458 /* master device ID key */
459 BTM_LE_KEY_LID = (SMP_SEC_KEY_TYPE_ID << 4),
460 /* local CSRK has been deliver to peer */
461 BTM_LE_KEY_LCSRK = (SMP_SEC_KEY_TYPE_CSRK << 4),
462 };
463 typedef uint8_t tBTM_LE_KEY_TYPE;
464
465 #define BTM_LE_AUTH_REQ_NO_BOND SMP_AUTH_NO_BOND /* 0 */
466 #define BTM_LE_AUTH_REQ_BOND SMP_AUTH_BOND /* 1 << 0 */
467 #define BTM_LE_AUTH_REQ_MITM SMP_AUTH_YN_BIT /* 1 << 2 */
468 typedef uint8_t tBTM_LE_AUTH_REQ;
469 #define BTM_LE_SC_SUPPORT_BIT SMP_SC_SUPPORT_BIT /* (1 << 3) */
470 #define BTM_LE_KP_SUPPORT_BIT SMP_KP_SUPPORT_BIT /* (1 << 4) */
471 #define BTM_LE_H7_SUPPORT_BIT SMP_H7_SUPPORT_BIT /* (1 << 5) */
472
473 #define BTM_LE_AUTH_REQ_SC_ONLY SMP_AUTH_SC_ENC_ONLY /* 00101000 */
474 #define BTM_LE_AUTH_REQ_SC_BOND SMP_AUTH_SC_GB /* 00101001 */
475 #define BTM_LE_AUTH_REQ_SC_MITM SMP_AUTH_SC_MITM_NB /* 00101100 */
476 #define BTM_LE_AUTH_REQ_SC_MITM_BOND SMP_AUTH_SC_MITM_GB /* 00101101 */
477 #define BTM_LE_AUTH_REQ_MASK SMP_AUTH_MASK /* 0x3D */
478
479 typedef struct {
480 /* local IO capabilities */
481 tBTM_IO_CAP io_cap;
482 /* OOB data present (locally) for the peer device */
483 uint8_t oob_data;
484 /* Authentication request (for local device) containing bonding and MITM
485 * info */
486 tBTM_LE_AUTH_REQ auth_req;
487 uint8_t max_key_size; /* max encryption key size */
488 tBTM_LE_KEY_TYPE init_keys; /* keys to be distributed, bit mask */
489 tBTM_LE_KEY_TYPE resp_keys; /* keys to be distributed, bit mask */
490 } tBTM_LE_IO_REQ;
491
492 /* data type for tBTM_LE_COMPLT */
493 typedef struct {
494 tSMP_STATUS reason;
495 uint8_t sec_level;
496 bool is_pair_cancel;
497 bool smp_over_br;
498 } tBTM_LE_COMPLT;
499
500 /************************
501 * Stored Linkkey Types
502 ************************/
503 #define BTM_CB_EVT_DELETE_STORED_LINK_KEYS 4
504
505 typedef struct {
506 uint8_t event;
507 uint8_t status;
508 uint16_t num_keys;
509 } tBTM_DELETE_STORED_LINK_KEY_COMPLETE;
510
511 enum tBTM_BOND_TYPE : uint8_t {
512 BOND_TYPE_UNKNOWN = 0,
513 BOND_TYPE_PERSISTENT = 1,
514 BOND_TYPE_TEMPORARY = 2
515 };
516
bond_type_text(const tBTM_BOND_TYPE & bond_type)517 inline std::string bond_type_text(const tBTM_BOND_TYPE& bond_type) {
518 switch (bond_type) {
519 CASE_RETURN_TEXT(BOND_TYPE_UNKNOWN);
520 CASE_RETURN_TEXT(BOND_TYPE_PERSISTENT);
521 CASE_RETURN_TEXT(BOND_TYPE_TEMPORARY);
522 default:
523 return std::format("UNKNOWN[{}]", static_cast<uint8_t>(bond_type));
524 }
525 }
526
527 namespace std {
528 template <>
529 struct formatter<tBTM_BLE_SEC_ACT> : enum_formatter<tBTM_BLE_SEC_ACT> {};
530 template <>
531 struct formatter<tBTM_BOND_TYPE> : enum_formatter<tBTM_BOND_TYPE> {};
532 } // namespace std
533