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]