| ## This file is part of Scapy |
| ## See http://www.secdev.org/projects/scapy for more informations |
| ## Copyright (C) Philippe Biondi <phil@secdev.org> |
| ## This program is published under a GPLv2 license |
| |
| """ |
| PPP (Point to Point Protocol) |
| |
| [RFC 1661] |
| """ |
| |
| import struct |
| from scapy.config import conf |
| from scapy.data import DLT_PPP, DLT_PPP_SERIAL, DLT_PPP_ETHER |
| from scapy.compat import * |
| from scapy.packet import Packet, bind_layers |
| from scapy.layers.eap import EAP |
| from scapy.layers.l2 import Ether, CookedLinux, GRE_PPTP |
| from scapy.layers.inet import IP |
| from scapy.layers.inet6 import IPv6 |
| from scapy.fields import BitField, ByteEnumField, ByteField, \ |
| ConditionalField, FieldLenField, IntField, IPField, \ |
| PacketListField, PacketField, ShortEnumField, ShortField, \ |
| StrFixedLenField, StrLenField, XByteField, XShortField, XStrLenField |
| |
| |
| class PPPoE(Packet): |
| name = "PPP over Ethernet" |
| fields_desc = [ BitField("version", 1, 4), |
| BitField("type", 1, 4), |
| ByteEnumField("code", 0, {0:"Session"}), |
| XShortField("sessionid", 0x0), |
| ShortField("len", None) ] |
| |
| def post_build(self, p, pay): |
| p += pay |
| if self.len is None: |
| l = len(p)-6 |
| p = p[:4]+struct.pack("!H", l)+p[6:] |
| return p |
| |
| class PPPoED(PPPoE): |
| name = "PPP over Ethernet Discovery" |
| fields_desc = [ BitField("version", 1, 4), |
| BitField("type", 1, 4), |
| ByteEnumField("code", 0x09, {0x09:"PADI",0x07:"PADO",0x19:"PADR",0x65:"PADS",0xa7:"PADT"}), |
| XShortField("sessionid", 0x0), |
| ShortField("len", None) ] |
| |
| |
| _PPP_proto = { 0x0001: "Padding Protocol", |
| 0x0003: "ROHC small-CID [RFC3095]", |
| 0x0005: "ROHC large-CID [RFC3095]", |
| 0x0021: "Internet Protocol version 4", |
| 0x0023: "OSI Network Layer", |
| 0x0025: "Xerox NS IDP", |
| 0x0027: "DECnet Phase IV", |
| 0x0029: "Appletalk", |
| 0x002b: "Novell IPX", |
| 0x002d: "Van Jacobson Compressed TCP/IP", |
| 0x002f: "Van Jacobson Uncompressed TCP/IP", |
| 0x0031: "Bridging PDU", |
| 0x0033: "Stream Protocol (ST-II)", |
| 0x0035: "Banyan Vines", |
| 0x0037: "reserved (until 1993) [Typo in RFC1172]", |
| 0x0039: "AppleTalk EDDP", |
| 0x003b: "AppleTalk SmartBuffered", |
| 0x003d: "Multi-Link [RFC1717]", |
| 0x003f: "NETBIOS Framing", |
| 0x0041: "Cisco Systems", |
| 0x0043: "Ascom Timeplex", |
| 0x0045: "Fujitsu Link Backup and Load Balancing (LBLB)", |
| 0x0047: "DCA Remote Lan", |
| 0x0049: "Serial Data Transport Protocol (PPP-SDTP)", |
| 0x004b: "SNA over 802.2", |
| 0x004d: "SNA", |
| 0x004f: "IPv6 Header Compression", |
| 0x0051: "KNX Bridging Data [ianp]", |
| 0x0053: "Encryption [Meyer]", |
| 0x0055: "Individual Link Encryption [Meyer]", |
| 0x0057: "Internet Protocol version 6 [Hinden]", |
| 0x0059: "PPP Muxing [RFC3153]", |
| 0x005b: "Vendor-Specific Network Protocol (VSNP) [RFC3772]", |
| 0x0061: "RTP IPHC Full Header [RFC3544]", |
| 0x0063: "RTP IPHC Compressed TCP [RFC3544]", |
| 0x0065: "RTP IPHC Compressed Non TCP [RFC3544]", |
| 0x0067: "RTP IPHC Compressed UDP 8 [RFC3544]", |
| 0x0069: "RTP IPHC Compressed RTP 8 [RFC3544]", |
| 0x006f: "Stampede Bridging", |
| 0x0071: "Reserved [Fox]", |
| 0x0073: "MP+ Protocol [Smith]", |
| 0x007d: "reserved (Control Escape) [RFC1661]", |
| 0x007f: "reserved (compression inefficient [RFC1662]", |
| 0x0081: "Reserved Until 20-Oct-2000 [IANA]", |
| 0x0083: "Reserved Until 20-Oct-2000 [IANA]", |
| 0x00c1: "NTCITS IPI [Ungar]", |
| 0x00cf: "reserved (PPP NLID)", |
| 0x00fb: "single link compression in multilink [RFC1962]", |
| 0x00fd: "compressed datagram [RFC1962]", |
| 0x00ff: "reserved (compression inefficient)", |
| 0x0201: "802.1d Hello Packets", |
| 0x0203: "IBM Source Routing BPDU", |
| 0x0205: "DEC LANBridge100 Spanning Tree", |
| 0x0207: "Cisco Discovery Protocol [Sastry]", |
| 0x0209: "Netcs Twin Routing [Korfmacher]", |
| 0x020b: "STP - Scheduled Transfer Protocol [Segal]", |
| 0x020d: "EDP - Extreme Discovery Protocol [Grosser]", |
| 0x0211: "Optical Supervisory Channel Protocol (OSCP)[Prasad]", |
| 0x0213: "Optical Supervisory Channel Protocol (OSCP)[Prasad]", |
| 0x0231: "Luxcom", |
| 0x0233: "Sigma Network Systems", |
| 0x0235: "Apple Client Server Protocol [Ridenour]", |
| 0x0281: "MPLS Unicast [RFC3032] ", |
| 0x0283: "MPLS Multicast [RFC3032]", |
| 0x0285: "IEEE p1284.4 standard - data packets [Batchelder]", |
| 0x0287: "ETSI TETRA Network Protocol Type 1 [Nieminen]", |
| 0x0289: "Multichannel Flow Treatment Protocol [McCann]", |
| 0x2063: "RTP IPHC Compressed TCP No Delta [RFC3544]", |
| 0x2065: "RTP IPHC Context State [RFC3544]", |
| 0x2067: "RTP IPHC Compressed UDP 16 [RFC3544]", |
| 0x2069: "RTP IPHC Compressed RTP 16 [RFC3544]", |
| 0x4001: "Cray Communications Control Protocol [Stage]", |
| 0x4003: "CDPD Mobile Network Registration Protocol [Quick]", |
| 0x4005: "Expand accelerator protocol [Rachmani]", |
| 0x4007: "ODSICP NCP [Arvind]", |
| 0x4009: "DOCSIS DLL [Gaedtke]", |
| 0x400B: "Cetacean Network Detection Protocol [Siller]", |
| 0x4021: "Stacker LZS [Simpson]", |
| 0x4023: "RefTek Protocol [Banfill]", |
| 0x4025: "Fibre Channel [Rajagopal]", |
| 0x4027: "EMIT Protocols [Eastham]", |
| 0x405b: "Vendor-Specific Protocol (VSP) [RFC3772]", |
| 0x8021: "Internet Protocol Control Protocol", |
| 0x8023: "OSI Network Layer Control Protocol", |
| 0x8025: "Xerox NS IDP Control Protocol", |
| 0x8027: "DECnet Phase IV Control Protocol", |
| 0x8029: "Appletalk Control Protocol", |
| 0x802b: "Novell IPX Control Protocol", |
| 0x802d: "reserved", |
| 0x802f: "reserved", |
| 0x8031: "Bridging NCP", |
| 0x8033: "Stream Protocol Control Protocol", |
| 0x8035: "Banyan Vines Control Protocol", |
| 0x8037: "reserved (until 1993)", |
| 0x8039: "reserved", |
| 0x803b: "reserved", |
| 0x803d: "Multi-Link Control Protocol", |
| 0x803f: "NETBIOS Framing Control Protocol", |
| 0x8041: "Cisco Systems Control Protocol", |
| 0x8043: "Ascom Timeplex", |
| 0x8045: "Fujitsu LBLB Control Protocol", |
| 0x8047: "DCA Remote Lan Network Control Protocol (RLNCP)", |
| 0x8049: "Serial Data Control Protocol (PPP-SDCP)", |
| 0x804b: "SNA over 802.2 Control Protocol", |
| 0x804d: "SNA Control Protocol", |
| 0x804f: "IP6 Header Compression Control Protocol", |
| 0x8051: "KNX Bridging Control Protocol [ianp]", |
| 0x8053: "Encryption Control Protocol [Meyer]", |
| 0x8055: "Individual Link Encryption Control Protocol [Meyer]", |
| 0x8057: "IPv6 Control Protovol [Hinden]", |
| 0x8059: "PPP Muxing Control Protocol [RFC3153]", |
| 0x805b: "Vendor-Specific Network Control Protocol (VSNCP) [RFC3772]", |
| 0x806f: "Stampede Bridging Control Protocol", |
| 0x8073: "MP+ Control Protocol [Smith]", |
| 0x8071: "Reserved [Fox]", |
| 0x807d: "Not Used - reserved [RFC1661]", |
| 0x8081: "Reserved Until 20-Oct-2000 [IANA]", |
| 0x8083: "Reserved Until 20-Oct-2000 [IANA]", |
| 0x80c1: "NTCITS IPI Control Protocol [Ungar]", |
| 0x80cf: "Not Used - reserved [RFC1661]", |
| 0x80fb: "single link compression in multilink control [RFC1962]", |
| 0x80fd: "Compression Control Protocol [RFC1962]", |
| 0x80ff: "Not Used - reserved [RFC1661]", |
| 0x8207: "Cisco Discovery Protocol Control [Sastry]", |
| 0x8209: "Netcs Twin Routing [Korfmacher]", |
| 0x820b: "STP - Control Protocol [Segal]", |
| 0x820d: "EDPCP - Extreme Discovery Protocol Ctrl Prtcl [Grosser]", |
| 0x8235: "Apple Client Server Protocol Control [Ridenour]", |
| 0x8281: "MPLSCP [RFC3032]", |
| 0x8285: "IEEE p1284.4 standard - Protocol Control [Batchelder]", |
| 0x8287: "ETSI TETRA TNP1 Control Protocol [Nieminen]", |
| 0x8289: "Multichannel Flow Treatment Protocol [McCann]", |
| 0xc021: "Link Control Protocol", |
| 0xc023: "Password Authentication Protocol", |
| 0xc025: "Link Quality Report", |
| 0xc027: "Shiva Password Authentication Protocol", |
| 0xc029: "CallBack Control Protocol (CBCP)", |
| 0xc02b: "BACP Bandwidth Allocation Control Protocol [RFC2125]", |
| 0xc02d: "BAP [RFC2125]", |
| 0xc05b: "Vendor-Specific Authentication Protocol (VSAP) [RFC3772]", |
| 0xc081: "Container Control Protocol [KEN]", |
| 0xc223: "Challenge Handshake Authentication Protocol", |
| 0xc225: "RSA Authentication Protocol [Narayana]", |
| 0xc227: "Extensible Authentication Protocol [RFC2284]", |
| 0xc229: "Mitsubishi Security Info Exch Ptcl (SIEP) [Seno]", |
| 0xc26f: "Stampede Bridging Authorization Protocol", |
| 0xc281: "Proprietary Authentication Protocol [KEN]", |
| 0xc283: "Proprietary Authentication Protocol [Tackabury]", |
| 0xc481: "Proprietary Node ID Authentication Protocol [KEN]"} |
| |
| |
| class HDLC(Packet): |
| fields_desc = [ XByteField("address",0xff), |
| XByteField("control",0x03) ] |
| |
| class PPP(Packet): |
| name = "PPP Link Layer" |
| fields_desc = [ ShortEnumField("proto", 0x0021, _PPP_proto) ] |
| @classmethod |
| def dispatch_hook(cls, _pkt=None, *args, **kargs): |
| if _pkt and orb(_pkt[0]) == 0xff: |
| cls = HDLC |
| return cls |
| |
| _PPP_conftypes = { 1:"Configure-Request", |
| 2:"Configure-Ack", |
| 3:"Configure-Nak", |
| 4:"Configure-Reject", |
| 5:"Terminate-Request", |
| 6:"Terminate-Ack", |
| 7:"Code-Reject", |
| 8:"Protocol-Reject", |
| 9:"Echo-Request", |
| 10:"Echo-Reply", |
| 11:"Discard-Request", |
| 14:"Reset-Request", |
| 15:"Reset-Ack", |
| } |
| |
| |
| ### PPP IPCP stuff (RFC 1332) |
| |
| # All IPCP options are defined below (names and associated classes) |
| _PPP_ipcpopttypes = { 1:"IP-Addresses (Deprecated)", |
| 2:"IP-Compression-Protocol", |
| 3:"IP-Address", |
| 4:"Mobile-IPv4", # not implemented, present for completeness |
| 129:"Primary-DNS-Address", |
| 130:"Primary-NBNS-Address", |
| 131:"Secondary-DNS-Address", |
| 132:"Secondary-NBNS-Address"} |
| |
| |
| class PPP_IPCP_Option(Packet): |
| name = "PPP IPCP Option" |
| fields_desc = [ ByteEnumField("type" , None , _PPP_ipcpopttypes), |
| FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2), |
| StrLenField("data", "", length_from=lambda p:max(0,p.len-2)) ] |
| def extract_padding(self, pay): |
| return b"",pay |
| |
| registered_options = {} |
| @classmethod |
| def register_variant(cls): |
| cls.registered_options[cls.type.default] = cls |
| @classmethod |
| def dispatch_hook(cls, _pkt=None, *args, **kargs): |
| if _pkt: |
| o = orb(_pkt[0]) |
| return cls.registered_options.get(o, cls) |
| return cls |
| |
| |
| class PPP_IPCP_Option_IPAddress(PPP_IPCP_Option): |
| name = "PPP IPCP Option: IP Address" |
| fields_desc = [ ByteEnumField("type" , 3 , _PPP_ipcpopttypes), |
| FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2), |
| IPField("data","0.0.0.0"), |
| ConditionalField(StrLenField("garbage","", length_from=lambda pkt:pkt.len-6), lambda p:p.len!=6) ] |
| |
| class PPP_IPCP_Option_DNS1(PPP_IPCP_Option): |
| name = "PPP IPCP Option: DNS1 Address" |
| fields_desc = [ ByteEnumField("type" , 129 , _PPP_ipcpopttypes), |
| FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2), |
| IPField("data","0.0.0.0"), |
| ConditionalField(StrLenField("garbage","", length_from=lambda pkt:pkt.len-6), lambda p:p.len!=6) ] |
| |
| class PPP_IPCP_Option_DNS2(PPP_IPCP_Option): |
| name = "PPP IPCP Option: DNS2 Address" |
| fields_desc = [ ByteEnumField("type" , 131 , _PPP_ipcpopttypes), |
| FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2), |
| IPField("data","0.0.0.0"), |
| ConditionalField(StrLenField("garbage","", length_from=lambda pkt:pkt.len-6), lambda p:p.len!=6) ] |
| |
| class PPP_IPCP_Option_NBNS1(PPP_IPCP_Option): |
| name = "PPP IPCP Option: NBNS1 Address" |
| fields_desc = [ ByteEnumField("type" , 130 , _PPP_ipcpopttypes), |
| FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2), |
| IPField("data","0.0.0.0"), |
| ConditionalField(StrLenField("garbage","", length_from=lambda pkt:pkt.len-6), lambda p:p.len!=6) ] |
| |
| class PPP_IPCP_Option_NBNS2(PPP_IPCP_Option): |
| name = "PPP IPCP Option: NBNS2 Address" |
| fields_desc = [ ByteEnumField("type" , 132 , _PPP_ipcpopttypes), |
| FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2), |
| IPField("data","0.0.0.0"), |
| ConditionalField(StrLenField("garbage","", length_from=lambda pkt:pkt.len-6), lambda p:p.len!=6) ] |
| |
| |
| class PPP_IPCP(Packet): |
| fields_desc = [ ByteEnumField("code" , 1, _PPP_conftypes), |
| XByteField("id", 0 ), |
| FieldLenField("len" , None, fmt="H", length_of="options", adjust=lambda p,x:x+4 ), |
| PacketListField("options", [], PPP_IPCP_Option, length_from=lambda p:p.len-4,) ] |
| |
| |
| ### ECP |
| |
| _PPP_ecpopttypes = { 0:"OUI", |
| 1:"DESE", } |
| |
| class PPP_ECP_Option(Packet): |
| name = "PPP ECP Option" |
| fields_desc = [ ByteEnumField("type" , None , _PPP_ecpopttypes), |
| FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2), |
| StrLenField("data", "", length_from=lambda p:max(0,p.len-2)) ] |
| def extract_padding(self, pay): |
| return b"",pay |
| |
| registered_options = {} |
| @classmethod |
| def register_variant(cls): |
| cls.registered_options[cls.type.default] = cls |
| @classmethod |
| def dispatch_hook(cls, _pkt=None, *args, **kargs): |
| if _pkt: |
| o = orb(_pkt[0]) |
| return cls.registered_options.get(o, cls) |
| return cls |
| |
| class PPP_ECP_Option_OUI(PPP_ECP_Option): |
| fields_desc = [ ByteEnumField("type" , 0 , _PPP_ecpopttypes), |
| FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+6), |
| StrFixedLenField("oui","",3), |
| ByteField("subtype",0), |
| StrLenField("data", "", length_from=lambda p:p.len-6) ] |
| |
| |
| |
| class PPP_ECP(Packet): |
| fields_desc = [ ByteEnumField("code" , 1, _PPP_conftypes), |
| XByteField("id", 0 ), |
| FieldLenField("len" , None, fmt="H", length_of="options", adjust=lambda p,x:x+4 ), |
| PacketListField("options", [], PPP_ECP_Option, length_from=lambda p:p.len-4,) ] |
| |
| ### Link Control Protocol (RFC 1661) |
| |
| _PPP_lcptypes = {1: "Configure-Request", |
| 2: "Configure-Ack", |
| 3: "Configure-Nak", |
| 4: "Configure-Reject", |
| 5: "Terminate-Request", |
| 6: "Terminate-Ack", |
| 7: "Code-Reject", |
| 8: "Protocol-Reject", |
| 9: "Echo-Request", |
| 10: "Echo-Reply", |
| 11: "Discard-Request"} |
| |
| |
| class PPP_LCP(Packet): |
| name = "PPP Link Control Protocol" |
| fields_desc = [ByteEnumField("code", 5, _PPP_lcptypes), |
| XByteField("id", 0), |
| FieldLenField("len", None, fmt="H", length_of="data", |
| adjust=lambda p, x: x + 4), |
| StrLenField("data", "", |
| length_from=lambda p:p.len-4)] |
| |
| def mysummary(self): |
| return self.sprintf('LCP %code%') |
| |
| def extract_padding(self, pay): |
| return b"", pay |
| |
| @classmethod |
| def dispatch_hook(cls, _pkt = None, *args, **kargs): |
| if _pkt: |
| o = orb(_pkt[0]) |
| if o in [1, 2, 3, 4]: |
| return PPP_LCP_Configure |
| elif o in [5,6]: |
| return PPP_LCP_Terminate |
| elif o == 7: |
| return PPP_LCP_Code_Reject |
| elif o == 8: |
| return PPP_LCP_Protocol_Reject |
| elif o in [9, 10]: |
| return PPP_LCP_Echo |
| elif o == 11: |
| return PPP_LCP_Discard_Request |
| else: |
| return cls |
| return cls |
| |
| |
| _PPP_lcp_optiontypes = {1: "Maximum-Receive-Unit", |
| 2: "Async-Control-Character-Map", |
| 3: "Authentication-protocol", |
| 4: "Quality-protocol", |
| 5: "Magic-number", |
| 7: "Protocol-Field-Compression", |
| 8: "Address-and-Control-Field-Compression", |
| 13: "Callback"} |
| |
| |
| class PPP_LCP_Option(Packet): |
| name = "PPP LCP Option" |
| fields_desc = [ByteEnumField("type", None, _PPP_lcp_optiontypes), |
| FieldLenField("len", None, fmt="B", length_of="data", |
| adjust=lambda p,x:x+2), |
| StrLenField("data", None, length_from=lambda p:p.len-2)] |
| |
| def extract_padding(self, pay): |
| return b"", pay |
| |
| registered_options = {} |
| |
| @classmethod |
| def register_variant(cls): |
| cls.registered_options[cls.type.default] = cls |
| |
| @classmethod |
| def dispatch_hook(cls, _pkt=None, *args, **kargs): |
| if _pkt: |
| o = orb(_pkt[0]) |
| return cls.registered_options.get(o, cls) |
| return cls |
| |
| |
| class PPP_LCP_MRU_Option(PPP_LCP_Option): |
| fields_desc = [ByteEnumField("type", 1, _PPP_lcp_optiontypes), |
| FieldLenField("len", 4, fmt="B", adjust=lambda p,x:4), |
| ShortField("max_recv_unit", 1500)] |
| |
| _PPP_LCP_auth_protocols = {0xc023: "Password authentication protocol", |
| 0xc223: "Challenge-response authentication protocol", |
| 0xc227: "PPP Extensible authentication protocol"} |
| |
| _PPP_LCP_CHAP_algorithms = {5: "MD5", |
| 6: "SHA1", |
| 128: "MS-CHAP", |
| 129: "MS-CHAP-v2"} |
| |
| |
| class PPP_LCP_ACCM_Option(PPP_LCP_Option): |
| fields_desc = [ByteEnumField("type", 2, _PPP_lcp_optiontypes), |
| FieldLenField("len", 6, fmt="B"), |
| BitField("accm", 0x00000000, 32)] |
| |
| |
| def adjust_auth_len(pkt, x): |
| if pkt.auth_protocol == 0xc223: |
| return 5 |
| elif pkt.auth_protocol == 0xc023: |
| return 4 |
| else: |
| return x + 4 |
| |
| |
| class PPP_LCP_Auth_Protocol_Option(PPP_LCP_Option): |
| fields_desc = [ByteEnumField("type", 3, _PPP_lcp_optiontypes), |
| FieldLenField("len", None, fmt="B", length_of="data", |
| adjust=adjust_auth_len), |
| ShortEnumField("auth_protocol", 0xc023, _PPP_LCP_auth_protocols), |
| ConditionalField(StrLenField("data", '', length_from=lambda p:p.len-4), |
| lambda p:p.auth_protocol != 0xc223), |
| ConditionalField(ByteEnumField("algorithm", 5, _PPP_LCP_CHAP_algorithms), |
| lambda p:p.auth_protocol == 0xc223)] |
| |
| |
| _PPP_LCP_quality_protocols = {0xc025: "Link Quality Report"} |
| |
| |
| class PPP_LCP_Quality_Protocol_Option(PPP_LCP_Option): |
| fields_desc = [ByteEnumField("type", 4, _PPP_lcp_optiontypes), |
| FieldLenField("len", None, fmt="B", length_of="data", |
| adjust=lambda p,x:x+4), |
| ShortEnumField("quality_protocol", 0xc025, _PPP_LCP_quality_protocols), |
| StrLenField("data", "", length_from=lambda p:p.len-4)] |
| |
| |
| class PPP_LCP_Magic_Number_Option(PPP_LCP_Option): |
| fields_desc = [ByteEnumField("type", 5, _PPP_lcp_optiontypes), |
| FieldLenField("len", 6, fmt="B", adjust = lambda p,x:6), |
| IntField("magic_number", None)] |
| |
| |
| _PPP_lcp_callback_operations = {0: "Location determined by user authentication", |
| 1: "Dialing string", |
| 2: "Location identifier", |
| 3: "E.164 number", |
| 4: "Distinguished name"} |
| |
| |
| class PPP_LCP_Callback_Option(PPP_LCP_Option): |
| fields_desc = [ByteEnumField("type", 13, _PPP_lcp_optiontypes), |
| FieldLenField("len", None, fmt="B", length_of="message", |
| adjust=lambda p,x:x+3), |
| ByteEnumField("operation", 0, _PPP_lcp_callback_operations), |
| StrLenField("message", "", length_from=lambda p:p.len-3)] |
| |
| |
| class PPP_LCP_Configure(PPP_LCP): |
| fields_desc = [ByteEnumField("code", 1, _PPP_lcptypes), |
| XByteField("id", 0), |
| FieldLenField("len", None, fmt="H", length_of="options", |
| adjust=lambda p,x:x+4), |
| PacketListField("options", [], PPP_LCP_Option, |
| length_from=lambda p:p.len-4)] |
| |
| def answers(self, other): |
| return isinstance(other, PPP_LCP_Configure) and self.code in [2, 3, 4]\ |
| and other.code == 1 and other.id == self.id |
| |
| |
| class PPP_LCP_Terminate(PPP_LCP): |
| |
| def answers(self, other): |
| return isinstance(other, PPP_LCP_Terminate) and self.code == 6\ |
| and other.code == 5 and other.id == self.id |
| |
| |
| class PPP_LCP_Code_Reject(PPP_LCP): |
| fields_desc = [ByteEnumField("code", 7, _PPP_lcptypes), |
| XByteField("id", 0), |
| FieldLenField("len", None, fmt="H", length_of="rejected_packet", |
| adjust=lambda p,x:x+4), |
| PacketField("rejected_packet", None, PPP_LCP)] |
| |
| |
| class PPP_LCP_Protocol_Reject(PPP_LCP): |
| fields_desc = [ByteEnumField("code", 8, _PPP_lcptypes), |
| XByteField("id", 0), |
| FieldLenField("len", None, fmt="H", length_of="rejected_information", |
| adjust=lambda p,x:x+6), |
| ShortEnumField("rejected_protocol", None, _PPP_proto), |
| PacketField("rejected_information", None, Packet)] |
| |
| |
| class PPP_LCP_Echo(PPP_LCP): |
| fields_desc = [ByteEnumField("code", 9, _PPP_lcptypes), |
| XByteField("id", 0), |
| FieldLenField("len", None, fmt="H", length_of="data", |
| adjust=lambda p,x:x+8), |
| IntField("magic_number", None), |
| StrLenField("data", "", length_from=lambda p:p.len-8)] |
| |
| def answers(self, other): |
| return isinstance(other, PPP_LCP_Echo) and self.code == 10\ |
| and other.code == 9 and self.id == other.id |
| |
| |
| class PPP_LCP_Discard_Request(PPP_LCP): |
| fields_desc = [ByteEnumField("code", 11, _PPP_lcptypes), |
| XByteField("id", 0), |
| FieldLenField("len", None, fmt="H", length_of="data", |
| adjust=lambda p,x:x+8), |
| IntField("magic_number", None), |
| StrLenField("data", "", length_from=lambda p:p.len-8)] |
| |
| ### Password authentication protocol (RFC 1334) |
| |
| _PPP_paptypes = {1: "Authenticate-Request", |
| 2: "Authenticate-Ack", |
| 3: "Authenticate-Nak"} |
| |
| |
| class PPP_PAP(Packet): |
| name = "PPP Password Authentication Protocol" |
| fields_desc = [ByteEnumField("code", 1, _PPP_paptypes), |
| XByteField("id", 0), |
| FieldLenField("len", None, fmt="!H", length_of="data", |
| adjust=lambda _, x: x + 4), |
| StrLenField("data", "", length_from=lambda p: p.len-4)] |
| |
| @classmethod |
| def dispatch_hook(cls, _pkt=None, *_, **kargs): |
| code = None |
| if _pkt: |
| code = orb(_pkt[0]) |
| elif "code" in kargs: |
| code = kargs["code"] |
| if isinstance(code, six.string_types): |
| code = cls.fields_desc[0].s2i[code] |
| |
| if code == 1: |
| return PPP_PAP_Request |
| elif code in [2, 3]: |
| return PPP_PAP_Response |
| return cls |
| |
| def extract_padding(self, pay): |
| return "", pay |
| |
| |
| class PPP_PAP_Request(PPP_PAP): |
| fields_desc = [ByteEnumField("code", 1, _PPP_paptypes), |
| XByteField("id", 0), |
| FieldLenField("len", None, fmt="!H", length_of="username", |
| adjust=lambda p, x: x + 6 + len(p.password)), |
| FieldLenField("username_len", None, fmt="B", length_of="username"), |
| StrLenField("username", None, length_from=lambda p: p.username_len), |
| FieldLenField("passwd_len", None, fmt="B", length_of="password"), |
| StrLenField("password", None, length_from=lambda p: p.passwd_len)] |
| |
| def mysummary(self): |
| return self.sprintf("PAP-Request username=%PPP_PAP_Request.username%" + |
| " password=%PPP_PAP_Request.password%") |
| |
| |
| class PPP_PAP_Response(PPP_PAP): |
| fields_desc = [ByteEnumField("code", 2, _PPP_paptypes), |
| XByteField("id", 0), |
| FieldLenField("len", None, fmt="!H", length_of="message", |
| adjust=lambda _, x: x + 5), |
| FieldLenField("msg_len", None, fmt="B", length_of="message"), |
| StrLenField("message", "", length_from=lambda p: p.msg_len)] |
| |
| def answers(self, other): |
| return isinstance(other, PPP_PAP_Request) and other.id == self.id |
| |
| def mysummary(self): |
| res = "PAP-Ack" if self.code == 2 else "PAP-Nak" |
| if self.msg_len > 0: |
| res += self.sprintf(" msg=%PPP_PAP_Response.message%") |
| return res |
| |
| |
| ### Challenge Handshake Authentication protocol (RFC1994) |
| |
| _PPP_chaptypes = {1: "Challenge", |
| 2: "Response", |
| 3: "Success", |
| 4: "Failure"} |
| |
| |
| class PPP_CHAP(Packet): |
| name = "PPP Challenge Handshake Authentication Protocol" |
| fields_desc = [ByteEnumField("code", 1, _PPP_chaptypes), |
| XByteField("id", 0), |
| FieldLenField("len", None, fmt="!H", length_of="data", |
| adjust=lambda _, x: x + 4), |
| StrLenField("data", "", length_from=lambda p: p.len - 4)] |
| |
| def answers(self, other): |
| return isinstance(other, PPP_CHAP_ChallengeResponse) and other.code == 2\ |
| and self.code in (3, 4) and self.id == other.id |
| |
| @classmethod |
| def dispatch_hook(cls, _pkt=None, *_, **kargs): |
| code = None |
| if _pkt: |
| code = orb(_pkt[0]) |
| elif "code" in kargs: |
| code = kargs["code"] |
| if isinstance(code, six.string_types): |
| code = cls.fields_desc[0].s2i[code] |
| |
| if code in (1, 2): |
| return PPP_CHAP_ChallengeResponse |
| return cls |
| |
| def extract_padding(self, pay): |
| return "", pay |
| |
| def mysummary(self): |
| if self.code == 3: |
| return self.sprintf("CHAP Success message=%PPP_CHAP.data%") |
| elif self.code == 4: |
| return self.sprintf("CHAP Failure message=%PPP_CHAP.data%") |
| |
| |
| class PPP_CHAP_ChallengeResponse(PPP_CHAP): |
| fields_desc = [ByteEnumField("code", 1, _PPP_chaptypes), |
| XByteField("id", 0), |
| FieldLenField("len", None, fmt="!H", length_of="value", |
| adjust=lambda p, x: x + len(p.optional_name) + 5), |
| FieldLenField("value_size", None, fmt="B", length_of="value"), |
| XStrLenField("value", b"\0"*8, length_from=lambda p: p.value_size), |
| StrLenField("optional_name", "", length_from=lambda p: p.len - p.value_size - 5)] |
| |
| def answers(self, other): |
| return isinstance(other, PPP_CHAP_ChallengeResponse) and other.code == 1\ |
| and self.code == 2 and self.id == other.id |
| |
| def mysummary(self): |
| if self.code == 1: |
| return self.sprintf("CHAP challenge=0x%PPP_CHAP_ChallengeResponse.value% " + |
| "optional_name=%PPP_CHAP_ChallengeResponse.optional_name%") |
| elif self.code == 2: |
| return self.sprintf("CHAP response=0x%PPP_CHAP_ChallengeResponse.value% " + |
| "optional_name=%PPP_CHAP_ChallengeResponse.optional_name%") |
| else: |
| return PPP_CHAP.mysummary(self) |
| |
| |
| bind_layers( Ether, PPPoED, type=0x8863) |
| bind_layers( Ether, PPPoE, type=0x8864) |
| bind_layers( CookedLinux, PPPoED, proto=0x8863) |
| bind_layers( CookedLinux, PPPoE, proto=0x8864) |
| bind_layers( PPPoE, PPP, code=0) |
| bind_layers( HDLC, PPP, ) |
| bind_layers( PPP, EAP, proto=0xc227) |
| bind_layers( PPP, IP, proto=0x0021) |
| bind_layers( PPP, IPv6, proto=0x0057) |
| bind_layers( PPP, PPP_CHAP, proto=0xc223) |
| bind_layers( PPP, PPP_IPCP, proto=0x8021) |
| bind_layers( PPP, PPP_ECP, proto=0x8053) |
| bind_layers( PPP, PPP_LCP, proto=0xc021) |
| bind_layers( PPP, PPP_PAP, proto=0xc023) |
| bind_layers( Ether, PPP_IPCP, type=0x8021) |
| bind_layers( Ether, PPP_ECP, type=0x8053) |
| bind_layers( GRE_PPTP, PPP, proto=0x880b) |
| |
| |
| conf.l2types.register(DLT_PPP, PPP) |
| conf.l2types.register(DLT_PPP_SERIAL, HDLC) |
| conf.l2types.register(DLT_PPP_ETHER, PPPoE) |
