Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/scapy/layers/netbios.py: 61%
Shortcuts on this page
r m x toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
Shortcuts on this page
r m x toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
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>
6"""
7NetBIOS over TCP/IP
9[RFC 1001/1002]
10"""
12import struct
13from scapy.arch import get_if_addr
14from scapy.base_classes import Net
15from scapy.ansmachine import AnsweringMachine
16from scapy.compat import bytes_encode
17from scapy.config import conf
19from scapy.packet import Packet, bind_bottom_up, bind_layers, bind_top_down
20from scapy.fields import (
21 BitEnumField,
22 BitField,
23 ByteEnumField,
24 ByteField,
25 FieldLenField,
26 FlagsField,
27 IPField,
28 IntField,
29 NetBIOSNameField,
30 PacketListField,
31 ShortEnumField,
32 ShortField,
33 StrFixedLenField,
34 XShortField,
35 XStrFixedLenField
36)
37from scapy.interfaces import _GlobInterfaceType
38from scapy.sendrecv import sr1
39from scapy.layers.inet import IP, UDP, TCP
40from scapy.layers.l2 import Ether, SourceMACField
42# Typing imports
43from typing import (
44 List,
45 Tuple,
46 Union,
47)
50class NetBIOS_DS(Packet):
51 name = "NetBIOS datagram service"
52 fields_desc = [
53 ByteEnumField("type", 17, {17: "direct_group"}),
54 ByteField("flags", 0),
55 XShortField("id", 0),
56 IPField("src", "127.0.0.1"),
57 ShortField("sport", 138),
58 ShortField("len", None),
59 ShortField("ofs", 0),
60 NetBIOSNameField("srcname", ""),
61 NetBIOSNameField("dstname", ""),
62 ]
64 def post_build(self, p, pay):
65 p += pay
66 if self.len is None:
67 tmp_len = len(p) - 14
68 p = p[:10] + struct.pack("!H", tmp_len) + p[12:]
69 return p
71# ShortField("length",0),
72# ShortField("Delimiter",0),
73# ByteField("command",0),
74# ByteField("data1",0),
75# ShortField("data2",0),
76# ShortField("XMIt",0),
77# ShortField("RSPCor",0),
78# StrFixedLenField("dest","",16),
79# StrFixedLenField("source","",16),
80#
81# ]
82#
84# NetBIOS
87_NETBIOS_SUFFIXES = {
88 0x4141 + 0x00: "Workstation Service",
89 0x4141 + 0x01: "Messenger Service",
90 0x4141 + 0x03: "Messenger service",
91 0x4141 + 0x06: "RAS Server Service",
92 0x4141 + 0x1B: "Exchange MTA",
93 0x4141 + 0x1F: "NetDDE Service",
94 0x4141 + 0x20: "File Server Service",
95 0x4141 + 0x21: "RAS Client Service",
96 0x4141 + 0x22: "Exchange Interchange Service",
97 0x4141 + 0x23: "Exchange Store",
98 0x4141 + 0x24: "Exchange Directory",
99 0x4141 + 0x30: "Modern Sharing Server Service",
100 0x4141 + 0x31: "Modern Sharing Client Service",
101 0x4141 + 0x43: "SMS Client Remote Control",
102 0x4141 + 0x44: "SMS Admin Remote Control Tool",
103 0x4141 + 0x45: "SMS Client Remote Chat",
104 0x4141 + 0x46: "SMS Client Remote Transfer",
105 0x4141 + 0x4C: "DEC Pathworks TCP/IP Service",
106 0x4141 + 0x52: "DEC Pathworks TCP/IP Service",
107 0x4141 + 0x6A: "Exchange IMC",
108 0x4141 + 0x87: "Exchange MTA",
109 0x4141 + 0xBE: "Network Monitor Agent",
110 0x4141 + 0xBF: "Network Monitor Apps",
111 0x4141 + 0x10b: "Domain Master Browser",
112 0x4141 + 0x10c: "Domain Controller",
113 0x4141 + 0x10e: "Browser Election Service",
114 0x4141 + 0x200: "File Server Service",
115}
117_NETBIOS_QRTYPES = {
118 0x20: "NB",
119 0x21: "NBSTAT"
120}
122_NETBIOS_QRCLASS = {
123 1: "INTERNET"
124}
126_NETBIOS_RNAMES = {
127 0xC00C: "Label String Pointer to QUESTION_NAME"
128}
130_NETBIOS_OWNER_MODE_TYPES = {
131 0: "B node",
132 1: "P node",
133 2: "M node",
134 3: "H node"
135}
137_NETBIOS_GNAMES = {
138 0: "Unique name",
139 1: "Group name"
140}
143class NBNSHeader(Packet):
144 name = "NBNS Header"
145 fields_desc = [
146 ShortField("NAME_TRN_ID", 0),
147 BitField("RESPONSE", 0, 1),
148 BitField("OPCODE", 0, 4),
149 FlagsField("NM_FLAGS", 0, 7, ["B",
150 "res1",
151 "res0",
152 "RA",
153 "RD",
154 "TC",
155 "AA"]),
156 BitField("RCODE", 0, 4),
157 ShortField("QDCOUNT", 0),
158 ShortField("ANCOUNT", 0),
159 ShortField("NSCOUNT", 0),
160 ShortField("ARCOUNT", 0),
161 ]
163 def hashret(self):
164 return b"NBNS" + struct.pack("!B", self.OPCODE)
167# Name Query Request
168# RFC1002 sect 4.2.12
171class NBNSQueryRequest(Packet):
172 name = "NBNS query request"
173 fields_desc = [NetBIOSNameField("QUESTION_NAME", "windows"),
174 ShortEnumField("SUFFIX", 0x4141, _NETBIOS_SUFFIXES),
175 ByteField("NULL", 0),
176 ShortEnumField("QUESTION_TYPE", 0x20, _NETBIOS_QRTYPES),
177 ShortEnumField("QUESTION_CLASS", 1, _NETBIOS_QRCLASS)]
179 def mysummary(self):
180 return "NBNSQueryRequest who has '\\\\%s'" % (
181 self.QUESTION_NAME.decode(errors="backslashreplace")
182 )
185bind_layers(NBNSHeader, NBNSQueryRequest,
186 OPCODE=0x0, NM_FLAGS=0x11, QDCOUNT=1)
189# Name Query Response
190# RFC1002 sect 4.2.13
193class NBNS_ADD_ENTRY(Packet):
194 fields_desc = [
195 BitEnumField("G", 0, 1, _NETBIOS_GNAMES),
196 BitEnumField("OWNER_NODE_TYPE", 00, 2,
197 _NETBIOS_OWNER_MODE_TYPES),
198 BitEnumField("UNUSED", 0, 13, {0: "Unused"}),
199 IPField("NB_ADDRESS", "127.0.0.1")
200 ]
202 def default_payload_class(self, payload):
203 return conf.padding_layer
206class NBNSQueryResponse(Packet):
207 name = "NBNS query response"
208 fields_desc = [NetBIOSNameField("RR_NAME", "windows"),
209 ShortEnumField("SUFFIX", 0x4141, _NETBIOS_SUFFIXES),
210 ByteField("NULL", 0),
211 ShortEnumField("QUESTION_TYPE", 0x20, _NETBIOS_QRTYPES),
212 ShortEnumField("QUESTION_CLASS", 1, _NETBIOS_QRCLASS),
213 IntField("TTL", 0x493e0),
214 FieldLenField("RDLENGTH", None, length_of="ADDR_ENTRY"),
215 PacketListField("ADDR_ENTRY",
216 [NBNS_ADD_ENTRY()], NBNS_ADD_ENTRY,
217 length_from=lambda pkt: pkt.RDLENGTH)
218 ]
220 def mysummary(self):
221 if not self.ADDR_ENTRY or \
222 not isinstance(self.ADDR_ENTRY[0], NBNS_ADD_ENTRY):
223 return "NBNSQueryResponse"
224 return "NBNSQueryResponse '\\\\%s' is at %s" % (
225 self.RR_NAME.decode(errors="backslashreplace"),
226 self.ADDR_ENTRY[0].NB_ADDRESS
227 )
229 def answers(self, other):
230 return (
231 isinstance(other, NBNSQueryRequest) and
232 other.QUESTION_NAME == self.RR_NAME
233 )
236bind_layers(NBNSHeader, NBNSQueryResponse, # RD+AA
237 OPCODE=0x0, NM_FLAGS=0x50, RESPONSE=1, ANCOUNT=1)
238for _flg in [0x58, 0x70, 0x78]:
239 bind_bottom_up(NBNSHeader, NBNSQueryResponse,
240 OPCODE=0x0, NM_FLAGS=_flg, RESPONSE=1, ANCOUNT=1)
243# Node Status Request
244# RFC1002 sect 4.2.17
246class NBNSNodeStatusRequest(NBNSQueryRequest):
247 name = "NBNS status request"
248 QUESTION_NAME = b"*" + b"\x00" * 14
249 QUESTION_TYPE = 0x21
251 def mysummary(self):
252 return "NBNSNodeStatusRequest who has '\\\\%s'" % (
253 self.QUESTION_NAME.decode(errors="backslashreplace")
254 )
257bind_bottom_up(NBNSHeader, NBNSNodeStatusRequest, OPCODE=0x0, NM_FLAGS=0, QDCOUNT=1)
258bind_layers(NBNSHeader, NBNSNodeStatusRequest, OPCODE=0x0, NM_FLAGS=1, QDCOUNT=1)
261# Node Status Response
262# RFC1002 sect 4.2.18
264class NBNSNodeStatusResponseService(Packet):
265 name = "NBNS Node Status Response Service"
266 fields_desc = [StrFixedLenField("NETBIOS_NAME", "WINDOWS ", 15),
267 ByteEnumField("SUFFIX", 0, {0: "workstation",
268 0x03: "messenger service",
269 0x20: "file server service",
270 0x1b: "domain master browser",
271 0x1c: "domain controller",
272 0x1e: "browser election service"
273 }),
274 ByteField("NAME_FLAGS", 0x4),
275 ByteEnumField("UNUSED", 0, {0: "unused"})]
277 def default_payload_class(self, payload):
278 return conf.padding_layer
281class NBNSNodeStatusResponse(Packet):
282 name = "NBNS Node Status Response"
283 fields_desc = [NetBIOSNameField("RR_NAME", "windows"),
284 ShortEnumField("SUFFIX", 0x4141, _NETBIOS_SUFFIXES),
285 ByteField("NULL", 0),
286 ShortEnumField("RR_TYPE", 0x21, _NETBIOS_QRTYPES),
287 ShortEnumField("RR_CLASS", 1, _NETBIOS_QRCLASS),
288 IntField("TTL", 0),
289 ShortField("RDLENGTH", 83),
290 FieldLenField("NUM_NAMES", None, fmt="B",
291 count_of="NODE_NAME"),
292 PacketListField("NODE_NAME",
293 [NBNSNodeStatusResponseService()],
294 NBNSNodeStatusResponseService,
295 count_from=lambda pkt: pkt.NUM_NAMES),
296 SourceMACField("MAC_ADDRESS"),
297 XStrFixedLenField("STATISTICS", b"", 46)]
299 def answers(self, other):
300 return (
301 isinstance(other, NBNSNodeStatusRequest) and
302 other.QUESTION_NAME == self.RR_NAME
303 )
306bind_layers(NBNSHeader, NBNSNodeStatusResponse,
307 OPCODE=0x0, NM_FLAGS=0x40, RESPONSE=1, ANCOUNT=1)
310# Name Registration Request
311# RFC1002 sect 4.2.2
313class NBNSRegistrationRequest(Packet):
314 name = "NBNS registration request"
315 fields_desc = [
316 NetBIOSNameField("QUESTION_NAME", "Windows"),
317 ShortEnumField("SUFFIX", 0x4141, _NETBIOS_SUFFIXES),
318 ByteField("NULL", 0),
319 ShortEnumField("QUESTION_TYPE", 0x20, _NETBIOS_QRTYPES),
320 ShortEnumField("QUESTION_CLASS", 1, _NETBIOS_QRCLASS),
321 ShortEnumField("RR_NAME", 0xC00C, _NETBIOS_RNAMES),
322 ShortEnumField("RR_TYPE", 0x20, _NETBIOS_QRTYPES),
323 ShortEnumField("RR_CLASS", 1, _NETBIOS_QRCLASS),
324 IntField("TTL", 0),
325 ShortField("RDLENGTH", 6),
326 BitEnumField("G", 0, 1, _NETBIOS_GNAMES),
327 BitEnumField("OWNER_NODE_TYPE", 00, 2,
328 _NETBIOS_OWNER_MODE_TYPES),
329 BitEnumField("UNUSED", 0, 13, {0: "Unused"}),
330 IPField("NB_ADDRESS", "127.0.0.1")
331 ]
333 def mysummary(self):
334 return self.sprintf("Register %G% %QUESTION_NAME% at %NB_ADDRESS%")
337bind_bottom_up(NBNSHeader, NBNSRegistrationRequest, OPCODE=0x5)
338bind_layers(NBNSHeader, NBNSRegistrationRequest,
339 OPCODE=0x5, NM_FLAGS=0x11, QDCOUNT=1, ARCOUNT=1)
342# Wait for Acknowledgement Response
343# RFC1002 sect 4.2.16
345class NBNSWackResponse(Packet):
346 name = "NBNS Wait for Acknowledgement Response"
347 fields_desc = [NetBIOSNameField("RR_NAME", "windows"),
348 ShortEnumField("SUFFIX", 0x4141, _NETBIOS_SUFFIXES),
349 ByteField("NULL", 0),
350 ShortEnumField("RR_TYPE", 0x20, _NETBIOS_QRTYPES),
351 ShortEnumField("RR_CLASS", 1, _NETBIOS_QRCLASS),
352 IntField("TTL", 2),
353 ShortField("RDLENGTH", 2),
354 BitField("RDATA", 10512, 16)] # 10512=0010100100010000
357bind_layers(NBNSHeader, NBNSWackResponse,
358 OPCODE=0x7, NM_FLAGS=0x40, RESPONSE=1, ANCOUNT=1)
360# NetBIOS DATAGRAM HEADER
363class NBTDatagram(Packet):
364 name = "NBT Datagram Packet"
365 fields_desc = [ByteField("Type", 0x10),
366 ByteField("Flags", 0x02),
367 ShortField("ID", 0),
368 IPField("SourceIP", "127.0.0.1"),
369 ShortField("SourcePort", 138),
370 ShortField("Length", None),
371 ShortField("Offset", 0),
372 NetBIOSNameField("SourceName", "windows"),
373 ShortEnumField("SUFFIX1", 0x4141, _NETBIOS_SUFFIXES),
374 ByteField("NULL1", 0),
375 NetBIOSNameField("DestinationName", "windows"),
376 ShortEnumField("SUFFIX2", 0x4141, _NETBIOS_SUFFIXES),
377 ByteField("NULL2", 0)]
379 def post_build(self, pkt, pay):
380 if self.Length is None:
381 length = len(pay) + 68
382 pkt = pkt[:10] + struct.pack("!H", length) + pkt[12:]
383 return pkt + pay
386# SESSION SERVICE PACKETS
389class NBTSession(Packet):
390 name = "NBT Session Packet"
391 MAXLENGTH = 0x3ffff
392 fields_desc = [ByteEnumField("TYPE", 0, {0x00: "Session Message",
393 0x81: "Session Request",
394 0x82: "Positive Session Response",
395 0x83: "Negative Session Response",
396 0x84: "Retarget Session Response",
397 0x85: "Session Keepalive"}),
398 BitField("RESERVED", 0x00, 7),
399 BitField("LENGTH", None, 17)]
401 def post_build(self, pkt, pay):
402 if self.LENGTH is None:
403 length = len(pay) & self.MAXLENGTH
404 pkt = pkt[:1] + struct.pack("!I", length)[1:]
405 return pkt + pay
407 def extract_padding(self, s):
408 return s[:self.LENGTH], s[self.LENGTH:]
410 @classmethod
411 def tcp_reassemble(cls, data, *args, **kwargs):
412 if len(data) < 4:
413 return None
414 length = struct.unpack("!I", data[:4])[0] & cls.MAXLENGTH
415 if len(data) >= length + 4:
416 return cls(data)
419bind_bottom_up(UDP, NBNSHeader, dport=137)
420bind_bottom_up(UDP, NBNSHeader, sport=137)
421bind_top_down(UDP, NBNSHeader, sport=137, dport=137)
423bind_bottom_up(UDP, NBTDatagram, dport=138)
424bind_bottom_up(UDP, NBTDatagram, sport=138)
425bind_top_down(UDP, NBTDatagram, sport=138, dport=138)
427bind_bottom_up(TCP, NBTSession, dport=445)
428bind_bottom_up(TCP, NBTSession, sport=445)
429bind_bottom_up(TCP, NBTSession, dport=139)
430bind_bottom_up(TCP, NBTSession, sport=139)
431bind_layers(TCP, NBTSession, dport=139, sport=139)
434_nbns_cache = conf.netcache.new_cache("nbns_cache", 300)
437@conf.commands.register
438def nbns_resolve(
439 qname: Union[str, bytes, List[Union[str, bytes]], Tuple[Union[str, bytes], ...]],
440 iface: Union[_GlobInterfaceType, List[_GlobInterfaceType]] = None,
441 raw: bool = False,
442 timeout: int = 3,
443 **kwargs,
444) -> Union[List[str], Packet, None]:
445 """
446 Perform a simple NBNS (NetBios Name Services) resolution with caching
448 :param qname: the name (or list/tuple of names) to query
449 :param iface: the interfaces to use. (default: all)
450 :param raw: return the whole netbios packet (default False)
451 :param timeout: seconds until timeout (per server)
452 :raise TimeoutError: if no DNS servers were reached in time.
453 """
454 kwargs.setdefault("verbose", 0)
456 # Unify types (for caching)
457 if isinstance(qname, (list, tuple)):
458 if not qname:
459 return None
460 qname = [NBNSQueryRequest.QUESTION_NAME.any2i(None, q) for q in qname]
461 cache_key = tuple(qname)
462 else:
463 qname = NBNSQueryRequest.QUESTION_NAME.any2i(None, qname)
464 cache_key = qname
466 # Check cache
467 cache_ident = (cache_key, raw)
468 result = _nbns_cache.get(cache_ident)
469 if result:
470 return result
472 if iface is None:
473 ifaces = [
474 x
475 for name, x in conf.ifaces.items()
476 if x.is_valid() and name != conf.loopback_name
477 ]
478 elif isinstance(iface, list):
479 ifaces = iface
480 else:
481 ifaces = [iface]
483 # Builds a request for each broadcast address of each interface
484 requests = []
485 for iface in ifaces:
486 for bdcst in conf.route.get_if_bcast(iface):
487 if bdcst == "255.255.255.255":
488 continue
489 requests.append(
490 IP(dst=bdcst) /
491 UDP() /
492 NBNSHeader() /
493 NBNSQueryRequest(QUESTION_NAME=qname)
494 )
496 if not requests:
497 return None
499 # Perform requests, get the first response
500 try:
501 old_checkIPAddr = conf.checkIPaddr
502 conf.checkIPaddr = False
504 res = sr1(
505 requests,
506 timeout=timeout,
507 first=True,
508 **kwargs,
509 )
510 finally:
511 conf.checkIPaddr = old_checkIPAddr
513 if res is not None:
514 if raw:
515 # Raw
516 result = res
517 else:
518 # Get IP
519 result = [x.NB_ADDRESS for x in res.ADDR_ENTRY]
520 if result:
521 # Cache it
522 _nbns_cache[cache_ident] = result
523 return result
524 else:
525 raise TimeoutError
528class NBNS_am(AnsweringMachine):
529 function_name = "nbnsd"
530 filter = "udp port 137"
531 sniff_options = {"store": 0}
533 def parse_options(self, server_name=None, from_ip=None, ip=None):
534 """
535 NBNS answering machine
537 :param server_name: the netbios server name to match
538 :param from_ip: an IP (can have a netmask) to filter on
539 :param ip: the IP to answer with
540 """
541 self.ServerName = bytes_encode(server_name or "")
542 self.ip = ip
543 if isinstance(from_ip, str):
544 self.from_ip = Net(from_ip)
545 else:
546 self.from_ip = from_ip
548 def is_request(self, req):
549 if self.from_ip and IP in req and req[IP].src not in self.from_ip:
550 return False
551 return NBNSQueryRequest in req and (
552 not self.ServerName or
553 req[NBNSQueryRequest].QUESTION_NAME.strip() == self.ServerName
554 )
556 def make_reply(self, req):
557 # type: (Packet) -> Packet
558 resp = Ether(
559 dst=req[Ether].src,
560 src=None if req[Ether].dst == "ff:ff:ff:ff:ff:ff" else req[Ether].dst,
561 ) / IP(dst=req[IP].src) / UDP(
562 sport=req.dport,
563 dport=req.sport,
564 )
565 address = self.ip or get_if_addr(self.optsniff.get("iface", conf.iface))
566 resp /= NBNSHeader() / NBNSQueryResponse(
567 RR_NAME=self.ServerName or req.QUESTION_NAME,
568 SUFFIX=req.SUFFIX,
569 ADDR_ENTRY=[NBNS_ADD_ENTRY(NB_ADDRESS=address)]
570 )
571 resp.NAME_TRN_ID = req.NAME_TRN_ID
572 return resp