Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/scapy/layers/bluetooth.py: 86%

Shortcuts on this page

r m x   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1354 statements  

1# SPDX-License-Identifier: GPL-2.0-only 

2# This file is part of Scapy 

3# See https://scapy.net/ for more information 

4# Copyright (C) Philippe Biondi <phil@secdev.org> 

5# Copyright (C) Mike Ryan <mikeryan@lacklustre.net> 

6# Copyright (C) Michael Farrell <micolous+git@gmail.com> 

7# Copyright (C) Haram Park <freehr94@korea.ac.kr> 

8# Copyright (C) Guillaume Bouffard <guillaume.bouffard@ssi.gouv.fr> 

9# Copyright (C) Philippe Trébuchet <philippe.trebuchet@ssi.gouv.fr> 

10 

11""" 

12Bluetooth layers, sockets and send/receive functions. 

13""" 

14 

15import socket 

16import struct 

17import select 

18 

19try: 

20 import ctypes 

21 from ctypes import sizeof 

22except OSError: 

23 ctypes = None 

24 sizeof = None 

25 

26from scapy.config import conf 

27from scapy.data import ( 

28 DLT_BLUETOOTH_HCI_H4, 

29 DLT_BLUETOOTH_HCI_H4_WITH_PHDR, 

30 DLT_BLUETOOTH_LINUX_MONITOR, 

31 BLUETOOTH_CORE_COMPANY_IDENTIFIERS 

32) 

33from scapy.packet import bind_layers, Packet 

34from scapy.fields import ( 

35 BitField, 

36 LEFieldLenField, 

37 XBitField, 

38 BitLenField, 

39 ByteEnumField, 

40 ByteField, 

41 FieldLenField, 

42 FieldListField, 

43 FlagsField, 

44 IntField, 

45 LEShortEnumField, 

46 LEShortField, 

47 LEIntField, 

48 LenField, 

49 MultipleTypeField, 

50 NBytesField, 

51 PacketField, 

52 PacketListField, 

53 PadField, 

54 ShortField, 

55 ShortEnumField, 

56 SignedByteField, 

57 StrField, 

58 StrFixedLenField, 

59 XStrFixedLenField, 

60 StrLenField, 

61 StrNullField, 

62 UUIDField, 

63 XByteField, 

64 XLE3BytesField, 

65 XLELongField, 

66 XStrLenField, 

67 XLEShortField, 

68 XLEIntField, 

69 LEMACField, 

70 BitEnumField, 

71 LEThreeBytesField, 

72 ConditionalField 

73) 

74from scapy.supersocket import SuperSocket 

75from scapy.sendrecv import sndrcv 

76from scapy.data import MTU 

77from scapy.consts import WINDOWS 

78from scapy.error import Scapy_Exception, warning 

79 

80 

81############ 

82# Consts # 

83############ 

84 

85# From hci.h 

86HCI_CHANNEL_RAW = 0 

87HCI_CHANNEL_USER = 1 

88HCI_CHANNEL_MONITOR = 2 

89HCI_CHANNEL_CONTROL = 3 

90HCI_CHANNEL_LOGGING = 4 

91 

92HCI_DEV_NONE = 0xffff 

93 

94 

95########## 

96# Layers # 

97########## 

98 

99# See bluez/lib/hci.h for details 

100 

101# Transport layers 

102 

103class HCI_PHDR_Hdr(Packet): 

104 name = "HCI PHDR transport layer" 

105 fields_desc = [IntField("direction", 0)] 

106 

107 

108# Real layers 

109 

110_bluetooth_packet_types = { 

111 0: "Acknowledgement", 

112 1: "Command", 

113 2: "ACL Data", 

114 3: "Synchronous", 

115 4: "Event", 

116 5: "Reserve", 

117 14: "Vendor", 

118 15: "Link Control" 

119} 

120 

121_bluetooth_error_codes = { 

122 0x00: "Success", 

123 0x01: "Unknown HCI Command", 

124 0x02: "Unknown Connection Identifier", 

125 0x03: "Hardware Failure", 

126 0x04: "Page Timeout", 

127 0x05: "Authentication Failure", 

128 0x06: "PIN or Key Missing", 

129 0x07: "Memory Capacity Exceeded", 

130 0x08: "Connection Timeout", 

131 0x09: "Connection Limit Exceeded", 

132 0x0A: "Synchronous Connection Limit To A Device Exceeded", 

133 0x0B: "Connection Already Exists", 

134 0x0C: "Command Disallowed", 

135 0x0D: "Connection Rejected due to Limited Resources", 

136 0x0E: "Connection Rejected Due To Security Reasons", 

137 0x0F: "Connection Rejected due to Unacceptable BD_ADDR", 

138 0x10: "Connection Accept Timeout Exceeded", 

139 0x11: "Unsupported Feature or Parameter Value", 

140 0x12: "Invalid HCI Command parameters", 

141 0x13: "Remote User Terminated Connection", 

142 0x14: "Remote Device Terminated Connection due to Low Resources", 

143 0x15: "Remote Device Terminated Connection due to Power Off", 

144 0x16: "Connection Terminated By Local Host", 

145 0x17: "Repeated Attempts", 

146 0x18: "Pairing Not Allowed", 

147 0x19: "Unknown LMP PDU", 

148 0x1A: "Unsupported Remote Feature / Unsupported LMP Feature", 

149 0x1B: "SCO Offset Rejected", 

150 0x1C: "SCO Interval Rejected", 

151 0x1D: "SCO Air Mode Rejected", 

152 0x1E: "Invalid LMP parameters / Invalid LL parameters", 

153 0x1F: "Unspecified Error", 

154 0x20: "Unsupported LMP Parameter Value / Unsupported LL Parameter Value", 

155 0x21: "Role Change Not Allowed", 

156 0x22: "LMP Response Timeout / LL Response Timeout", 

157 0x23: "LMP Error Transaction Collision / LL Procedure Collision", 

158 0x24: "LMP PDU Not Allowed", 

159 0x25: "Encryption Mode Not Acceptable", 

160 0x26: "Link Key cannot be Changed", 

161 0x27: "Requested QoS Not Supported", 

162 0x28: "Instant Passed", 

163 0x29: "Pairing With Unit Key Not Supported", 

164 0x2A: "Different Transaction Collision", 

165 0x2B: "Reserved for future use", 

166 0x2C: "QoS Unacceptable Parameter", 

167 0x2D: "QoS Rejected", 

168 0x2E: "Channel Classification Not Supported", 

169 0x2F: "Insufficient Security", 

170 0x30: "Parameter Out Of Mandatory Range", 

171 0x31: "Reserved for future use", 

172 0x32: "Role Switch Pending", 

173 0x33: "Reserved for future use", 

174 0x34: "Reserved Slot Violation", 

175 0x35: "Role Switch Failed", 

176 0x36: "Extended Inquiry Response Too Large", 

177 0x37: "Secure Simple Pairing Not Supported By Host", 

178 0x38: "Host Busy - Pairing", 

179 0x39: "Connection Rejected due to No Suitable Channel Found", 

180 0x3A: "Controller Busy", 

181 0x3B: "Unacceptable Connection parameters", 

182 0x3C: "Advertising Timeout", 

183 0x3D: "Connection Terminated due to MIC Failure", 

184 0x3E: "Connection Failed to be Established / Synchronization Timeout", 

185 0x3F: "MAC Connection Failed", 

186 0x40: "Coarse Clock Adjustment Rejected but Will Try to Adjust Using Clock" 

187 " Dragging", 

188 0x41: "Type0 Submap Not Defined", 

189 0x42: "Unknown Advertising Identifier", 

190 0x43: "Limit Reached", 

191 0x44: "Operation Cancelled by Host", 

192 0x45: "Packet Too Long" 

193} 

194 

195_att_error_codes = { 

196 0x01: "invalid handle", 

197 0x02: "read not permitted", 

198 0x03: "write not permitted", 

199 0x04: "invalid pdu", 

200 0x05: "insufficient auth", 

201 0x06: "unsupported req", 

202 0x07: "invalid offset", 

203 0x08: "insufficient author", 

204 0x09: "prepare queue full", 

205 0x0a: "attr not found", 

206 0x0b: "attr not long", 

207 0x0c: "insufficient key size", 

208 0x0d: "invalid value size", 

209 0x0e: "unlikely", 

210 0x0f: "insufficiet encrypt", 

211 0x10: "unsupported gpr type", 

212 0x11: "insufficient resources", 

213} 

214 

215_bluetooth_features = [ 

216 '3_slot_packets', 

217 '5_slot_packets', 

218 'encryption', 

219 'slot_offset', 

220 'timing_accuracy', 

221 'role_switch', 

222 'hold_mode', 

223 'sniff_mode', 

224 'park_mode', 

225 'power_control_requests', 

226 'channel_quality_driven_data_rate', 

227 'sco_link', 

228 'hv2_packets', 

229 'hv3_packets', 

230 'u_law_log_synchronous_data', 

231 'a_law_log_synchronous_data', 

232 'cvsd_synchronous_data', 

233 'paging_parameter_negotiation', 

234 'power_control', 

235 'transparent_synchronous_data', 

236 'flow_control_lag_4_bit0', 

237 'flow_control_lag_4_bit1', 

238 'flow_control_lag_4_bit2', 

239 'broadband_encryption', 

240 'cvsd_synchronous_data', 

241 'edr_acl_2_mbps_mode', 

242 'edr_acl_3_mbps_mode', 

243 'enhanced_inquiry_scan', 

244 'interlaced_inquiry_scan', 

245 'interlaced_page_scan', 

246 'rssi_with_inquiry_results', 

247 'ev3_packets', 

248 'ev4_packets', 

249 'ev5_packets', 

250 'reserved', 

251 'afh_capable_slave', 

252 'afh_classification_slave', 

253 'br_edr_not_supported', 

254 'le_supported_controller', 

255 '3_slot_edr_acl_packets', 

256 '5_slot_edr_acl_packets', 

257 'sniff_subrating', 

258 'pause_encryption', 

259 'afh_capable_master', 

260 'afh_classification_master', 

261 'edr_esco_2_mbps_mode', 

262 'edr_esco_3_mbps_mode', 

263 '3_slot_edr_esco_packets', 

264 'extended_inquiry_response', 

265 'simultaneous_le_and_br_edr_to_same_device_capable_controller', 

266 'reserved2', 

267 'secure_simple_pairing', 

268 'encapsulated_pdu', 

269 'erroneous_data_reporting', 

270 'non_flushable_packet_boundary_flag', 

271 'reserved3', 

272 'link_supervision_timeout_changed_event', 

273 'inquiry_tx_power_level', 

274 'enhanced_power_control', 

275 'reserved4_bit0', 

276 'reserved4_bit1', 

277 'reserved4_bit2', 

278 'reserved4_bit3', 

279 'extended_features', 

280] 

281 

282_bluetooth_core_specification_versions = { 

283 0x00: '1.0b', 

284 0x01: '1.1', 

285 0x02: '1.2', 

286 0x03: '2.0+EDR', 

287 0x04: '2.1+EDR', 

288 0x05: '3.0+HS', 

289 0x06: '4.0', 

290 0x07: '4.1', 

291 0x08: '4.2', 

292 0x09: '5.0', 

293 0x0a: '5.1', 

294 0x0b: '5.2', 

295 0x0c: '5.3', 

296 0x0d: '5.4', 

297 0x0e: '6.0', 

298} 

299 

300 

301class HCI_Hdr(Packet): 

302 name = "HCI header" 

303 fields_desc = [ByteEnumField("type", 2, _bluetooth_packet_types)] 

304 

305 def mysummary(self): 

306 return self.sprintf("HCI %type%") 

307 

308 

309class HCI_ACL_Hdr(Packet): 

310 name = "HCI ACL header" 

311 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

312 fields_desc = [BitField("BC", 0, 2, tot_size=-2), 

313 BitField("PB", 0, 2), 

314 BitField("connection_handle", 0, 12, end_tot_size=-2), 

315 LEShortField("len", None), ] 

316 

317 def post_build(self, p, pay): 

318 p += pay 

319 if self.len is None: 

320 p = p[:2] + struct.pack("<H", len(pay)) + p[4:] 

321 return p 

322 

323 

324class L2CAP_Hdr(Packet): 

325 name = "L2CAP header" 

326 fields_desc = [LEShortField("len", None), 

327 LEShortEnumField("cid", 0, {1: "control", 4: "attribute"}), ] # noqa: E501 

328 

329 def post_build(self, p, pay): 

330 p += pay 

331 if self.len is None: 

332 p = struct.pack("<H", len(pay)) + p[2:] 

333 return p 

334 

335 

336class L2CAP_CmdHdr(Packet): 

337 name = "L2CAP command header" 

338 fields_desc = [ 

339 ByteEnumField("code", 8, {1: "rej", 

340 2: "conn_req", 

341 3: "conn_resp", 

342 4: "conf_req", 

343 5: "conf_resp", 

344 6: "disconn_req", 

345 7: "disconn_resp", 

346 8: "echo_req", 

347 9: "echo_resp", 

348 10: "info_req", 

349 11: "info_resp", 

350 12: "create_channel_req", 

351 13: "create_channel_resp", 

352 14: "move_channel_req", 

353 15: "move_channel_resp", 

354 16: "move_channel_confirm_req", 

355 17: "move_channel_confirm_resp", 

356 18: "conn_param_update_req", 

357 19: "conn_param_update_resp", 

358 20: "LE_credit_based_conn_req", 

359 21: "LE_credit_based_conn_resp", 

360 22: "flow_control_credit_ind", 

361 23: "credit_based_conn_req", 

362 24: "credit_based_conn_resp", 

363 25: "credit_based_reconf_req", 

364 26: "credit_based_reconf_resp"}), 

365 ByteField("id", 1), 

366 LEShortField("len", None)] 

367 

368 def post_build(self, p, pay): 

369 p += pay 

370 if self.len is None: 

371 p = p[:2] + struct.pack("<H", len(pay)) + p[4:] 

372 return p 

373 

374 def answers(self, other): 

375 if other.id == self.id: 

376 if self.code == 1: 

377 return 1 

378 if other.code in [2, 4, 6, 8, 10, 18] and self.code == other.code + 1: # noqa: E501 

379 if other.code == 8: 

380 return 1 

381 return self.payload.answers(other.payload) 

382 return 0 

383 

384 

385class L2CAP_ConnReq(Packet): 

386 name = "L2CAP Conn Req" 

387 fields_desc = [LEShortEnumField("psm", 0, {1: "SDP", 

388 3: "RFCOMM", 

389 5: "TCS-BIN", 

390 7: "TCS-BIN-CORDLESS", 

391 15: "BNEP", 

392 17: "HID-Control", 

393 19: "HID-Interrupt", 

394 21: "UPnP", 

395 23: "AVCTP-Control", 

396 25: "AVDTP", 

397 27: "AVCTP-Browsing", 

398 29: "UDI_C-Plane", 

399 31: "ATT", 

400 33: "3DSP", 

401 35: "IPSP", 

402 37: "OTS"}), 

403 LEShortField("scid", 0), 

404 ] 

405 

406 

407class L2CAP_ConnResp(Packet): 

408 name = "L2CAP Conn Resp" 

409 fields_desc = [LEShortField("dcid", 0), 

410 LEShortField("scid", 0), 

411 LEShortEnumField("result", 0, ["success", "pend", "cr_bad_psm", "cr_sec_block", "cr_no_mem", "reserved", "cr_inval_scid", "cr_scid_in_use"]), # noqa: E501 

412 LEShortEnumField("status", 0, ["no_info", "authen_pend", "author_pend", "reserved"]), # noqa: E501 

413 ] 

414 

415 def answers(self, other): 

416 # dcid Resp == scid Req. Therefore compare SCIDs 

417 return isinstance(other, L2CAP_ConnReq) and self.scid == other.scid 

418 

419 

420class L2CAP_CmdRej(Packet): 

421 name = "L2CAP Command Rej" 

422 fields_desc = [LEShortField("reason", 0), 

423 ] 

424 

425 

426class L2CAP_ConfReq(Packet): 

427 name = "L2CAP Conf Req" 

428 fields_desc = [LEShortField("dcid", 0), 

429 LEShortField("flags", 0), 

430 ] 

431 

432 

433class L2CAP_ConfResp(Packet): 

434 name = "L2CAP Conf Resp" 

435 fields_desc = [LEShortField("scid", 0), 

436 LEShortField("flags", 0), 

437 LEShortEnumField("result", 0, ["success", "unaccept", "reject", "unknown"]), # noqa: E501 

438 ] 

439 

440 def answers(self, other): 

441 # Req and Resp contain either the SCID or the DCID. 

442 return isinstance(other, L2CAP_ConfReq) 

443 

444 

445class L2CAP_ConfSet(Packet): 

446 name = "L2CAP Conf Set" 

447 fields_desc = [ 

448 ByteEnumField("type", 0x0, {1: "mtu", 

449 2: "flushtimeout", 

450 3: "QoS"}), 

451 PacketListField("option", [], next_cls_cb=lambda pkt, _, __, ___: { 

452 1: L2CAP_ConfSet_MTU, 

453 2: L2CAP_ConfSet_FlushTimeOut, 

454 3: L2CAP_ConfSet_QoS, 

455 }[pkt.type]) 

456 ] 

457 

458 

459class L2CAP_ConfSet_MTU(Packet): 

460 name = "L2CAP Conf Set MTU" 

461 fields_desc = [ 

462 ByteField("length", 0x02), 

463 LEShortField("mtu", 0x30), 

464 ] 

465 

466 

467class L2CAP_ConfSet_FlushTimeOut(Packet): 

468 name = "L2CAP Conf Set Flush Timeout" 

469 fields_desc = [ 

470 ByteField("length", 0x02), 

471 LEShortField("flushtimeout", 0x30), 

472 ] 

473 

474 

475class L2CAP_ConfSet_QoS(Packet): 

476 name = "L2CAP Conf Set QoS" 

477 fields_desc = [ 

478 ByteField("length", 0x16), 

479 ByteField("flags", 0x0), 

480 ByteField("service_type", 0x1), 

481 LEIntField("token_rate", 0x30), 

482 LEIntField("token_bucket_size", 0x30), 

483 LEIntField("peak_bandwidth", 0x30), 

484 LEIntField("latency", 0xffff_ffff), 

485 LEIntField("delay_variation", 0xffff_ffff), 

486 ] 

487 

488 

489class L2CAP_DisconnReq(Packet): 

490 name = "L2CAP Disconn Req" 

491 fields_desc = [LEShortField("dcid", 0), 

492 LEShortField("scid", 0), ] 

493 

494 

495class L2CAP_DisconnResp(Packet): 

496 name = "L2CAP Disconn Resp" 

497 fields_desc = [LEShortField("dcid", 0), 

498 LEShortField("scid", 0), ] 

499 

500 def answers(self, other): 

501 return self.scid == other.scid 

502 

503 

504class L2CAP_EchoReq(Packet): 

505 name = "L2CAP Echo Req" 

506 fields_desc = [StrField("data", ""), ] 

507 

508 

509class L2CAP_EchoResp(Packet): 

510 name = "L2CAP Echo Resp" 

511 fields_desc = [StrField("data", ""), ] 

512 

513 

514class L2CAP_InfoReq(Packet): 

515 name = "L2CAP Info Req" 

516 fields_desc = [LEShortEnumField("type", 0, {1: "CL_MTU", 2: "FEAT_MASK"}), 

517 StrField("data", "") 

518 ] 

519 

520 

521class L2CAP_InfoResp(Packet): 

522 name = "L2CAP Info Resp" 

523 fields_desc = [LEShortField("type", 0), 

524 LEShortEnumField("result", 0, ["success", "not_supp"]), 

525 StrField("data", ""), ] 

526 

527 def answers(self, other): 

528 return self.type == other.type 

529 

530 

531class L2CAP_Create_Channel_Request(Packet): 

532 name = "L2CAP Create Channel Request" 

533 fields_desc = [LEShortEnumField("psm", 0, {1: "SDP", 

534 3: "RFCOMM", 

535 5: "TCS-BIN", 

536 7: "TCS-BIN-CORDLESS", 

537 15: "BNEP", 

538 17: "HID-Control", 

539 19: "HID-Interrupt", 

540 21: "UPnP", 

541 23: "AVCTP-Control", 

542 25: "AVDTP", 

543 27: "AVCTP-Browsing", 

544 29: "UDI_C-Plane", 

545 31: "ATT", 

546 33: "3DSP", 

547 35: "IPSP", 

548 37: "OTS"}), 

549 LEShortField("scid", 0), 

550 ByteField("controller_id", 0), ] 

551 

552 

553class L2CAP_Create_Channel_Response(Packet): 

554 name = "L2CAP Create Channel Response" 

555 fields_desc = [LEShortField("dcid", 0), 

556 LEShortField("scid", 0), 

557 LEShortEnumField("result", 0, { 

558 0: "Connection successful", 

559 1: "Connection pending", 

560 2: "Connection refused - PSM not supported", 

561 3: "Connection refused - security block", 

562 4: "Connection refused - no resources available", 

563 5: "Connection refused - cont_ID not supported", 

564 6: "Connection refused - invalid scid", 

565 7: "Connection refused - scid already allocated"}), 

566 LEShortEnumField("status", 0, { 

567 0: "No further information available", 

568 1: "Authentication pending", 

569 2: "Authorization pending"}), ] 

570 

571 

572class L2CAP_Move_Channel_Request(Packet): 

573 name = "L2CAP Move Channel Request" 

574 fields_desc = [LEShortField("icid", 0), 

575 ByteField("dest_controller_id", 0), ] 

576 

577 

578class L2CAP_Move_Channel_Response(Packet): 

579 name = "L2CAP Move Channel Response" 

580 fields_desc = [LEShortField("icid", 0), 

581 LEShortEnumField("result", 0, { 

582 0: "Move success", 

583 1: "Move pending", 

584 2: "Move refused - Cont_ID not supported", 

585 3: "Move refused - Cont_ID is same as old one", 

586 4: "Move refused - Configuration not supported", 

587 5: "Move refused - Move channel collision", 

588 6: "Move refused - Not allowed to be moved"}), ] 

589 

590 

591class L2CAP_Move_Channel_Confirmation_Request(Packet): 

592 name = "L2CAP Move Channel Confirmation Request" 

593 fields_desc = [LEShortField("icid", 0), 

594 LEShortEnumField("result", 0, {0: "Move success", 

595 1: "Move failure"}), ] 

596 

597 

598class L2CAP_Move_Channel_Confirmation_Response(Packet): 

599 name = "L2CAP Move Channel Confirmation Response" 

600 fields_desc = [LEShortField("icid", 0), ] 

601 

602 

603class L2CAP_Connection_Parameter_Update_Request(Packet): 

604 name = "L2CAP Connection Parameter Update Request" 

605 fields_desc = [LEShortField("min_interval", 0), 

606 LEShortField("max_interval", 0), 

607 LEShortField("slave_latency", 0), 

608 LEShortField("timeout_mult", 0), ] 

609 

610 

611class L2CAP_Connection_Parameter_Update_Response(Packet): 

612 name = "L2CAP Connection Parameter Update Response" 

613 fields_desc = [LEShortField("move_result", 0), ] 

614 

615 

616class L2CAP_LE_Credit_Based_Connection_Request(Packet): 

617 name = "L2CAP LE Credit Based Connection Request" 

618 fields_desc = [LEShortField("spsm", 0), 

619 LEShortField("scid", 0), 

620 LEShortField("mtu", 0), 

621 LEShortField("mps", 0), 

622 LEShortField("initial_credits", 0), ] 

623 

624 

625class L2CAP_LE_Credit_Based_Connection_Response(Packet): 

626 name = "L2CAP LE Credit Based Connection Response" 

627 fields_desc = [LEShortField("dcid", 0), 

628 LEShortField("mtu", 0), 

629 LEShortField("mps", 0), 

630 LEShortField("initial_credits", 0), 

631 LEShortEnumField("result", 0, { 

632 0: "Connection successful", 

633 2: "Connection refused - SPSM not supported", 

634 4: "Connection refused - no resources available", 

635 5: "Connection refused - authentication error", 

636 6: "Connection refused - authorization error", 

637 7: "Connection refused - encrypt_key size error", 

638 8: "Connection refused - insufficient encryption", 

639 9: "Connection refused - invalid scid", 

640 10: "Connection refused - scid already allocated", 

641 11: "Connection refused - parameters error"}), ] 

642 

643 

644class L2CAP_Flow_Control_Credit_Ind(Packet): 

645 name = "L2CAP Flow Control Credit Ind" 

646 fields_desc = [LEShortField("cid", 0), 

647 LEShortField("credits", 0), ] 

648 

649 

650class L2CAP_Credit_Based_Connection_Request(Packet): 

651 name = "L2CAP Credit Based Connection Request" 

652 fields_desc = [LEShortField("spsm", 0), 

653 LEShortField("mtu", 0), 

654 LEShortField("mps", 0), 

655 LEShortField("initial_credits", 0), 

656 LEShortField("scid", 0), ] 

657 

658 

659class L2CAP_Credit_Based_Connection_Response(Packet): 

660 name = "L2CAP Credit Based Connection Response" 

661 fields_desc = [LEShortField("mtu", 0), 

662 LEShortField("mps", 0), 

663 LEShortField("initial_credits", 0), 

664 LEShortEnumField("result", 0, { 

665 0: "All connection successful", 

666 2: "All connection refused - SPSM not supported", 

667 4: "Some connections refused - resources error", 

668 5: "All connection refused - authentication error", 

669 6: "All connection refused - authorization error", 

670 7: "All connection refused - encrypt_key size error", 

671 8: "All connection refused - encryption error", 

672 9: "Some connection refused - invalid scid", 

673 10: "Some connection refused - scid already allocated", 

674 11: "All Connection refused - unacceptable parameters", 

675 12: "All connections refused - invalid parameters"}), 

676 LEShortField("dcid", 0), ] 

677 

678 

679class L2CAP_Credit_Based_Reconfigure_Request(Packet): 

680 name = "L2CAP Credit Based Reconfigure Request" 

681 fields_desc = [LEShortField("mtu", 0), 

682 LEShortField("mps", 0), 

683 LEShortField("dcid", 0), ] 

684 

685 

686class L2CAP_Credit_Based_Reconfigure_Response(Packet): 

687 name = "L2CAP Credit Based Reconfigure Response" 

688 fields_desc = [LEShortEnumField("result", 0, { 

689 0: "Reconfig successful", 

690 1: "Reconfig failed - MTU size reduction not allowed", 

691 2: "Reconfig failed - MPS size reduction not allowed", 

692 3: "Reconfig failed - one or more dcids invalid", 

693 4: "Reconfig failed - unacceptable parameters"}), ] 

694 

695 

696class ATT_Hdr(Packet): 

697 name = "ATT header" 

698 fields_desc = [XByteField("opcode", None), ] 

699 

700 

701class ATT_Handle(Packet): 

702 name = "ATT Short Handle" 

703 fields_desc = [XLEShortField("handle", 0), 

704 XLEShortField("value", 0)] 

705 

706 def extract_padding(self, s): 

707 return b'', s 

708 

709 

710class ATT_Handle_UUID128(Packet): 

711 name = "ATT Handle (UUID 128)" 

712 fields_desc = [XLEShortField("handle", 0), 

713 UUIDField("value", None, uuid_fmt=UUIDField.FORMAT_REV)] 

714 

715 def extract_padding(self, s): 

716 return b'', s 

717 

718 

719class ATT_Error_Response(Packet): 

720 name = "Error Response" 

721 fields_desc = [XByteField("request", 0), 

722 LEShortField("handle", 0), 

723 ByteEnumField("ecode", 0, _att_error_codes), ] 

724 

725 

726class ATT_Exchange_MTU_Request(Packet): 

727 name = "Exchange MTU Request" 

728 fields_desc = [LEShortField("mtu", 0), ] 

729 

730 

731class ATT_Exchange_MTU_Response(Packet): 

732 name = "Exchange MTU Response" 

733 fields_desc = [LEShortField("mtu", 0), ] 

734 

735 

736class ATT_Find_Information_Request(Packet): 

737 name = "Find Information Request" 

738 fields_desc = [XLEShortField("start", 0x0000), 

739 XLEShortField("end", 0xffff), ] 

740 

741 

742class ATT_Find_Information_Response(Packet): 

743 name = "Find Information Response" 

744 fields_desc = [ 

745 XByteField("format", 1), 

746 MultipleTypeField( 

747 [ 

748 (PacketListField("handles", [], ATT_Handle), 

749 lambda pkt: pkt.format == 1), 

750 (PacketListField("handles", [], ATT_Handle_UUID128), 

751 lambda pkt: pkt.format == 2), 

752 ], 

753 StrFixedLenField("handles", "", length=0) 

754 ) 

755 ] 

756 

757 

758class ATT_Find_By_Type_Value_Request(Packet): 

759 name = "Find By Type Value Request" 

760 fields_desc = [XLEShortField("start", 0x0001), 

761 XLEShortField("end", 0xffff), 

762 XLEShortField("uuid", None), 

763 StrField("data", ""), ] 

764 

765 

766class ATT_Find_By_Type_Value_Response(Packet): 

767 name = "Find By Type Value Response" 

768 fields_desc = [PacketListField("handles", [], ATT_Handle)] 

769 

770 

771class ATT_Read_By_Type_Request_128bit(Packet): 

772 name = "Read By Type Request" 

773 fields_desc = [XLEShortField("start", 0x0001), 

774 XLEShortField("end", 0xffff), 

775 XLELongField("uuid1", None), 

776 XLELongField("uuid2", None)] 

777 

778 @classmethod 

779 def dispatch_hook(cls, _pkt=None, *args, **kargs): 

780 if _pkt and len(_pkt) == 6: 

781 return ATT_Read_By_Type_Request 

782 return ATT_Read_By_Type_Request_128bit 

783 

784 

785class ATT_Read_By_Type_Request(Packet): 

786 name = "Read By Type Request" 

787 fields_desc = [XLEShortField("start", 0x0001), 

788 XLEShortField("end", 0xffff), 

789 XLEShortField("uuid", None)] 

790 

791 

792class ATT_Handle_Variable(Packet): 

793 fields_desc = [XLEShortField("handle", 0), 

794 XStrLenField( 

795 "value", 0, 

796 length_from=lambda pkt: pkt and pkt.parent.len - 2 or 0)] 

797 

798 def extract_padding(self, s): 

799 return b"", s 

800 

801 

802class ATT_Read_By_Type_Response(Packet): 

803 name = "Read By Type Response" 

804 fields_desc = [ByteField("len", 4), 

805 PacketListField("handles", [], ATT_Handle_Variable)] 

806 

807 

808class ATT_Read_Request(Packet): 

809 name = "Read Request" 

810 fields_desc = [XLEShortField("gatt_handle", 0), ] 

811 

812 

813class ATT_Read_Response(Packet): 

814 name = "Read Response" 

815 fields_desc = [StrField("value", "")] 

816 

817 

818class ATT_Read_Multiple_Request(Packet): 

819 name = "Read Multiple Request" 

820 fields_desc = [FieldListField("handles", [], XLEShortField("", 0))] 

821 

822 

823class ATT_Read_Multiple_Response(Packet): 

824 name = "Read Multiple Response" 

825 fields_desc = [StrField("values", "")] 

826 

827 

828class ATT_Read_By_Group_Type_Request(Packet): 

829 name = "Read By Group Type Request" 

830 fields_desc = [XLEShortField("start", 0), 

831 XLEShortField("end", 0xffff), 

832 XLEShortField("uuid", 0), ] 

833 

834 

835class ATT_Group_Handle_Variable(Packet): 

836 fields_desc = [XLEShortField("handle", 0), 

837 XLEShortField("group_end_handle", 0), 

838 XStrLenField( 

839 "value", 0, 

840 length_from=lambda pkt: pkt and pkt.parent.len - 4 or 0)] 

841 

842 def extract_padding(self, s): 

843 return b"", s 

844 

845 

846class ATT_Read_By_Group_Type_Response(Packet): 

847 name = "Read By Group Type Response" 

848 fields_desc = [ByteField("len", 4), 

849 PacketListField("handles", [], ATT_Group_Handle_Variable)] 

850 

851 

852class ATT_Write_Request(Packet): 

853 name = "Write Request" 

854 fields_desc = [XLEShortField("gatt_handle", 0), 

855 StrField("data", ""), ] 

856 

857 

858class ATT_Write_Command(Packet): 

859 name = "Write Request" 

860 fields_desc = [XLEShortField("gatt_handle", 0), 

861 StrField("data", ""), ] 

862 

863 

864class ATT_Write_Response(Packet): 

865 name = "Write Response" 

866 

867 

868class ATT_Prepare_Write_Request(Packet): 

869 name = "Prepare Write Request" 

870 fields_desc = [ 

871 XLEShortField("gatt_handle", 0), 

872 LEShortField("offset", 0), 

873 StrField("data", "") 

874 ] 

875 

876 

877class ATT_Prepare_Write_Response(ATT_Prepare_Write_Request): 

878 name = "Prepare Write Response" 

879 

880 

881class ATT_Handle_Value_Notification(Packet): 

882 name = "Handle Value Notification" 

883 fields_desc = [XLEShortField("gatt_handle", 0), 

884 StrField("value", ""), ] 

885 

886 

887class ATT_Execute_Write_Request(Packet): 

888 name = "Execute Write Request" 

889 fields_desc = [ 

890 ByteEnumField("flags", 1, { 

891 0: "Cancel all prepared writes", 

892 1: "Immediately write all pending prepared values", 

893 }), 

894 ] 

895 

896 

897class ATT_Execute_Write_Response(Packet): 

898 name = "Execute Write Response" 

899 

900 

901class ATT_Read_Multiple_Variable_Request(Packet): 

902 name = "Read Multiple Variable Request" 

903 fields_desc = [FieldListField("handles", [], XLEShortField("", 0))] 

904 

905 

906class ATT_Length_Value_Tuple(Packet): 

907 fields_desc = [LEFieldLenField("len", None, length_of="value"), 

908 XStrLenField("value", "", length_from=lambda pkt: pkt.len)] 

909 

910 def extract_padding(self, s): 

911 return b"", s 

912 

913 

914class ATT_Read_Multiple_Variable_Response(Packet): 

915 name = "Read Multiple Variable Response" 

916 fields_desc = [PacketListField("values", [], ATT_Length_Value_Tuple)] 

917 

918 

919# Bluetooth Core Specification, Vol 3, Part B (SDP) 

920 

921SDP_FIXED_SIZES = {1: 2, 2: 4, 4: 16} 

922 

923 

924class SDP_Continuation(Packet): 

925 name = "SDP Continuation State" 

926 fields_desc = [ 

927 ByteField("count", 0x00), 

928 ConditionalField( 

929 BitLenField("continuation_state_info", 0, 

930 length_from=lambda pkt: pkt.count * 8), 

931 lambda pkt: pkt.count != 0 

932 ), 

933 ] 

934 

935 

936class SDP_DataElement(Packet): 

937 name = "Data Element" 

938 fields_desc = [ 

939 BitEnumField("data_type", 0, 5, { 

940 0: "null", # size = 0 

941 1: "unsigned_integer", # size_index = 0, 1, 2, 3, 4 

942 2: "signed_integer", # size_index = 0, 1, 2, 3, 4 

943 3: "UUID", # size_index = 1, 2, 4 

944 4: "text_string", # size_index = 5, 6, 7 

945 5: "boolean", # size_index = 0 | False == 0 

946 6: "data_element_sequence", # size_index = 5, 6, 7 

947 7: "data_element_alternative", # size_index = 5, 6, 7 

948 8: "URL", # size_index = 5, 6, 7 

949 # Other Reserved for future use 

950 }), 

951 BitField("size_index", None, size=3), 

952 ConditionalField( 

953 MultipleTypeField( 

954 [ 

955 ( 

956 FieldLenField("size", None, fmt="B", length_of="data"), 

957 lambda pkt: pkt.size_index == 5 

958 ), 

959 ( 

960 FieldLenField("size", None, fmt="H", length_of="data"), 

961 lambda pkt: pkt.size_index == 6 

962 ), 

963 ( 

964 FieldLenField("size", None, fmt="I", length_of="data"), 

965 lambda pkt: pkt.size_index == 7 

966 ), 

967 ], 

968 FieldLenField("size", None, length_of="data"), 

969 ), 

970 lambda pkt: 5 <= pkt.size_index <= 7 

971 ), 

972 ConditionalField( 

973 MultipleTypeField( 

974 [ 

975 ( 

976 # Unsigned Integer 

977 BitLenField("data", 0, 

978 length_from=lambda pkt: pkt.get_data_size() * 8), 

979 lambda pkt: pkt.data_type == 1 and 0 <= pkt.size_index <= 4 

980 ), 

981 ( 

982 # Signed two's-complement integer 

983 BitLenField("data", 0, 

984 length_from=lambda pkt: pkt.get_data_size() * 8), 

985 lambda pkt: pkt.data_type == 2 and 0 <= pkt.size_index <= 4 

986 ), 

987 ( 

988 # UUID, a universally unique identifier 

989 XStrFixedLenField("data", "", 

990 length_from=lambda pkt: pkt.get_data_size()), 

991 lambda pkt: pkt.data_type == 3 and pkt.size_index in (1, 2, 4) 

992 ), 

993 ( 

994 # Text string 

995 StrLenField("data", "", 

996 length_from=lambda pkt: pkt.get_data_size()), 

997 lambda pkt: pkt.data_type == 4 and 5 <= pkt.size_index <= 7 

998 ), 

999 ( 

1000 # Boolean 

1001 ByteField("data", 0), 

1002 lambda pkt: pkt.data_type == 5 and pkt.size_index == 0 

1003 ), 

1004 ( 

1005 # Sequence or alternative 

1006 PacketListField( 

1007 "data", [], 

1008 length_from=lambda pkt: pkt.get_data_size(), 

1009 next_cls_cb=lambda pkt, _, __, ___: SDP_DataElement), 

1010 lambda pkt: (pkt.data_type in (6, 7) and 

1011 5 <= pkt.size_index <= 7) 

1012 ), 

1013 ( 

1014 # URL 

1015 StrLenField("data", "", 

1016 length_from=lambda pkt: pkt.get_data_size()), 

1017 lambda pkt: pkt.data_type == 8 and 5 <= pkt.size_index <= 7 

1018 ), 

1019 ], 

1020 StrLenField("data", "", 

1021 length_from=lambda pkt: pkt.get_data_size()), 

1022 ), 

1023 lambda pkt: 5 <= pkt.size_index <= 7 or pkt.get_data_size() > 0 

1024 ), 

1025 ] 

1026 

1027 def get_data_size(self): 

1028 if self.data_type == 0: 

1029 return 0 

1030 if self.size_index == 0: 

1031 return 1 

1032 if self.size_index in SDP_FIXED_SIZES: 

1033 return SDP_FIXED_SIZES[self.size_index] 

1034 return self.size 

1035 

1036 def extract_padding(self, s): 

1037 return b"", s 

1038 

1039 

1040class SDP_Error_Response(Packet): 

1041 name = "SDP PDU Error" 

1042 fields_desc = [ 

1043 ShortEnumField("error_code", 1, { 

1044 1: "Invalid/unsupported SDP version", 

1045 2: "Invalid Service Record Handle", 

1046 3: "Invalid request syntax", 

1047 4: "Invalid PDU Size", 

1048 5: "Invalid Continuation State", 

1049 6: "Insufficient Resources to satisfy Request", 

1050 # All other values are reserved for future use 

1051 }), 

1052 ] 

1053 

1054 

1055class SDP_Service_Search_Request(Packet): 

1056 name = "SDP Service Search Req PDU" 

1057 fields_desc = [ 

1058 PacketField("service_search_pattern", None, SDP_DataElement), 

1059 # Range: 0x0001 to 0xFFFF 

1060 ShortField("max_service_record_count", 0x0001), 

1061 PacketField("continuation_state", None, SDP_Continuation), 

1062 ] 

1063 

1064 

1065class SDP_Service_Search_Response(Packet): 

1066 name = "SDP Service Search RSP PDU" 

1067 fields_desc = [ 

1068 ShortField("total_service_record_count", 0x0000), 

1069 FieldLenField("current_service_record_count", None, fmt="H", 

1070 count_of="service_record_handle_list"), 

1071 FieldListField( 

1072 "service_record_handle_list", [], IntField("", 0), 

1073 count_from=lambda pkt: pkt.current_service_record_count), 

1074 PacketField("continuation_state", None, SDP_Continuation), 

1075 ] 

1076 

1077 

1078class SDP_Service_Attr_Request(Packet): 

1079 name = "SDP Service ATTR REQ PDU" 

1080 fields_desc = [ 

1081 IntField("service_record_handle", 0x0000), 

1082 # Range: 0x0007 to 0xFFFF 

1083 ShortField("max_attribute_byte_count", 0x0000), 

1084 PacketField("attribute_id_list", None, SDP_DataElement), 

1085 PacketField("continuation_state", None, SDP_Continuation), 

1086 ] 

1087 

1088 

1089class SDP_Service_Attr_Response(Packet): 

1090 name = "SDP Service ATTR RSP PDU" 

1091 fields_desc = [ 

1092 FieldLenField("attribute_list_byte_count", None, fmt="H", 

1093 length_of="attribute_list"), 

1094 PacketListField( 

1095 "attribute_list", [], SDP_DataElement, 

1096 length_from=lambda pkt: pkt.attribute_list_byte_count), 

1097 PacketField("continuation_state", None, SDP_Continuation), 

1098 ] 

1099 

1100 

1101class SDP_Service_Search_Attr_Request(Packet): 

1102 name = "SDP Service Search ATTR REQ PDU" 

1103 fields_desc = [ 

1104 PacketField("service_search_pattern", None, SDP_DataElement), 

1105 # Range: 0x0007 to 0xFFFF 

1106 ShortField("max_attribute_byte_count", 0x0000), 

1107 PacketField("attribute_id_list", None, SDP_DataElement), 

1108 PacketField("continuation_state", None, SDP_Continuation), 

1109 ] 

1110 

1111 

1112class SDP_Service_Search_Attr_Response(Packet): 

1113 name = "SDP Service Search ATTR RSP PDU" 

1114 fields_desc = [ 

1115 FieldLenField("attribute_lists_byte_count", None, fmt="H", 

1116 length_of="attribute_lists"), 

1117 PacketListField( 

1118 "attribute_lists", [], SDP_DataElement, 

1119 length_from=lambda pkt: pkt.attribute_lists_byte_count), 

1120 PacketField("continuation_state", None, SDP_Continuation), 

1121 ] 

1122 

1123 

1124SDP_PDU_CLASSES = { 

1125 1: SDP_Error_Response, 

1126 2: SDP_Service_Search_Request, 

1127 3: SDP_Service_Search_Response, 

1128 4: SDP_Service_Attr_Request, 

1129 5: SDP_Service_Attr_Response, 

1130 6: SDP_Service_Search_Attr_Request, 

1131 7: SDP_Service_Search_Attr_Response, 

1132} 

1133 

1134 

1135class SDP_Hdr(Packet): 

1136 name = "SDP Protocol Data Unit Format" 

1137 fields_desc = [ 

1138 ByteEnumField("pdu_id", 1, { 

1139 1: "SDP_ERROR_RSP", 

1140 2: "SDP_SERVICE_SEARCH_REQ", 

1141 3: "SDP_SERVICE_SEARCH_RSP", 

1142 4: "SDP_SERVICE_ATTR_REQ", 

1143 5: "SDP_SERVICE_ATTR_RSP", 

1144 6: "SDP_SERVICE_SEARCH_ATTR_REQ", 

1145 7: "SDP_SERVICE_SEARCH_ATTR_RSP", 

1146 # All other values are reserved for future use 

1147 }), 

1148 ShortField("transaction_id", 0), 

1149 FieldLenField("parameter_length", 0, fmt="H", length_of="parameters"), 

1150 PacketListField( 

1151 "parameters", [], 

1152 length_from=lambda pkt: pkt.parameter_length, 

1153 next_cls_cb=lambda pkt, _, __, ___: SDP_PDU_CLASSES[pkt.pdu_id]), 

1154 ] 

1155 

1156 def post_build(self, p, pay): 

1157 size = len(p[5:]) 

1158 

1159 p = p[:3] + struct.pack(">H", size) + p[5:] 

1160 

1161 return p + pay 

1162 

1163 

1164class ATT_Handle_Length_Value_Tuple(Packet): 

1165 fields_desc = [XLEShortField("handle", 0), 

1166 LEFieldLenField("len", None, length_of="value"), 

1167 XStrLenField("value", "", length_from=lambda pkt: pkt.len)] 

1168 

1169 def extract_padding(self, s): 

1170 return b"", s 

1171 

1172 

1173class ATT_Multiple_Handle_Value_Notification(Packet): 

1174 name = "Multiple Handle Value Notification" 

1175 fields_desc = [PacketListField("handles", [], ATT_Handle_Length_Value_Tuple)] 

1176 

1177 

1178class ATT_Read_Blob_Request(Packet): 

1179 name = "Read Blob Request" 

1180 fields_desc = [ 

1181 XLEShortField("gatt_handle", 0), 

1182 LEShortField("offset", 0) 

1183 ] 

1184 

1185 

1186class ATT_Read_Blob_Response(Packet): 

1187 name = "Read Blob Response" 

1188 fields_desc = [ 

1189 StrField("value", "") 

1190 ] 

1191 

1192 

1193class ATT_Handle_Value_Indication(Packet): 

1194 name = "Handle Value Indication" 

1195 fields_desc = [ 

1196 XLEShortField("gatt_handle", 0), 

1197 StrField("value", ""), 

1198 ] 

1199 

1200 

1201class ATT_Handle_Value_Confirmation(Packet): 

1202 name = "Handle Value Confirmation" 

1203 

1204 

1205class ATT_Signed_Write_Command(Packet): 

1206 name = "Signed Write Command" 

1207 

1208 fields_desc = [XLEShortField("handle", 0), 

1209 StrLenField("value", "", 

1210 length_from=lambda pkt: len(pkt.original) - 14), 

1211 LEIntField("sign_counter", 0), 

1212 StrFixedLenField("signature", b'\x00' * 8, 8), ] 

1213 

1214 

1215class SM_Hdr(Packet): 

1216 name = "SM header" 

1217 fields_desc = [ByteField("sm_command", None)] 

1218 

1219 

1220class SM_Pairing_Request(Packet): 

1221 name = "Pairing Request" 

1222 fields_desc = [ByteEnumField("iocap", 3, {0: "DisplayOnly", 1: "DisplayYesNo", 2: "KeyboardOnly", 3: "NoInputNoOutput", 4: "KeyboardDisplay"}), # noqa: E501 

1223 ByteEnumField("oob", 0, {0: "Not Present", 1: "Present (from remote device)"}), # noqa: E501 

1224 BitField("authentication", 0, 8), 

1225 ByteField("max_key_size", 16), 

1226 ByteField("initiator_key_distribution", 0), 

1227 ByteField("responder_key_distribution", 0), ] 

1228 

1229 

1230class SM_Pairing_Response(Packet): 

1231 name = "Pairing Response" 

1232 fields_desc = [ByteEnumField("iocap", 3, {0: "DisplayOnly", 1: "DisplayYesNo", 2: "KeyboardOnly", 3: "NoInputNoOutput", 4: "KeyboardDisplay"}), # noqa: E501 

1233 ByteEnumField("oob", 0, {0: "Not Present", 1: "Present (from remote device)"}), # noqa: E501 

1234 BitField("authentication", 0, 8), 

1235 ByteField("max_key_size", 16), 

1236 ByteField("initiator_key_distribution", 0), 

1237 ByteField("responder_key_distribution", 0), ] 

1238 

1239 

1240class SM_Confirm(Packet): 

1241 name = "Pairing Confirm" 

1242 fields_desc = [StrFixedLenField("confirm", b'\x00' * 16, 16)] 

1243 

1244 

1245class SM_Random(Packet): 

1246 name = "Pairing Random" 

1247 fields_desc = [StrFixedLenField("random", b'\x00' * 16, 16)] 

1248 

1249 

1250class SM_Failed(Packet): 

1251 name = "Pairing Failed" 

1252 fields_desc = [XByteField("reason", 0)] 

1253 

1254 

1255class SM_Encryption_Information(Packet): 

1256 name = "Encryption Information" 

1257 fields_desc = [StrFixedLenField("ltk", b"\x00" * 16, 16), ] 

1258 

1259 

1260class SM_Master_Identification(Packet): 

1261 name = "Master Identification" 

1262 fields_desc = [XLEShortField("ediv", 0), 

1263 StrFixedLenField("rand", b'\x00' * 8, 8), ] 

1264 

1265 

1266class SM_Identity_Information(Packet): 

1267 name = "Identity Information" 

1268 fields_desc = [StrFixedLenField("irk", b'\x00' * 16, 16), ] 

1269 

1270 

1271class SM_Identity_Address_Information(Packet): 

1272 name = "Identity Address Information" 

1273 fields_desc = [ByteEnumField("addr_type", 0, {0: "public"}), 

1274 LEMACField("bd_addr", None), ] 

1275 deprecated_fields = { 

1276 "atype": ("addr_type", "2.7.0"), 

1277 "address": ("bd_addr", "2.7.0"), 

1278 "addr": ("bd_addr", "2.8.0"), 

1279 } 

1280 

1281 

1282class SM_Signing_Information(Packet): 

1283 name = "Signing Information" 

1284 fields_desc = [StrFixedLenField("csrk", b'\x00' * 16, 16), ] 

1285 

1286 

1287class SM_Security_Request(Packet): 

1288 name = "Security Request" 

1289 fields_desc = [BitField("auth_req", 0, 8), ] 

1290 

1291 

1292class SM_Public_Key(Packet): 

1293 name = "Public Key" 

1294 fields_desc = [StrFixedLenField("key_x", b'\x00' * 32, 32), 

1295 StrFixedLenField("key_y", b'\x00' * 32, 32), ] 

1296 

1297 

1298class SM_DHKey_Check(Packet): 

1299 name = "DHKey Check" 

1300 fields_desc = [StrFixedLenField("dhkey_check", b'\x00' * 16, 16), ] 

1301 

1302 

1303class SM_Keypress_Notification(Packet): 

1304 name = "Keypress Notification" 

1305 fields_desc = [ByteEnumField("notification_type", 0, { 

1306 0: "Passkey entry started", 

1307 1: "Passkey digit entered", 

1308 2: "Passkey digit erased", 

1309 3: "Passkey cleared", 

1310 4: "Passkey entry completed", 

1311 })] 

1312 

1313 

1314class EIR_Hdr(Packet): 

1315 name = "EIR Header" 

1316 fields_desc = [ 

1317 LenField("len", None, fmt="B", adjust=lambda x: x + 1), # Add bytes mark # noqa: E501 

1318 # https://www.bluetooth.com/specifications/assigned-numbers/generic-access-profile 

1319 ByteEnumField("type", 0, { 

1320 0x01: "flags", 

1321 0x02: "incomplete_list_16_bit_svc_uuids", 

1322 0x03: "complete_list_16_bit_svc_uuids", 

1323 0x04: "incomplete_list_32_bit_svc_uuids", 

1324 0x05: "complete_list_32_bit_svc_uuids", 

1325 0x06: "incomplete_list_128_bit_svc_uuids", 

1326 0x07: "complete_list_128_bit_svc_uuids", 

1327 0x08: "shortened_local_name", 

1328 0x09: "complete_local_name", 

1329 0x0a: "tx_power_level", 

1330 0x0d: "class_of_device", 

1331 0x0e: "simple_pairing_hash", 

1332 0x0f: "simple_pairing_rand", 

1333 

1334 0x10: "sec_mgr_tk", 

1335 0x11: "sec_mgr_oob_flags", 

1336 0x12: "slave_conn_intvl_range", 

1337 0x14: "list_16_bit_svc_sollication_uuids", 

1338 0x15: "list_128_bit_svc_sollication_uuids", 

1339 0x16: "svc_data_16_bit_uuid", 

1340 0x17: "pub_target_addr", 

1341 0x18: "rand_target_addr", 

1342 0x19: "appearance", 

1343 0x1a: "adv_intvl", 

1344 0x1b: "le_addr", 

1345 0x1c: "le_role", 

1346 0x1d: "simple_pairing_hash_256", 

1347 0x1e: "simple_pairing_rand_256", 

1348 0x1f: "list_32_bit_svc_sollication_uuids", 

1349 

1350 0x20: "svc_data_32_bit_uuid", 

1351 0x21: "svc_data_128_bit_uuid", 

1352 0x22: "sec_conn_confirm", 

1353 0x23: "sec_conn_rand", 

1354 0x24: "uri", 

1355 0x25: "indoor_positioning", 

1356 0x26: "transport_discovery", 

1357 0x27: "le_supported_features", 

1358 0x28: "channel_map_update", 

1359 0x29: "mesh_pb_adv", 

1360 0x2a: "mesh_message", 

1361 0x2b: "mesh_beacon", 

1362 

1363 0x30: "broadcast_name", 

1364 

1365 0x3d: "3d_information", 

1366 

1367 0xff: "mfg_specific_data", 

1368 }), 

1369 ] 

1370 

1371 def mysummary(self): 

1372 return self.sprintf("EIR %type%") 

1373 

1374 def guess_payload_class(self, payload): 

1375 if self.len == 0: 

1376 # For Extended_Inquiry_Response, stop when len=0 

1377 return conf.padding_layer 

1378 return super(EIR_Hdr, self).guess_payload_class(payload) 

1379 

1380 

1381class EIR_Element(Packet): 

1382 name = "EIR Element" 

1383 

1384 def extract_padding(self, s): 

1385 # Needed to end each EIR_Element packet and make PacketListField work. 

1386 return b'', s 

1387 

1388 @staticmethod 

1389 def length_from(pkt): 

1390 if not pkt.underlayer: 

1391 warning("Missing an upper-layer") 

1392 return 0 

1393 # 'type' byte is included in the length, so subtract 1: 

1394 return pkt.underlayer.len - 1 

1395 

1396 

1397class EIR_Raw(EIR_Element): 

1398 name = "EIR Raw" 

1399 fields_desc = [ 

1400 StrLenField("data", "", length_from=EIR_Element.length_from) 

1401 ] 

1402 

1403 

1404class EIR_Flags(EIR_Element): 

1405 name = "Flags" 

1406 fields_desc = [ 

1407 FlagsField("flags", 0x2, 8, 

1408 ["limited_disc_mode", "general_disc_mode", 

1409 "br_edr_not_supported", "simul_le_br_edr_ctrl", 

1410 "simul_le_br_edr_host"] + 3 * ["reserved"]) 

1411 ] 

1412 

1413 

1414class EIR_CompleteList16BitServiceUUIDs(EIR_Element): 

1415 name = "Complete list of 16-bit service UUIDs" 

1416 fields_desc = [ 

1417 # https://www.bluetooth.com/specifications/assigned-numbers/16-bit-uuids-for-members 

1418 FieldListField("svc_uuids", None, XLEShortField("uuid", 0), 

1419 length_from=EIR_Element.length_from) 

1420 ] 

1421 

1422 

1423class EIR_IncompleteList16BitServiceUUIDs(EIR_CompleteList16BitServiceUUIDs): 

1424 name = "Incomplete list of 16-bit service UUIDs" 

1425 

1426 

1427class EIR_CompleteList32BitServiceUUIDs(EIR_Element): 

1428 name = 'Complete list of 32-bit service UUIDs' 

1429 fields_desc = [ 

1430 # https://www.bluetooth.com/specifications/assigned-numbers 

1431 FieldListField('svc_uuids', None, XLEIntField('uuid', 0), 

1432 length_from=EIR_Element.length_from) 

1433 ] 

1434 

1435 

1436class EIR_IncompleteList32BitServiceUUIDs(EIR_CompleteList32BitServiceUUIDs): 

1437 name = 'Incomplete list of 32-bit service UUIDs' 

1438 

1439 

1440class EIR_CompleteList128BitServiceUUIDs(EIR_Element): 

1441 name = "Complete list of 128-bit service UUIDs" 

1442 fields_desc = [ 

1443 FieldListField("svc_uuids", None, 

1444 UUIDField("uuid", None, uuid_fmt=UUIDField.FORMAT_REV), 

1445 length_from=EIR_Element.length_from) 

1446 ] 

1447 

1448 

1449class EIR_IncompleteList128BitServiceUUIDs(EIR_CompleteList128BitServiceUUIDs): 

1450 name = "Incomplete list of 128-bit service UUIDs" 

1451 

1452 

1453class EIR_CompleteLocalName(EIR_Element): 

1454 name = "Complete Local Name" 

1455 fields_desc = [ 

1456 StrLenField("local_name", "", length_from=EIR_Element.length_from) 

1457 ] 

1458 

1459 

1460class EIR_ShortenedLocalName(EIR_CompleteLocalName): 

1461 name = "Shortened Local Name" 

1462 

1463 

1464class EIR_TX_Power_Level(EIR_Element): 

1465 name = "TX Power Level" 

1466 fields_desc = [SignedByteField("level", 0)] 

1467 

1468 

1469class EIR_ClassOfDevice(EIR_Element): 

1470 name = 'Class of device' 

1471 fields_desc = [ 

1472 FlagsField('major_service_classes', 0, 11, [ 

1473 'limited_discoverable_mode', 

1474 'le_audio', 

1475 'reserved', 

1476 'positioning', 

1477 'networking', 

1478 'rendering', 

1479 'capturing', 

1480 'object_transfer', 

1481 'audio', 

1482 'telephony', 

1483 'information' 

1484 ], tot_size=-3), 

1485 BitEnumField('major_device_class', 0, 5, { 

1486 0x00: 'miscellaneous', 

1487 0x01: 'computer', 

1488 0x02: 'phone', 

1489 0x03: 'lan', 

1490 0x04: 'audio_video', 

1491 0x05: 'peripheral', 

1492 0x06: 'imaging', 

1493 0x07: 'wearable', 

1494 0x08: 'toy', 

1495 0x09: 'health', 

1496 0x1f: 'uncategorized' 

1497 }), 

1498 BitField('minor_device_class', 0, 6), 

1499 BitField('fixed', 0, 2, end_tot_size=-3) 

1500 ] 

1501 

1502 

1503class EIR_SecureSimplePairingHashC192(EIR_Element): 

1504 name = 'Secure Simple Pairing Hash C-192' 

1505 fields_desc = [NBytesField('hash', 0, 16)] 

1506 

1507 

1508class EIR_SecureSimplePairingRandomizerR192(EIR_Element): 

1509 name = 'Secure Simple Pairing Randomizer R-192' 

1510 fields_desc = [NBytesField('randomizer', 0, 16)] 

1511 

1512 

1513class EIR_SecurityManagerOOBFlags(EIR_Element): 

1514 name = 'Security Manager Out of Band Flags' 

1515 fields_desc = [ 

1516 BitField('oob_flags_field', 0, 1), 

1517 BitField('le_supported', 0, 1), 

1518 BitField('previously_used', 0, 1), 

1519 BitField('address_type', 0, 1), 

1520 BitField('reserved', 0, 4) 

1521 ] 

1522 

1523 

1524class EIR_PeripheralConnectionIntervalRange(EIR_Element): 

1525 name = 'Peripheral Connection Interval Range' 

1526 fields_desc = [ 

1527 LEShortField('conn_interval_min', 0xFFFF), 

1528 LEShortField('conn_interval_max', 0xFFFF) 

1529 ] 

1530 

1531 

1532class EIR_Manufacturer_Specific_Data(EIR_Element): 

1533 name = "EIR Manufacturer Specific Data" 

1534 deprecated_fields = { 

1535 "company_id": ("company_identifier", "2.6.2"), 

1536 } 

1537 fields_desc = [ 

1538 # https://www.bluetooth.com/specifications/assigned-numbers/company-identifiers 

1539 LEShortEnumField("company_identifier", None, 

1540 BLUETOOTH_CORE_COMPANY_IDENTIFIERS), 

1541 ] 

1542 

1543 registered_magic_payloads = {} 

1544 

1545 @classmethod 

1546 def register_magic_payload(cls, payload_cls, magic_check=None): 

1547 """ 

1548 Registers a payload type that uses magic data. 

1549 

1550 Traditional payloads require registration of a Bluetooth Company ID 

1551 (requires company membership of the Bluetooth SIG), or a Bluetooth 

1552 Short UUID (requires a once-off payment). 

1553 

1554 There are alternatives which don't require registration (such as 

1555 128-bit UUIDs), but the biggest consumer of energy in a beacon is the 

1556 radio -- so the energy consumption of a beacon is proportional to the 

1557 number of bytes in a beacon frame. 

1558 

1559 Some beacon formats side-step this issue by using the Company ID of 

1560 their beacon hardware manufacturer, and adding a "magic data sequence" 

1561 at the start of the Manufacturer Specific Data field. 

1562 

1563 Examples of this are AltBeacon and GeoBeacon. 

1564 

1565 For an example of this method in use, see ``scapy.contrib.altbeacon``. 

1566 

1567 :param Type[scapy.packet.Packet] payload_cls: 

1568 A reference to a Packet subclass to register as a payload. 

1569 :param Callable[[bytes], bool] magic_check: 

1570 (optional) callable to use to if a payload should be associated 

1571 with this type. If not supplied, ``payload_cls.magic_check`` is 

1572 used instead. 

1573 :raises TypeError: If ``magic_check`` is not specified, 

1574 and ``payload_cls.magic_check`` is not implemented. 

1575 """ 

1576 if magic_check is None: 

1577 if hasattr(payload_cls, "magic_check"): 

1578 magic_check = payload_cls.magic_check 

1579 else: 

1580 raise TypeError("magic_check not specified, and {} has no " 

1581 "attribute magic_check".format(payload_cls)) 

1582 

1583 cls.registered_magic_payloads[payload_cls] = magic_check 

1584 

1585 def default_payload_class(self, payload): 

1586 for cls, check in ( 

1587 EIR_Manufacturer_Specific_Data.registered_magic_payloads.items() 

1588 ): 

1589 if check(payload): 

1590 return cls 

1591 

1592 return Packet.default_payload_class(self, payload) 

1593 

1594 def extract_padding(self, s): 

1595 # Needed to end each EIR_Element packet and make PacketListField work. 

1596 plen = EIR_Element.length_from(self) - 2 

1597 return s[:plen], s[plen:] 

1598 

1599 

1600class EIR_Device_ID(EIR_Element): 

1601 name = "Device ID" 

1602 fields_desc = [ 

1603 XLEShortField("vendor_id_source", 0), 

1604 XLEShortField("vendor_id", 0), 

1605 XLEShortField("product_id", 0), 

1606 XLEShortField("version", 0), 

1607 ] 

1608 

1609 

1610class EIR_ServiceSolicitation16BitUUID(EIR_Element): 

1611 name = "EIR Service Solicitation - 16-bit UUID" 

1612 fields_desc = [ 

1613 XLEShortField("svc_uuid", None) 

1614 ] 

1615 

1616 def extract_padding(self, s): 

1617 # Needed to end each EIR_Element packet and make PacketListField work. 

1618 plen = EIR_Element.length_from(self) - 2 

1619 return s[:plen], s[plen:] 

1620 

1621 

1622class EIR_ServiceSolicitation128BitUUID(EIR_Element): 

1623 name = "EIR Service Solicitation - 128-bit UUID" 

1624 fields_desc = [ 

1625 UUIDField('svc_uuid', None, uuid_fmt=UUIDField.FORMAT_REV) 

1626 ] 

1627 

1628 def extract_padding(self, s): 

1629 # Needed to end each EIR_Element packet and make PacketListField work. 

1630 plen = EIR_Element.length_from(self) - 2 

1631 return s[:plen], s[plen:] 

1632 

1633 

1634class EIR_ServiceData16BitUUID(EIR_Element): 

1635 name = "EIR Service Data - 16-bit UUID" 

1636 fields_desc = [ 

1637 # https://www.bluetooth.com/specifications/assigned-numbers/16-bit-uuids-for-members 

1638 XLEShortField("svc_uuid", None), 

1639 ] 

1640 

1641 def extract_padding(self, s): 

1642 # Needed to end each EIR_Element packet and make PacketListField work. 

1643 plen = EIR_Element.length_from(self) - 2 

1644 return s[:plen], s[plen:] 

1645 

1646 

1647class EIR_PublicTargetAddress(EIR_Element): 

1648 name = "Public Target Address" 

1649 fields_desc = [ 

1650 LEMACField('bd_addr', None) 

1651 ] 

1652 

1653 

1654class EIR_RandomTargetAddress(EIR_Element): 

1655 name = "Random Target Address" 

1656 fields_desc = [ 

1657 LEMACField('bd_addr', None) 

1658 ] 

1659 

1660 

1661class EIR_AdvertisingInterval(EIR_Element): 

1662 name = "Advertising Interval" 

1663 fields_desc = [ 

1664 MultipleTypeField( 

1665 [ 

1666 (ByteField("advertising_interval", 0), 

1667 lambda p: p.underlayer.len - 1 == 1), 

1668 (LEShortField("advertising_interval", 0), 

1669 lambda p: p.underlayer.len - 1 == 2), 

1670 (LEThreeBytesField("advertising_interval", 0), 

1671 lambda p: p.underlayer.len - 1 == 3), 

1672 (LEIntField("advertising_interval", 0), 

1673 lambda p: p.underlayer.len - 1 == 4), 

1674 ], 

1675 LEShortField("advertising_interval", 0) 

1676 ) 

1677 ] 

1678 

1679 

1680class EIR_LEBluetoothDeviceAddress(EIR_Element): 

1681 name = "LE Bluetooth Device Address" 

1682 fields_desc = [ 

1683 XBitField('reserved', 0, 7, tot_size=-1), 

1684 BitEnumField('addr_type', 0, 1, end_tot_size=-1, enum={ 

1685 0x0: 'Public', 

1686 0x1: 'Random' 

1687 }), 

1688 LEMACField('bd_addr', None) 

1689 ] 

1690 

1691 

1692class EIR_LERole(EIR_Element): 

1693 name = "LE Role" 

1694 fields_desc = [ 

1695 ByteEnumField("role", 0, { 

1696 0: "Only Peripheral Role supported", 

1697 1: "Only Central Role supported", 

1698 2: "Peripheral and Central Role supported, " 

1699 "Peripheral Role preferred for connection establishment", 

1700 3: "Peripheral and Central Role supported, " 

1701 "Central Role preferred for connection establishment", 

1702 }), 

1703 ] 

1704 

1705 

1706class EIR_BroadcastName(EIR_Element): 

1707 name = "Broadcast Name" 

1708 fields_desc = [ 

1709 StrLenField("broadcast_name", "", 

1710 length_from=EIR_Element.length_from) 

1711 ] 

1712 

1713 

1714class EIR_3DInformation(EIR_Element): 

1715 name = "3D Information" 

1716 fields_desc = [ 

1717 BitField("factory_test_mode", 0, 1, tot_size=-1), 

1718 BitField("reserved", 0, 4), 

1719 BitField("send_battery_level_on_startup", 0, 1), 

1720 BitField("battery_level_reporting", 0, 1), 

1721 BitField("association_notification", 0, 1, end_tot_size=-1), 

1722 ByteField("path_loss_threshold", 0), 

1723 ] 

1724 

1725 

1726class EIR_Appearance(EIR_Element): 

1727 name = "EIR_Appearance" 

1728 fields_desc = [ 

1729 BitEnumField('category', 0, 10, tot_size=-2, enum={ 

1730 0x000: 'Unknown', 

1731 0x001: 'Phone', 

1732 0x002: 'Computer', 

1733 0x003: 'Watch', 

1734 0x004: 'Clock', 

1735 0x005: 'Display', 

1736 0x006: 'Remote Control', 

1737 0x007: 'Eyeglasses', 

1738 0x008: 'Tag', 

1739 0x009: 'Keyring', 

1740 0x00A: 'Media Player', 

1741 0x00B: 'Barcode Scanner', 

1742 0x00C: 'Thermometer', 

1743 0x00D: 'Heart Rate Sensor', 

1744 0x00E: 'Blood Pressure', 

1745 0x00F: 'Human Interface Device', 

1746 0x010: 'Glucose Meter', 

1747 0x011: 'Running Walking Sensor', 

1748 0x012: 'Cycling', 

1749 0x013: 'Control Device', 

1750 0x014: 'Network Device', 

1751 0x015: 'Sensor', 

1752 0x016: 'Light Fixtures', 

1753 0x017: 'Fan', 

1754 0x018: 'HVAC', 

1755 0x019: 'Air Conditioning', 

1756 0x01A: 'Humidifier', 

1757 0x01B: 'Heating', 

1758 0x01C: 'Access Control', 

1759 0x01D: 'Motorized Device', 

1760 0x01E: 'Power Device', 

1761 0x01F: 'Light Source', 

1762 0x020: 'Window Covering', 

1763 0x021: 'Audio Sink', 

1764 0x022: 'Audio Source', 

1765 0x023: 'Motorized Vehicle', 

1766 0x024: 'Domestic Appliance', 

1767 0x025: 'Wearable Audio Device', 

1768 0x026: 'Aircraft', 

1769 0x027: 'AV Equipment', 

1770 0x028: 'Display Equipment', 

1771 0x029: 'Hearing aid', 

1772 0x02A: 'Gaming', 

1773 0x02B: 'Signage', 

1774 0x031: 'Pulse Oximeter', 

1775 0x032: 'Weight Scale', 

1776 0x033: 'Personal Mobility Device', 

1777 0x034: 'Continuous Glucose Monitor', 

1778 0x035: 'Insulin Pump', 

1779 0x036: 'Medication Delivery', 

1780 0x037: 'Spirometer', 

1781 0x051: 'Outdoor Sports Activity' 

1782 }), 

1783 XBitField('subcategory', 0, 6, end_tot_size=-2) 

1784 ] 

1785 

1786 @property 

1787 def appearance(self): 

1788 return (self.category << 6) + self.subcategory 

1789 

1790 

1791class EIR_ServiceData32BitUUID(EIR_Element): 

1792 name = 'EIR Service Data - 32-bit UUID' 

1793 fields_desc = [ 

1794 XLEIntField('svc_uuid', 0), 

1795 ] 

1796 

1797 def extract_padding(self, s): 

1798 # Needed to end each EIR_Element packet and make PacketListField work. 

1799 plen = EIR_Element.length_from(self) - 4 

1800 return s[:plen], s[plen:] 

1801 

1802 

1803class EIR_ServiceData128BitUUID(EIR_Element): 

1804 name = 'EIR Service Data - 128-bit UUID' 

1805 fields_desc = [ 

1806 UUIDField('svc_uuid', None, uuid_fmt=UUIDField.FORMAT_REV) 

1807 ] 

1808 

1809 def extract_padding(self, s): 

1810 # Needed to end each EIR_Element packet and make PacketListField work. 

1811 plen = EIR_Element.length_from(self) - 16 

1812 return s[:plen], s[plen:] 

1813 

1814 

1815class EIR_URI(EIR_Element): 

1816 name = 'EIR URI' 

1817 fields_desc = [ 

1818 ByteEnumField('scheme', 0, { 

1819 0x01: '', 

1820 0x02: 'aaa:', 

1821 0x03: 'aaas:', 

1822 0x04: 'about:', 

1823 0x05: 'acap:', 

1824 0x06: 'acct:', 

1825 0x07: 'cap:', 

1826 0x08: 'cid:', 

1827 0x09: 'coap:', 

1828 0x0A: 'coaps:', 

1829 0x0B: 'crid:', 

1830 0x0C: 'data:', 

1831 0x0D: 'dav:', 

1832 0x0E: 'dict:', 

1833 0x0F: 'dns:', 

1834 0x10: 'file:', 

1835 0x11: 'ftp:', 

1836 0x12: 'geo:', 

1837 0x13: 'go:', 

1838 0x14: 'gopher:', 

1839 0x15: 'h323:', 

1840 0x16: 'http:', 

1841 0x17: 'https:', 

1842 0x18: 'iax:', 

1843 0x19: 'icap:', 

1844 0x1A: 'im:', 

1845 0x1B: 'imap:', 

1846 0x1C: 'info:', 

1847 0x1D: 'ipp:', 

1848 0x1E: 'ipps:', 

1849 0x1F: 'iris:', 

1850 0x20: 'iris.beep:', 

1851 0x21: 'iris.xpc:', 

1852 0x22: 'iris.xpcs:', 

1853 0x23: 'iris.lwz:', 

1854 0x24: 'jabber:', 

1855 0x25: 'ldap:', 

1856 0x26: 'mailto:', 

1857 0x27: 'mid:', 

1858 0x28: 'msrp:', 

1859 0x29: 'msrps:', 

1860 0x2A: 'mtqp:', 

1861 0x2B: 'mupdate:', 

1862 0x2C: 'news:', 

1863 0x2D: 'nfs:', 

1864 0x2E: 'ni:', 

1865 0x2F: 'nih:', 

1866 0x30: 'nntp:', 

1867 0x31: 'opaquelocktoken:', 

1868 0x32: 'pop:', 

1869 0x33: 'pres:', 

1870 0x34: 'reload:', 

1871 0x35: 'rtsp:', 

1872 0x36: 'rtsps:', 

1873 0x37: 'rtspu:', 

1874 0x38: 'service:', 

1875 0x39: 'session:', 

1876 0x3A: 'shttp:', 

1877 0x3B: 'sieve:', 

1878 0x3C: 'sip:', 

1879 0x3D: 'sips:', 

1880 0x3E: 'sms:', 

1881 0x3F: 'snmp:', 

1882 0x40: 'soap.beep:', 

1883 0x41: 'soap.beeps:', 

1884 0x42: 'stun:', 

1885 0x43: 'stuns:', 

1886 0x44: 'tag:', 

1887 0x45: 'tel:', 

1888 0x46: 'telnet:', 

1889 0x47: 'tftp:', 

1890 0x48: 'thismessage:', 

1891 0x49: 'tn3270:', 

1892 0x4A: 'tip:', 

1893 0x4B: 'turn:', 

1894 0x4C: 'turns:', 

1895 0x4D: 'tv:', 

1896 0x4E: 'urn:', 

1897 0x4F: 'vemmi:', 

1898 0x50: 'ws:', 

1899 0x51: 'wss:', 

1900 0x52: 'xcon:', 

1901 0x53: 'xconuserid:', 

1902 0x54: 'xmlrpc.beep:', 

1903 0x55: 'xmlrpc.beeps:', 

1904 0x56: 'xmpp:', 

1905 0x57: 'z39.50r:', 

1906 0x58: 'z39.50s:', 

1907 0x59: 'acr:', 

1908 0x5A: 'adiumxtra:', 

1909 0x5B: 'afp:', 

1910 0x5C: 'afs:', 

1911 0x5D: 'aim:', 

1912 0x5E: 'apt:', 

1913 0x5F: 'attachment:', 

1914 0x60: 'aw:', 

1915 0x61: 'barion:', 

1916 0x62: 'beshare:', 

1917 0x63: 'bitcoin:', 

1918 0x64: 'bolo:', 

1919 0x65: 'callto:', 

1920 0x66: 'chrome:', 

1921 0x67: 'chromeextension:', 

1922 0x68: 'comeventbriteattendee:', 

1923 0x69: 'content:', 

1924 0x6A: 'cvs:', 

1925 0x6B: 'dlnaplaysingle:', 

1926 0x6C: 'dlnaplaycontainer:', 

1927 0x6D: 'dtn:', 

1928 0x6E: 'dvb:', 

1929 0x6F: 'ed2k:', 

1930 0x70: 'facetime:', 

1931 0x71: 'feed:', 

1932 0x72: 'feedready:', 

1933 0x73: 'finger:', 

1934 0x74: 'fish:', 

1935 0x75: 'gg:', 

1936 0x76: 'git:', 

1937 0x77: 'gizmoproject:', 

1938 0x78: 'gtalk:', 

1939 0x79: 'ham:', 

1940 0x7A: 'hcp:', 

1941 0x7B: 'icon:', 

1942 0x7C: 'ipn:', 

1943 0x7D: 'irc:', 

1944 0x7E: 'irc6:', 

1945 0x7F: 'ircs:', 

1946 0x80: 'itms:', 

1947 0x81: 'jar:', 

1948 0x82: 'jms:', 

1949 0x83: 'keyparc:', 

1950 0x84: 'lastfm:', 

1951 0x85: 'ldaps:', 

1952 0x86: 'magnet:', 

1953 0x87: 'maps:', 

1954 0x88: 'market:', 

1955 0x89: 'message:', 

1956 0x8A: 'mms:', 

1957 0x8B: 'mshelp:', 

1958 0x8C: 'mssettingspower:', 

1959 0x8D: 'msnim:', 

1960 0x8E: 'mumble:', 

1961 0x8F: 'mvn:', 

1962 0x90: 'notes:', 

1963 0x91: 'oid:', 

1964 0x92: 'palm:', 

1965 0x93: 'paparazzi:', 

1966 0x94: 'pkcs11:', 

1967 0x95: 'platform:', 

1968 0x96: 'proxy:', 

1969 0x97: 'psyc:', 

1970 0x98: 'query:', 

1971 0x99: 'res:', 

1972 0x9A: 'resource:', 

1973 0x9B: 'rmi:', 

1974 0x9C: 'rsync:', 

1975 0x9D: 'rtmfp:', 

1976 0x9E: 'rtmp:', 

1977 0x9F: 'secondlife:', 

1978 0xA0: 'sftp:', 

1979 0xA1: 'sgn:', 

1980 0xA2: 'skype:', 

1981 0xA3: 'smb:', 

1982 0xA4: 'smtp:', 

1983 0xA5: 'soldat:', 

1984 0xA6: 'spotify:', 

1985 0xA7: 'ssh:', 

1986 0xA8: 'steam:', 

1987 0xA9: 'submit:', 

1988 0xAA: 'svn:', 

1989 0xAB: 'teamspeak:', 

1990 0xAC: 'teliaeid:', 

1991 0xAD: 'things:', 

1992 0xAE: 'udp:', 

1993 0xAF: 'unreal:', 

1994 0xB0: 'ut2004:', 

1995 0xB1: 'ventrilo:', 

1996 0xB2: 'viewsource:', 

1997 0xB3: 'webcal:', 

1998 0xB4: 'wtai:', 

1999 0xB5: 'wyciwyg:', 

2000 0xB6: 'xfire:', 

2001 0xB7: 'xri:', 

2002 0xB8: 'ymsgr:', 

2003 0xB9: 'example:', 

2004 0xBA: 'mssettingscloudstorage:' 

2005 }), 

2006 StrLenField('uri_hier_part', None, length_from=EIR_Element.length_from) 

2007 ] 

2008 

2009 @property 

2010 def uri(self): 

2011 return EIR_URI.scheme.i2s[self.scheme] + self.uri_hier_part.decode('utf-8') 

2012 

2013 

2014class HCI_Command_Hdr(Packet): 

2015 name = "HCI Command header" 

2016 fields_desc = [XBitField("ogf", 0, 6, tot_size=-2), 

2017 XBitField("ocf", 0, 10, end_tot_size=-2), 

2018 LenField("len", None, fmt="B"), ] 

2019 

2020 def answers(self, other): 

2021 return False 

2022 

2023 @property 

2024 def opcode(self): 

2025 return (self.ogf << 10) + self.ocf 

2026 

2027 def post_build(self, p, pay): 

2028 p += pay 

2029 if self.len is None: 

2030 p = p[:2] + struct.pack("B", len(pay)) + p[3:] 

2031 return p 

2032 

2033 

2034# BUETOOTH CORE SPECIFICATION 5.4 | Vol 3, Part C 

2035# 8 EXTENDED INQUIRY RESPONSE 

2036 

2037class HCI_Extended_Inquiry_Response(Packet): 

2038 fields_desc = [ 

2039 PadField( 

2040 PacketListField( 

2041 "eir_data", [], 

2042 next_cls_cb=lambda *args: ( 

2043 (not args[2] or args[2].len != 0) and EIR_Hdr or conf.raw_layer 

2044 ) 

2045 ), 

2046 align=31, padwith=b"\0", 

2047 ), 

2048 ] 

2049 

2050 

2051# BLUETOOTH CORE SPECIFICATION Version 5.4 | Vol 4, Part E 

2052# 7 HCI COMMANDS AND EVENTS 

2053# 7.1 LINK CONTROL COMMANDS, the OGF is defined as 0x01 

2054 

2055class HCI_Cmd_Inquiry(Packet): 

2056 """ 

2057 7.1.1 Inquiry command 

2058 """ 

2059 name = "HCI_Inquiry" 

2060 fields_desc = [XLE3BytesField("lap", 0x9E8B33), 

2061 ByteField("inquiry_length", 0), 

2062 ByteField("num_responses", 0)] 

2063 

2064 

2065class HCI_Cmd_Inquiry_Cancel(Packet): 

2066 """ 

2067 7.1.2 Inquiry Cancel command 

2068 """ 

2069 name = "HCI_Inquiry_Cancel" 

2070 

2071 

2072class HCI_Cmd_Periodic_Inquiry_Mode(Packet): 

2073 """ 

2074 7.1.3 Periodic Inquiry Mode command 

2075 """ 

2076 name = "HCI_Periodic_Inquiry_Mode" 

2077 fields_desc = [LEShortField("max_period_length", 0x0003), 

2078 LEShortField("min_period_length", 0x0002), 

2079 XLE3BytesField("lap", 0x9E8B33), 

2080 ByteField("inquiry_length", 0), 

2081 ByteField("num_responses", 0)] 

2082 

2083 

2084class HCI_Cmd_Exit_Peiodic_Inquiry_Mode(Packet): 

2085 """ 

2086 7.1.4 Exit Periodic Inquiry Mode command 

2087 """ 

2088 name = "HCI_Exit_Periodic_Inquiry_Mode" 

2089 

2090 

2091class HCI_Cmd_Create_Connection(Packet): 

2092 """ 

2093 7.1.5 Create Connection command 

2094 """ 

2095 name = "HCI_Create_Connection" 

2096 fields_desc = [LEMACField("bd_addr", None), 

2097 LEShortField("packet_type", 0xcc18), 

2098 ByteField("page_scan_repetition_mode", 0x02), 

2099 ByteField("reserved", 0x0), 

2100 LEShortField("clock_offset", 0x0), 

2101 ByteField("allow_role_switch", 0x1), ] 

2102 

2103 

2104class HCI_Cmd_Disconnect(Packet): 

2105 """ 

2106 7.1.6 Disconnect command 

2107 """ 

2108 name = "HCI_Disconnect" 

2109 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

2110 fields_desc = [XLEShortField("connection_handle", 0), 

2111 ByteField("reason", 0x13), ] 

2112 

2113 

2114class HCI_Cmd_Create_Connection_Cancel(Packet): 

2115 """ 

2116 7.1.7 Create Connection Cancel command 

2117 """ 

2118 name = "HCI_Create_Connection_Cancel" 

2119 fields_desc = [LEMACField("bd_addr", None), ] 

2120 

2121 

2122class HCI_Cmd_Accept_Connection_Request(Packet): 

2123 """ 

2124 7.1.8 Accept Connection Request command 

2125 """ 

2126 name = "HCI_Accept_Connection_Request" 

2127 fields_desc = [LEMACField("bd_addr", None), 

2128 ByteField("role", 0x1), ] 

2129 

2130 

2131class HCI_Cmd_Reject_Connection_Response(Packet): 

2132 """ 

2133 7.1.9 Reject Connection Request command 

2134 """ 

2135 name = "HCI_Reject_Connection_Response" 

2136 fields_desc = [LEMACField("bd_addr", None), 

2137 ByteField("reason", 0x1), ] 

2138 

2139 

2140class HCI_Cmd_Link_Key_Request_Reply(Packet): 

2141 """ 

2142 7.1.10 Link Key Request Reply command 

2143 """ 

2144 name = "HCI_Link_Key_Request_Reply" 

2145 fields_desc = [LEMACField("bd_addr", None), 

2146 NBytesField("link_key", None, 16), ] 

2147 

2148 

2149class HCI_Cmd_Link_Key_Request_Negative_Reply(Packet): 

2150 """ 

2151 7.1.11 Link Key Request Negative Reply command 

2152 """ 

2153 name = "HCI_Link_Key_Request_Negative_Reply" 

2154 fields_desc = [LEMACField("bd_addr", None), ] 

2155 

2156 

2157class HCI_Cmd_PIN_Code_Request_Reply(Packet): 

2158 """ 

2159 7.1.12 PIN Code Request Reply command 

2160 """ 

2161 name = "HCI_PIN_Code_Request_Reply" 

2162 fields_desc = [LEMACField("bd_addr", None), 

2163 ByteField("pin_code_length", 7), 

2164 NBytesField("pin_code", b"\x00" * 16, sz=16), ] 

2165 

2166 

2167class HCI_Cmd_PIN_Code_Request_Negative_Reply(Packet): 

2168 """ 

2169 7.1.13 PIN Code Request Negative Reply command 

2170 """ 

2171 name = "HCI_PIN_Code_Request_Negative_Reply" 

2172 fields_desc = [LEMACField("bd_addr", None), ] 

2173 

2174 

2175class HCI_Cmd_Change_Connection_Packet_Type(Packet): 

2176 """ 

2177 7.1.14 Change Connection Packet Type command 

2178 """ 

2179 name = "HCI_Cmd_Change_Connection_Packet_Type" 

2180 fields_desc = [XLEShortField("connection_handle", None), 

2181 LEShortField("packet_type", 0), ] 

2182 

2183 

2184class HCI_Cmd_Authentication_Requested(Packet): 

2185 """ 

2186 7.1.15 Authentication Requested command 

2187 """ 

2188 name = "HCI_Authentication_Requested" 

2189 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

2190 fields_desc = [LEShortField("connection_handle", 0)] 

2191 

2192 

2193class HCI_Cmd_Set_Connection_Encryption(Packet): 

2194 """ 

2195 7.1.16 Set Connection Encryption command 

2196 """ 

2197 name = "HCI_Set_Connection_Encryption" 

2198 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

2199 fields_desc = [LEShortField("connection_handle", 0), 

2200 ByteField("encryption_enable", 0)] 

2201 

2202 

2203class HCI_Cmd_Change_Connection_Link_Key(Packet): 

2204 """ 

2205 7.1.17 Change Connection Link Key command 

2206 """ 

2207 name = "HCI_Change_Connection_Link_Key" 

2208 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

2209 fields_desc = [LEShortField("connection_handle", 0), ] 

2210 

2211 

2212class HCI_Cmd_Link_Key_Selection(Packet): 

2213 """ 

2214 7.1.18 Change Connection Link Key command 

2215 """ 

2216 name = "HCI_Cmd_Link_Key_Selection" 

2217 fields_desc = [ByteEnumField("handle", 0, {0: "Use semi-permanent Link Keys", 

2218 1: "Use Temporary Link Key", }), ] 

2219 

2220 

2221class HCI_Cmd_Remote_Name_Request(Packet): 

2222 """ 

2223 7.1.19 Remote Name Request command 

2224 """ 

2225 name = "HCI_Remote_Name_Request" 

2226 fields_desc = [LEMACField("bd_addr", None), 

2227 ByteField("page_scan_repetition_mode", 0x02), 

2228 ByteField("reserved", 0x0), 

2229 LEShortField("clock_offset", 0x0), ] 

2230 

2231 

2232class HCI_Cmd_Remote_Name_Request_Cancel(Packet): 

2233 """ 

2234 7.1.20 Remote Name Request Cancel command 

2235 """ 

2236 name = "HCI_Remote_Name_Request_Cancel" 

2237 fields_desc = [LEMACField("bd_addr", None), ] 

2238 

2239 

2240class HCI_Cmd_Read_Remote_Supported_Features(Packet): 

2241 """ 

2242 7.1.21 Read Remote Supported Features command 

2243 """ 

2244 name = "HCI_Read_Remote_Supported_Features" 

2245 fields_desc = [LEShortField("connection_handle", None), ] 

2246 

2247 

2248class HCI_Cmd_Read_Remote_Extended_Features(Packet): 

2249 """ 

2250 7.1.22 Read Remote Extended Features command 

2251 """ 

2252 name = "HCI_Read_Remote_Supported_Features" 

2253 fields_desc = [LEShortField("connection_handle", None), 

2254 ByteField("page_number", None), ] 

2255 

2256 

2257class HCI_Cmd_IO_Capability_Request_Reply(Packet): 

2258 """ 

2259 7.1.29 IO Capability Request Reply command 

2260 """ 

2261 name = "HCI_Read_Remote_Supported_Features" 

2262 fields_desc = [LEMACField("bd_addr", None), 

2263 ByteEnumField("io_capability", None, {0x00: "DisplayOnly", 

2264 0x01: "DisplayYesNo", 

2265 0x02: "KeyboardOnly", 

2266 0x03: "NoInputNoOutput", }), 

2267 ByteEnumField("oob_data_present", None, {0x00: "Not Present", 

2268 0x01: "P-192", 

2269 0x02: "P-256", 

2270 0x03: "P-192 + P-256", }), 

2271 ByteEnumField("authentication_requirement", None, 

2272 {0x00: "MITM Not Required", 

2273 0x01: "MITM Required, No Bonding", 

2274 0x02: "MITM Not Required + Dedicated Pairing", 

2275 0x03: "MITM Required + Dedicated Pairing", 

2276 0x04: "MITM Not Required, General Bonding", 

2277 0x05: "MITM Required + General Bonding"}), ] 

2278 

2279 

2280class HCI_Cmd_User_Confirmation_Request_Reply(Packet): 

2281 """ 

2282 7.1.30 User Confirmation Request Reply command 

2283 """ 

2284 name = "HCI_User_Confirmation_Request_Reply" 

2285 fields_desc = [LEMACField("bd_addr", None), ] 

2286 

2287 

2288class HCI_Cmd_User_Confirmation_Request_Negative_Reply(Packet): 

2289 """ 

2290 7.1.31 User Confirmation Request Negative Reply command 

2291 """ 

2292 name = "HCI_User_Confirmation_Request_Negative_Reply" 

2293 fields_desc = [LEMACField("bd_addr", None), ] 

2294 

2295 

2296class HCI_Cmd_User_Passkey_Request_Reply(Packet): 

2297 """ 

2298 7.1.32 User Passkey Request Reply command 

2299 """ 

2300 name = "HCI_User_Passkey_Request_Reply" 

2301 fields_desc = [LEMACField("bd_addr", None), 

2302 LEIntField("numeric_value", None), ] 

2303 

2304 

2305class HCI_Cmd_User_Passkey_Request_Negative_Reply(Packet): 

2306 """ 

2307 7.1.33 User Passkey Request Negative Reply command 

2308 """ 

2309 name = "HCI_User_Passkey_Request_Negative_Reply" 

2310 fields_desc = [LEMACField("bd_addr", None), ] 

2311 

2312 

2313class HCI_Cmd_Remote_OOB_Data_Request_Reply(Packet): 

2314 """ 

2315 7.1.34 Remote OOB Data Request Reply command 

2316 """ 

2317 name = "HCI_Remote_OOB_Data_Request_Reply" 

2318 fields_desc = [LEMACField("bd_addr", None), 

2319 NBytesField("C", b"\x00" * 16, sz=16), 

2320 NBytesField("R", b"\x00" * 16, sz=16), ] 

2321 

2322 

2323class HCI_Cmd_Remote_OOB_Data_Request_Negative_Reply(Packet): 

2324 """ 

2325 7.1.35 Remote OOB Data Request Negative Reply command 

2326 """ 

2327 name = "HCI_Remote_OOB_Data_Request_Negative_Reply" 

2328 fields_desc = [LEMACField("bd_addr", None), ] 

2329 

2330 

2331# 7.2 Link Policy commands, the OGF is defined as 0x02 

2332 

2333class HCI_Cmd_Hold_Mode(Packet): 

2334 """ 

2335 7.2.1 Hold Mode command 

2336 """ 

2337 name = "HCI_Hold_Mode" 

2338 fields_desc = [LEShortField("connection_handle", 0), 

2339 LEShortField("hold_mode_max_interval", 0x0002), 

2340 LEShortField("hold_mode_min_interval", 0x0002), ] 

2341 

2342 

2343class HCI_Cmd_Switch_Role(Packet): 

2344 """ 

2345 7.2.8 Switch Role command 

2346 """ 

2347 name = "HCI_Switch_Role" 

2348 fields_desc = [LEMACField("bd_addr", None), 

2349 ByteField("role", 0x00), ] 

2350 

2351 

2352# 7.3 CONTROLLER & BASEBAND COMMANDS, the OGF is defined as 0x03 

2353 

2354class HCI_Cmd_Set_Event_Mask(Packet): 

2355 """ 

2356 7.3.1 Set Event Mask command 

2357 """ 

2358 name = "HCI_Set_Event_Mask" 

2359 fields_desc = [StrFixedLenField("mask", b"\xff\xff\xfb\xff\x07\xf8\xbf\x3d", 8)] # noqa: E501 

2360 

2361 

2362class HCI_Cmd_Reset(Packet): 

2363 """ 

2364 7.3.2 Reset command 

2365 """ 

2366 name = "HCI_Reset" 

2367 

2368 

2369class HCI_Cmd_Set_Event_Filter(Packet): 

2370 """ 

2371 7.3.3 Set Event Filter command 

2372 """ 

2373 name = "HCI_Set_Event_Filter" 

2374 fields_desc = [ByteEnumField("type", 0, {0: "clear"}), ] 

2375 

2376 

2377class HCI_Cmd_Write_Local_Name(Packet): 

2378 """ 

2379 7.3.11 Write Local Name command 

2380 """ 

2381 name = "HCI_Write_Local_Name" 

2382 fields_desc = [StrFixedLenField('name', '', length=248)] 

2383 

2384 

2385class HCI_Cmd_Read_Local_Name(Packet): 

2386 """ 

2387 7.3.12 Read Local Name command 

2388 """ 

2389 name = "HCI_Read_Local_Name" 

2390 

2391 

2392class HCI_Cmd_Write_Connect_Accept_Timeout(Packet): 

2393 name = "HCI_Write_Connection_Accept_Timeout" 

2394 fields_desc = [LEShortField("timeout", 32000)] # 32000 slots is 20000 msec 

2395 

2396 

2397class HCI_Cmd_Read_Simple_Pairing_Mode(Packet): 

2398 """ 

2399 7.3.58 Read Simple Pairing Mode command 

2400 """ 

2401 name = "HCI_Read_Simple_Pairing_Mode_command" 

2402 fields_desc = [] 

2403 

2404 

2405class HCI_Cmd_Write_Simple_Pairing_Mode(Packet): 

2406 """ 

2407 7.3.59 Write Simple Paring Mode 

2408 """ 

2409 name = "HCI_Write_Simple_Pairing_Mode" 

2410 fields_desc = [ByteField("status", 0x00)] 

2411 

2412 

2413class HCI_Cmd_Write_Extended_Inquiry_Response(Packet): 

2414 name = "HCI_Write_Extended_Inquiry_Response" 

2415 fields_desc = [ByteField("fec_required", 0), 

2416 HCI_Extended_Inquiry_Response] 

2417 

2418 

2419class HCI_Cmd_Read_LE_Host_Support(Packet): 

2420 name = "HCI_Read_LE_Host_Support" 

2421 

2422 

2423class HCI_Cmd_Write_LE_Host_Support(Packet): 

2424 name = "HCI_Write_LE_Host_Support" 

2425 fields_desc = [ByteField("supported", 1), 

2426 ByteField("unused", 1), ] 

2427 

2428 

2429# 7.4 INFORMATIONAL PARAMETERS, the OGF is defined as 0x04 

2430 

2431class HCI_Cmd_Read_Local_Version_Information(Packet): 

2432 """ 

2433 7.4.1 Read Local Version Information command 

2434 """ 

2435 name = "HCI_Read_Local_Version_Information" 

2436 

2437 

2438class HCI_Cmd_Read_Local_Extended_Features(Packet): 

2439 """ 

2440 7.4.4 Read Local Extended Features command 

2441 """ 

2442 name = "HCI_Read_Local_Extended_Features" 

2443 fields_desc = [ByteField("page_number", 0)] 

2444 

2445 

2446class HCI_Cmd_Read_BD_Addr(Packet): 

2447 """ 

2448 7.4.6 Read BD_ADDR command 

2449 """ 

2450 name = "HCI_Read_BD_ADDR" 

2451 

2452 

2453# 7.5 STATUS PARAMETERS, the OGF is defined as 0x05 

2454 

2455class HCI_Cmd_Read_Link_Quality(Packet): 

2456 name = "HCI_Read_Link_Quality" 

2457 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

2458 fields_desc = [LEShortField("connection_handle", 0)] 

2459 

2460 

2461class HCI_Cmd_Read_RSSI(Packet): 

2462 name = "HCI_Read_RSSI" 

2463 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

2464 fields_desc = [LEShortField("connection_handle", 0)] 

2465 

2466 

2467# 7.6 TESTING COMMANDS, the OGF is defined as 0x06 

2468 

2469class HCI_Cmd_Read_Loopback_Mode(Packet): 

2470 name = "HCI_Read_Loopback_Mode" 

2471 

2472 

2473class HCI_Cmd_Write_Loopback_Mode(Packet): 

2474 name = "HCI_Write_Loopback_Mode" 

2475 fields_desc = [ByteEnumField("loopback_mode", 0, 

2476 {0: "no loopback", 

2477 1: "enable local loopback", 

2478 2: "enable remote loopback"})] 

2479 

2480 

2481# 7.8 LE CONTROLLER COMMANDS, the OGF code is defined as 0x08 

2482 

2483class HCI_Cmd_LE_Set_Event_Mask(Packet): 

2484 name = 'HCI_LE_Set_Event_Mask' 

2485 fields_desc = [StrFixedLenField('mask', b'\xff\xff\xff\xff\xff\x1f\x00\x00', 8)] 

2486 

2487 

2488class HCI_Cmd_LE_Read_Buffer_Size_V1(Packet): 

2489 name = "HCI_LE_Read_Buffer_Size [v1]" 

2490 

2491 

2492class HCI_Cmd_LE_Read_Buffer_Size_V2(Packet): 

2493 name = "HCI_LE_Read_Buffer_Size [v2]" 

2494 

2495 

2496class HCI_Cmd_LE_Read_Local_Supported_Features(Packet): 

2497 name = "HCI_LE_Read_Local_Supported_Features" 

2498 

2499 

2500class HCI_Cmd_LE_Set_Random_Address(Packet): 

2501 name = "HCI_LE_Set_Random_Address" 

2502 fields_desc = [LEMACField("addr", None)] 

2503 deprecated_fields = {"address": ("addr", "2.7.0")} 

2504 

2505 

2506class HCI_Cmd_LE_Set_Advertising_Parameters(Packet): 

2507 name = "HCI_LE_Set_Advertising_Parameters" 

2508 fields_desc = [LEShortField("interval_min", 0x0800), 

2509 LEShortField("interval_max", 0x0800), 

2510 ByteEnumField("adv_type", 0, { 

2511 0: "ADV_IND", 

2512 1: "ADV_DIRECT_IND", 

2513 2: "ADV_SCAN_IND", 

2514 3: "ADV_NONCONN_IND", 

2515 4: "ADV_DIRECT_IND_LOW"}), 

2516 ByteEnumField("own_addr_type", 0, { 

2517 0: "public", 

2518 1: "random"}), 

2519 ByteEnumField("peer_addr_type", 0, { 

2520 0: "public", 

2521 1: "random"}), 

2522 LEMACField("peer_addr", None), 

2523 ByteField("channel_map", 7), 

2524 ByteEnumField("filter_policy", 0, { 

2525 0: "all:all", 

2526 1: "connect:all scan:whitelist", 

2527 2: "connect:whitelist scan:all", 

2528 3: "all:whitelist"}), ] 

2529 deprecated_fields = { 

2530 "oatype": ("own_addr_type", "2.7.0"), 

2531 "datype": ("peer_addr_type", "2.7.0"), 

2532 "daddr": ("peer_addr", "2.7.0"), 

2533 } 

2534 

2535 

2536class HCI_Cmd_LE_Set_Extended_Advertising_Parameters(Packet): 

2537 name = 'HCI_LE_Set_Extended_Advertising_Parameters' 

2538 fields_desc = [ByteField('handle', 0), 

2539 LEShortField('properties', 19), 

2540 LEThreeBytesField('pri_interval_min', 160), 

2541 LEThreeBytesField('pri_interval_max', 160), 

2542 ByteField('pri_channel_map', 7), 

2543 ByteEnumField('own_addr_type', 0, { 

2544 0: 'public', 

2545 1: 'random', 

2546 2: 'rpa_pub', 

2547 3: 'rpa_rand'}), 

2548 ByteEnumField('peer_addr_type', 0, { 

2549 0: 'public', 

2550 1: 'random', 

2551 2: 'rpa_pub', 

2552 3: 'rpa_rand'}), 

2553 LEMACField('peer_addr', None), 

2554 ByteEnumField("filter_policy", 0, { 

2555 0: "all:all", 

2556 1: "connect:all scan:whitelist", 

2557 2: "connect:whitelist scan:all", 

2558 3: "all:whitelist"}), 

2559 SignedByteField('tx_power', 127), 

2560 ByteEnumField('pri_phy', 1, {1: '1M', 3: 'Coded'}), 

2561 ByteField('sec_max_skip', 0), 

2562 ByteEnumField('sec_phy', 1, {1: '1M', 2: '2M', 3: 'Coded'}), 

2563 ByteField('sid', 0), 

2564 ByteField('scan_req_notify_enable', 0)] 

2565 

2566 

2567class HCI_Cmd_LE_Set_Advertising_Set_Random_Address(Packet): 

2568 name = 'HCI_LE_Set_Advertising_Set_Random_Address' 

2569 fields_desc = [ByteField('handle', 0), LEMACField('addr', None)] 

2570 

2571 

2572class HCI_Cmd_LE_Set_Advertising_Data(Packet): 

2573 name = "HCI_LE_Set_Advertising_Data" 

2574 fields_desc = [FieldLenField("len", None, length_of="data", fmt="B"), 

2575 PadField( 

2576 PacketListField("data", [], EIR_Hdr, 

2577 length_from=lambda pkt: pkt.len), 

2578 align=31, padwith=b"\0"), ] 

2579 

2580 

2581class HCI_Cmd_LE_Set_Extended_Advertising_Data(Packet): 

2582 name = 'HCI_LE_Set_Extended_Advertising_Data' 

2583 fields_desc = [ByteField('handle', 0), 

2584 ByteEnumField('operation', 3, { 

2585 0: 'intermediate_frag', 

2586 1: 'first_frag', 

2587 2: 'last_frag', 

2588 3: 'complete', 

2589 4: 'unchanged_data'}), 

2590 ByteEnumField('frag_pref', 1, {0: 'allow_frag', 1: 'no_frag'}), 

2591 FieldLenField('len', None, length_of='data', fmt='B'), 

2592 PacketListField('data', [], EIR_Hdr, length_from=lambda pkt: pkt.len)] # noqa: E501 

2593 

2594 

2595class HCI_Cmd_LE_Set_Scan_Response_Data(Packet): 

2596 name = "HCI_LE_Set_Scan_Response_Data" 

2597 fields_desc = [FieldLenField("len", None, length_of="data", fmt="B"), 

2598 StrLenField("data", "", length_from=lambda pkt: pkt.len), ] 

2599 

2600 

2601class HCI_Cmd_LE_Set_Advertise_Enable(Packet): 

2602 name = "HCI_LE_Set_Advertising_Enable" 

2603 fields_desc = [ByteField("enable", 0)] 

2604 

2605 

2606class Extended_Advertise_Set(Packet): 

2607 name = 'Extended Advertising Set' 

2608 fields_desc = [ByteField('handle', 0), 

2609 LEShortField('duration', 0), 

2610 ByteField('max_events', 0)] 

2611 

2612 def extract_padding(self, s): 

2613 return b'', s 

2614 

2615 

2616class HCI_Cmd_LE_Set_Extended_Advertise_Enable(Packet): 

2617 name = 'HCI_LE_Set_Extended_Advertising_Enable' 

2618 fields_desc = [ByteEnumField('enable', 1, {0: 'disable', 1: 'enable'}), 

2619 FieldLenField('num_sets', None, count_of='sets', fmt='B'), 

2620 PacketListField('sets', [], Extended_Advertise_Set, count_from=lambda pkt: pkt.num_sets)] # noqa: E501 

2621 

2622 

2623class HCI_Cmd_LE_Set_Scan_Parameters(Packet): 

2624 name = "HCI_LE_Set_Scan_Parameters" 

2625 fields_desc = [ByteEnumField("type", 0, {0: "passive", 1: "active"}), 

2626 XLEShortField("interval", 16), 

2627 XLEShortField("window", 16), 

2628 ByteEnumField("addr_type", 0, { 

2629 0: "public", 

2630 1: "random", 

2631 2: "rpa (pub)", 

2632 3: "rpa (random)"}), 

2633 ByteEnumField("policy", 0, {0: "all", 1: "whitelist"})] 

2634 deprecated_fields = {"atype": ("addr_type", "2.7.0")} 

2635 

2636 

2637class HCI_Cmd_LE_Set_Extended_Scan_Parameters(Packet): 

2638 name = 'HCI_LE_Set_Extended_Scan_Parameters' 

2639 fields_desc = [ 

2640 ByteEnumField('own_address_type', 0, { 

2641 0: 'public', 

2642 1: 'random', 

2643 2: 'rpa_pub', 

2644 3: 'rpa_rand'}), 

2645 ByteEnumField('scanning_filter_policy', 0, { 

2646 0: 'basic', 

2647 1: 'whitelist', 

2648 2: 'basic_rpa', 

2649 3: 'whitelist_rpa'}), 

2650 ByteField('scanning_phys', 1), 

2651 ConditionalField(ByteEnumField('scan_type_1m', 1, { 

2652 0: 'passive', 

2653 1: 'active'}), lambda pkt: pkt.scanning_phys & 1), 

2654 ConditionalField(LEShortField('scan_interval_1m', 16), 

2655 lambda pkt: pkt.scanning_phys & 1), 

2656 ConditionalField(LEShortField('scan_window_1m', 16), 

2657 lambda pkt: pkt.scanning_phys & 1), 

2658 ConditionalField(ByteEnumField('scan_type_2m', 1, { 

2659 0: 'passive', 

2660 1: 'active'}), lambda pkt: pkt.scanning_phys & 2), 

2661 ConditionalField(LEShortField('scan_interval_2m', 16), 

2662 lambda pkt: pkt.scanning_phys & 2), 

2663 ConditionalField(LEShortField('scan_window_2m', 16), 

2664 lambda pkt: pkt.scanning_phys & 2), 

2665 ConditionalField(ByteEnumField('scan_type_coded', 1, { 

2666 0: 'passive', 

2667 1: 'active'}), lambda pkt: pkt.scanning_phys & 4), 

2668 ConditionalField(LEShortField('scan_interval_coded', 16), 

2669 lambda pkt: pkt.scanning_phys & 4), 

2670 ConditionalField(LEShortField('scan_window_coded', 16), 

2671 lambda pkt: pkt.scanning_phys & 4)] 

2672 

2673 

2674class HCI_Cmd_LE_Set_Scan_Enable(Packet): 

2675 name = "HCI_LE_Set_Scan_Enable" 

2676 fields_desc = [ByteField("enable", 1), 

2677 ByteField("filter_dups", 1), ] 

2678 

2679 

2680class HCI_Cmd_LE_Set_Extended_Scan_Enable(Packet): 

2681 name = 'HCI_LE_Set_Extended_Scan_Enable' 

2682 fields_desc = [ByteEnumField('enable', 1, {0: 'disabled', 1: 'enabled'}), 

2683 ByteEnumField('filter_dups', 1, { 

2684 0: 'disabled', 

2685 1: 'enabled', 

2686 2: 'reset_period'}), 

2687 LEShortField('duration', 500), 

2688 LEShortField('period', 0)] 

2689 

2690 

2691class HCI_Cmd_LE_Create_Connection(Packet): 

2692 name = "HCI_LE_Create_Connection" 

2693 fields_desc = [LEShortField("interval", 96), 

2694 LEShortField("window", 48), 

2695 ByteEnumField("filter", 0, {0: "address"}), 

2696 ByteEnumField("peer_addr_type", 0, {0: "public", 1: "random"}), 

2697 LEMACField("peer_addr", None), 

2698 ByteEnumField("own_addr_type", 0, {0: "public", 1: "random"}), 

2699 LEShortField("min_interval", 40), 

2700 LEShortField("max_interval", 56), 

2701 LEShortField("latency", 0), 

2702 LEShortField("timeout", 42), 

2703 LEShortField("min_ce", 0), 

2704 LEShortField("max_ce", 0), ] 

2705 deprecated_fields = { 

2706 "patype": ("peer_addr_type", "2.7.0"), 

2707 "paddr": ("peer_addr", "2.7.0"), 

2708 "atype": ("own_addr_type", "2.7.0"), 

2709 } 

2710 

2711 

2712class HCI_Cmd_LE_Extended_Create_Connection(Packet): 

2713 name = 'HCI_LE_Extended_Create_Connection' 

2714 fields_desc = [ByteEnumField('filter_policy', 0, {0: 'peer_addr', 1: 'accept_list'}), # noqa: E501 

2715 ByteEnumField('address_type', 0, { 

2716 0: 'public', 

2717 1: 'random', 

2718 2: 'rpa_pub', 

2719 3: 'rpa_rand'}), 

2720 ByteEnumField('peer_addr_type', 0, { 

2721 0: 'public', 

2722 1: 'random', 

2723 2: 'rpa_pub', 

2724 3: 'rpa_rand'}), 

2725 LEMACField('peer_addr', None), 

2726 ByteField('phys', 1), 

2727 ConditionalField(LEShortField('interval_1m', 96), 

2728 lambda pkt: pkt.phys & 1), 

2729 ConditionalField(LEShortField('window_1m', 96), 

2730 lambda pkt: pkt.phys & 1), 

2731 ConditionalField(LEShortField('min_interval_1m', 40), 

2732 lambda pkt: pkt.phys & 1), 

2733 ConditionalField(LEShortField('max_interval_1m', 56), 

2734 lambda pkt: pkt.phys & 1), 

2735 ConditionalField(LEShortField('latency_1m', 0), 

2736 lambda pkt: pkt.phys & 1), 

2737 ConditionalField(LEShortField('timeout_1m', 42), 

2738 lambda pkt: pkt.phys & 1), 

2739 ConditionalField(LEShortField('min_ce_1m', 0), 

2740 lambda pkt: pkt.phys & 1), 

2741 ConditionalField(LEShortField('max_ce_1m', 0), 

2742 lambda pkt: pkt.phys & 1), 

2743 ConditionalField(LEShortField('interval_2m', 96), 

2744 lambda pkt: pkt.phys & 2), 

2745 ConditionalField(LEShortField('window_2m', 96), 

2746 lambda pkt: pkt.phys & 2), 

2747 ConditionalField(LEShortField('min_interval_2m', 40), 

2748 lambda pkt: pkt.phys & 2), 

2749 ConditionalField(LEShortField('max_interval_2m', 56), 

2750 lambda pkt: pkt.phys & 2), 

2751 ConditionalField(LEShortField('latency_2m', 0), 

2752 lambda pkt: pkt.phys & 2), 

2753 ConditionalField(LEShortField('timeout_2m', 42), 

2754 lambda pkt: pkt.phys & 2), 

2755 ConditionalField(LEShortField('min_ce_2m', 0), 

2756 lambda pkt: pkt.phys & 2), 

2757 ConditionalField(LEShortField('max_ce_2m', 0), 

2758 lambda pkt: pkt.phys & 2), 

2759 ConditionalField(LEShortField('interval_coded', 96), 

2760 lambda pkt: pkt.phys & 4), 

2761 ConditionalField(LEShortField('window_coded', 96), 

2762 lambda pkt: pkt.phys & 4), 

2763 ConditionalField(LEShortField('min_interval_coded', 40), 

2764 lambda pkt: pkt.phys & 4), 

2765 ConditionalField(LEShortField('max_interval_coded', 56), 

2766 lambda pkt: pkt.phys & 4), 

2767 ConditionalField(LEShortField('latency_coded', 0), 

2768 lambda pkt: pkt.phys & 4), 

2769 ConditionalField(LEShortField('timeout_coded', 42), 

2770 lambda pkt: pkt.phys & 4), 

2771 ConditionalField(LEShortField('min_ce_coded', 0), 

2772 lambda pkt: pkt.phys & 4), 

2773 ConditionalField(LEShortField('max_ce_coded', 0), 

2774 lambda pkt: pkt.phys & 4)] 

2775 

2776 

2777class HCI_Cmd_LE_Create_Connection_Cancel(Packet): 

2778 name = "HCI_LE_Create_Connection_Cancel" 

2779 

2780 

2781class HCI_Cmd_LE_Read_Filter_Accept_List_Size(Packet): 

2782 name = "HCI_LE_Read_Filter_Accept_List_Size" 

2783 

2784 

2785class HCI_Cmd_LE_Clear_Filter_Accept_List(Packet): 

2786 name = "HCI_LE_Clear_Filter_Accept_List" 

2787 

2788 

2789class HCI_Cmd_LE_Add_Device_To_Filter_Accept_List(Packet): 

2790 name = "HCI_LE_Add_Device_To_Filter_Accept_List" 

2791 fields_desc = [ByteEnumField("addr_type", 0, {0: "public", 

2792 1: "random", 

2793 0xff: "anonymous"}), 

2794 LEMACField("addr", None)] 

2795 

2796 

2797class HCI_Cmd_LE_Remove_Device_From_Filter_Accept_List(HCI_Cmd_LE_Add_Device_To_Filter_Accept_List): # noqa: E501 

2798 name = "HCI_LE_Remove_Device_From_Filter_Accept_List" 

2799 

2800 

2801class HCI_Cmd_LE_Connection_Update(Packet): 

2802 name = "HCI_LE_Connection_Update" 

2803 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

2804 fields_desc = [XLEShortField("connection_handle", 0), 

2805 XLEShortField("min_interval", 0), 

2806 XLEShortField("max_interval", 0), 

2807 XLEShortField("latency", 0), 

2808 XLEShortField("timeout", 0), 

2809 LEShortField("min_ce", 0), 

2810 LEShortField("max_ce", 0xffff), ] 

2811 

2812 

2813class HCI_Cmd_LE_Read_Remote_Features(Packet): 

2814 name = "HCI_LE_Read_Remote_Features" 

2815 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

2816 fields_desc = [LEShortField("connection_handle", 64)] 

2817 

2818 

2819class HCI_Cmd_LE_Enable_Encryption(Packet): 

2820 name = "HCI_LE_Enable_Encryption" 

2821 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

2822 fields_desc = [LEShortField("connection_handle", 0), 

2823 StrFixedLenField("rand", None, 8), 

2824 XLEShortField("ediv", 0), 

2825 StrFixedLenField("ltk", b'\x00' * 16, 16), ] 

2826 

2827 

2828class HCI_Cmd_LE_Long_Term_Key_Request_Reply(Packet): 

2829 name = "HCI_LE_Long_Term_Key_Request_Reply" 

2830 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

2831 fields_desc = [LEShortField("connection_handle", 0), 

2832 StrFixedLenField("ltk", b'\x00' * 16, 16), ] 

2833 

2834 

2835class HCI_Cmd_LE_Long_Term_Key_Request_Negative_Reply(Packet): 

2836 name = "HCI_LE_Long_Term_Key_Request _Negative_Reply" 

2837 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

2838 fields_desc = [LEShortField("connection_handle", 0), ] 

2839 

2840 

2841class HCI_Event_Hdr(Packet): 

2842 name = "HCI Event header" 

2843 fields_desc = [XByteField("code", 0), 

2844 LenField("len", None, fmt="B"), ] 

2845 

2846 def answers(self, other): 

2847 if HCI_Command_Hdr not in other: 

2848 return False 

2849 

2850 # Delegate answers to event types 

2851 return self.payload.answers(other) 

2852 

2853 

2854class HCI_Event_Inquiry_Complete(Packet): 

2855 """ 

2856 7.7.1 Inquiry Complete event 

2857 """ 

2858 name = "HCI_Inquiry_Complete" 

2859 fields_desc = [ 

2860 ByteEnumField('status', 0, _bluetooth_error_codes) 

2861 ] 

2862 

2863 

2864class HCI_Event_Inquiry_Result(Packet): 

2865 """ 

2866 7.7.2 Inquiry Result event 

2867 """ 

2868 name = "HCI_Inquiry_Result" 

2869 fields_desc = [ 

2870 ByteField("num_response", 0x00), 

2871 FieldListField("bd_addr", None, LEMACField("", None), 

2872 count_from=lambda p: p.num_response), 

2873 FieldListField("page_scan_repetition_mode", None, 

2874 ByteField("page_scan_repetition_mode", 0), 

2875 count_from=lambda p: p.num_response), 

2876 FieldListField("reserved", None, LEShortField("reserved", 0), 

2877 count_from=lambda p: p.num_response), 

2878 FieldListField("device_class", None, XLE3BytesField("device_class", 0), 

2879 count_from=lambda p: p.num_response), 

2880 FieldListField("clock_offset", None, LEShortField("clock_offset", 0), 

2881 count_from=lambda p: p.num_response) 

2882 ] 

2883 deprecated_fields = {"addr": ("bd_addr", "2.8.0")} 

2884 

2885 

2886class HCI_Event_Connection_Complete(Packet): 

2887 """ 

2888 7.7.3 Connection Complete event 

2889 """ 

2890 name = "HCI_Connection_Complete" 

2891 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

2892 fields_desc = [ByteEnumField('status', 0, _bluetooth_error_codes), 

2893 LEShortField("connection_handle", 0x0100), 

2894 LEMACField("bd_addr", None), 

2895 ByteEnumField("link_type", 0, {0: "SCO connection", 

2896 1: "ACL connection", }), 

2897 ByteEnumField("encryption_enabled", 0, 

2898 {0: "link level encryption disabled", 

2899 1: "link level encryption enabled", }), ] 

2900 

2901 

2902class HCI_Event_Connection_Request(Packet): 

2903 """ 

2904 7.7.4 Connection Request event 

2905 """ 

2906 name = "HCI_Connection_Request" 

2907 fields_desc = [LEMACField("bd_addr", None), 

2908 XLE3BytesField("device_class", 0), 

2909 ByteEnumField("link_type", 0, {0: "SCO connection", 

2910 1: "ACL connection", 

2911 2: "eSCO connection", }), ] 

2912 

2913 

2914class HCI_Event_Disconnection_Complete(Packet): 

2915 """ 

2916 7.7.5 Disconnection Complete event 

2917 """ 

2918 name = "HCI_Disconnection_Complete" 

2919 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

2920 fields_desc = [ByteEnumField("status", 0, _bluetooth_error_codes), 

2921 LEShortField("connection_handle", 0), 

2922 XByteField("reason", 0), ] 

2923 

2924 

2925class HCI_Event_Authentication_Complete(Packet): 

2926 """ 

2927 7.7.6 Authentication Complete event 

2928 """ 

2929 name = "HCI_Authientication_Complete" 

2930 fields_desc = [ 

2931 ByteField("status", 0x00), 

2932 ShortField("connection_handle", 0x0000), 

2933 ] 

2934 

2935 

2936class HCI_Event_Remote_Name_Request_Complete(Packet): 

2937 """ 

2938 7.7.7 Remote Name Request Complete event 

2939 """ 

2940 name = "HCI_Remote_Name_Request_Complete" 

2941 fields_desc = [ByteEnumField("status", 0, _bluetooth_error_codes), 

2942 LEMACField("bd_addr", None), 

2943 StrFixedLenField("remote_name", b"\x00", 248), ] 

2944 

2945 

2946class HCI_Event_Encryption_Change(Packet): 

2947 """ 

2948 7.7.8 Encryption Change event 

2949 """ 

2950 name = "HCI_Encryption_Change" 

2951 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

2952 fields_desc = [ByteEnumField("status", 0, {0: "change has occurred"}), 

2953 LEShortField("connection_handle", 0), 

2954 ByteEnumField("enabled", 0, {0: "OFF", 1: "ON (LE)", 2: "ON (BR/EDR)"}), ] # noqa: E501 

2955 

2956 

2957class HCI_Event_Read_Remote_Supported_Features_Complete(Packet): 

2958 """ 

2959 7.7.11 Read Remote Supported Features Complete event 

2960 """ 

2961 name = "HCI_Read_Remote_Supported_Features_Complete" 

2962 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

2963 fields_desc = [ 

2964 ByteEnumField('status', 0, _bluetooth_error_codes), 

2965 LEShortField('connection_handle', 0), 

2966 FlagsField('lmp_features', 0, -64, _bluetooth_features) 

2967 ] 

2968 

2969 

2970class HCI_Event_Remote_Host_Supported_Features_Notification(Packet): 

2971 """ 

2972 7.7.50 Remote Host Supported Features Notification event 

2973 """ 

2974 name = "HCI_Remote_Host_Supported_Features_Notification" 

2975 fields_desc = [ 

2976 LEMACField('bd_addr', None), 

2977 XLELongField('host_supported_features', 0) 

2978 ] 

2979 

2980 

2981class HCI_Event_Read_Remote_Version_Information_Complete(Packet): 

2982 """ 

2983 7.7.12 Read Remote Version Information Complete event 

2984 """ 

2985 name = "HCI_Read_Remote_Version_Information" 

2986 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

2987 fields_desc = [ 

2988 ByteEnumField('status', 0, _bluetooth_error_codes), 

2989 LEShortField('connection_handle', 0), 

2990 ByteField('version', 0x00), 

2991 LEShortField('manufacturer_name', 0x0000), 

2992 LEShortField('subversion', 0x0000) 

2993 ] 

2994 

2995 

2996class HCI_Event_Command_Complete(Packet): 

2997 """ 

2998 7.7.14 Command Complete event 

2999 """ 

3000 name = "HCI_Command_Complete" 

3001 fields_desc = [ByteField("number", 0), 

3002 XLEShortField("opcode", 0), 

3003 ByteEnumField("status", 0, _bluetooth_error_codes)] 

3004 

3005 def answers(self, other): 

3006 if HCI_Command_Hdr not in other: 

3007 return False 

3008 

3009 return other[HCI_Command_Hdr].opcode == self.opcode 

3010 

3011 

3012class HCI_Event_Command_Status(Packet): 

3013 """ 

3014 7.7.15 Command Status event 

3015 """ 

3016 name = "HCI_Command_Status" 

3017 fields_desc = [ByteEnumField("status", 0, {0: "pending"}), 

3018 ByteField("number", 0), 

3019 XLEShortField("opcode", None), ] 

3020 

3021 def answers(self, other): 

3022 if HCI_Command_Hdr not in other: 

3023 return False 

3024 

3025 return other[HCI_Command_Hdr].opcode == self.opcode 

3026 

3027 

3028class HCI_Event_Role_Change(Packet): 

3029 """ 

3030 7.7.18 Role Change event 

3031 """ 

3032 name = "HCI_Role_Change_event" 

3033 fields_desc = [ByteField("status", 0x00), 

3034 LEMACField("bd_addr", None), 

3035 ByteField("new_role", 0x00)] 

3036 

3037 

3038class HCI_Event_Number_Of_Completed_Packets(Packet): 

3039 """ 

3040 7.7.19 Number Of Completed Packets event 

3041 """ 

3042 name = "HCI_Number_Of_Completed_Packets" 

3043 fields_desc = [ByteField("num_handles", 0), 

3044 FieldListField("connection_handle_list", None, 

3045 LEShortField("connection_handle", 0), 

3046 count_from=lambda p: p.num_handles), 

3047 FieldListField("num_completed_packets_list", None, 

3048 LEShortField("num_completed_packets", 0), 

3049 count_from=lambda p: p.num_handles)] 

3050 

3051 

3052class HCI_Event_Link_Key_Request(Packet): 

3053 """ 

3054 7.7.23 Link Key Request event 

3055 """ 

3056 name = 'HCI_Link_Key_Request' 

3057 fields_desc = [ 

3058 LEMACField('bd_addr', None) 

3059 ] 

3060 

3061 

3062class HCI_Event_Inquiry_Result_With_Rssi(Packet): 

3063 """ 

3064 7.7.33 Inquiry Result with RSSI event 

3065 """ 

3066 name = "HCI_Inquiry_Result_with_RSSI" 

3067 fields_desc = [ 

3068 ByteField("num_response", 0x00), 

3069 FieldListField("bd_addr", None, LEMACField("", None), 

3070 count_from=lambda p: p.num_response), 

3071 FieldListField("page_scan_repetition_mode", None, ByteField("", 0), 

3072 count_from=lambda p: p.num_response), 

3073 FieldListField("reserved", None, LEShortField("", 0), 

3074 count_from=lambda p: p.num_response), 

3075 FieldListField("device_class", None, XLE3BytesField("", 0), 

3076 count_from=lambda p: p.num_response), 

3077 FieldListField("clock_offset", None, LEShortField("", 0), 

3078 count_from=lambda p: p.num_response), 

3079 FieldListField("rssi", None, SignedByteField("", 0), 

3080 count_from=lambda p: p.num_response) 

3081 ] 

3082 

3083 

3084class HCI_Event_Read_Remote_Extended_Features_Complete(Packet): 

3085 """ 

3086 7.7.34 Read Remote Extended Features Complete event 

3087 """ 

3088 name = "HCI_Read_Remote_Extended_Features_Complete" 

3089 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

3090 fields_desc = [ 

3091 ByteEnumField('status', 0, _bluetooth_error_codes), 

3092 LEShortField('connection_handle', 0), 

3093 ByteField('page', 0x00), 

3094 ByteField('max_page', 0x00), 

3095 XLELongField('extended_features', 0) 

3096 ] 

3097 

3098 

3099class HCI_Event_Extended_Inquiry_Result(Packet): 

3100 """ 

3101 7.7.38 Extended Inquiry Result event 

3102 """ 

3103 name = "HCI_Extended_Inquiry_Result" 

3104 fields_desc = [ 

3105 ByteField('num_response', 0x01), 

3106 LEMACField('bd_addr', None), 

3107 ByteField('page_scan_repetition_mode', 0x00), 

3108 ByteField('reserved', 0x00), 

3109 XLE3BytesField('device_class', 0x000000), 

3110 LEShortField('clock_offset', 0x0000), 

3111 SignedByteField('rssi', 0x00), 

3112 HCI_Extended_Inquiry_Response, 

3113 ] 

3114 

3115 

3116class HCI_Event_IO_Capability_Response(Packet): 

3117 """ 

3118 7.7.41 IO Capability Response event 

3119 """ 

3120 name = "HCI_IO_Capability_Response" 

3121 fields_desc = [ 

3122 LEMACField('bd_addr', None), 

3123 ByteField('io_capability', 0x00), 

3124 ByteField('oob_data_present', 0x00), 

3125 ByteField('authentication_requirements', 0x00) 

3126 ] 

3127 

3128 

3129class HCI_Event_Vendor(Packet): 

3130 """ 

3131 Vendor-Specific Debug event (event code 0xFF). 

3132 

3133 Bluetooth Core 5.4, Vol 4, Part E, section 5.4.4 reserves 0xFF for 

3134 vendor-specific debugging events; the format of the parameters is 

3135 vendor-defined, so by default the parameters are exposed as a raw ``data`` 

3136 byte string. 

3137 

3138 Several vendors reuse this single event code with incompatible parameter 

3139 layouts, so ``code=0xFF`` alone is not enough to pick a dissector and 

3140 :func:`~scapy.packet.bind_layers` cannot be used. Instead a vendor 

3141 registers a dissector with :meth:`register_handler`, providing a 

3142 ``check(body)`` that recognises its own parameter layout (typically a 

3143 fixed leading subcode). :meth:`dispatch_hook` then dissects a matching 

3144 body with that class, so several vendor contribs coexist. When no check 

3145 claims the body, ``HCI_Event_Vendor`` itself is used and the body stays in 

3146 ``data``, exactly as before. 

3147 

3148 Handlers should subclass ``HCI_Event_Vendor`` and set ``match_subclass``, 

3149 so that ``HCI_Event_Vendor in pkt`` keeps matching vendor events:: 

3150 

3151 class HCI_Event_Vendor_Foo(HCI_Event_Vendor): 

3152 name = "HCI_Vendor_Foo" 

3153 match_subclass = True 

3154 fields_desc = [XByteField("subcode", 0xa5), 

3155 ByteField("value", 0)] 

3156 

3157 @classmethod 

3158 def check(cls, body): 

3159 return body[:1] == b"\\xa5" 

3160 

3161 HCI_Event_Vendor.register_handler(HCI_Event_Vendor_Foo) 

3162 """ 

3163 name = "HCI_Vendor_Specific" 

3164 fields_desc = [StrLenField("data", b"", 

3165 length_from=lambda pkt: pkt.underlayer.len)] 

3166 

3167 registered_handlers = {} 

3168 

3169 @classmethod 

3170 def register_handler(cls, handler_cls, check=None): 

3171 """ 

3172 Registers a vendor dissector for the ``code=0xFF`` event body. 

3173 

3174 This event is shared across vendors with incompatible parameter 

3175 layouts, so a contrib cannot simply bind its layer to it. Instead each 

3176 vendor handler declares a ``check`` that returns True only for its own 

3177 body (typically by testing a fixed leading subcode) and registers 

3178 itself here. The first registered check that accepts a body wins, so 

3179 checks should be as specific as possible. Re-registering the same 

3180 ``handler_cls`` replaces its previous entry, so reloading a contrib is 

3181 idempotent. 

3182 

3183 :param Type[scapy.packet.Packet] handler_cls: 

3184 A reference to a Packet subclass to dissect the event body with. 

3185 It should subclass ``HCI_Event_Vendor``. 

3186 :param Callable[[bytes], bool] check: 

3187 (optional) callable used to decide whether a body should be 

3188 associated with this handler. If not supplied, 

3189 ``handler_cls.check`` is used instead. 

3190 :raises TypeError: If ``check`` is not specified, 

3191 and ``handler_cls.check`` is not implemented. 

3192 """ 

3193 if check is None: 

3194 if hasattr(handler_cls, "check"): 

3195 check = handler_cls.check 

3196 else: 

3197 raise TypeError("check not specified, and {} has no " 

3198 "attribute check".format(handler_cls)) 

3199 

3200 cls.registered_handlers[handler_cls] = check 

3201 

3202 @classmethod 

3203 def dispatch_hook(cls, _pkt=None, *args, **kargs): 

3204 if _pkt: 

3205 for handler_cls, check in cls.registered_handlers.items(): 

3206 if check(_pkt): 

3207 return handler_cls 

3208 return cls 

3209 

3210 

3211class HCI_Event_LE_Meta(Packet): 

3212 """ 

3213 7.7.65 LE Meta event 

3214 """ 

3215 name = "HCI_LE_Meta" 

3216 fields_desc = [ByteEnumField("event", 0, { 

3217 0x01: "connection_complete", 

3218 0x02: "advertising_report", 

3219 0x03: "connection_update_complete", 

3220 0x04: "read_remote_features_page_0_complete", 

3221 0x05: "long_term_key_request", 

3222 0x06: "remote_connection_parameter_request", 

3223 0x07: "data_length_change", 

3224 0x08: "read_local_p256_public_key_complete", 

3225 0x09: "generate_dhkey_complete", 

3226 0x0a: "enhanced_connection_complete_v1", 

3227 0x0b: "directed_advertising_report", 

3228 0x0c: "phy_update_complete", 

3229 0x0d: "extended_advertising_report", 

3230 0x29: "enhanced_connection_complete_v2" 

3231 }), ] 

3232 

3233 def answers(self, other): 

3234 if not self.payload: 

3235 return False 

3236 

3237 # Delegate answers to payload 

3238 return self.payload.answers(other) 

3239 

3240 

3241class HCI_Cmd_Complete_Read_Local_Name(Packet): 

3242 """ 

3243 7.3.12 Read Local Name command complete 

3244 """ 

3245 name = 'Read Local Name command complete' 

3246 fields_desc = [StrFixedLenField('local_name', '', length=248)] 

3247 

3248 

3249class HCI_Cmd_Complete_Read_Local_Version_Information(Packet): 

3250 """ 

3251 7.4.1 Read Local Version Information command complete 

3252 """ 

3253 name = 'Read Local Version Information' 

3254 fields_desc = [ 

3255 ByteEnumField('hci_version', 0, _bluetooth_core_specification_versions), 

3256 LEShortField('hci_subversion', 0), 

3257 ByteEnumField('lmp_version', 0, _bluetooth_core_specification_versions), 

3258 LEShortEnumField('company_identifier', 0, BLUETOOTH_CORE_COMPANY_IDENTIFIERS), 

3259 LEShortField('lmp_subversion', 0)] 

3260 

3261 

3262class HCI_Cmd_Complete_Read_Local_Extended_Features(Packet): 

3263 """ 

3264 7.4.4 Read Local Extended Features command complete 

3265 """ 

3266 name = 'Read Local Extended Features command complete' 

3267 fields_desc = [ 

3268 ByteField('page', 0x00), 

3269 ByteField('max_page', 0x00), 

3270 XLELongField('extended_features', 0) 

3271 ] 

3272 

3273 

3274class HCI_Cmd_Complete_Read_BD_Addr(Packet): 

3275 """ 

3276 7.4.6 Read BD_ADDR command complete 

3277 """ 

3278 name = "Read BD Addr" 

3279 fields_desc = [LEMACField("bd_addr", None), ] 

3280 deprecated_fields = {"addr": ("bd_addr", "2.8.0")} 

3281 

3282 

3283class HCI_Cmd_Complete_LE_Read_White_List_Size(Packet): 

3284 name = "LE Read White List Size" 

3285 fields_desc = [ByteField("status", 0), 

3286 ByteField("size", 0), ] 

3287 

3288 

3289class HCI_LE_Meta_Connection_Complete(Packet): 

3290 name = "Connection Complete" 

3291 fields_desc = [ByteEnumField("status", 0, {0: "success"}), 

3292 LEShortField("connection_handle", 0), 

3293 ByteEnumField("role", 0, {0: "master"}), 

3294 ByteEnumField("peer_addr_type", 0, {0: "public", 1: "random"}), 

3295 LEMACField("peer_addr", None), 

3296 LEShortField("interval", 54), 

3297 LEShortField("latency", 0), 

3298 LEShortField("supervision", 42), 

3299 XByteField("master_clock_accuracy", 5)] 

3300 deprecated_fields = { 

3301 "handle": ("connection_handle", "2.8.0"), 

3302 "patype": ("peer_addr_type", "2.7.0"), 

3303 "paddr": ("peer_addr", "2.7.0"), 

3304 "clock_latency": ("master_clock_accuracy", "2.7.0"), 

3305 } 

3306 

3307 def answers(self, other): 

3308 if HCI_Cmd_LE_Create_Connection in other: 

3309 cmd = other[HCI_Cmd_LE_Create_Connection] 

3310 elif HCI_Cmd_LE_Extended_Create_Connection in other: 

3311 cmd = other[HCI_Cmd_LE_Extended_Create_Connection] 

3312 else: 

3313 return False 

3314 

3315 return (cmd.peer_addr_type == self.peer_addr_type and 

3316 cmd.peer_addr == self.peer_addr) 

3317 

3318 

3319class HCI_LE_Meta_Enhanced_Connection_Complete(Packet): 

3320 name = 'LE Enhanced Connection Complete' 

3321 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

3322 fields_desc = [ByteEnumField('status', 0, {0: 'success'}), 

3323 LEShortField('connection_handle', 0), 

3324 ByteEnumField('role', 0, {0: 'master', 1: 'slave'}), 

3325 ByteEnumField('peer_addr_type', 0, { 

3326 0: 'public', 

3327 1: 'random', 

3328 2: 'public_identity', 

3329 3: 'random_identity'}), 

3330 LEMACField('peer_addr', None), 

3331 LEMACField('local_rpa', None), 

3332 LEMACField('peer_rpa', None), 

3333 LEShortField('interval', 54), 

3334 LEShortField('latency', 0), 

3335 LEShortField('supervision', 42), 

3336 XByteField('master_clock_accuracy', 5)] 

3337 

3338 def answers(self, other): 

3339 if HCI_Cmd_LE_Create_Connection in other: 

3340 cmd = other[HCI_Cmd_LE_Create_Connection] 

3341 elif HCI_Cmd_LE_Extended_Create_Connection in other: 

3342 cmd = other[HCI_Cmd_LE_Extended_Create_Connection] 

3343 else: 

3344 return False 

3345 

3346 return cmd.peer_addr_type == self.peer_addr_type and cmd.peer_addr == self.peer_addr # noqa: E501 

3347 

3348 

3349class HCI_LE_Meta_Connection_Update_Complete(Packet): 

3350 name = "Connection Update Complete" 

3351 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

3352 fields_desc = [ByteEnumField("status", 0, {0: "success"}), 

3353 LEShortField("connection_handle", 0), 

3354 LEShortField("interval", 54), 

3355 LEShortField("latency", 0), 

3356 LEShortField("timeout", 42), ] 

3357 

3358 

3359class HCI_LE_Meta_LE_Read_Remote_Features_Complete(Packet): 

3360 name = "LE Read Remote Features Complete" 

3361 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

3362 fields_desc = [ByteEnumField("status", 0, _bluetooth_error_codes), 

3363 LEShortField("connection_handle", 0), 

3364 XLELongField("le_features", 0)] 

3365 

3366 

3367class HCI_LE_Meta_Advertising_Report(Packet): 

3368 name = "Advertising Report" 

3369 fields_desc = [ByteEnumField("type", 0, {0: "conn_und", 4: "scan_rsp"}), 

3370 ByteEnumField("addr_type", 0, {0: "public", 1: "random"}), 

3371 LEMACField("addr", None), 

3372 FieldLenField("len", None, length_of="data", fmt="B"), 

3373 PacketListField("data", [], EIR_Hdr, 

3374 length_from=lambda pkt: pkt.len), 

3375 SignedByteField("rssi", 0)] 

3376 deprecated_fields = {"atype": ("addr_type", "2.7.0")} 

3377 

3378 def extract_padding(self, s): 

3379 return '', s 

3380 

3381 

3382class HCI_LE_Meta_Advertising_Reports(Packet): 

3383 name = "Advertising Reports" 

3384 fields_desc = [FieldLenField("len", None, count_of="reports", fmt="B"), 

3385 PacketListField("reports", None, 

3386 HCI_LE_Meta_Advertising_Report, 

3387 count_from=lambda pkt: pkt.len)] 

3388 

3389 

3390class HCI_LE_Meta_Long_Term_Key_Request(Packet): 

3391 name = "Long Term Key Request" 

3392 deprecated_fields = {"handle": ("connection_handle", "2.8.0")} 

3393 fields_desc = [LEShortField("connection_handle", 0), 

3394 StrFixedLenField("rand", None, 8), 

3395 XLEShortField("ediv", 0), ] 

3396 

3397 

3398class HCI_LE_Meta_Extended_Advertising_Report(Packet): 

3399 name = "Extended Advertising Report" 

3400 fields_desc = [ 

3401 BitField("reserved0", 0, 1), 

3402 BitEnumField("data_status", 0, 2, { 

3403 0b00: "complete", 

3404 0b01: "incomplete", 

3405 0b10: "incomplete_truncated", 

3406 0b11: "reserved" 

3407 }), 

3408 BitField("legacy", 0, 1), 

3409 BitField("scan_response", 0, 1), 

3410 BitField("directed", 0, 1), 

3411 BitField("scannable", 0, 1), 

3412 BitField("connectable", 0, 1), 

3413 ByteField("reserved", 0), 

3414 ByteEnumField("addr_type", 0, { 

3415 0x00: "public_device_address", 

3416 0x01: "random_device_address", 

3417 0x02: "public_identity_address", 

3418 0x03: "random_identity_address", 

3419 0xff: "anonymous" 

3420 }), 

3421 LEMACField('addr', None), 

3422 ByteEnumField("primary_phy", 0, { 

3423 0x01: "le_1m", 

3424 0x03: "le_coded_s8", 

3425 0x04: "le_coded_s2" 

3426 }), 

3427 ByteEnumField("secondary_phy", 0, { 

3428 0x01: "le_1m", 

3429 0x02: "le_2m", 

3430 0x03: "le_coded_s8", 

3431 0x04: "le_coded_s2" 

3432 }), 

3433 ByteField("advertising_sid", 0xff), 

3434 ByteField("tx_power", 0x7f), 

3435 SignedByteField("rssi", 0x00), 

3436 LEShortField("periodic_advertising_interval", 0x0000), 

3437 ByteEnumField("direct_addr_type", 0, { 

3438 0x00: "public_device_address", 

3439 0x01: "non_resolvable_private_address", 

3440 0x02: "resolvable_private_address_resolved_0", 

3441 0x03: "resolvable_private_address_resolved_1", 

3442 0xfe: "resolvable_private_address_unable_resolve"}), 

3443 LEMACField("direct_addr", None), 

3444 FieldLenField("data_length", None, length_of="data", fmt="B"), 

3445 PacketListField("data", [], EIR_Hdr, 

3446 length_from=lambda pkt: pkt.data_length), 

3447 ] 

3448 deprecated_fields = { 

3449 "address_type": ("addr_type", "2.7.0"), 

3450 "address": ("addr", "2.7.0"), 

3451 "direct_address_type": ("direct_addr_type", "2.7.0"), 

3452 "direct_address": ("direct_addr", "2.7.0"), 

3453 } 

3454 

3455 def extract_padding(self, s): 

3456 return '', s 

3457 

3458 

3459class HCI_LE_Meta_Extended_Advertising_Reports(Packet): 

3460 name = "Extended Advertising Reports" 

3461 fields_desc = [FieldLenField("num_reports", None, count_of="reports", fmt="B"), 

3462 PacketListField("reports", None, 

3463 HCI_LE_Meta_Extended_Advertising_Report, 

3464 count_from=lambda pkt: pkt.num_reports)] 

3465 

3466 

3467bind_layers(HCI_PHDR_Hdr, HCI_Hdr) 

3468 

3469bind_layers(HCI_Hdr, HCI_Command_Hdr, type=1) 

3470bind_layers(HCI_Hdr, HCI_ACL_Hdr, type=2) 

3471bind_layers(HCI_Hdr, HCI_Event_Hdr, type=4) 

3472bind_layers(HCI_Hdr, conf.raw_layer,) 

3473 

3474conf.l2types.register(DLT_BLUETOOTH_HCI_H4, HCI_Hdr) 

3475conf.l2types.register(DLT_BLUETOOTH_HCI_H4_WITH_PHDR, HCI_PHDR_Hdr) 

3476 

3477 

3478# 7.1 LINK CONTROL COMMANDS, the OGF is defined as 0x01 

3479bind_layers(HCI_Command_Hdr, HCI_Cmd_Inquiry, ogf=0x01, ocf=0x0001) 

3480bind_layers(HCI_Command_Hdr, HCI_Cmd_Inquiry_Cancel, ogf=0x01, ocf=0x0002) 

3481bind_layers(HCI_Command_Hdr, HCI_Cmd_Periodic_Inquiry_Mode, ogf=0x01, ocf=0x0003) 

3482bind_layers(HCI_Command_Hdr, HCI_Cmd_Exit_Peiodic_Inquiry_Mode, ogf=0x01, ocf=0x0004) 

3483bind_layers(HCI_Command_Hdr, HCI_Cmd_Create_Connection, ogf=0x01, ocf=0x0005) 

3484bind_layers(HCI_Command_Hdr, HCI_Cmd_Disconnect, ogf=0x01, ocf=0x0006) 

3485bind_layers(HCI_Command_Hdr, HCI_Cmd_Create_Connection_Cancel, ogf=0x01, ocf=0x0008) 

3486bind_layers(HCI_Command_Hdr, HCI_Cmd_Accept_Connection_Request, ogf=0x01, ocf=0x0009) 

3487bind_layers(HCI_Command_Hdr, HCI_Cmd_Reject_Connection_Response, ogf=0x01, ocf=0x000a) 

3488bind_layers(HCI_Command_Hdr, HCI_Cmd_Link_Key_Request_Reply, ogf=0x01, ocf=0x000b) 

3489bind_layers(HCI_Command_Hdr, HCI_Cmd_Link_Key_Request_Negative_Reply, 

3490 ogf=0x01, ocf=0x000c) 

3491bind_layers(HCI_Command_Hdr, HCI_Cmd_PIN_Code_Request_Reply, ogf=0x01, ocf=0x000d) 

3492bind_layers(HCI_Command_Hdr, HCI_Cmd_Change_Connection_Packet_Type, 

3493 ogf=0x01, ocf=0x000f) 

3494bind_layers(HCI_Command_Hdr, HCI_Cmd_Authentication_Requested, ogf=0x01, ocf=0x0011) 

3495bind_layers(HCI_Command_Hdr, HCI_Cmd_Set_Connection_Encryption, ogf=0x01, ocf=0x0013) 

3496bind_layers(HCI_Command_Hdr, HCI_Cmd_Change_Connection_Link_Key, ogf=0x01, ocf=0x0017) 

3497bind_layers(HCI_Command_Hdr, HCI_Cmd_Remote_Name_Request, ogf=0x01, ocf=0x0019) 

3498bind_layers(HCI_Command_Hdr, HCI_Cmd_Remote_Name_Request_Cancel, ogf=0x01, ocf=0x001a) 

3499bind_layers(HCI_Command_Hdr, HCI_Cmd_Read_Remote_Supported_Features, 

3500 ogf=0x01, ocf=0x001b) 

3501bind_layers(HCI_Command_Hdr, HCI_Cmd_Read_Remote_Extended_Features, 

3502 ogf=0x01, ocf=0x001c) 

3503bind_layers(HCI_Command_Hdr, HCI_Cmd_IO_Capability_Request_Reply, ogf=0x01, ocf=0x002b) 

3504bind_layers(HCI_Command_Hdr, HCI_Cmd_User_Confirmation_Request_Reply, 

3505 ogf=0x01, ocf=0x002c) 

3506bind_layers(HCI_Command_Hdr, HCI_Cmd_User_Confirmation_Request_Negative_Reply, 

3507 ogf=0x01, ocf=0x002d) 

3508bind_layers(HCI_Command_Hdr, HCI_Cmd_User_Passkey_Request_Reply, ogf=0x01, ocf=0x002e) 

3509bind_layers(HCI_Command_Hdr, HCI_Cmd_User_Passkey_Request_Negative_Reply, 

3510 ogf=0x01, ocf=0x002f) 

3511bind_layers(HCI_Command_Hdr, HCI_Cmd_Remote_OOB_Data_Request_Reply, 

3512 ogf=0x01, ocf=0x0030) 

3513bind_layers(HCI_Command_Hdr, HCI_Cmd_Remote_OOB_Data_Request_Negative_Reply, 

3514 ogf=0x01, ocf=0x0033) 

3515 

3516# 7.2 Link Policy commands, the OGF is defined as 0x02 

3517bind_layers(HCI_Command_Hdr, HCI_Cmd_Hold_Mode, ogf=0x02, ocf=0x0001) 

3518bind_layers(HCI_Command_Hdr, HCI_Cmd_Switch_Role, ogf=0x02, ocf=0x000B) 

3519 

3520# 7.3 CONTROLLER & BASEBAND COMMANDS, the OGF is defined as 0x03 

3521bind_layers(HCI_Command_Hdr, HCI_Cmd_Set_Event_Mask, ogf=0x03, ocf=0x0001) 

3522bind_layers(HCI_Command_Hdr, HCI_Cmd_Reset, ogf=0x03, ocf=0x0003) 

3523bind_layers(HCI_Command_Hdr, HCI_Cmd_Set_Event_Filter, ogf=0x03, ocf=0x0005) 

3524bind_layers(HCI_Command_Hdr, HCI_Cmd_Write_Local_Name, ogf=0x03, ocf=0x0013) 

3525bind_layers(HCI_Command_Hdr, HCI_Cmd_Read_Local_Name, ogf=0x03, ocf=0x0014) 

3526bind_layers(HCI_Command_Hdr, HCI_Cmd_Write_Connect_Accept_Timeout, ogf=0x03, ocf=0x0016) 

3527bind_layers(HCI_Command_Hdr, HCI_Cmd_Write_Extended_Inquiry_Response, ogf=0x03, ocf=0x0052) # noqa: E501 

3528bind_layers(HCI_Command_Hdr, HCI_Cmd_Read_Simple_Pairing_Mode, ogf=0x03, ocf=0x0055) 

3529bind_layers(HCI_Command_Hdr, HCI_Cmd_Write_Simple_Pairing_Mode, ogf=0x03, ocf=0x0056) 

3530bind_layers(HCI_Command_Hdr, HCI_Cmd_Read_LE_Host_Support, ogf=0x03, ocf=0x006c) 

3531bind_layers(HCI_Command_Hdr, HCI_Cmd_Write_LE_Host_Support, ogf=0x03, ocf=0x006d) 

3532 

3533# 7.4 INFORMATIONAL PARAMETERS, the OGF is defined as 0x04 

3534bind_layers(HCI_Command_Hdr, HCI_Cmd_Read_Local_Version_Information, ogf=0x04, ocf=0x0001) # noqa: E501 

3535bind_layers(HCI_Command_Hdr, HCI_Cmd_Read_Local_Extended_Features, ogf=0x04, ocf=0x0004) 

3536bind_layers(HCI_Command_Hdr, HCI_Cmd_Read_BD_Addr, ogf=0x04, ocf=0x0009) 

3537 

3538# 7.5 STATUS PARAMETERS, the OGF is defined as 0x05 

3539bind_layers(HCI_Command_Hdr, HCI_Cmd_Read_Link_Quality, ogf=0x05, ocf=0x0003) 

3540bind_layers(HCI_Command_Hdr, HCI_Cmd_Read_RSSI, ogf=0x05, ocf=0x0005) 

3541 

3542# 7.6 TESTING COMMANDS, the OGF is defined as 0x06 

3543bind_layers(HCI_Command_Hdr, HCI_Cmd_Read_Loopback_Mode, ogf=0x06, ocf=0x0001) 

3544bind_layers(HCI_Command_Hdr, HCI_Cmd_Write_Loopback_Mode, ogf=0x06, ocf=0x0002) 

3545 

3546# 7.8 LE CONTROLLER COMMANDS, the OGF code is defined as 0x08 

3547bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Set_Event_Mask, ogf=0x08, ocf=0x0001) 

3548bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Read_Buffer_Size_V1, ogf=0x08, ocf=0x0002) 

3549bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Read_Buffer_Size_V2, ogf=0x08, ocf=0x0060) 

3550bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Read_Local_Supported_Features, 

3551 ogf=0x08, ocf=0x0003) 

3552bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Set_Random_Address, ogf=0x08, ocf=0x0005) 

3553bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Set_Advertising_Parameters, ogf=0x08, ocf=0x0006) # noqa: E501 

3554bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Set_Advertising_Set_Random_Address, ogf=0x08, ocf=0x0035) # noqa: E501 

3555bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Set_Extended_Advertising_Parameters, ogf=0x08, ocf=0x0036) # noqa: E501 

3556bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Set_Advertising_Data, ogf=0x08, ocf=0x0008) 

3557bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Set_Extended_Advertising_Data, ogf=0x08, ocf=0x0037) # noqa: E501 

3558bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Set_Scan_Response_Data, ogf=0x08, ocf=0x0009) 

3559bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Set_Advertise_Enable, ogf=0x08, ocf=0x000a) 

3560bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Set_Extended_Advertise_Enable, ogf=0x08, ocf=0x0039) # noqa: E501 

3561bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Set_Scan_Parameters, ogf=0x08, ocf=0x000b) 

3562bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Set_Extended_Scan_Parameters, ogf=0x08, ocf=0x0041) # noqa: E501 

3563bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Set_Scan_Enable, ogf=0x08, ocf=0x000c) 

3564bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Set_Extended_Scan_Enable, ogf=0x08, ocf=0x0042) 

3565bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Create_Connection, ogf=0x08, ocf=0x000d) 

3566bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Extended_Create_Connection, ogf=0x08, ocf=0x0043) # noqa: E501 

3567bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Create_Connection_Cancel, ogf=0x08, ocf=0x000e) # noqa: E501 

3568bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Read_Filter_Accept_List_Size, 

3569 ogf=0x08, ocf=0x000f) 

3570bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Clear_Filter_Accept_List, ogf=0x08, ocf=0x0010) 

3571bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Add_Device_To_Filter_Accept_List, ogf=0x08, ocf=0x0011) # noqa: E501 

3572bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Remove_Device_From_Filter_Accept_List, ogf=0x08, ocf=0x0012) # noqa: E501 

3573bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Connection_Update, ogf=0x08, ocf=0x0013) 

3574bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Read_Remote_Features, ogf=0x08, ocf=0x0016) # noqa: E501 

3575bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Enable_Encryption, ogf=0x08, ocf=0x0019) # noqa: E501 

3576bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Long_Term_Key_Request_Reply, ogf=0x08, ocf=0x001a) # noqa: E501 

3577bind_layers(HCI_Command_Hdr, HCI_Cmd_LE_Long_Term_Key_Request_Negative_Reply, ogf=0x08, ocf=0x001b) # noqa: E501 

3578 

3579# 7.7 EVENTS 

3580bind_layers(HCI_Event_Hdr, HCI_Event_Inquiry_Complete, code=0x01) 

3581bind_layers(HCI_Event_Hdr, HCI_Event_Inquiry_Result, code=0x02) 

3582bind_layers(HCI_Event_Hdr, HCI_Event_Connection_Complete, code=0x03) 

3583bind_layers(HCI_Event_Hdr, HCI_Event_Connection_Request, code=0x04) 

3584bind_layers(HCI_Event_Hdr, HCI_Event_Disconnection_Complete, code=0x05) 

3585bind_layers(HCI_Event_Hdr, HCI_Event_Authentication_Complete, code=0x06) 

3586bind_layers(HCI_Event_Hdr, HCI_Event_Remote_Name_Request_Complete, code=0x07) 

3587bind_layers(HCI_Event_Hdr, HCI_Event_Encryption_Change, code=0x08) 

3588bind_layers(HCI_Event_Hdr, HCI_Event_Read_Remote_Supported_Features_Complete, code=0x0b) 

3589bind_layers(HCI_Event_Hdr, HCI_Event_Read_Remote_Version_Information_Complete, code=0x0c) # noqa: E501 

3590bind_layers(HCI_Event_Hdr, HCI_Event_Command_Complete, code=0x0e) 

3591bind_layers(HCI_Event_Hdr, HCI_Event_Command_Status, code=0x0f) 

3592bind_layers(HCI_Event_Hdr, HCI_Event_Role_Change, code=0x12) 

3593bind_layers(HCI_Event_Hdr, HCI_Event_Number_Of_Completed_Packets, code=0x13) 

3594bind_layers(HCI_Event_Hdr, HCI_Event_Link_Key_Request, code=0x17) 

3595bind_layers(HCI_Event_Hdr, HCI_Event_Inquiry_Result_With_Rssi, code=0x22) 

3596bind_layers(HCI_Event_Hdr, HCI_Event_Read_Remote_Extended_Features_Complete, code=0x23) 

3597bind_layers(HCI_Event_Hdr, HCI_Event_Extended_Inquiry_Result, code=0x2f) 

3598bind_layers(HCI_Event_Hdr, HCI_Event_IO_Capability_Response, code=0x32) 

3599bind_layers(HCI_Event_Hdr, HCI_Event_Remote_Host_Supported_Features_Notification, code=0x3d) # noqa: E501 

3600bind_layers(HCI_Event_Hdr, HCI_Event_LE_Meta, code=0x3e) 

3601bind_layers(HCI_Event_Hdr, HCI_Event_Vendor, code=0xff) 

3602 

3603bind_layers(HCI_Event_Command_Complete, HCI_Cmd_Complete_Read_Local_Name, opcode=0x0c14) # noqa: E501 

3604bind_layers(HCI_Event_Command_Complete, HCI_Cmd_Complete_Read_Local_Version_Information, opcode=0x1001) # noqa: E501 

3605bind_layers(HCI_Event_Command_Complete, HCI_Cmd_Complete_Read_Local_Extended_Features, opcode=0x1004) # noqa: E501 

3606bind_layers(HCI_Event_Command_Complete, HCI_Cmd_Complete_Read_BD_Addr, opcode=0x1009) # noqa: E501 

3607bind_layers(HCI_Event_Command_Complete, HCI_Cmd_Complete_LE_Read_White_List_Size, opcode=0x200f) # noqa: E501 

3608 

3609bind_layers(HCI_Event_LE_Meta, HCI_LE_Meta_Connection_Complete, event=0x01) 

3610bind_layers(HCI_Event_LE_Meta, HCI_LE_Meta_Enhanced_Connection_Complete, event=0x0a) 

3611bind_layers(HCI_Event_LE_Meta, HCI_LE_Meta_Advertising_Reports, event=0x02) 

3612bind_layers(HCI_Event_LE_Meta, HCI_LE_Meta_Connection_Update_Complete, event=0x03) 

3613bind_layers(HCI_Event_LE_Meta, HCI_LE_Meta_LE_Read_Remote_Features_Complete, event=0x04) # noqa: E501 

3614bind_layers(HCI_Event_LE_Meta, HCI_LE_Meta_Long_Term_Key_Request, event=0x05) 

3615bind_layers(HCI_Event_LE_Meta, HCI_LE_Meta_Extended_Advertising_Reports, event=0x0d) 

3616 

3617bind_layers(EIR_Hdr, EIR_Flags, type=0x01) 

3618bind_layers(EIR_Hdr, EIR_IncompleteList16BitServiceUUIDs, type=0x02) 

3619bind_layers(EIR_Hdr, EIR_CompleteList16BitServiceUUIDs, type=0x03) 

3620bind_layers(EIR_Hdr, EIR_IncompleteList32BitServiceUUIDs, type=0x04) 

3621bind_layers(EIR_Hdr, EIR_CompleteList32BitServiceUUIDs, type=0x05) 

3622bind_layers(EIR_Hdr, EIR_IncompleteList128BitServiceUUIDs, type=0x06) 

3623bind_layers(EIR_Hdr, EIR_CompleteList128BitServiceUUIDs, type=0x07) 

3624bind_layers(EIR_Hdr, EIR_ShortenedLocalName, type=0x08) 

3625bind_layers(EIR_Hdr, EIR_CompleteLocalName, type=0x09) 

3626bind_layers(EIR_Hdr, EIR_Device_ID, type=0x10) 

3627bind_layers(EIR_Hdr, EIR_TX_Power_Level, type=0x0a) 

3628bind_layers(EIR_Hdr, EIR_ClassOfDevice, type=0x0d) 

3629bind_layers(EIR_Hdr, EIR_SecureSimplePairingHashC192, type=0x0e) 

3630bind_layers(EIR_Hdr, EIR_SecureSimplePairingRandomizerR192, type=0x0f) 

3631bind_layers(EIR_Hdr, EIR_SecurityManagerOOBFlags, type=0x11) 

3632bind_layers(EIR_Hdr, EIR_PeripheralConnectionIntervalRange, type=0x12) 

3633bind_layers(EIR_Hdr, EIR_ServiceSolicitation16BitUUID, type=0x14) 

3634bind_layers(EIR_Hdr, EIR_ServiceSolicitation128BitUUID, type=0x15) 

3635bind_layers(EIR_Hdr, EIR_ServiceData16BitUUID, type=0x16) 

3636bind_layers(EIR_Hdr, EIR_PublicTargetAddress, type=0x17) 

3637bind_layers(EIR_Hdr, EIR_RandomTargetAddress, type=0x18) 

3638bind_layers(EIR_Hdr, EIR_Appearance, type=0x19) 

3639bind_layers(EIR_Hdr, EIR_AdvertisingInterval, type=0x1a) 

3640bind_layers(EIR_Hdr, EIR_LEBluetoothDeviceAddress, type=0x1b) 

3641bind_layers(EIR_Hdr, EIR_LERole, type=0x1c) 

3642bind_layers(EIR_Hdr, EIR_ServiceData32BitUUID, type=0x20) 

3643bind_layers(EIR_Hdr, EIR_ServiceData128BitUUID, type=0x21) 

3644bind_layers(EIR_Hdr, EIR_URI, type=0x24) 

3645bind_layers(EIR_Hdr, EIR_BroadcastName, type=0x30) 

3646bind_layers(EIR_Hdr, EIR_3DInformation, type=0x3d) 

3647bind_layers(EIR_Hdr, EIR_Manufacturer_Specific_Data, type=0xff) 

3648bind_layers(EIR_Hdr, EIR_Raw) 

3649 

3650bind_layers(HCI_ACL_Hdr, L2CAP_Hdr,) 

3651bind_layers(L2CAP_Hdr, L2CAP_CmdHdr, cid=1) 

3652bind_layers(L2CAP_Hdr, L2CAP_CmdHdr, cid=5) # LE L2CAP Signaling Channel 

3653bind_layers(L2CAP_CmdHdr, L2CAP_CmdRej, code=1) 

3654bind_layers(L2CAP_CmdHdr, L2CAP_ConnReq, code=2) 

3655bind_layers(L2CAP_CmdHdr, L2CAP_ConnResp, code=3) 

3656bind_layers(L2CAP_CmdHdr, L2CAP_ConfReq, code=4) 

3657bind_layers(L2CAP_CmdHdr, L2CAP_ConfResp, code=5) 

3658bind_layers(L2CAP_CmdHdr, L2CAP_DisconnReq, code=6) 

3659bind_layers(L2CAP_CmdHdr, L2CAP_DisconnResp, code=7) 

3660bind_layers(L2CAP_CmdHdr, L2CAP_EchoReq, code=8) 

3661bind_layers(L2CAP_CmdHdr, L2CAP_EchoResp, code=9) 

3662bind_layers(L2CAP_CmdHdr, L2CAP_InfoReq, code=10) 

3663bind_layers(L2CAP_CmdHdr, L2CAP_InfoResp, code=11) 

3664bind_layers(L2CAP_CmdHdr, L2CAP_Create_Channel_Request, code=12) 

3665bind_layers(L2CAP_CmdHdr, L2CAP_Create_Channel_Response, code=13) 

3666bind_layers(L2CAP_CmdHdr, L2CAP_Move_Channel_Request, code=14) 

3667bind_layers(L2CAP_CmdHdr, L2CAP_Move_Channel_Response, code=15) 

3668bind_layers(L2CAP_CmdHdr, L2CAP_Move_Channel_Confirmation_Request, code=16) 

3669bind_layers(L2CAP_CmdHdr, L2CAP_Move_Channel_Confirmation_Response, code=17) 

3670bind_layers(L2CAP_CmdHdr, L2CAP_Connection_Parameter_Update_Request, code=18) 

3671bind_layers(L2CAP_CmdHdr, L2CAP_Connection_Parameter_Update_Response, code=19) 

3672bind_layers(L2CAP_CmdHdr, L2CAP_LE_Credit_Based_Connection_Request, code=20) 

3673bind_layers(L2CAP_CmdHdr, L2CAP_LE_Credit_Based_Connection_Response, code=21) 

3674bind_layers(L2CAP_CmdHdr, L2CAP_Flow_Control_Credit_Ind, code=22) 

3675bind_layers(L2CAP_CmdHdr, L2CAP_Credit_Based_Connection_Request, code=23) 

3676bind_layers(L2CAP_CmdHdr, L2CAP_Credit_Based_Connection_Response, code=24) 

3677bind_layers(L2CAP_CmdHdr, L2CAP_Credit_Based_Reconfigure_Request, code=25) 

3678bind_layers(L2CAP_CmdHdr, L2CAP_Credit_Based_Reconfigure_Response, code=26) 

3679bind_layers(L2CAP_ConfReq, L2CAP_ConfSet) 

3680bind_layers(L2CAP_ConfResp, L2CAP_ConfSet) 

3681bind_layers(L2CAP_Hdr, ATT_Hdr, cid=4) 

3682bind_layers(ATT_Hdr, ATT_Error_Response, opcode=0x1) 

3683bind_layers(ATT_Hdr, ATT_Exchange_MTU_Request, opcode=0x2) 

3684bind_layers(ATT_Hdr, ATT_Exchange_MTU_Response, opcode=0x3) 

3685bind_layers(ATT_Hdr, ATT_Find_Information_Request, opcode=0x4) 

3686bind_layers(ATT_Hdr, ATT_Find_Information_Response, opcode=0x5) 

3687bind_layers(ATT_Hdr, ATT_Find_By_Type_Value_Request, opcode=0x6) 

3688bind_layers(ATT_Hdr, ATT_Find_By_Type_Value_Response, opcode=0x7) 

3689bind_layers(ATT_Hdr, ATT_Read_By_Type_Request_128bit, opcode=0x8) 

3690bind_layers(ATT_Hdr, ATT_Read_By_Type_Request, opcode=0x8) 

3691bind_layers(ATT_Hdr, ATT_Read_By_Type_Response, opcode=0x9) 

3692bind_layers(ATT_Hdr, ATT_Read_Request, opcode=0xa) 

3693bind_layers(ATT_Hdr, ATT_Read_Response, opcode=0xb) 

3694bind_layers(ATT_Hdr, ATT_Read_Blob_Request, opcode=0xc) 

3695bind_layers(ATT_Hdr, ATT_Read_Blob_Response, opcode=0xd) 

3696bind_layers(ATT_Hdr, ATT_Read_Multiple_Request, opcode=0xe) 

3697bind_layers(ATT_Hdr, ATT_Read_Multiple_Response, opcode=0xf) 

3698bind_layers(ATT_Hdr, ATT_Read_By_Group_Type_Request, opcode=0x10) 

3699bind_layers(ATT_Hdr, ATT_Read_By_Group_Type_Response, opcode=0x11) 

3700bind_layers(ATT_Hdr, ATT_Write_Request, opcode=0x12) 

3701bind_layers(ATT_Hdr, ATT_Write_Response, opcode=0x13) 

3702bind_layers(ATT_Hdr, ATT_Prepare_Write_Request, opcode=0x16) 

3703bind_layers(ATT_Hdr, ATT_Prepare_Write_Response, opcode=0x17) 

3704bind_layers(ATT_Hdr, ATT_Execute_Write_Request, opcode=0x18) 

3705bind_layers(ATT_Hdr, ATT_Execute_Write_Response, opcode=0x19) 

3706bind_layers(ATT_Hdr, ATT_Read_Multiple_Variable_Request, opcode=0x20) 

3707bind_layers(ATT_Hdr, ATT_Read_Multiple_Variable_Response, opcode=0x21) 

3708bind_layers(ATT_Hdr, ATT_Multiple_Handle_Value_Notification, opcode=0x23) 

3709bind_layers(ATT_Hdr, ATT_Write_Command, opcode=0x52) 

3710bind_layers(ATT_Hdr, ATT_Handle_Value_Notification, opcode=0x1b) 

3711bind_layers(ATT_Hdr, ATT_Handle_Value_Indication, opcode=0x1d) 

3712bind_layers(ATT_Hdr, ATT_Handle_Value_Confirmation, opcode=0x1e) 

3713bind_layers(ATT_Hdr, ATT_Signed_Write_Command, opcode=0xd2) 

3714bind_layers(L2CAP_Hdr, SM_Hdr, cid=6) 

3715bind_layers(SM_Hdr, SM_Pairing_Request, sm_command=0x01) 

3716bind_layers(SM_Hdr, SM_Pairing_Response, sm_command=0x02) 

3717bind_layers(SM_Hdr, SM_Confirm, sm_command=0x03) 

3718bind_layers(SM_Hdr, SM_Random, sm_command=0x04) 

3719bind_layers(SM_Hdr, SM_Failed, sm_command=0x05) 

3720bind_layers(SM_Hdr, SM_Encryption_Information, sm_command=0x06) 

3721bind_layers(SM_Hdr, SM_Master_Identification, sm_command=0x07) 

3722bind_layers(SM_Hdr, SM_Identity_Information, sm_command=0x08) 

3723bind_layers(SM_Hdr, SM_Identity_Address_Information, sm_command=0x09) 

3724bind_layers(SM_Hdr, SM_Signing_Information, sm_command=0x0a) 

3725bind_layers(SM_Hdr, SM_Security_Request, sm_command=0x0b) 

3726bind_layers(SM_Hdr, SM_Public_Key, sm_command=0x0c) 

3727bind_layers(SM_Hdr, SM_DHKey_Check, sm_command=0x0d) 

3728bind_layers(SM_Hdr, SM_Keypress_Notification, sm_command=0x0e) 

3729 

3730 

3731############### 

3732# HCI Monitor # 

3733############### 

3734 

3735 

3736# https://elixir.bootlin.com/linux/v6.4.2/source/include/net/bluetooth/hci_mon.h#L27 

3737class HCI_Mon_Hdr(Packet): 

3738 name = 'Bluetooth Linux Monitor Transport Header' 

3739 fields_desc = [ 

3740 LEShortEnumField('opcode', None, { 

3741 0: "New index", 

3742 1: "Delete index", 

3743 2: "Command pkt", 

3744 3: "Event pkt", 

3745 4: "ACL TX pkt", 

3746 5: "ACL RX pkt", 

3747 6: "SCO TX pkt", 

3748 7: "SCO RX pkt", 

3749 8: "Open index", 

3750 9: "Close index", 

3751 10: "Index info", 

3752 11: "Vendor diag", 

3753 12: "System note", 

3754 13: "User logging", 

3755 14: "Ctrl open", 

3756 15: "Ctrl close", 

3757 16: "Ctrl command", 

3758 17: "Ctrl event", 

3759 18: "ISO TX pkt", 

3760 19: "ISO RX pkt", 

3761 }), 

3762 LEShortField('adapter_id', None), 

3763 LEShortField('len', None) 

3764 ] 

3765 

3766 

3767# https://www.tcpdump.org/linktypes/LINKTYPE_BLUETOOTH_LINUX_MONITOR.html 

3768class HCI_Mon_Pcap_Hdr(HCI_Mon_Hdr): 

3769 name = 'Bluetooth Linux Monitor Transport Pcap Header' 

3770 fields_desc = [ 

3771 ShortField('adapter_id', None), 

3772 ShortField('opcode', None) 

3773 ] 

3774 

3775 

3776class HCI_Mon_New_Index(Packet): 

3777 name = 'Bluetooth Linux Monitor Transport New Index Packet' 

3778 fields_desc = [ 

3779 ByteEnumField('bus', 0, { 

3780 0x00: "BR/EDR", 

3781 0x01: "AMP" 

3782 }), 

3783 ByteEnumField('type', 0, { 

3784 0x00: "Virtual", 

3785 0x01: "USB", 

3786 0x02: "PC Card", 

3787 0x03: "UART", 

3788 0x04: "RS232", 

3789 0x05: "PCI", 

3790 0x06: "SDIO" 

3791 }), 

3792 LEMACField('addr', None), 

3793 StrFixedLenField('devname', None, 8) 

3794 ] 

3795 

3796 

3797class HCI_Mon_Index_Info(Packet): 

3798 name = 'Bluetooth Linux Monitor Transport Index Info Packet' 

3799 fields_desc = [ 

3800 LEMACField('addr', None), 

3801 XLEShortField('manufacturer', None) 

3802 ] 

3803 

3804 

3805class HCI_Mon_System_Note(Packet): 

3806 name = 'Bluetooth Linux Monitor Transport System Note Packet' 

3807 fields_desc = [ 

3808 StrNullField('note', None) 

3809 ] 

3810 

3811 

3812# https://elixir.bootlin.com/linux/v6.4.2/source/include/net/bluetooth/hci_mon.h#L34 

3813bind_layers(HCI_Mon_Hdr, HCI_Mon_New_Index, opcode=0) 

3814bind_layers(HCI_Mon_Hdr, HCI_Command_Hdr, opcode=2) 

3815bind_layers(HCI_Mon_Hdr, HCI_Event_Hdr, opcode=3) 

3816bind_layers(HCI_Mon_Hdr, HCI_ACL_Hdr, opcode=5) 

3817bind_layers(HCI_Mon_Hdr, HCI_Mon_Index_Info, opcode=10) 

3818bind_layers(HCI_Mon_Hdr, HCI_Mon_System_Note, opcode=12) 

3819 

3820conf.l2types.register(DLT_BLUETOOTH_LINUX_MONITOR, HCI_Mon_Pcap_Hdr) 

3821 

3822 

3823########### 

3824# Helpers # 

3825########### 

3826 

3827class LowEnergyBeaconHelper: 

3828 """ 

3829 Helpers for building packets for Bluetooth Low Energy Beacons. 

3830 

3831 Implementers provide a :meth:`build_eir` implementation. 

3832 

3833 This is designed to be used as a mix-in -- see 

3834 ``scapy.contrib.eddystone`` and ``scapy.contrib.ibeacon`` for examples. 

3835 """ 

3836 

3837 # Basic flags that should be used by most beacons. 

3838 base_eir = [EIR_Hdr() / EIR_Flags(flags=[ 

3839 "general_disc_mode", "br_edr_not_supported"]), ] 

3840 

3841 def build_eir(self): 

3842 """ 

3843 Builds a list of EIR messages to wrap this frame. 

3844 

3845 Users of this helper must implement this method. 

3846 

3847 :return: List of HCI_Hdr with payloads that describe this beacon type 

3848 :rtype: list[scapy.bluetooth.HCI_Hdr] 

3849 """ 

3850 raise NotImplementedError("build_eir") 

3851 

3852 def build_advertising_report(self): 

3853 """ 

3854 Builds a HCI_LE_Meta_Advertising_Report containing this frame. 

3855 

3856 :rtype: scapy.bluetooth.HCI_LE_Meta_Advertising_Report 

3857 """ 

3858 

3859 return HCI_LE_Meta_Advertising_Report( 

3860 type=0, # Undirected 

3861 addr_type=1, # Random address 

3862 data=self.build_eir() 

3863 ) 

3864 

3865 def build_set_advertising_data(self): 

3866 """Builds a HCI_Cmd_LE_Set_Advertising_Data containing this frame. 

3867 

3868 This includes the :class:`HCI_Hdr` and :class:`HCI_Command_Hdr` layers. 

3869 

3870 :rtype: scapy.bluetooth.HCI_Hdr 

3871 """ 

3872 

3873 return HCI_Hdr() / HCI_Command_Hdr() / HCI_Cmd_LE_Set_Advertising_Data( 

3874 data=self.build_eir() 

3875 ) 

3876 

3877 

3878########### 

3879# Sockets # 

3880########### 

3881 

3882class BluetoothSocketError(BaseException): 

3883 pass 

3884 

3885 

3886class BluetoothCommandError(BaseException): 

3887 pass 

3888 

3889 

3890class BluetoothL2CAPSocket(SuperSocket): 

3891 desc = "read/write packets on a connected L2CAP socket" 

3892 

3893 def __init__(self, bt_address): 

3894 if WINDOWS: 

3895 warning("Not available on Windows") 

3896 return 

3897 s = socket.socket(socket.AF_BLUETOOTH, socket.SOCK_RAW, 

3898 socket.BTPROTO_L2CAP) 

3899 s.connect((bt_address, 0)) 

3900 self.ins = self.outs = s 

3901 

3902 def recv(self, x=MTU): 

3903 return L2CAP_CmdHdr(self.ins.recv(x)) 

3904 

3905 

3906class BluetoothRFCommSocket(BluetoothL2CAPSocket): 

3907 """read/write packets on a connected RFCOMM socket""" 

3908 

3909 def __init__(self, bt_address, port=0): 

3910 s = socket.socket(socket.AF_BLUETOOTH, socket.SOCK_RAW, 

3911 socket.BTPROTO_RFCOMM) 

3912 s.connect((bt_address, port)) 

3913 self.ins = self.outs = s 

3914 

3915 

3916class BluetoothHCISocket(SuperSocket): 

3917 desc = "read/write on a BlueTooth HCI socket" 

3918 

3919 def __init__(self, iface=0x10000, type=None): 

3920 if WINDOWS: 

3921 warning("Not available on Windows") 

3922 return 

3923 s = socket.socket(socket.AF_BLUETOOTH, socket.SOCK_RAW, socket.BTPROTO_HCI) # noqa: E501 

3924 s.setsockopt(socket.SOL_HCI, socket.HCI_DATA_DIR, 1) 

3925 s.setsockopt(socket.SOL_HCI, socket.HCI_TIME_STAMP, 1) 

3926 s.setsockopt(socket.SOL_HCI, socket.HCI_FILTER, struct.pack("IIIh2x", 0xffffffff, 0xffffffff, 0xffffffff, 0)) # type mask, event mask, event mask, opcode # noqa: E501 

3927 s.bind((iface,)) 

3928 self.ins = self.outs = s 

3929# s.connect((peer,0)) 

3930 

3931 def recv(self, x=MTU): 

3932 return HCI_Hdr(self.ins.recv(x)) 

3933 

3934 

3935if ctypes is not None: 

3936 class sockaddr_hci(ctypes.Structure): 

3937 _fields_ = [ 

3938 ("sin_family", ctypes.c_ushort), 

3939 ("hci_dev", ctypes.c_ushort), 

3940 ("hci_channel", ctypes.c_ushort), 

3941 ] 

3942else: 

3943 class sockaddr_hci(object): 

3944 pass 

3945 

3946 

3947class _BluetoothLibcSocket(SuperSocket): 

3948 def __init__(self, socket_domain, socket_type, socket_protocol, sock_address): 

3949 # type: (int, int, int, sockaddr_hci) -> None 

3950 if WINDOWS: 

3951 warning("Not available on Windows") 

3952 return 

3953 # Python socket and bind implementations do not allow us to pass down 

3954 # the correct parameters. We must call libc functions directly via 

3955 # ctypes. 

3956 if ctypes is None: 

3957 raise Scapy_Exception("ctypes is not available") 

3958 sockaddr_hcip = ctypes.POINTER(sockaddr_hci) 

3959 from ctypes.util import find_library 

3960 libc = ctypes.cdll.LoadLibrary(find_library("c")) 

3961 

3962 socket_c = libc.socket 

3963 socket_c.argtypes = (ctypes.c_int, ctypes.c_int, ctypes.c_int) 

3964 socket_c.restype = ctypes.c_int 

3965 

3966 bind = libc.bind 

3967 bind.argtypes = (ctypes.c_int, 

3968 ctypes.POINTER(sockaddr_hci), 

3969 ctypes.c_int) 

3970 bind.restype = ctypes.c_int 

3971 

3972 # Socket 

3973 s = socket_c(socket_domain, socket_type, socket_protocol) 

3974 if s < 0: 

3975 raise BluetoothSocketError( 

3976 f"Unable to open socket({socket_domain}, {socket_type}, " 

3977 f"{socket_protocol})") 

3978 

3979 # Bind 

3980 r = bind(s, sockaddr_hcip(sock_address), sizeof(sock_address)) 

3981 if r != 0: 

3982 raise BluetoothSocketError("Unable to bind") 

3983 

3984 self.hci_fd = s 

3985 self.ins = self.outs = socket.fromfd( 

3986 s, socket_domain, socket_type, socket_protocol) 

3987 

3988 def readable(self, timeout=0): 

3989 (ins, _, _) = select.select([self.ins], [], [], timeout) 

3990 return len(ins) > 0 

3991 

3992 def flush(self): 

3993 while self.readable(): 

3994 self.recv() 

3995 

3996 def close(self): 

3997 if self.closed: 

3998 return 

3999 

4000 # Properly close socket so we can free the device 

4001 from ctypes.util import find_library 

4002 libc = ctypes.cdll.LoadLibrary(find_library("c")) 

4003 

4004 close = libc.close 

4005 close.restype = ctypes.c_int 

4006 self.closed = True 

4007 if hasattr(self, "outs"): 

4008 if not hasattr(self, "ins") or self.ins != self.outs: 

4009 if self.outs and (WINDOWS or self.outs.fileno() != -1): 

4010 close(self.outs.fileno()) 

4011 if hasattr(self, "ins"): 

4012 if self.ins and (WINDOWS or self.ins.fileno() != -1): 

4013 close(self.ins.fileno()) 

4014 if hasattr(self, "hci_fd"): 

4015 close(self.hci_fd) 

4016 

4017 

4018class BluetoothUserSocket(_BluetoothLibcSocket): 

4019 desc = "read/write H4 over a Bluetooth user channel" 

4020 

4021 def __init__(self, adapter_index=0): 

4022 sa = sockaddr_hci() 

4023 sa.sin_family = socket.AF_BLUETOOTH 

4024 sa.hci_dev = adapter_index 

4025 sa.hci_channel = HCI_CHANNEL_USER 

4026 super().__init__( 

4027 socket_domain=socket.AF_BLUETOOTH, 

4028 socket_type=socket.SOCK_RAW, 

4029 socket_protocol=socket.BTPROTO_HCI, 

4030 sock_address=sa) 

4031 

4032 def send_command(self, cmd): 

4033 opcode = cmd[HCI_Command_Hdr].opcode 

4034 self.send(cmd) 

4035 while True: 

4036 r = self.recv() 

4037 if r.type == 0x04 and r.code in (0xe, 0xf) and r.opcode == opcode: 

4038 if hasattr(r, 'status') and r.status != 0: 

4039 raise BluetoothCommandError("Command %x failed with %x" % (opcode, r.status)) # noqa: E501 

4040 return r 

4041 

4042 def recv(self, x=MTU): 

4043 return HCI_Hdr(self.ins.recv(x)) 

4044 

4045 

4046class BluetoothMonitorSocket(_BluetoothLibcSocket): 

4047 desc = "Read/write over a Bluetooth monitor channel" 

4048 

4049 def __init__(self): 

4050 sa = sockaddr_hci() 

4051 sa.sin_family = socket.AF_BLUETOOTH 

4052 sa.hci_dev = HCI_DEV_NONE 

4053 sa.hci_channel = HCI_CHANNEL_MONITOR 

4054 super().__init__( 

4055 socket_domain=socket.AF_BLUETOOTH, 

4056 socket_type=socket.SOCK_RAW, 

4057 socket_protocol=socket.BTPROTO_HCI, 

4058 sock_address=sa) 

4059 

4060 def recv(self, x=MTU): 

4061 return HCI_Mon_Hdr(self.ins.recv(x)) 

4062 

4063 

4064conf.BTsocket = BluetoothRFCommSocket 

4065 

4066# Bluetooth 

4067 

4068 

4069@conf.commands.register 

4070def srbt(bt_address, pkts, inter=0.1, *args, **kargs): 

4071 """send and receive using a bluetooth socket""" 

4072 if "port" in kargs: 

4073 s = conf.BTsocket(bt_address=bt_address, port=kargs.pop("port")) 

4074 else: 

4075 s = conf.BTsocket(bt_address=bt_address) 

4076 a, b = sndrcv(s, pkts, inter=inter, *args, **kargs) 

4077 s.close() 

4078 return a, b 

4079 

4080 

4081@conf.commands.register 

4082def srbt1(bt_address, pkts, *args, **kargs): 

4083 """send and receive 1 packet using a bluetooth socket""" 

4084 a, b = srbt(bt_address, pkts, *args, **kargs) 

4085 if len(a) > 0: 

4086 return a[0][1]