From 47ea10548c42dafe0b920bb5b403a3f9f6afae45 Mon Sep 17 00:00:00 2001 From: gpotter2 <10530980+gpotter2@users.noreply.github.com> Date: Tue, 17 Nov 2026 23:05:49 +0100 Subject: [PATCH 1/3] http: Nego2 support --- scapy/layers/http.py | 41 +++++++++++++++++++++++++++++------------ 1 file changed, 29 insertions(+), 12 deletions(-) diff --git a/scapy/layers/http.py b/scapy/layers/http.py index 3e0f7c78e0b..c971ec60c08 100644 --- a/scapy/layers/http.py +++ b/scapy/layers/http.py @@ -839,6 +839,7 @@ class HTTP_AUTH_MECHS(Enum): BASIC = "Basic" NTLM = "NTLM" NEGOTIATE = "Negotiate" + NEGO2 = "Nego2" class HTTP_Client(object): @@ -1022,6 +1023,7 @@ def request( if self.authmethod in [ HTTP_AUTH_MECHS.NTLM, HTTP_AUTH_MECHS.NEGOTIATE, + HTTP_AUTH_MECHS.NEGO2, ]: # Parse authenticate if b" " in resp.WWW_Authenticate: @@ -1176,7 +1178,7 @@ def __init__( self.chan_bindings = GSS_C_NO_CHANNEL_BINDINGS # Auth settings - self.basic = False + self.mech = mech self.BASIC_IDENTITIES = kwargs.pop("BASIC_IDENTITIES", {}) self.BASIC_REALM = kwargs.pop("BASIC_REALM", "default") if mech == HTTP_AUTH_MECHS.BASIC: @@ -1184,10 +1186,10 @@ def __init__( raise ValueError("Please provide 'BASIC_IDENTITIES' !") if ssp is not None: raise ValueError("Can't use 'BASIC_IDENTITIES' with 'ssp' !") - self.basic = True elif mech == HTTP_AUTH_MECHS.NONE: if ssp is not None: raise ValueError("Cannot use ssp with mech=NONE !") + # Initialize Automaton.__init__(self, *args, **kwargs) @@ -1235,9 +1237,13 @@ def AUTH(self, pkt=None): authorization = pkt.Authorization if not authorization: # Initial ask. - data = self.authmethod - if self.basic: - data += " realm='%s'" % self.BASIC_REALM + if self.mech == HTTP_AUTH_MECHS.BASIC: + data = ("realm='%s'" % self.BASIC_REALM).encode() + elif self.mech == HTTP_AUTH_MECHS.NEGO2: + self.sspcontext, tok = self.ssp.NegTokenInit2() + data = base64.b64encode(bytes(tok)) + else: + data = None self._ask_authorization(proxy, data) return # Parse authorization @@ -1251,12 +1257,16 @@ def AUTH(self, pkt=None): self.debug(3, "Couldn't unpack base64 of auth.") raise self.AUTH_ERROR(proxy) # Now process the authorization - if not self.basic: + if self.mech in [ + HTTP_AUTH_MECHS.NTLM, + HTTP_AUTH_MECHS.NEGOTIATE, + HTTP_AUTH_MECHS.NEGO2, + ]: try: ssp_blob = GSSAPI_BLOB(data) except Exception: self.sspcontext = None - self._ask_authorization(proxy, self.authmethod) + self._ask_authorization(proxy, None) self.debug(3, "Couldn't unpack GSSAPI_BLOB of auth.") raise self.AUTH_ERROR(proxy) # And call the SSP @@ -1266,7 +1276,7 @@ def AUTH(self, pkt=None): req_flags=self.ssp_req_flags, chan_bindings=self.chan_bindings, ) - else: + elif self.mech == HTTP_AUTH_MECHS.BASIC: # This is actually Basic authentication try: next( @@ -1281,11 +1291,13 @@ def AUTH(self, pkt=None): # Send answer if status not in [GSS_S_COMPLETE, GSS_S_CONTINUE_NEEDED]: self.debug(3, "Authentication failed: %s." % status) + ssp_blob.show() raise self.AUTH_ERROR(proxy) elif status == GSS_S_CONTINUE_NEEDED: - data = self.authmethod.encode() if tok: - data += b" " + base64.b64encode(bytes(tok)) + data = base64.b64encode(bytes(tok)) + else: + data = None self._ask_authorization(proxy, data) raise self.AUTH() else: @@ -1297,7 +1309,7 @@ def AUTH(self, pkt=None): @ATMT.state() def AUTH_ERROR(self, proxy): self.sspcontext = None - self._ask_authorization(proxy, self.authmethod) + self._ask_authorization(proxy, None) self.vprint("AUTH ERROR") @ATMT.condition(AUTH_ERROR) @@ -1305,6 +1317,11 @@ def allow_reauth(self): raise self.AUTH() def _ask_authorization(self, proxy, data): + # Append authmethod + data = ( + self.authmethod.encode() + + ((b" " + data) if data else b"") + ) if proxy: self.send( HTTPResponse( @@ -1362,7 +1379,7 @@ def serve_eof(self): @ATMT.receive_condition(SERVE) def new_request(self, pkt): - if self.basic: + if self.mech == HTTP_AUTH_MECHS.BASIC: raise self.AUTH(pkt) raise self.SERVE(pkt) From d5639c81f9b49da87fec15d8d3bd7822f2c1c9c7 Mon Sep 17 00:00:00 2001 From: gpotter2 <10530980+gpotter2@users.noreply.github.com> Date: Tue, 17 Nov 2026 23:06:07 +0100 Subject: [PATCH 2/3] kerberos: fix server-triggered U2U --- scapy/layers/kerberos.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/scapy/layers/kerberos.py b/scapy/layers/kerberos.py index 38364e65e10..ffef6f84ecb 100644 --- a/scapy/layers/kerberos.py +++ b/scapy/layers/kerberos.py @@ -5899,6 +5899,7 @@ def GSS_Accept_sec_context( password=self.PASSWORD, ) self.TGT, self.TGTSessionKey = res.asrep.ticket, res.sessionkey + self.KEY = self.TGTSessionKey # Server receives AP-req, sends AP-rep if isinstance(input_token, KRB_AP_REQ): @@ -5921,7 +5922,6 @@ def GSS_Accept_sec_context( if isinstance(ap_req, KRB_TGT_REQ): # Special U2U case - Context.U2U = True return ( None, KRB_GSSAPI_Token( @@ -5946,7 +5946,6 @@ def GSS_Accept_sec_context( # If using a UPN, require U2U if self.UPN and ap_req.apOptions.val[1] != "1": # use-session-key # Required but not provided. Return an error - Context.U2U = True err = KRB_GSSAPI_Token( innerToken=KRB_InnerToken( TOK_ID=b"\x03\x00", From dd266e1e80ce67d0c73482ccde8e77081bada279 Mon Sep 17 00:00:00 2001 From: gpotter2 <10530980+gpotter2@users.noreply.github.com> Date: Tue, 17 Nov 2026 23:06:42 +0100 Subject: [PATCH 3/3] answeringmachine: cleanup + dnsd over TCP --- scapy/ansmachine.py | 215 +++++++++++++++----------------- scapy/contrib/automotive/ecu.py | 4 +- scapy/layers/dns.py | 184 ++++++++++++++++----------- scapy/layers/l2.py | 4 +- scapy/layers/llmnr.py | 2 +- 5 files changed, 220 insertions(+), 189 deletions(-) diff --git a/scapy/ansmachine.py b/scapy/ansmachine.py index 3c5cb865d33..cb2281e982c 100644 --- a/scapy/ansmachine.py +++ b/scapy/ansmachine.py @@ -12,6 +12,7 @@ ######################## import abc +import enum import functools import threading import socket @@ -68,6 +69,23 @@ def __new__(cls, class AnsweringMachine(Generic[_T], metaclass=ReferenceAM): + """ + This class acts as a template of a small server that answers stimuli. + + The following classes should be extended: + + - parse_options -> store / process a parameter + - make_reply -> called with a request to make a reply + - is_request -> acts as a filter for requests + + By default, it listens on a RAW socket, but it can be configured to run + on a normal socket (UDP, TCP, ...) if necessary, through the ansmode param. + + In RAW mode, set a "filter" class attribute to use a BPF filter. + + Provide a "function_name" class attribute to register the answering machine + as a command. + """ function_name = "" filter = None # type: Optional[str] sniff_options = {"store": 0} # type: Dict[str, Any] @@ -77,17 +95,23 @@ class AnsweringMachine(Generic[_T], metaclass=ReferenceAM): send_options_list = ["iface", "inter", "loop", "verbose", "socket"] send_function = staticmethod(sendp) + class MODE(enum.IntEnum): + RAW = socket.SOCK_RAW + TCP = socket.SOCK_STREAM + UDP = socket.SOCK_DGRAM + def __init__(self, **kargs): # type: (Any) -> None - self.mode = 0 + self.mode = kargs.pop("ansmode", self.MODE.RAW) self.verbose = kargs.get("verbose", conf.verb >= 0) + self.port = kargs.get("port", 0) + self.cls = kargs.get("cls", conf.raw_layer) if self.filter: kargs.setdefault("filter", self.filter) kargs.setdefault("prn", self.reply) - self.optam1 = {} # type: Dict[str, Any] - self.optam2 = {} # type: Dict[str, Any] - self.optam0 = {} # type: Dict[str, Any] - doptsend, doptsniff = self.parse_all_options(1, kargs) + doptsend, doptsniff, defoptuser = self.split_all_options(kargs) + self.defoptuser = defoptuser + self.parse_options(**defoptuser) self.defoptsend = self.send_options.copy() self.defoptsend.update(doptsend) self.defoptsniff = self.sniff_options.copy() @@ -95,27 +119,12 @@ def __init__(self, **kargs): self.optsend = {} # type: Dict[str, Any] self.optsniff = {} # type: Dict[str, Any] - def __getattr__(self, attr): - # type: (str) -> Any - for dct in [self.optam2, self.optam1]: - if attr in dct: - return dct[attr] - raise AttributeError(attr) - - def __setattr__(self, attr, val): - # type: (str, Any) -> None - mode = self.__dict__.get("mode", 0) - if mode == 0: - self.__dict__[attr] = val - else: - [self.optam1, self.optam2][mode - 1][attr] = val - def parse_options(self): # type: () -> None pass - def parse_all_options(self, mode, kargs): - # type: (int, Any) -> Tuple[Dict[str, Any], Dict[str, Any]] + def split_all_options(self, kargs): + # type: (Any) -> Tuple[Dict[str, Any], Dict[str, Any], Dict[str, Any]] sniffopt = {} # type: Dict[str, Any] sendopt = {} # type: Dict[str, Any] for k in list(kargs): # use list(): kargs is modified in the loop @@ -125,27 +134,14 @@ def parse_all_options(self, mode, kargs): sendopt[k] = kargs[k] if k in self.sniff_options_list + self.send_options_list: del kargs[k] - if mode != 2 or kargs: - if mode == 1: - self.optam0 = kargs - elif mode == 2 and kargs: - k = self.optam0.copy() - k.update(kargs) - self.parse_options(**k) - kargs = k - omode = self.__dict__.get("mode", 0) - self.__dict__["mode"] = mode - self.parse_options(**kargs) - self.__dict__["mode"] = omode - return sendopt, sniffopt + return sendopt, sniffopt, kargs def is_request(self, req): # type: (Packet) -> int return 1 @abc.abstractmethod - def make_reply(self, req): - # type: (Packet) -> _T + def make_reply(self, req: Packet, address: Optional[Any] = None) -> _T: pass def send_reply(self, reply, send_function=None): @@ -168,9 +164,10 @@ def reply(self, pkt, send_function=None, address=None): if not self.is_request(pkt): return if address: - # Only on AnsweringMachineTCP - reply = self.make_reply(pkt, address=address) # type: ignore + reply = self.make_reply(pkt, address) else: + # For backwards compatibility, we don't pass address if undefined (RAW) + # since the 'address' parameter is new reply = self.make_reply(pkt) if not reply: return @@ -199,12 +196,20 @@ def bg(self, *args, **kwargs): def __call__(self, *args, **kargs): # type: (Any, Any) -> None bg = kargs.pop("bg", False) - optsend, optsniff = self.parse_all_options(2, kargs) + + # Separate the kargs in the send/sniff/user + optsend, optsniff, optuser = self.split_all_options(kargs) self.optsend = self.defoptsend.copy() self.optsend.update(optsend) self.optsniff = self.defoptsniff.copy() self.optsniff.update(optsniff) + # Finally call the AnsweringMachine's parse_options with user + # provided arguments. + kargs = self.defoptuser.copy() + kargs.update(optuser) + self.parse_options(**kargs) + if bg: self.sniff_bg() else: @@ -213,80 +218,62 @@ def __call__(self, *args, **kargs): except KeyboardInterrupt: print("Interrupted by user") - def sniff(self): - # type: () -> None - sniff(**self.optsniff) - - def sniff_bg(self): - # type: () -> None - self.sniffer = AsyncSniffer(**self.optsniff) - self.sniffer.start() - - -class AnsweringMachineTCP(AnsweringMachine[Packet]): - """ - An answering machine that use the classic socket.socket to - answer multiple TCP clients - """ - TYPE = socket.SOCK_STREAM - - def parse_options(self, port=80, cls=conf.raw_layer): - # type: (int, Type[Packet]) -> None - self.port = port - self.cls = cls - - def close(self): - # type: () -> None - pass - - def sniff(self): - # type: () -> None - from scapy.supersocket import StreamSocket - ssock = socket.socket(socket.AF_INET, self.TYPE) - try: - ssock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) - except OSError: - pass - ssock.bind( - (get_if_addr(self.optsniff.get("iface", conf.iface)), self.port)) - ssock.listen() - sniffers = [] - try: - while True: - clientsocket, address = ssock.accept() - print("%s connected" % repr(address)) - sock = StreamSocket(clientsocket, self.cls) - optsniff = self.optsniff.copy() - optsniff["prn"] = functools.partial(self.reply, - send_function=sock.send, - address=address) - del optsniff["iface"] - sniffer = AsyncSniffer(opened_socket=sock, **optsniff) - sniffer.start() - sniffers.append((sniffer, sock)) - finally: - for (sniffer, sock) in sniffers: - try: - sniffer.stop() - except Exception: - pass - sock.close() - self.close() - ssock.close() + def sniff(self) -> None: + """ + Start sniffing. This is blocking + """ + if self.mode == self.MODE.RAW: + # Sniff using RAW method. + sniff(**self.optsniff) + elif self.mode in [self.MODE.TCP, self.MODE.UDP]: + # Sniff using a normal socket + from scapy.supersocket import StreamSocket + ssock = socket.socket(socket.AF_INET, self.mode) + try: + ssock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + except OSError: + pass + ssock.bind( + ( + get_if_addr(self.optsniff.get("iface", conf.iface)), + self.port + ) + ) + if self.mode == self.MODE.TCP: + ssock.listen() + sniffers = [] + try: + while True: + clientsocket, address = ssock.accept() + print("%s connected" % repr(address)) + sock = StreamSocket(clientsocket, self.cls) + optsniff = self.optsniff.copy() + optsniff["prn"] = functools.partial(self.reply, + send_function=sock.send, + address=address) + optsniff.pop("iface", None) + sniffer = AsyncSniffer(opened_socket=sock, **optsniff) + sniffer.start() + sniffers.append((sniffer, sock)) + finally: + for (sniffer, sock) in sniffers: + try: + sniffer.stop() + except Exception: + pass + sock.close() + ssock.close() + else: + raise ValueError def sniff_bg(self): # type: () -> None - self.sniffer = threading.Thread(target=self.sniff) # type: ignore - self.sniffer.start() - - def make_reply(self, req, address=None): - # type: (Packet, Optional[Any]) -> Packet - return req - - -class AnsweringMachineUDP(AnsweringMachineTCP): - """ - An answering machine that use the classic socket.socket to - answer multiple UDP clients - """ - TYPE = socket.SOCK_DGRAM + if self.mode == self.MODE.RAW: + self.sniffer = AsyncSniffer(**self.optsniff) + self.sniffer.start() + elif self.mode in [self.MODE.TCP, self.MODE.UDP]: + # Sniff using a normal socket + self.sniffer = threading.Thread(target=self.sniff) # type: ignore + self.sniffer.start() + else: + raise ValueError diff --git a/scapy/contrib/automotive/ecu.py b/scapy/contrib/automotive/ecu.py index 948feba8990..6f3eebba739 100644 --- a/scapy/contrib/automotive/ecu.py +++ b/scapy/contrib/automotive/ecu.py @@ -714,8 +714,8 @@ def is_request(self, req): # type: (Packet) -> bool return isinstance(req, self._basecls) - def make_reply(self, req): - # type: (Packet) -> PacketList + def make_reply(self, req, addr=None): + # type: (Packet, Any) -> PacketList """ Checks if a given request can be answered by the internal list of EcuResponses. First, it's evaluated if the internal EcuState of this diff --git a/scapy/layers/dns.py b/scapy/layers/dns.py index de000aaacda..39f5bc50081 100644 --- a/scapy/layers/dns.py +++ b/scapy/layers/dns.py @@ -238,14 +238,21 @@ def DNSgetstr(*args, **kwargs): def dns_compress(pkt): - """This function compresses a DNS packet according to compression rules. + """ + This function compresses a DNS packet according to compression rules. """ if DNS not in pkt: raise Scapy_Exception("Can only compress DNS layers") + pkt = pkt.copy() dns_pkt = pkt.getlayer(DNS) dns_pkt.clear_cache() + + # Have a binary representation of that DNS packet, + # so that we can calculate the indexes of the replacements. build_pkt = raw(dns_pkt) + if dns_pkt.istcp(): + build_pkt = build_pkt[2:] def field_gen(dns_pkt): """Iterates through all DNS strings that can be compressed""" @@ -268,6 +275,7 @@ def possible_shortens(dat): yield dat for x in range(1, dat.count(b".")): yield dat.split(b".", x)[x] + data = {} for current, name, dat in field_gen(dns_pkt): for part in possible_shortens(dat): @@ -294,6 +302,7 @@ def possible_shortens(dat): 1 ) break + # Apply compression rules for ck in data: # compression_key is a DNS string @@ -314,6 +323,7 @@ def possible_shortens(dat): del rep[0].rdlen except AttributeError: pass + # End of the compression algorithm # Destroy the previous DNS layer if needed if not isinstance(pkt, DNS) and pkt.getlayer(DNS).underlayer: @@ -1298,7 +1308,7 @@ class DNS(DNSCompressedPacket): FORCE_TCP = False fields_desc = [ ConditionalField(ShortField("length", None), - lambda p: p.FORCE_TCP or isinstance(p.underlayer, TCP)), + lambda p: p.istcp()), ShortField("id", 0), BitField("qr", 0, 1), BitEnumField("opcode", 0, 4, {0: "QUERY", 1: "IQUERY", 2: "STATUS"}), @@ -1323,9 +1333,12 @@ class DNS(DNSCompressedPacket): _DNSPacketListField("ar", [], _DNSRR, count_from=lambda pkt: pkt.arcount), ] + def istcp(self): + return isinstance(self.underlayer, TCP) or self.FORCE_TCP + def get_full(self): # Required for DNSCompressedPacket - if isinstance(self.underlayer, TCP) or self.FORCE_TCP: + if self.istcp(): return self.original[2:] else: return self.original @@ -1557,20 +1570,24 @@ def dyndns_del(nameserver, name, type="ALL", ttl=10): class DNS_am(AnsweringMachine): function_name = "dnsd" filter = "udp port 53" - cls = DNS # We also use this automaton for llmnrd / mdnsd - - def parse_options(self, joker=None, - match=None, - srvmatch=None, - joker6=False, - send_error=False, - relay=False, - from_ip=True, - from_ip6=False, - src_ip=None, - src_ip6=None, - ttl=10, - jokerarpa=False): + port = 53 + am = "dns" # We also use this automaton for llmnrd / mdnsd + + def parse_options( + self, + joker=None, + match=None, + srvmatch=None, + joker6=False, + send_error=False, + relay=False, + from_ip=True, + from_ip6=False, + src_ip=None, + src_ip6=None, + ttl=10, + jokerarpa=False, + ): """ Simple DNS answering machine. @@ -1634,8 +1651,17 @@ def parse_options(self, joker=None, """ from scapy.layers.inet6 import Net6 - self.mDNS = isinstance(self, mDNS_am) - self.llmnr = self.cls != DNS + self.mDNS = self.am == "mdns" + self.llmnr = self.am == "llmnr" + if self.mDNS: + self.cls = DNS + elif self.llmnr: + from scapy.layers.llmnr import LLMNRQuery + self.cls = LLMNRQuery + elif self.mode == self.MODE.TCP: + self.cls = DNSTCP + else: + self.cls = DNS # Add some checks (to help) if not isinstance(joker, (str, bool)) and joker is not None: @@ -1729,54 +1755,62 @@ def is_request(self, req): ) ) - def make_reply(self, req): + def make_reply(self, req, addr=None): # Build reply from the request - resp = req.copy() - if Ether in req: - if self.mDNS: - resp[Ether].src, resp[Ether].dst = None, None - elif self.llmnr: - resp[Ether].src, resp[Ether].dst = None, req[Ether].src - else: - resp[Ether].src, resp[Ether].dst = ( - None if req[Ether].dst == "ff:ff:ff:ff:ff:ff" else req[Ether].dst, - req[Ether].src, - ) - from scapy.layers.inet6 import IPv6 - if IPv6 in req: - resp[IPv6].underlayer.remove_payload() - if self.mDNS: - # "All Multicast DNS responses (including responses sent via unicast) - # SHOULD be sent with IP TTL set to 255." - resp /= IPv6(dst="ff02::fb", src=self.src_ip6, - fl=req[IPv6].fl, hlim=255) - elif self.llmnr: - resp /= IPv6(dst=req[IPv6].src, src=self.src_ip6, - fl=req[IPv6].fl, hlim=req[IPv6].hlim) - else: - resp /= IPv6(dst=req[IPv6].src, src=self.src_ip6 or req[IPv6].dst, - fl=req[IPv6].fl, hlim=req[IPv6].hlim) - elif IP in req: - resp[IP].underlayer.remove_payload() - if self.mDNS: - # "All Multicast DNS responses (including responses sent via unicast) - # SHOULD be sent with IP TTL set to 255." - resp /= IP(dst="224.0.0.251", src=self.src_ip, - id=req[IP].id, ttl=255) - elif self.llmnr: - resp /= IP(dst=req[IP].src, src=self.src_ip, - id=req[IP].id, ttl=req[IP].ttl) - else: - resp /= IP(dst=req[IP].src, src=self.src_ip or req[IP].dst, - id=req[IP].id, ttl=req[IP].ttl) + if self.mode != self.MODE.RAW: + resp = None else: - warning("No IP or IPv6 layer in %s", req.command()) - return - try: - resp /= UDP(sport=req[UDP].dport, dport=req[UDP].sport) - except IndexError: - warning("No UDP layer in %s", req.command(), exc_info=True) - return + resp = req.copy() + if Ether in req: + if self.mDNS: + resp[Ether].src, resp[Ether].dst = None, None + elif self.llmnr: + resp[Ether].src, resp[Ether].dst = None, req[Ether].src + else: + resp[Ether].src, resp[Ether].dst = ( + None if req[Ether].dst == "ff:ff:ff:ff:ff:ff" + else req[Ether].dst, + req[Ether].src, + ) + from scapy.layers.inet6 import IPv6 + if IPv6 in req: + resp[IPv6].underlayer.remove_payload() + if self.mDNS: + # "All Multicast DNS responses (including responses sent via + # unicast) SHOULD be sent with IP TTL set to 255." + resp /= IPv6(dst="ff02::fb", src=self.src_ip6, + fl=req[IPv6].fl, hlim=255) + elif self.llmnr: + resp /= IPv6(dst=req[IPv6].src, src=self.src_ip6, + fl=req[IPv6].fl, hlim=req[IPv6].hlim) + else: + resp /= IPv6(dst=req[IPv6].src, src=self.src_ip6 or req[IPv6].dst, + fl=req[IPv6].fl, hlim=req[IPv6].hlim) + elif IP in req: + resp[IP].underlayer.remove_payload() + if self.mDNS: + # "All Multicast DNS responses (including responses sent via + # unicast) SHOULD be sent with IP TTL set to 255." + resp /= IP(dst="224.0.0.251", src=self.src_ip, + id=req[IP].id, ttl=255) + elif self.llmnr: + resp /= IP(dst=req[IP].src, src=self.src_ip, + id=req[IP].id, ttl=req[IP].ttl) + else: + resp /= IP(dst=req[IP].src, src=self.src_ip or req[IP].dst, + id=req[IP].id, ttl=req[IP].ttl) + else: + warning("No IP or IPv6 layer in %s", req.command()) + return + + if UDP in req: + try: + resp /= UDP(sport=req[UDP].dport, dport=req[UDP].sport) + except IndexError: + warning("No UDP layer in %s", req.command(), exc_info=True) + return + + # Common to all modes try: req = req[self.cls] except IndexError: @@ -1927,8 +1961,11 @@ def make_reply(self, req): if not ans: # No answer is available. if self.send_error: - resp /= self.cls(id=req.id, qr=1, qd=req.qd, rcode=3) - return resp + err = self.cls(id=req.id, qr=1, qd=req.qd, rcode=3) + if resp: + return resp / err + else: + return err log_runtime.info("No answer could be provided to: %s" % req.summary()) return # Handle Additional Records @@ -1942,18 +1979,24 @@ def make_reply(self, req): ), ], )) + # All rq were answered if self.mDNS: # in mDNS mode, don't repeat the question, set aa=1, rd=0 dns = self.cls(id=req.id, aa=1, rd=0, qr=1, qd=[], ar=ars, an=ans) else: dns = self.cls(id=req.id, qr=1, qd=req.qd, ar=ars, an=ans) + # Compress DNS and mDNS if not self.llmnr: - resp /= dns_compress(dns) + result = dns_compress(dns) + else: + result = dns + + if resp: + return resp / result else: - resp /= dns - return resp + return result class mDNS_am(DNS_am): @@ -1985,6 +2028,7 @@ class mDNS_am(DNS_am): """ function_name = "mdnsd" filter = "udp port 5353" + am = "mdns" # DNS-SD (RFC 6763) diff --git a/scapy/layers/l2.py b/scapy/layers/l2.py index 05bb6ba0c2b..00a5f54eaea 100644 --- a/scapy/layers/l2.py +++ b/scapy/layers/l2.py @@ -1183,8 +1183,8 @@ def is_request(self, req): (self.from_ip is None or arp.psrc in self.from_ip) ) - def make_reply(self, req): - # type: (Packet) -> Packet + def make_reply(self, req, addr=None): + # type: (Packet, Any) -> Packet ether = req[Ether] arp = req[ARP] diff --git a/scapy/layers/llmnr.py b/scapy/layers/llmnr.py index bdda3a20608..142c4b4a6b6 100644 --- a/scapy/layers/llmnr.py +++ b/scapy/layers/llmnr.py @@ -120,7 +120,7 @@ class LLMNR_am(DNS_am): """ function_name = "llmnrd" filter = "udp port 5355" - cls = LLMNRQuery + am = "llmnr" # LLMNRQuery(id=RandShort(), qd=DNSQR(qname="vista.")))