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

185 statements  

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

2# This file is part of Scapy 

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

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

5 

6""" 

7NetBIOS over TCP/IP 

8 

9[RFC 1001/1002] 

10""" 

11 

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 

18 

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 

41 

42# Typing imports 

43from typing import ( 

44 List, 

45 Tuple, 

46 Union, 

47) 

48 

49 

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 ] 

63 

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 

70 

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# 

83 

84# NetBIOS 

85 

86 

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} 

116 

117_NETBIOS_QRTYPES = { 

118 0x20: "NB", 

119 0x21: "NBSTAT" 

120} 

121 

122_NETBIOS_QRCLASS = { 

123 1: "INTERNET" 

124} 

125 

126_NETBIOS_RNAMES = { 

127 0xC00C: "Label String Pointer to QUESTION_NAME" 

128} 

129 

130_NETBIOS_OWNER_MODE_TYPES = { 

131 0: "B node", 

132 1: "P node", 

133 2: "M node", 

134 3: "H node" 

135} 

136 

137_NETBIOS_GNAMES = { 

138 0: "Unique name", 

139 1: "Group name" 

140} 

141 

142 

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 ] 

162 

163 def hashret(self): 

164 return b"NBNS" + struct.pack("!B", self.OPCODE) 

165 

166 

167# Name Query Request 

168# RFC1002 sect 4.2.12 

169 

170 

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)] 

178 

179 def mysummary(self): 

180 return "NBNSQueryRequest who has '\\\\%s'" % ( 

181 self.QUESTION_NAME.decode(errors="backslashreplace") 

182 ) 

183 

184 

185bind_layers(NBNSHeader, NBNSQueryRequest, 

186 OPCODE=0x0, NM_FLAGS=0x11, QDCOUNT=1) 

187 

188 

189# Name Query Response 

190# RFC1002 sect 4.2.13 

191 

192 

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 ] 

201 

202 def default_payload_class(self, payload): 

203 return conf.padding_layer 

204 

205 

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 ] 

219 

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 ) 

228 

229 def answers(self, other): 

230 return ( 

231 isinstance(other, NBNSQueryRequest) and 

232 other.QUESTION_NAME == self.RR_NAME 

233 ) 

234 

235 

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) 

241 

242 

243# Node Status Request 

244# RFC1002 sect 4.2.17 

245 

246class NBNSNodeStatusRequest(NBNSQueryRequest): 

247 name = "NBNS status request" 

248 QUESTION_NAME = b"*" + b"\x00" * 14 

249 QUESTION_TYPE = 0x21 

250 

251 def mysummary(self): 

252 return "NBNSNodeStatusRequest who has '\\\\%s'" % ( 

253 self.QUESTION_NAME.decode(errors="backslashreplace") 

254 ) 

255 

256 

257bind_bottom_up(NBNSHeader, NBNSNodeStatusRequest, OPCODE=0x0, NM_FLAGS=0, QDCOUNT=1) 

258bind_layers(NBNSHeader, NBNSNodeStatusRequest, OPCODE=0x0, NM_FLAGS=1, QDCOUNT=1) 

259 

260 

261# Node Status Response 

262# RFC1002 sect 4.2.18 

263 

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"})] 

276 

277 def default_payload_class(self, payload): 

278 return conf.padding_layer 

279 

280 

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)] 

298 

299 def answers(self, other): 

300 return ( 

301 isinstance(other, NBNSNodeStatusRequest) and 

302 other.QUESTION_NAME == self.RR_NAME 

303 ) 

304 

305 

306bind_layers(NBNSHeader, NBNSNodeStatusResponse, 

307 OPCODE=0x0, NM_FLAGS=0x40, RESPONSE=1, ANCOUNT=1) 

308 

309 

310# Name Registration Request 

311# RFC1002 sect 4.2.2 

312 

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 ] 

332 

333 def mysummary(self): 

334 return self.sprintf("Register %G% %QUESTION_NAME% at %NB_ADDRESS%") 

335 

336 

337bind_bottom_up(NBNSHeader, NBNSRegistrationRequest, OPCODE=0x5) 

338bind_layers(NBNSHeader, NBNSRegistrationRequest, 

339 OPCODE=0x5, NM_FLAGS=0x11, QDCOUNT=1, ARCOUNT=1) 

340 

341 

342# Wait for Acknowledgement Response 

343# RFC1002 sect 4.2.16 

344 

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 

355 

356 

357bind_layers(NBNSHeader, NBNSWackResponse, 

358 OPCODE=0x7, NM_FLAGS=0x40, RESPONSE=1, ANCOUNT=1) 

359 

360# NetBIOS DATAGRAM HEADER 

361 

362 

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)] 

378 

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 

384 

385 

386# SESSION SERVICE PACKETS 

387 

388 

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)] 

400 

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 

406 

407 def extract_padding(self, s): 

408 return s[:self.LENGTH], s[self.LENGTH:] 

409 

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) 

417 

418 

419bind_bottom_up(UDP, NBNSHeader, dport=137) 

420bind_bottom_up(UDP, NBNSHeader, sport=137) 

421bind_top_down(UDP, NBNSHeader, sport=137, dport=137) 

422 

423bind_bottom_up(UDP, NBTDatagram, dport=138) 

424bind_bottom_up(UDP, NBTDatagram, sport=138) 

425bind_top_down(UDP, NBTDatagram, sport=138, dport=138) 

426 

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) 

432 

433 

434_nbns_cache = conf.netcache.new_cache("nbns_cache", 300) 

435 

436 

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 

447 

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) 

455 

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 

465 

466 # Check cache 

467 cache_ident = (cache_key, raw) 

468 result = _nbns_cache.get(cache_ident) 

469 if result: 

470 return result 

471 

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] 

482 

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 ) 

495 

496 if not requests: 

497 return None 

498 

499 # Perform requests, get the first response 

500 try: 

501 old_checkIPAddr = conf.checkIPaddr 

502 conf.checkIPaddr = False 

503 

504 res = sr1( 

505 requests, 

506 timeout=timeout, 

507 first=True, 

508 **kwargs, 

509 ) 

510 finally: 

511 conf.checkIPaddr = old_checkIPAddr 

512 

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 

526 

527 

528class NBNS_am(AnsweringMachine): 

529 function_name = "nbnsd" 

530 filter = "udp port 137" 

531 sniff_options = {"store": 0} 

532 

533 def parse_options(self, server_name=None, from_ip=None, ip=None): 

534 """ 

535 NBNS answering machine 

536 

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 

547 

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 ) 

555 

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