scapy.layers.dns

DNS: Domain Name System

This implements: - RFC1035: Domain Names - RFC6762: Multicast DNS - RFC6763: DNS-Based Service Discovery

class scapy.layers.dns.ClientSubnetv4(name: str, default: bytes, length_from: Callable[[Packet], int] | None = None, max_length: Any | None = None)[source]

Bases: StrLenField

af_default = b'\xc0'

af_familly = 2

af_length = 32

getfield(pkt: Packet, s: bytes) → Tuple[bytes, I][source]

i2len(pkt: Packet, x: Any) → int[source]

i2m(pkt: Packet | None, x: str | Net | None) → bytes[source]

m2i(pkt: Packet | None, x: bytes) → str[source]

class scapy.layers.dns.ClientSubnetv6(name: str, default: bytes, length_from: Callable[[Packet], int] | None = None, max_length: Any | None = None)[source]

Bases: ClientSubnetv4

af_default = b' '

af_familly = 10

af_length = 128

class scapy.layers.dns.DNS(_pkt, /, *, length=None, id=0, qr=0, opcode=0, aa=0, tc=0, rd=1, ra=0, z=0, ad=0, cd=0, rcode=0, qdcount=None, ancount=None, nscount=None, arcount=None, qd=[<DNSQR |>], an=[], ns=[], ar=[])[source]

Bases: DNSCompressedPacket

FORCE_TCP = False

aliastypes = [<class 'scapy.layers.dns.DNS'>, <class 'scapy.layers.dns.DNSCompressedPacket'>, <class 'scapy.packet.Packet'>]

answers(other)[source]

compress()[source]: Return the compressed DNS packet (using dns_compress())

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<scapy.fields.ConditionalField object>, <ShortField (DNS,DNSTCP).id>, <BitField (DNS,DNSTCP).qr>, <BitEnumField (DNS,DNSTCP).opcode>, <BitField (DNS,DNSTCP).aa>, <BitField (DNS,DNSTCP).tc>, <BitField (DNS,DNSTCP).rd>, <BitField (DNS,DNSTCP).ra>, <BitField (DNS,DNSTCP).z>, <BitField (DNS,DNSTCP).ad>, <BitField (DNS,DNSTCP).cd>, <BitEnumField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).rcode>, <FieldLenField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).qdcount>, <FieldLenField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).ancount>, <FieldLenField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).nscount>, <FieldLenField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).arcount>, <_DNSPacketListField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).qd>, <_DNSPacketListField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).an>, <_DNSPacketListField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).ns>, <_DNSPacketListField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).ar>]

get_full()[source]

mysummary()[source]

post_build(pkt, pay)[source]

pre_dissect(s)[source]: Check that a valid DNS over TCP message can be decoded

class scapy.layers.dns.DNSCompressedPacket(_pkt, /)[source]

Bases: Packet

Class to mark that a packet contains DNSStrField and supports compression

aliastypes = [<class 'scapy.layers.dns.DNSCompressedPacket'>, <class 'scapy.packet.Packet'>]

abstractmethod get_full()[source]

class scapy.layers.dns.DNSQR(_pkt, /, *, qname=b'www.example.com.', qtype=1, unicastresponse=0, qclass=1)[source]

Bases: Packet

aliastypes = [<class 'scapy.layers.dns.DNSQR'>, <class 'scapy.packet.Packet'>]

default_payload_class(payload)[source]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSQR).qname>, <ShortEnumField (DNSQR).qtype>, <BitField (DNSQR).unicastresponse>, <BitEnumField (DNSQR).qclass>]

show_indent = 0

class scapy.layers.dns.DNSRR(_pkt, /, *, rrname=b'.', type=1, cacheflush=0, rclass=1, ttl=0, rdlen=None, rdata=None)[source]

Bases: Packet

aliastypes = [<class 'scapy.layers.dns.DNSRR'>, <class 'scapy.packet.Packet'>]

default_payload_class(payload)[source]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRR).rrname>, <ShortEnumField (DNSRR).type>, <BitField (DNSRR).cacheflush>, <BitEnumField (DNSRR).rclass>, <IntField (DNSRR).ttl>, <FieldLenField (DNSRR).rdlen>, <scapy.fields.MultipleTypeField object>]

show_indent = 0

class scapy.layers.dns.DNSRRDLV(_pkt, /, *, rrname=b'.', type=43, cacheflush=0, rclass=1, ttl=0, rdlen=None, keytag=0, algorithm=5, digesttype=5, digest=b'')[source]

Bases: DNSRRDS

aliastypes = [<class 'scapy.layers.dns.DNSRRDLV'>, <class 'scapy.layers.dns.DNSRRDS'>, <class 'scapy.layers.dns._DNSRRdummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRRDS,DNSRRDLV).rrname>, <ShortEnumField (DNSRRDS,DNSRRDLV).type>, <BitField (DNSRRDS,DNSRRDLV).cacheflush>, <BitEnumField (DNSRRDS,DNSRRDLV).rclass>, <IntField (DNSRRDS,DNSRRDLV).ttl>, <ShortField (DNSRRDS,DNSRRDLV).rdlen>, <ShortField (DNSRRDS,DNSRRDLV).keytag>, <ByteEnumField (DNSRRDS,DNSRRDLV).algorithm>, <ByteEnumField (DNSRRDS,DNSRRDLV).digesttype>, <StrField (DNSRRDS,DNSRRDLV).digest>]

class scapy.layers.dns.DNSRRDNSKEY(_pkt, /, *, rrname=b'.', type=48, cacheflush=0, rclass=1, ttl=0, rdlen=None, flags=<Flag 256 (Z)>, protocol=3, algorithm=5, publickey=b'')[source]

Bases: _DNSRRdummy

aliastypes = [<class 'scapy.layers.dns.DNSRRDNSKEY'>, <class 'scapy.layers.dns._DNSRRdummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRRDNSKEY).rrname>, <ShortEnumField (DNSRRDNSKEY).type>, <BitField (DNSRRDNSKEY).cacheflush>, <BitEnumField (DNSRRDNSKEY).rclass>, <IntField (DNSRRDNSKEY).ttl>, <ShortField (DNSRRDNSKEY).rdlen>, <FlagsField (DNSRRDNSKEY).flags>, <ByteField (DNSRRDNSKEY).protocol>, <ByteEnumField (DNSRRDNSKEY).algorithm>, <StrField (DNSRRDNSKEY).publickey>]

class scapy.layers.dns.DNSRRDS(_pkt, /, *, rrname=b'.', type=43, cacheflush=0, rclass=1, ttl=0, rdlen=None, keytag=0, algorithm=5, digesttype=5, digest=b'')[source]

Bases: _DNSRRdummy

aliastypes = [<class 'scapy.layers.dns.DNSRRDS'>, <class 'scapy.layers.dns._DNSRRdummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRRDS,DNSRRDLV).rrname>, <ShortEnumField (DNSRRDS,DNSRRDLV).type>, <BitField (DNSRRDS,DNSRRDLV).cacheflush>, <BitEnumField (DNSRRDS,DNSRRDLV).rclass>, <IntField (DNSRRDS,DNSRRDLV).ttl>, <ShortField (DNSRRDS,DNSRRDLV).rdlen>, <ShortField (DNSRRDS,DNSRRDLV).keytag>, <ByteEnumField (DNSRRDS,DNSRRDLV).algorithm>, <ByteEnumField (DNSRRDS,DNSRRDLV).digesttype>, <StrField (DNSRRDS,DNSRRDLV).digest>]

class scapy.layers.dns.DNSRRHINFO(_pkt, /, *, rrname=b'.', type=13, cacheflush=0, rclass=1, ttl=0, rdlen=None, cpulen=None, cpu=b'', oslen=None, os=b'')[source]

Bases: _DNSRRdummy

aliastypes = [<class 'scapy.layers.dns.DNSRRHINFO'>, <class 'scapy.layers.dns._DNSRRdummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRRHINFO).rrname>, <ShortEnumField (DNSRRHINFO).type>, <BitField (DNSRRHINFO).cacheflush>, <BitEnumField (DNSRRHINFO).rclass>, <IntField (DNSRRHINFO).ttl>, <ShortField (DNSRRHINFO).rdlen>, <FieldLenField (DNSRRHINFO).cpulen>, <StrLenField (DNSRRHINFO).cpu>, <FieldLenField (DNSRRHINFO).oslen>, <StrLenField (DNSRRHINFO).os>]

class scapy.layers.dns.DNSRRHTTPS(_pkt, /, *, rrname=b'.', type=65, cacheflush=0, rclass=1, ttl=0, rdlen=None, svc_priority=0, target_name=b'.', svc_params=[])[source]

Bases: _DNSRRdummy

aliastypes = [<class 'scapy.layers.dns.DNSRRHTTPS'>, <class 'scapy.layers.dns._DNSRRdummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRRHTTPS).rrname>, <ShortEnumField (DNSRRHTTPS).type>, <BitField (DNSRRSVCB,DNSRRHTTPS).cacheflush>, <BitEnumField (DNSRRSVCB,DNSRRHTTPS).rclass>, <IntField (DNSRRSVCB,DNSRRHTTPS).ttl>, <ShortField (DNSRRSVCB,DNSRRHTTPS).rdlen>, <ShortField (DNSRRSVCB,DNSRRHTTPS).svc_priority>, <DNSStrField (DNSRRSVCB,DNSRRHTTPS).target_name>, <PacketListField (DNSRRSVCB,DNSRRHTTPS).svc_params>]

class scapy.layers.dns.DNSRRMX(_pkt, /, *, rrname=b'.', type=15, cacheflush=0, rclass=1, ttl=0, rdlen=None, preference=0, exchange=b'.')[source]

Bases: _DNSRRdummy

aliastypes = [<class 'scapy.layers.dns.DNSRRMX'>, <class 'scapy.layers.dns._DNSRRdummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRRMX).rrname>, <ShortEnumField (DNSRRMX).type>, <BitField (DNSRRMX).cacheflush>, <BitEnumField (DNSRRMX).rclass>, <IntField (DNSRRMX).ttl>, <ShortField (DNSRRMX).rdlen>, <ShortField (DNSRRMX).preference>, <DNSStrField (DNSRRMX).exchange>]

class scapy.layers.dns.DNSRRNAPTR(_pkt, /, *, rrname=b'.', type=35, cacheflush=0, rclass=1, ttl=0, rdlen=None, order=0, preference=0, flags_len=None, flags=b'', services_len=None, services=b'', regexp_len=None, regexp=b'', replacement=b'.')[source]

Bases: _DNSRRdummy

aliastypes = [<class 'scapy.layers.dns.DNSRRNAPTR'>, <class 'scapy.layers.dns._DNSRRdummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRRNAPTR).rrname>, <ShortEnumField (DNSRRNAPTR).type>, <BitField (DNSRRNAPTR).cacheflush>, <BitEnumField (DNSRRNAPTR).rclass>, <IntField (DNSRRNAPTR).ttl>, <ShortField (DNSRRNAPTR).rdlen>, <ShortField (DNSRRNAPTR).order>, <ShortField (DNSRRNAPTR).preference>, <FieldLenField (DNSRRNAPTR).flags_len>, <StrLenField (DNSRRNAPTR).flags>, <FieldLenField (DNSRRNAPTR).services_len>, <StrLenField (DNSRRNAPTR).services>, <FieldLenField (DNSRRNAPTR).regexp_len>, <StrLenField (DNSRRNAPTR).regexp>, <DNSStrField (DNSRRNAPTR).replacement>]

class scapy.layers.dns.DNSRRNSEC(_pkt, /, *, rrname=b'.', type=47, cacheflush=0, rclass=1, ttl=0, rdlen=None, nextname=b'.', typebitmaps=[])[source]

Bases: _DNSRRdummy

aliastypes = [<class 'scapy.layers.dns.DNSRRNSEC'>, <class 'scapy.layers.dns._DNSRRdummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRRNSEC).rrname>, <ShortEnumField (DNSRRNSEC).type>, <BitField (DNSRRNSEC).cacheflush>, <BitEnumField (DNSRRNSEC).rclass>, <IntField (DNSRRNSEC).ttl>, <ShortField (DNSRRNSEC).rdlen>, <DNSStrField (DNSRRNSEC).nextname>, <RRlistField (DNSRRNSEC).typebitmaps>]

class scapy.layers.dns.DNSRRNSEC3(_pkt, /, *, rrname=b'.', type=50, cacheflush=0, rclass=1, ttl=0, rdlen=None, hashalg=0, flags=0, iterations=0, saltlength=0, salt=b'', hashlength=0, nexthashedownername=b'', typebitmaps=[])[source]

Bases: _DNSRRdummy

aliastypes = [<class 'scapy.layers.dns.DNSRRNSEC3'>, <class 'scapy.layers.dns._DNSRRdummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRRNSEC3).rrname>, <ShortEnumField (DNSRRNSEC3).type>, <BitField (DNSRRNSEC3).cacheflush>, <BitEnumField (DNSRRNSEC3).rclass>, <IntField (DNSRRNSEC3).ttl>, <ShortField (DNSRRNSEC3).rdlen>, <ByteField (DNSRRNSEC3).hashalg>, <BitEnumField (DNSRRNSEC3).flags>, <ShortField (DNSRRNSEC3).iterations>, <FieldLenField (DNSRRNSEC3).saltlength>, <StrLenField (DNSRRNSEC3).salt>, <FieldLenField (DNSRRNSEC3).hashlength>, <StrLenField (DNSRRNSEC3).nexthashedownername>, <RRlistField (DNSRRNSEC3).typebitmaps>]

class scapy.layers.dns.DNSRRNSEC3PARAM(_pkt, /, *, rrname=b'.', type=51, cacheflush=0, rclass=1, ttl=0, rdlen=None, hashalg=0, flags=0, iterations=0, saltlength=0, salt=b'')[source]

Bases: _DNSRRdummy

aliastypes = [<class 'scapy.layers.dns.DNSRRNSEC3PARAM'>, <class 'scapy.layers.dns._DNSRRdummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRRNSEC3PARAM).rrname>, <ShortEnumField (DNSRRNSEC3PARAM).type>, <BitField (DNSRRNSEC3PARAM).cacheflush>, <BitEnumField (DNSRRNSEC3PARAM).rclass>, <IntField (DNSRRNSEC3PARAM).ttl>, <ShortField (DNSRRNSEC3PARAM).rdlen>, <ByteField (DNSRRNSEC3PARAM).hashalg>, <ByteField (DNSRRNSEC3PARAM).flags>, <ShortField (DNSRRNSEC3PARAM).iterations>, <FieldLenField (DNSRRNSEC3PARAM).saltlength>, <StrLenField (DNSRRNSEC3PARAM).salt>]

class scapy.layers.dns.DNSRROPT(_pkt, /, *, rrname=b'.', type=41, rclass=4096, extrcode=0, version=0, z=32768, rdlen=None, rdata=[])[source]

Bases: Packet

aliastypes = [<class 'scapy.layers.dns.DNSRROPT'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRROPT).rrname>, <ShortEnumField (DNSRROPT).type>, <ShortEnumField (DNSRROPT).rclass>, <ByteField (DNSRROPT).extrcode>, <ByteField (DNSRROPT).version>, <BitEnumField (DNSRROPT).z>, <FieldLenField (DNSRROPT).rdlen>, <PacketListField (DNSRROPT).rdata>]

class scapy.layers.dns.DNSRRRSIG(_pkt, /, *, rrname=b'.', type=46, cacheflush=0, rclass=1, ttl=0, rdlen=None, typecovered=1, algorithm=5, labels=0, originalttl=0, expiration=0, inception=0, keytag=0, signersname=b'.', signature=b'')[source]

Bases: _DNSRRdummy

aliastypes = [<class 'scapy.layers.dns.DNSRRRSIG'>, <class 'scapy.layers.dns._DNSRRdummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRRRSIG).rrname>, <ShortEnumField (DNSRRRSIG).type>, <BitField (DNSRRRSIG).cacheflush>, <BitEnumField (DNSRRRSIG).rclass>, <IntField (DNSRRRSIG).ttl>, <ShortField (DNSRRRSIG).rdlen>, <ShortEnumField (DNSRRRSIG).typecovered>, <ByteEnumField (DNSRRRSIG).algorithm>, <ByteField (DNSRRRSIG).labels>, <IntField (DNSRRRSIG).originalttl>, <UTCTimeField (DNSRRRSIG).expiration>, <UTCTimeField (DNSRRRSIG).inception>, <ShortField (DNSRRRSIG).keytag>, <DNSStrField (DNSRRRSIG).signersname>, <StrField (DNSRRRSIG).signature>]

class scapy.layers.dns.DNSRRSOA(_pkt, /, *, rrname=b'.', type=6, rclass=1, ttl=0, rdlen=None, mname=b'.', rname=b'.', serial=0, refresh=0, retry=0, expire=0, minimum=0)[source]

Bases: _DNSRRdummy

aliastypes = [<class 'scapy.layers.dns.DNSRRSOA'>, <class 'scapy.layers.dns._DNSRRdummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRRSOA).rrname>, <ShortEnumField (DNSRRSOA).type>, <ShortEnumField (DNSRRSOA).rclass>, <IntField (DNSRRSOA).ttl>, <ShortField (DNSRRSOA).rdlen>, <DNSStrField (DNSRRSOA).mname>, <DNSStrField (DNSRRSOA).rname>, <IntField (DNSRRSOA).serial>, <IntField (DNSRRSOA).refresh>, <IntField (DNSRRSOA).retry>, <IntField (DNSRRSOA).expire>, <IntField (DNSRRSOA).minimum>]

class scapy.layers.dns.DNSRRSRV(_pkt, /, *, rrname=b'.', type=33, cacheflush=0, rclass=1, ttl=0, rdlen=None, priority=0, weight=0, port=0, target=b'.')[source]

Bases: _DNSRRdummy

aliastypes = [<class 'scapy.layers.dns.DNSRRSRV'>, <class 'scapy.layers.dns._DNSRRdummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRRSRV).rrname>, <ShortEnumField (DNSRRSRV).type>, <BitField (DNSRRSRV).cacheflush>, <BitEnumField (DNSRRSRV).rclass>, <IntField (DNSRRSRV).ttl>, <ShortField (DNSRRSRV).rdlen>, <ShortField (DNSRRSRV).priority>, <ShortField (DNSRRSRV).weight>, <ShortField (DNSRRSRV).port>, <DNSStrField (DNSRRSRV).target>]

class scapy.layers.dns.DNSRRSVCB(_pkt, /, *, rrname=b'.', type=64, cacheflush=0, rclass=1, ttl=0, rdlen=None, svc_priority=0, target_name=b'.', svc_params=[])[source]

Bases: _DNSRRdummy

aliastypes = [<class 'scapy.layers.dns.DNSRRSVCB'>, <class 'scapy.layers.dns._DNSRRdummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRRSVCB).rrname>, <ShortEnumField (DNSRRSVCB).type>, <BitField (DNSRRSVCB,DNSRRHTTPS).cacheflush>, <BitEnumField (DNSRRSVCB,DNSRRHTTPS).rclass>, <IntField (DNSRRSVCB,DNSRRHTTPS).ttl>, <ShortField (DNSRRSVCB,DNSRRHTTPS).rdlen>, <ShortField (DNSRRSVCB,DNSRRHTTPS).svc_priority>, <DNSStrField (DNSRRSVCB,DNSRRHTTPS).target_name>, <PacketListField (DNSRRSVCB,DNSRRHTTPS).svc_params>]

class scapy.layers.dns.DNSRRTSIG(_pkt, /, *, rrname=b'.', type=250, rclass=1, ttl=0, rdlen=None, algo_name=b'hmac-sha1.', time_signed=0, fudge=0, mac_len=20, mac_data=b'', original_id=0, error=0, other_len=0, other_data=b'')[source]

Bases: _DNSRRdummy

aliastypes = [<class 'scapy.layers.dns.DNSRRTSIG'>, <class 'scapy.layers.dns._DNSRRdummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<DNSStrField (DNSRRTSIG).rrname>, <ShortEnumField (DNSRRTSIG).type>, <ShortEnumField (DNSRRTSIG).rclass>, <IntField (DNSRRTSIG).ttl>, <ShortField (DNSRRTSIG).rdlen>, <DNSStrField (DNSRRTSIG).algo_name>, <TimeSignedField (DNSRRTSIG).time_signed>, <ShortField (DNSRRTSIG).fudge>, <FieldLenField (DNSRRTSIG).mac_len>, <StrLenField (DNSRRTSIG).mac_data>, <ShortField (DNSRRTSIG).original_id>, <ShortField (DNSRRTSIG).error>, <FieldLenField (DNSRRTSIG).other_len>, <StrLenField (DNSRRTSIG).other_data>]

class scapy.layers.dns.DNSSDResult(res=None, name='DNS-SD', stats=None)[source]

Bases: SndRcvList

show(types: List[str] = ['PTR', 'SRV'], alltypes: bool = False) → None[source]

Print the list of discovered services.

Parameters:

types – types to show. Default [‘PTR’, ‘SRV’]
alltypes – show all types. Default False

class scapy.layers.dns.DNSStrField(name: str, default: bytes, length_from: Callable[[Packet], int] | None = None, max_length: Any | None = None)[source]

Bases: StrLenField

Special StrField that handles DNS encoding/decoding. It will also handle DNS decompression. (may be StrLenField if a length_from is passed),

any2i(pkt, x)[source]

get_full(pkt)[source]

getfield(pkt, s)[source]

h2i(pkt, x)[source]

i2len(pkt, x)[source]

i2m(pkt, x)[source]

class scapy.layers.dns.DNSTCP(_pkt, /, *, length=None, id=0, qr=0, opcode=0, aa=0, tc=0, rd=1, ra=0, z=0, ad=0, cd=0, rcode=0, qdcount=None, ancount=None, nscount=None, arcount=None, qd=[<DNSQR |>], an=[], ns=[], ar=[])[source]

Bases: DNS

A DNS packet that is always under TCP

FORCE_TCP = True

aliastypes = [<class 'scapy.layers.dns.DNSTCP'>, <class 'scapy.layers.dns.DNS'>, <class 'scapy.layers.dns.DNSCompressedPacket'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<scapy.fields.ConditionalField object>, <ShortField (DNS,DNSTCP).id>, <BitField (DNS,DNSTCP).qr>, <BitEnumField (DNS,DNSTCP).opcode>, <BitField (DNS,DNSTCP).aa>, <BitField (DNS,DNSTCP).tc>, <BitField (DNS,DNSTCP).rd>, <BitField (DNS,DNSTCP).ra>, <BitField (DNS,DNSTCP).z>, <BitField (DNS,DNSTCP).ad>, <BitField (DNS,DNSTCP).cd>, <BitEnumField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).rcode>, <FieldLenField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).qdcount>, <FieldLenField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).ancount>, <FieldLenField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).nscount>, <FieldLenField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).arcount>, <_DNSPacketListField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).qd>, <_DNSPacketListField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).an>, <_DNSPacketListField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).ns>, <_DNSPacketListField (DNS,DNSTCP,LLMNRQuery,LLMNRResponse).ar>]

match_subclass = True

class scapy.layers.dns.DNSTextField(name: str, default: bytes, length_from: Callable[[Packet], int] | None = None, max_length: Any | None = None)[source]

Bases: StrLenField

Special StrLenField that handles DNS TEXT data (16)

any2i(pkt, x)[source]

i2h(pkt, x)[source]

i2len(pkt, x)[source]

i2m(pkt, s)[source]

islist = 1

m2i(pkt, s)[source]

class scapy.layers.dns.DNS_am(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)[source]

Bases: AnsweringMachine

cls[source]: alias of DNS

filter: str | None = 'udp port 53'

function_name = 'dnsd'

is_request(req)[source]

make_reply(req)[source]

parse_options(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)[source]

Simple DNS answering machine.

Parameters:

joker – default IPv4 for unresolved domains. Set to False to disable, None to mirror the interface’s IP. Defaults to None, unless ‘match’ is used, then it defaults to False.
joker6 – default IPv6 for unresolved domains. Set to False to disable, None to mirror the interface’s IPv6. Defaults to False.
match – queries to match. This can be a dictionary of {name: val} where name is a string representing a domain name (A, AAAA) and val is a tuple of 2 elements, each representing an IP or a list of IPs. If val is a single element, (A, None) is assumed. This can also be a list or names, in which case joker(6) are used as a response.
jokerarpa – answer for .in-addr.arpa PTR requests. (Default: False)
relay – relay unresolved domains to conf.nameservers (Default: False).
send_error – send an error message when this server can’t answer (Default: False)
srvmatch – a dictionary of {name: (port, target)} used for SRV
from_ip – an source IP to filter. Can contain a netmask. True for all, False for none. Default True
from_ip6 – an source IPv6 to filter. Can contain a netmask. True for all, False for none. Default False
ttl – the DNS time to live (in seconds)
src_ip – override the source IP
src_ip6

Examples:

Answer all ‘A’ and ‘AAAA’ requests:

$ sudo iptables -I OUTPUT -p icmp --icmp-type 3/3 -j DROP
>>> dnsd(joker="192.168.0.2", joker6="fe80::260:8ff:fe52:f9d8",
...      iface="eth0")

Answer only ‘A’ query for google.com with 192.168.0.2:

>>> dnsd(match={"google.com": "192.168.0.2"}, iface="eth0")

Answer DNS for a Windows domain controller (‘SRV’, ‘A’ and ‘AAAA’):

>>> dnsd(
...     srvmatch={
...         "_ldap._tcp.dc._msdcs.DOMAIN.LOCAL.": (389,
...                                                "srv1.domain.local"),
...     },
...     match={"src1.domain.local": ("192.168.0.102",
...                                  "fe80::260:8ff:fe52:f9d8")},
... )

Relay all queries to another DNS server, except some:

>>> conf.nameservers = ["1.1.1.1"]  # server to relay to
>>> dnsd(
...     match={"test.com": "1.1.1.1"},
...     relay=True,
... )

scapy.layers.dns.DNSgetstr(*args, **kwargs)[source]: Legacy function. Deprecated

class scapy.layers.dns.EDNS0COOKIE(_pkt, /, *, optcode=10, optlen=None, client_cookie=b'\x00\x00\x00\x00\x00\x00\x00\x00', server_cookie=b'')[source]

Bases: _EDNS0Dummy

aliastypes = [<class 'scapy.layers.dns.EDNS0COOKIE'>, <class 'scapy.layers.dns._EDNS0Dummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<ShortEnumField (EDNS0COOKIE).optcode>, <FieldLenField (EDNS0COOKIE).optlen>, <XStrFixedLenField (EDNS0COOKIE).client_cookie>, <XStrLenField (EDNS0COOKIE).server_cookie>]

class scapy.layers.dns.EDNS0ClientSubnet(_pkt, /, *, optcode=8, optlen=None, family=1, source_plen=None, scope_plen=0, address=None)[source]

Bases: _EDNS0Dummy

aliastypes = [<class 'scapy.layers.dns.EDNS0ClientSubnet'>, <class 'scapy.layers.dns._EDNS0Dummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<ShortEnumField (EDNS0ClientSubnet).optcode>, <FieldLenField (EDNS0ClientSubnet).optlen>, <ShortField (EDNS0ClientSubnet).family>, <FieldLenField (EDNS0ClientSubnet).source_plen>, <ByteField (EDNS0ClientSubnet).scope_plen>, <scapy.fields.MultipleTypeField object>]

class scapy.layers.dns.EDNS0DAU(_pkt, /, *, optcode=5, optlen=None, alg_code=[])[source]

Bases: _EDNS0Dummy

aliastypes = [<class 'scapy.layers.dns.EDNS0DAU'>, <class 'scapy.layers.dns._EDNS0Dummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<ShortEnumField (EDNS0DAU).optcode>, <FieldLenField (EDNS0DAU).optlen>, <FieldListField (EDNS0DAU).alg_code>]

class scapy.layers.dns.EDNS0DHU(_pkt, /, *, optcode=6, optlen=None, alg_code=[])[source]

Bases: _EDNS0Dummy

aliastypes = [<class 'scapy.layers.dns.EDNS0DHU'>, <class 'scapy.layers.dns._EDNS0Dummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<ShortEnumField (EDNS0DHU).optcode>, <FieldLenField (EDNS0DHU).optlen>, <FieldListField (EDNS0DHU).alg_code>]

class scapy.layers.dns.EDNS0ExtendedDNSError(_pkt, /, *, optcode=15, optlen=None, info_code=0, extra_text=b'')[source]

Bases: _EDNS0Dummy

aliastypes = [<class 'scapy.layers.dns.EDNS0ExtendedDNSError'>, <class 'scapy.layers.dns._EDNS0Dummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<ShortEnumField (EDNS0ExtendedDNSError).optcode>, <FieldLenField (EDNS0ExtendedDNSError).optlen>, <ShortEnumField (EDNS0ExtendedDNSError).info_code>, <StrLenField (EDNS0ExtendedDNSError).extra_text>]

class scapy.layers.dns.EDNS0N3U(_pkt, /, *, optcode=7, optlen=None, alg_code=[])[source]

Bases: _EDNS0Dummy

aliastypes = [<class 'scapy.layers.dns.EDNS0N3U'>, <class 'scapy.layers.dns._EDNS0Dummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<ShortEnumField (EDNS0N3U).optcode>, <FieldLenField (EDNS0N3U).optlen>, <FieldListField (EDNS0N3U).alg_code>]

class scapy.layers.dns.EDNS0OWN(_pkt, /, *, optcode=4, optlen=None, v=0, s=0, primary_mac='00:00:00:00:00:00', wakeup_mac='00:00:00:00:00:00', password=b'')[source]

Bases: _EDNS0Dummy

aliastypes = [<class 'scapy.layers.dns.EDNS0OWN'>, <class 'scapy.layers.dns._EDNS0Dummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<ShortEnumField (EDNS0OWN).optcode>, <FieldLenField (EDNS0OWN).optlen>, <ByteField (EDNS0OWN).v>, <ByteField (EDNS0OWN).s>, <MACField (EDNS0OWN).primary_mac>, <scapy.fields.ConditionalField object>, <scapy.fields.ConditionalField object>]

post_build(pkt, pay)[source]

class scapy.layers.dns.EDNS0PADDING(_pkt, /, *, optcode=12, optlen=None, padding=b'')[source]

Bases: _EDNS0Dummy

aliastypes = [<class 'scapy.layers.dns.EDNS0PADDING'>, <class 'scapy.layers.dns._EDNS0Dummy'>, <class 'scapy.packet.Packet'>]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<ShortEnumField (EDNS0PADDING).optcode>, <FieldLenField (EDNS0PADDING).optlen>, <StrLenField (EDNS0PADDING).padding>]

class scapy.layers.dns.EDNS0TLV(_pkt, /, *, optcode=0, optlen=None, optdata=b'')[source]

Bases: _EDNS0Dummy

aliastypes = [<class 'scapy.layers.dns.EDNS0TLV'>, <class 'scapy.layers.dns._EDNS0Dummy'>, <class 'scapy.packet.Packet'>]

classmethod dispatch_hook(_pkt: bytes | None = None, *args: Any, **kargs: Any) → Type[Packet][source]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<ShortEnumField (EDNS0TLV).optcode>, <FieldLenField (EDNS0TLV).optlen>, <StrLenField (EDNS0TLV).optdata>]

scapy.layers.dns.RRlist2bitmap(lst)[source]: Encode a list of integers representing Resource Records to a bitmap field used in the NSEC Resource Record.

class scapy.layers.dns.RRlistField(name: str, default: I | None, fmt: str = 'H', remain: int = 0)[source]

Bases: StrField

h2i(pkt, x)[source]

i2repr(pkt, x)[source]

islist = 1

class scapy.layers.dns.SvcParam(_pkt, /, *, key=0, len=None, value=None)[source]

Bases: Packet

aliastypes = [<class 'scapy.layers.dns.SvcParam'>, <class 'scapy.packet.Packet'>]

extract_padding(p)[source]

fields_desc: List[Field[Any, Any] | _FieldContainer] = [<ShortEnumField (SvcParam).key>, <FieldLenField (SvcParam).len>, <scapy.fields.MultipleTypeField object>]

class scapy.layers.dns.TimeSignedField(name, default)[source]

Bases: Field[int, bytes]

i2m(pkt, seconds)[source]: Convert the number of seconds since 1-Jan-70 UTC to the packed representation.

i2repr(pkt, packed_seconds)[source]: Convert the internal representation to a nice one using the RFC format.

m2i(pkt, packed_seconds)[source]: Convert the internal representation to the number of seconds since 1-Jan-70 UTC.

scapy.layers.dns.bitmap2RRlist(bitmap)[source]: Decode the ‘Type Bit Maps’ field of the NSEC Resource Record into an integer list.

scapy.layers.dns.dns_compress(pkt)[source]: This function compresses a DNS packet according to compression rules.

scapy.layers.dns.dns_encode(x, check_built=False)[source]

Encodes a bytes string into the DNS format

Parameters:

x – the string
check_built – detect already-built strings and ignore them

Returns:

the encoded bytes string

scapy.layers.dns.dns_get_str(s, full=None, _ignore_compression=False)[source]

This function decompresses a string s, starting from the given pointer.

Parameters:

s – the string to decompress
full – (optional) the full packet (used for decompression)

Returns:

(decoded_string, end_index, left_string)

scapy.layers.dns.dns_resolve(qname, qtype='A', raw=False, tcp=False, verbose=1, timeout=3, **kwargs)[source]

Perform a simple DNS resolution using conf.nameservers with caching

Parameters:

qname – the name to query
qtype – the type to query (default A)
raw – return the whole DNS packet (default False)
tcp – whether to use directly TCP instead of UDP. If truncated is received, UDP automatically retries in TCP. (default: False)
verbose – show verbose errors
timeout – seconds until timeout (per server)

Raises:

TimeoutError – if no DNS servers were reached in time.

scapy.layers.dns.dnssd(service='_services._dns-sd._udp.local', af=AddressFamily.AF_INET, qtype='PTR', iface=None, verbose=2, timeout=3)[source]

Performs a DNS-SD (RFC6763) request

Parameters:

service – the service name to query (e.g. _spotify-connect._tcp.local)
af – the transport to use. socket.AF_INET or socket.AF_INET6
qtype – the type to use in the mDNS. Either TXT, PTR or SRV.
iface – the interface to do this discovery on.

scapy.layers.dns.dyndns_add(nameserver, name, rdata, type='A', ttl=10)[source]

Send a DNS add message to a nameserver for “name” to have a new “rdata” dyndns_add(nameserver, name, rdata, type=”A”, ttl=10) -> result code (0=ok)

example: dyndns_add(“ns1.toto.com”, “dyn.toto.com”, “127.0.0.1”) RFC2136

scapy.layers.dns.dyndns_del(nameserver, name, type='ALL', ttl=10)[source]

Send a DNS delete message to a nameserver for “name” dyndns_del(nameserver, name, type=”ANY”, ttl=10) -> result code (0=ok)

example: dyndns_del(“ns1.toto.com”, “dyn.toto.com”) RFC2136

class scapy.layers.dns.mDNS_am(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)[source]

Bases: DNS_am

mDNS answering machine.

This has the same arguments as DNS_am. See help(DNS_am)

Example:

- Answer for 'TEST.local' with local IPv4::

    >>> mdnsd(match=["TEST.local"])

- Answer all requests with other IP::

    >>> mdnsd(joker="192.168.0.2", joker6="fe80::260:8ff:fe52:f9d8",
    ...       iface="eth0")

- Answer for multiple different mDNS names::

    >>> mdnsd(match={"TEST.local": "192.168.0.100",
    ...              "BOB.local": "192.168.0.101"})

- Answer with both A and AAAA records::

    >>> mdnsd(match={"TEST.local": ("192.168.0.100",
    ...                             "fe80::260:8ff:fe52:f9d8")})

filter: str | None = 'udp port 5353'

function_name = 'mdnsd'