예제 #1
0
class OBD_MIDXX(OBD_Packet):
    standardized_test_ids = {
        1: "TID_01_RichToLeanSensorThresholdVoltage",
        2: "TID_02_LeanToRichSensorThresholdVoltage",
        3: "TID_03_LowSensorVoltageForSwitchTimeCalculation",
        4: "TID_04_HighSensorVoltageForSwitchTimeCalculation",
        5: "TID_05_RichToLeanSensorSwitchTime",
        6: "TID_06_LeanToRichSensorSwitchTime",
        7: "TID_07_MinimumSensorVoltageForTestCycle",
        8: "TID_08_MaximumSensorVoltageForTestCycle",
        9: "TID_09_TimeBetweenSensorTransitions",
        10: "TID_0A_SensorPeriod"
    }
    unit_and_scaling_ids = {
        0x01: "Raw Value",
        0x02: "Raw Value",
        0x03: "Raw Value",
        0x04: "Raw Value",
        0x05: "Raw Value",
        0x06: "Raw Value",
        0x07: "rotational frequency",
        0x08: "Speed",
        0x09: "Speed",
        0x0A: "Voltage",
        0x0B: "Voltage",
        0x0C: "Voltage",
        0x0D: "Current",
        0x0E: "Current",
        0x0F: "Current",
        0x10: "Time",
        0x11: "Time",
        0x12: "Time",
        0x13: "Resistance",
        0x14: "Resistance",
        0x15: "Resistance",
        0x16: "Temperature",
        0x17: "Pressure (Gauge)",
        0x18: "Pressure (Air pressure)",
        0x19: "Pressure (Fuel pressure)",
        0x1A: "Pressure (Gauge)",
        0x1B: "Pressure (Diesel pressure)",
        0x1C: "Angle",
        0x1D: "Angle",
        0x1E: "Equivalence ratio (lambda)",
        0x1F: "Air/Fuel ratio",
        0x20: "Ratio",
        0x21: "Frequency",
        0x22: "Frequency",
        0x23: "Frequency",
        0x24: "Counts",
        0x25: "Distance",
        0x26: "Voltage per time",
        0x27: "Mass per time",
        0x28: "Mass per time",
        0x29: "Pressure per time",
        0x2A: "Mass per time",
        0x2B: "Switches",
        0x2C: "Mass per cylinder",
        0x2D: "Mass per stroke",
        0x2E: "True/False",
        0x2F: "Percent",
        0x30: "Percent",
        0x31: "volume",
        0x32: "length",
        0x33: "Equivalence ratio (lambda)",
        0x34: "Time",
        0x35: "Time",
        0x36: "Weight",
        0x37: "Weight",
        0x38: "Weight",
        0x39: "Percent",
        0x81: "Raw Value",
        0x82: "Raw Value",
        0x83: "Raw Value",
        0x84: "Raw Value",
        0x85: "Raw Value",
        0x86: "Raw Value",
        0x8A: "Voltage",
        0x8B: "Voltage",
        0x8C: "Voltage",
        0x8D: "Current",
        0x8E: "Current",
        0x90: "Time",
        0x96: "Temperature",
        0x9C: "Angle",
        0x9D: "Angle",
        0xA8: "Mass per time",
        0xA9: "Pressure per time",
        0xAF: "Percent",
        0xB0: "Percent",
        0xB1: "Voltage per time",
        0xFD: "Pressure",
        0xFE: "Pressure"
    }

    name = "OBD MID data record"
    fields_desc = [
        ByteEnumField("standardized_test_id", 1, standardized_test_ids),
        ByteEnumField("unit_and_scaling_id", 1, unit_and_scaling_ids),
        MultipleTypeField(_unit_and_scaling_fields("test_value"),
                          ShortField("test_value", 0)),
        MultipleTypeField(_unit_and_scaling_fields("min_limit"),
                          ShortField("min_limit", 0)),
        MultipleTypeField(_unit_and_scaling_fields("max_limit"),
                          ShortField("max_limit", 0)),
    ]
class TLS_Ext_TruncatedHMAC(TLS_Ext_Unknown):                       # RFC 4366
    name = "TLS Extension - Truncated HMAC"
    fields_desc = [ShortEnumField("type", 4, _tls_ext),
                   ShortField("len", None)]
예제 #3
0
class EIGRPStub(EIGRPGeneric):
    name = "EIGRP Stub Router"
    fields_desc = [XShortField("type", 0x0006),
                   ShortField("len", 6),
                   FlagsField("flags", 0x000d, 16, _EIGRP_STUB_FLAGS)]
예제 #4
0
파일: dot11.py 프로젝트: cbnoc/cbnoc2019
class RadioTap(Packet):
    name = "RadioTap dummy"
    deprecated_fields = {
        "Channel": ("ChannelFrequency", "2.4.3"),
        "ChannelFlags2": ("ChannelPlusFlags", "2.4.3"),
        "ChannelNumber": ("ChannelPlusNumber", "2.4.3"),
    }
    fields_desc = [
        ByteField('version', 0),
        ByteField('pad', 0),
        LEShortField('len', None),
        FlagsField('present', None, -32, _rt_present),  # noqa: E501
        # Extended presence mask
        ConditionalField(
            PacketListField("Ext", [], next_cls_cb=_next_radiotap_extpm),
            lambda pkt: pkt.present and pkt.present.Ext),  # noqa: E501
        # RadioTap fields - each starts with a _RadiotapReversePadField
        # to handle padding

        # TSFT
        ConditionalField(
            _RadiotapReversePadField(LELongField("mac_timestamp", 0)),
            lambda pkt: pkt.present and pkt.present.TSFT),
        # Flags
        ConditionalField(
            _RadiotapReversePadField(FlagsField("Flags", None, -8, _rt_flags)),
            lambda pkt: pkt.present and pkt.present.Flags),
        # Rate
        ConditionalField(_RadiotapReversePadField(ByteField("Rate", 0)),
                         lambda pkt: pkt.present and pkt.present.Rate),
        # Channel
        ConditionalField(
            _RadiotapReversePadField(LEShortField("ChannelFrequency", 0)),
            lambda pkt: pkt.present and pkt.present.Channel),
        ConditionalField(
            FlagsField("ChannelFlags", None, -16, _rt_channelflags),
            lambda pkt: pkt.present and pkt.present.Channel),
        # dBm_AntSignal
        ConditionalField(
            _RadiotapReversePadField(_dbmField("dBm_AntSignal", -256)),
            lambda pkt: pkt.present and pkt.present.dBm_AntSignal),
        # dBm_AntNoise
        ConditionalField(
            _RadiotapReversePadField(_dbmField("dBm_AntNoise", -256)),
            lambda pkt: pkt.present and pkt.present.dBm_AntNoise),
        # Lock_Quality
        ConditionalField(
            _RadiotapReversePadField(LEShortField("Lock_Quality", 0), ),
            lambda pkt: pkt.present and pkt.present.Lock_Quality),
        # Antenna
        ConditionalField(_RadiotapReversePadField(ByteField("Antenna", 0)),
                         lambda pkt: pkt.present and pkt.present.Antenna),
        # RX Flags
        ConditionalField(
            _RadiotapReversePadField(
                FlagsField("RXFlags", None, -16, _rt_rxflags)),
            lambda pkt: pkt.present and pkt.present.RXFlags),
        # TX Flags
        ConditionalField(
            _RadiotapReversePadField(
                FlagsField("TXFlags", None, -16, _rt_txflags)),
            lambda pkt: pkt.present and pkt.present.TXFlags),
        # ChannelPlus
        ConditionalField(
            _RadiotapReversePadField(
                FlagsField("ChannelPlusFlags", None, -32, _rt_channelflags2)),
            lambda pkt: pkt.present and pkt.present.ChannelPlus),
        ConditionalField(LEShortField("ChannelPlusFrequency", 0),
                         lambda pkt: pkt.present and pkt.present.ChannelPlus),
        ConditionalField(ByteField("ChannelPlusNumber", 0),
                         lambda pkt: pkt.present and pkt.present.ChannelPlus),
        # MCS
        ConditionalField(
            _RadiotapReversePadField(
                FlagsField("knownMCS", None, -8, _rt_knownmcs)),
            lambda pkt: pkt.present and pkt.present.MCS),
        ConditionalField(BitField("Ness_LSB", 0, 1),
                         lambda pkt: pkt.present and pkt.present.MCS),
        ConditionalField(BitField("STBC_streams", 0, 2),
                         lambda pkt: pkt.present and pkt.present.MCS),
        ConditionalField(BitEnumField("FEC_type", 0, 1, {
            0: "BCC",
            1: "LDPC"
        }), lambda pkt: pkt.present and pkt.present.MCS),
        ConditionalField(
            BitEnumField("HT_format", 0, 1, {
                0: "mixed",
                1: "greenfield"
            }), lambda pkt: pkt.present and pkt.present.MCS),
        ConditionalField(
            BitEnumField("guard_interval", 0, 1, {
                0: "Long_GI",
                1: "Short_GI"
            }),  # noqa: E501
            lambda pkt: pkt.present and pkt.present.MCS),
        ConditionalField(BitEnumField("MCS_bandwidth", 0, 2, _rt_bandwidth),
                         lambda pkt: pkt.present and pkt.present.MCS),
        ConditionalField(ByteField("MCS_index", 0),
                         lambda pkt: pkt.present and pkt.present.MCS),
        # A_MPDU
        ConditionalField(_RadiotapReversePadField(LEIntField("A_MPDU_ref", 0)),
                         lambda pkt: pkt.present and pkt.present.A_MPDU),
        ConditionalField(
            FlagsField("A_MPDU_flags", None, -32, _rt_a_mpdu_flags),
            lambda pkt: pkt.present and pkt.present.A_MPDU),
        # VHT
        ConditionalField(
            _RadiotapReversePadField(
                FlagsField("KnownVHT", None, -16, _rt_knownvht)),
            lambda pkt: pkt.present and pkt.present.VHT),
        ConditionalField(FlagsField("PresentVHT", None, -8, _rt_presentvht),
                         lambda pkt: pkt.present and pkt.present.VHT),
        ConditionalField(ByteEnumField("VHT_bandwidth", 0, _rt_vhtbandwidth),
                         lambda pkt: pkt.present and pkt.present.VHT),
        ConditionalField(StrFixedLenField("mcs_nss", 0, length=5),
                         lambda pkt: pkt.present and pkt.present.VHT),
        ConditionalField(ByteField("GroupID", 0),
                         lambda pkt: pkt.present and pkt.present.VHT),
        ConditionalField(ShortField("PartialAID", 0),
                         lambda pkt: pkt.present and pkt.present.VHT),
        # timestamp
        ConditionalField(_RadiotapReversePadField(LELongField("timestamp", 0)),
                         lambda pkt: pkt.present and pkt.present.timestamp),
        ConditionalField(LEShortField("ts_accuracy", 0),
                         lambda pkt: pkt.present and pkt.present.timestamp),
        ConditionalField(ByteField("ts_position", 0),
                         lambda pkt: pkt.present and pkt.present.timestamp),
        ConditionalField(ByteField("ts_flags", 0),
                         lambda pkt: pkt.present and pkt.present.timestamp),
        # HE - XXX not complete
        ConditionalField(_RadiotapReversePadField(ShortField("he_data1", 0)),
                         lambda pkt: pkt.present and pkt.present.HE),
        ConditionalField(ShortField("he_data2", 0),
                         lambda pkt: pkt.present and pkt.present.HE),
        ConditionalField(ShortField("he_data3", 0),
                         lambda pkt: pkt.present and pkt.present.HE),
        ConditionalField(ShortField("he_data4", 0),
                         lambda pkt: pkt.present and pkt.present.HE),
        ConditionalField(ShortField("he_data5", 0),
                         lambda pkt: pkt.present and pkt.present.HE),
        ConditionalField(ShortField("he_data6", 0),
                         lambda pkt: pkt.present and pkt.present.HE),
        # HE_MU
        ConditionalField(
            _RadiotapReversePadField(LEShortField("hemu_flags1", 0)),
            lambda pkt: pkt.present and pkt.present.HE_MU),
        ConditionalField(LEShortField("hemu_flags2", 0),
                         lambda pkt: pkt.present and pkt.present.HE_MU),
        ConditionalField(
            FieldListField("RU_channel1", [],
                           ByteField,
                           count_from=lambda x: 4),
            lambda pkt: pkt.present and pkt.present.HE_MU),
        ConditionalField(
            FieldListField("RU_channel2", [],
                           ByteField,
                           count_from=lambda x: 4),
            lambda pkt: pkt.present and pkt.present.HE_MU),
        # HE_MU_other_user
        ConditionalField(
            _RadiotapReversePadField(LEShortField("hemuou_per_user_1",
                                                  0x7fff)),
            lambda pkt: pkt.present and pkt.present.HE_MU_other_user),
        ConditionalField(
            LEShortField("hemuou_per_user_2", 0x003f),
            lambda pkt: pkt.present and pkt.present.HE_MU_other_user),
        ConditionalField(
            ByteField("hemuou_per_user_position", 0),
            lambda pkt: pkt.present and pkt.present.HE_MU_other_user),
        ConditionalField(
            FlagsField("hemuou_per_user_known", 0, -16,
                       _rt_hemuother_per_user_known),
            lambda pkt: pkt.present and pkt.present.HE_MU_other_user),
        # L_SIG
        ConditionalField(
            _RadiotapReversePadField(
                FlagsField("lsig_data1", 0, -16, ["rate", "length"])),
            lambda pkt: pkt.present and pkt.present.L_SIG),
        ConditionalField(BitField("lsig_length", 0, 12),
                         lambda pkt: pkt.present and pkt.present.L_SIG),
        ConditionalField(BitField("lsig_rate", 0, 4),
                         lambda pkt: pkt.present and pkt.present.L_SIG),
        # Remaining
        StrLenField(
            'notdecoded',
            "",
            length_from=lambda pkt: max(pkt.len - pkt._tmp_dissect_pos, 0))
    ]

    def guess_payload_class(self, payload):
        if self.present and self.present.Flags and self.Flags.FCS:
            return Dot11FCS
        return Dot11

    def post_build(self, p, pay):
        if self.len is None:
            p = p[:2] + struct.pack("!H", len(p))[::-1] + p[4:]
        return p + pay
예제 #5
0
파일: ppp.py 프로젝트: antaema/IN-Botnet
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)]
예제 #6
0
 6:
 IPField("name_server", "0.0.0.0"),
 7:
 IPField("log_server", "0.0.0.0"),
 8:
 IPField("cookie_server", "0.0.0.0"),
 9:
 IPField("lpr_server", "0.0.0.0"),
 10:
 IPField("impress-servers", "0.0.0.0"),
 11:
 IPField("resource-location-servers", "0.0.0.0"),
 12:
 "hostname",
 13:
 ShortField("boot-size", 1000),
 14:
 "dump_path",
 15:
 "domain",
 16:
 IPField("swap-server", "0.0.0.0"),
 17:
 "root_disk_path",
 18:
 "extensions-path",
 19:
 ByteField("ip-forwarding", 0),
 20:
 ByteField("non-local-source-routing", 0),
 21:
예제 #7
0
class RadioTap(Packet):
    name = "RadioTap dummy"
    fields_desc = [
        ByteField('version', 0),
        ByteField('pad', 0),
        LEShortField('len', None),
        FlagsField(
            'present',
            None,
            -32,
            [
                'TSFT',
                'Flags',
                'Rate',
                'Channel',
                'FHSS',
                'dBm_AntSignal',  # noqa: E501
                'dBm_AntNoise',
                'Lock_Quality',
                'TX_Attenuation',
                'dB_TX_Attenuation',  # noqa: E501
                'dBm_TX_Power',
                'Antenna',
                'dB_AntSignal',
                'dB_AntNoise',  # noqa: E501
                'RXFlags',
                'b16',
                'b17',
                'b18',
                'ChannelPlus',
                'MCS',
                'A_MPDU',  # noqa: E501
                'VHT',
                'timestamp',
                'b24',
                'b25',
                'b26',
                'b27',
                'b28',
                'b29',  # noqa: E501
                'RadiotapNS',
                'VendorNS',
                'Ext'
            ]),  # noqa: E501
        # Extended presence mask
        ConditionalField(
            PacketListField("Ext", [], next_cls_cb=_next_radiotap_extpm),
            lambda pkt: pkt.present and pkt.present.Ext),  # noqa: E501
        # Default fields
        ConditionalField(
            _RadiotapReversePadField(BitField("mac_timestamp", 0, -64)),
            lambda pkt: pkt.present and pkt.present.TSFT),  # noqa: E501
        ConditionalField(
            _RadiotapReversePadField(
                FlagsField(
                    "Flags",
                    None,
                    -8,
                    [
                        'CFP',
                        'ShortPreamble',
                        'wep',
                        'fragment',  # noqa: E501
                        'FCS',
                        'pad',
                        'badFCS',
                        'ShortGI'
                    ])  # noqa: E501
            ),
            lambda pkt: pkt.present and pkt.present.Flags),
        ConditionalField(
            _RadiotapReversePadField(ByteField("Rate", 0)),
            lambda pkt: pkt.present and pkt.present.Rate),  # noqa: E501
        ConditionalField(
            _RadiotapReversePadField(LEShortField("Channel", 0)),
            lambda pkt: pkt.present and pkt.present.Channel),  # noqa: E501
        ConditionalField(
            _RadiotapReversePadField(
                FlagsField(
                    "ChannelFlags",
                    None,
                    -16,
                    [
                        'res1',
                        'res2',
                        'res3',
                        'res4',
                        'Turbo',
                        'CCK',  # noqa: E501
                        'OFDM',
                        '2GHz',
                        '5GHz',
                        'Passive',
                        'Dynamic_CCK_OFDM',  # noqa: E501
                        'GFSK',
                        'GSM',
                        'StaticTurbo',
                        '10MHz',
                        '5MHz'
                    ])  # noqa: E501
            ),
            lambda pkt: pkt.present and pkt.present.Channel),
        ConditionalField(
            _RadiotapReversePadField(_dbmField("dBm_AntSignal", -256)), lambda
            pkt: pkt.present and pkt.present.dBm_AntSignal),  # noqa: E501
        ConditionalField(
            _RadiotapReversePadField(_dbmField("dBm_AntNoise", -256)), lambda
            pkt: pkt.present and pkt.present.dBm_AntNoise),  # noqa: E501
        ConditionalField(
            _RadiotapReversePadField(ByteField("Antenna", 0)),
            lambda pkt: pkt.present and pkt.present.Antenna),  # noqa: E501
        # ChannelPlus
        ConditionalField(
            _RadiotapReversePadField(
                FlagsField(
                    "ChannelFlags2",
                    None,
                    -32,
                    [
                        'res1',
                        'res2',
                        'res3',
                        'res4',
                        'Turbo',
                        'CCK',  # noqa: E501
                        'OFDM',
                        '2GHz',
                        '5GHz',
                        'Passive',
                        'Dynamic_CCK_OFDM',  # noqa: E501
                        'GFSK',
                        'GSM',
                        'StaticTurbo',
                        '10MHz',
                        '5MHz',  # noqa: E501
                        '20MHz',
                        '40MHz_ext_channel_above',
                        '40MHz_ext_channel_below',  # noqa: E501
                        'res5',
                        'res6',
                        'res7',
                        'res8',
                        'res9'
                    ])  # noqa: E501
            ),
            lambda pkt: pkt.present and pkt.present.ChannelPlus),
        ConditionalField(
            _RadiotapReversePadField(LEShortField("ChannelFrequency", 0)),
            lambda pkt: pkt.present and pkt.present.ChannelPlus),  # noqa: E501
        ConditionalField(
            _RadiotapReversePadField(ByteField("ChannelNumber", 0)),
            lambda pkt: pkt.present and pkt.present.ChannelPlus),  # noqa: E501
        # A_MPDU
        ConditionalField(
            _RadiotapReversePadField(LEIntField("A_MPDU_ref", 0)),
            lambda pkt: pkt.present and pkt.present.A_MPDU),  # noqa: E501
        ConditionalField(
            _RadiotapReversePadField(
                FlagsField(
                    "A_MPDU_flags",
                    None,
                    -32,
                    [
                        'Report0Subframe',
                        'Is0Subframe',
                        'KnownLastSubframe',  # noqa: E501
                        'LastSubframe',
                        'CRCerror',
                        'EOFsubframe',
                        'KnownEOF',  # noqa: E501
                        'res1',
                        'res2',
                        'res3',
                        'res4',
                        'res5',
                        'res6',
                        'res7',
                        'res8'
                    ])  # noqa: E501
            ),
            lambda pkt: pkt.present and pkt.present.A_MPDU),
        # VHT
        ConditionalField(
            _RadiotapReversePadField(
                FlagsField(
                    "KnownVHT",
                    None,
                    -16,
                    [
                        'STBC',
                        'TXOP_PS_NOT_ALLOWED',
                        'GuardInterval',
                        'SGINsysmDis',  # noqa: E501
                        'LDPCextraOFDM',
                        'Beamformed',
                        'Bandwidth',
                        'GroupID',
                        'PartialAID',  # noqa: E501
                        'res1',
                        'res2',
                        'res3',
                        'res4',
                        'res5',
                        'res6',
                        'res7'
                    ])  # noqa: E501
            ),
            lambda pkt: pkt.present and pkt.present.VHT),
        ConditionalField(
            _RadiotapReversePadField(
                FlagsField(
                    "PresentVHT",
                    None,
                    -8,
                    [
                        'STBC',
                        'TXOP_PS_NOT_ALLOWED',
                        'GuardInterval',
                        'SGINsysmDis',  # noqa: E501
                        'LDPCextraOFDM',
                        'Beamformed',
                        'res1',
                        'res2'
                    ])  # noqa: E501
            ),
            lambda pkt: pkt.present and pkt.present.VHT),
        ConditionalField(
            _RadiotapReversePadField(
                ByteEnumField("bandwidth", 0, _vht_bandwidth)),
            lambda pkt: pkt.present and pkt.present.VHT),  # noqa: E501
        ConditionalField(
            _RadiotapReversePadField(StrFixedLenField("mcs_nss", 0, length=5)),
            lambda pkt: pkt.present and pkt.present.VHT),  # noqa: E501
        ConditionalField(
            _RadiotapReversePadField(ByteField("GroupID", 0)),
            lambda pkt: pkt.present and pkt.present.VHT),  # noqa: E501
        ConditionalField(
            _RadiotapReversePadField(ShortField("PartialAID", 0)),
            lambda pkt: pkt.present and pkt.present.VHT),  # noqa: E501
        StrLenField('notdecoded',
                    "",
                    length_from=lambda pkt: pkt.len - pkt._tmp_dissect_pos)
    ]  # noqa: E501

    def guess_payload_class(self, payload):
        if self.present and self.present.Flags and self.Flags.FCS:
            return Dot11FCS
        return Dot11

    def post_build(self, p, pay):
        if self.len is None:
            p = p[:2] + struct.pack("!H", len(p))[::-1] + p[4:]
        return p + pay
예제 #8
0
class TLS_Ext_SupportedVersions(TLS_Ext_Unknown):
    name = "TLS Extension - Supported Versions (dummy class)"
    fields_desc = [
        ShortEnumField("type", 0x2b, _tls_ext),
        ShortField("len", None)
    ]
예제 #9
0
class MQTTSNUnsuback(Packet):
    name = "MQTT-SN unsubscribe ACK"
    fields_desc = [
        ShortField("mid", 0),
    ]
예제 #10
0
class SAPRouter(Packet):
    """SAP Router packet

    This packet is used for general SAP Router packets. There are (at least)
    five types of SAP Router packets:

        1. Route packets. For requesting the routing of a connection to a
        remote hosts. The packet contains some general information and a
        connection string with a list of routing hops (:class:`SAPRouterRouteHop`).

        2. Administration packets. This packet is used for the SAP Router to
        send administrative commands. It's suppose to be used only from the
        hosts running the SAP Router or when an specific route is included in
        the routing table. Generally administration packets are not accepted
        from the external binding.

        3. Error Information packets. Packets sent when an error occurred.

        4. Control Message packets. Used to perform some control activities,
        like retrieving the current SAPRouter version or to perform the SNC
        handshake. They have the same structure that error information
        packets.

        5. Route accepted packet. Used to acknowledge a route request
        ("NI_PONG").


    Routed packets and some responses doesn't fill in these five packet
    types. For identifying those cases, you should check the type using the
    function :class:`router_is_known_type`.

    NI Versions found (unconfirmed):
        - 30: Release 40C
        - 36: Release <6.20
        - 38: Release 7.00/7.10
        - 39: Release 7.11
        - 40: Release 7.20/7.21
    """

    # Default router version to use
    SAPROUTER_DEFAULT_VERSION = 40

    # Constants for router types
    SAPROUTER_ROUTE = "NI_ROUTE"
    """ :cvar: Constant for route packets
        :type: C{string} """

    SAPROUTER_ADMIN = "ROUTER_ADM"
    """ :cvar: Constant for administration packets
        :type: C{string} """

    SAPROUTER_ERROR = "NI_RTERR"
    """ :cvar: Constant for error information packets
        :type: C{string} """

    SAPROUTER_CONTROL = "NI_RTERR"
    """ :cvar: Constant for control messages packets
        :type: C{string} """

    SAPROUTER_PONG = "NI_PONG"
    """ :cvar: Constant for route accepted packets
        :type: C{string} """

    router_type_values = [
        SAPROUTER_ADMIN,
        SAPROUTER_ERROR,
        SAPROUTER_CONTROL,
        SAPROUTER_ROUTE,
        SAPROUTER_PONG,
    ]
    """ :cvar: List of known packet types
        :type: ``list`` of C{string} """

    name = "SAP Router"
    fields_desc = [
        # General fields present in all SAP Router packets
        StrNullField("type", SAPROUTER_ROUTE),
        ConditionalField(
            ByteField("version", 2),
            lambda pkt: router_is_known_type(pkt) and not router_is_pong(pkt)),

        # Route packets
        ConditionalField(
            ByteField("route_ni_version", SAPROUTER_DEFAULT_VERSION),
            router_is_route),
        ConditionalField(ByteField("route_entries", 0), router_is_route),
        ConditionalField(
            ByteEnumKeysField("route_talk_mode", ROUTER_TALK_MODE_NI_MSG_IO,
                              router_ni_talk_mode_values), router_is_route),
        ConditionalField(ShortField("route_padd", 0), router_is_route),
        ConditionalField(ByteField("route_rest_nodes", 0), router_is_route),
        ConditionalField(
            FieldLenField("route_length", 0, length_of="route_string",
                          fmt="I"), router_is_route),
        ConditionalField(IntField("route_offset", 0), router_is_route),
        ConditionalField(
            PacketListField("route_string",
                            None,
                            SAPRouterRouteHop,
                            length_from=lambda pkt: pkt.route_length),
            router_is_route),

        # Admin packets
        ConditionalField(
            ByteEnumKeysField("adm_command", 0x02, router_adm_commands),
            router_is_admin),
        ConditionalField(
            ShortField("adm_unused", 0x00), lambda pkt: router_is_admin(pkt)
            and pkt.adm_command not in [10, 11, 12, 13]),

        # Info Request fields
        ConditionalField(
            StrNullFixedLenField("adm_password", "", 19),
            lambda pkt: router_is_admin(pkt) and pkt.adm_command in [2]),

        # Cancel Route fields
        ConditionalField(
            FieldLenField("adm_client_count",
                          None,
                          count_of="adm_client_ids",
                          fmt="H"),
            lambda pkt: router_is_admin(pkt) and pkt.adm_command in [6]),
        # Trace Connection fields
        ConditionalField(
            FieldLenField("adm_client_count",
                          None,
                          count_of="adm_client_ids",
                          fmt="I"),
            lambda pkt: router_is_admin(pkt) and pkt.adm_command in [12, 13]),

        # Cancel Route or Trace Connection fields
        ConditionalField(
            FieldListField("adm_client_ids", [0x00],
                           IntField("", 0),
                           count_from=lambda pkt: pkt.adm_client_count), lambda
            pkt: router_is_admin(pkt) and pkt.adm_command in [6, 12, 13]),

        # Set/Clear Peer Trace fields  # TODO: Check whether this field should be a IPv6 address or another proper field
        ConditionalField(
            StrFixedLenField("adm_address_mask", "", 32),
            lambda pkt: router_is_admin(pkt) and pkt.adm_command in [10, 11]),

        # Error Information/Control Messages fields
        ConditionalField(
            ByteEnumKeysField("opcode", 0, router_control_opcodes),
            lambda pkt: router_is_error(pkt) or router_is_control(pkt)),
        ConditionalField(
            ByteField("opcode_padd", 0),
            lambda pkt: router_is_error(pkt) or router_is_control(pkt)),
        ConditionalField(
            SignedIntEnumField("return_code", 0, router_return_codes),
            lambda pkt: router_is_error(pkt) or router_is_control(pkt)),

        # Error Information fields
        ConditionalField(
            FieldLenField("err_text_length",
                          None,
                          length_of="err_text_value",
                          fmt="!I"),
            lambda pkt: router_is_error(pkt) and pkt.opcode == 0),
        ConditionalField(
            PacketField("err_text_value", SAPRouterError(),
                        SAPRouterError), lambda pkt: router_is_error(pkt) and
            pkt.opcode == 0 and pkt.err_text_length > 0),
        ConditionalField(IntField("err_text_unknown", 0),
                         lambda pkt: router_is_error(pkt) and pkt.opcode == 0),

        # Control Message fields
        ConditionalField(
            IntField("control_text_length", 0),
            lambda pkt: router_is_control(pkt) and pkt.opcode != 0),
        ConditionalField(
            StrField("control_text_value", "*ERR"),
            lambda pkt: router_is_control(pkt) and pkt.opcode != 0),

        # SNC Frame fields
        ConditionalField(
            PacketField("snc_frame", None, SAPSNCFrame),
            lambda pkt: router_is_control(pkt) and pkt.opcode in [70, 71])
    ]
예제 #11
0
class MQTTSNPubrel(Packet):
    name = "MQTT-SN publish release"
    fields_desc = [
        ShortField("mid", 0),
    ]
예제 #12
0
class MQTTSNPubrec(Packet):
    name = "MQTT-SN publish received"
    fields_desc = [
        ShortField("mid", 0),
    ]
예제 #13
0
class MQTTSNPubcomp(Packet):
    name = "MQTT-SN publish complete"
    fields_desc = [
        ShortField("mid", 0),
    ]
예제 #14
0
class MQTTSNAdvertise(Packet):
    name = "MQTT-SN advertise gateway"
    fields_desc = [
        ByteField("gw_id", 0),
        ShortField("duration", 0),
    ]
예제 #15
0
class MQTTPubcomp(Packet):
    name = "MQTT pubcomp"
    fields_desc = [
        ShortField("msgid", None),
    ]
예제 #16
0
class TLS_Ext_EarlyDataIndication(TLS_Ext_Unknown):
    name = "TLS Extension - Early Data"
    fields_desc = [
        ShortEnumField("type", 0x2a, _tls_ext),
        ShortField("len", None)
    ]
예제 #17
0
class MQTTSuback(Packet):
    name = "MQTT suback"
    fields_desc = [
        ShortField("msgid", None),
        ByteEnumField("retcode", None, ALLOWED_RETURN_CODE)
    ]
예제 #18
0
class TLS_Ext_PostHandshakeAuth(TLS_Ext_Unknown):  # RFC 8446
    name = "TLS Extension - Post Handshake Auth"
    fields_desc = [
        ShortEnumField("type", 0x31, _tls_ext),
        ShortField("len", None)
    ]
예제 #19
0
class MQTTUnsubscribe(Packet):
    name = "MQTT unsubscribe"
    fields_desc = [
        ShortField("msgid", None),
        PacketListField("topics", [], next_cls_cb=cb_topic)
    ]
예제 #20
0
파일: igmpv3.py 프로젝트: Saad-20/Arp-Spoof
class IGMPv3mra(Packet):
    """IGMP Multicas Router Advertisement extension for IGMPv3.
    Payload of IGMPv3 when type=0x30"""
    name = "IGMPv3mra"
    fields_desc = [ShortField("qryIntvl", 0), ShortField("robust", 0)]
예제 #21
0
class MQTTUnsuback(Packet):
    name = "MQTT unsuback"
    fields_desc = [ShortField("msgid", None)]
예제 #22
0
class EIGRPNms(EIGRPGeneric):
    name = "EIGRP Next Multicast Sequence"
    fields_desc = [XShortField("type", 0x0005),
                   ShortField("len", 8),
                   IntField("nms", 2)
                   ]
예제 #23
0
class TLS_Ext_EncryptThenMAC(TLS_Ext_Unknown):  # RFC 7366
    name = "TLS Extension - Encrypt-then-MAC"
    fields_desc = [
        ShortEnumField("type", 0x16, _tls_ext),
        ShortField("len", None)
    ]
예제 #24
0
class CPUMetadata(Packet):
    name = "CPUMetadata"
    fields_desc = [
        ShortField("origEtherType", None),
        ShortField("srcPort", None)
    ]
예제 #25
0
class TLS_Ext_ExtendedMasterSecret(TLS_Ext_Unknown):  # RFC 7627
    name = "TLS Extension - Extended Master Secret"
    fields_desc = [
        ShortEnumField("type", 0x17, _tls_ext),
        ShortField("len", None)
    ]
예제 #26
0
파일: dot11.py 프로젝트: cbnoc/cbnoc2019
class Dot11(Packet):
    name = "802.11"
    fields_desc = [
        BitField("subtype", 0, 4),
        BitEnumField("type", 0, 2,
                     ["Management", "Control", "Data", "Reserved"]),
        BitField("proto", 0, 2),
        FlagsField("FCfield", 0, 8, [
            "to-DS", "from-DS", "MF", "retry", "pw-mgt", "MD", "protected",
            "order"
        ]),
        ShortField("ID", 0),
        MACField("addr1", ETHER_ANY),
        ConditionalField(
            MACField("addr2", ETHER_ANY),
            lambda pkt:
            (pkt.type != 1 or pkt.subtype in [0x8, 0x9, 0xa, 0xb, 0xe, 0xf]),
        ),
        ConditionalField(
            MACField("addr3", ETHER_ANY),
            lambda pkt: pkt.type in [0, 2],
        ),
        ConditionalField(LEShortField("SC", 0), lambda pkt: pkt.type != 1),
        ConditionalField(
            MACField("addr4", ETHER_ANY),
            lambda pkt:
            (pkt.type == 2 and pkt.FCfield & 3 == 3),  # from-DS+to-DS
        )
    ]

    def mysummary(self):
        # Supports both Dot11 and Dot11FCS
        return self.sprintf(
            "802.11 %%%s.type%% %%%s.subtype%% %%%s.addr2%% > %%%s.addr1%%" %
            ((self.__class__.__name__, ) * 4))  # noqa: E501

    def guess_payload_class(self, payload):
        if self.type == 0x02 and (0x08 <= self.subtype <= 0xF
                                  and self.subtype != 0xD):  # noqa: E501
            return Dot11QoS
        elif self.FCfield.protected:
            # When a frame is handled by encryption, the Protected Frame bit
            # (previously called WEP bit) is set to 1, and the Frame Body
            # begins with the appropriate cryptographic header.
            return Dot11Encrypted
        else:
            return Packet.guess_payload_class(self, payload)

    def answers(self, other):
        if isinstance(other, Dot11):
            if self.type == 0:  # management
                if self.addr1.lower() != other.addr2.lower(
                ):  # check resp DA w/ req SA  # noqa: E501
                    return 0
                if (other.subtype, self.subtype) in [(0, 1), (2, 3), (4, 5)]:
                    return 1
                if self.subtype == other.subtype == 11:  # auth
                    return self.payload.answers(other.payload)
            elif self.type == 1:  # control
                return 0
            elif self.type == 2:  # data
                return self.payload.answers(other.payload)
            elif self.type == 3:  # reserved
                return 0
        return 0

    def unwep(self, key=None, warn=1):
        if self.FCfield & 0x40 == 0:
            if warn:
                warning("No WEP to remove")
            return
        if isinstance(self.payload.payload, NoPayload):
            if key or conf.wepkey:
                self.payload.decrypt(key)
            if isinstance(self.payload.payload, NoPayload):
                if warn:
                    warning("Dot11 can't be decrypted. Check conf.wepkey.")
                return
        self.FCfield &= ~0x40
        self.payload = self.payload.payload
예제 #27
0
class TLS_Ext_KeyShare(TLS_Ext_Unknown):
    name = "TLS Extension - Key Share (dummy class)"
    fields_desc = [
        ShortEnumField("type", 0x33, _tls_ext),
        ShortField("len", None)
    ]
class TLS_Ext_ClientCertURL(TLS_Ext_Unknown):                       # RFC 4366
    name = "TLS Extension - Client Certificate URL"
    fields_desc = [ShortEnumField("type", 2, _tls_ext),
                   ShortField("len", None)]
예제 #29
0
class TLS_Ext_PreSharedKey(TLS_Ext_Unknown):
    name = "TLS Extension - Pre Shared Key (dummy class)"
    fields_desc = [
        ShortEnumField("type", 0x29, _tls_ext),
        ShortField("len", None)
    ]
예제 #30
0
파일: dns.py 프로젝트: netkey/scapy
 def __init__(self, name, default, rr):
     ShortField.__init__(self, name, default)
     self.rr = rr
예제 #31
0
class ProfinetDCP(Packet):
    """
    Profinet DCP Packet

    Requests are handles via ConditionalFields because here only 1 Block is used every time
    Ŕesoinse can contain 1..n Blocks, for that you have to use one ProfinetDCP Layer with one or multiple DCP*Block Layers
        ProfinetDCP / DCPNameOfStationBlock / DCPDeviceIDBlock ...

    Example for a DCP Identify All Request:
        Ether(dst="01:0e:cf:00:00:00") / ProfinetIO(frameID=DCP_IDENTIFY_REQUEST_FRAME_ID) / ProfinetDCP(
                    service_id=DCP_SERVICE_ID_IDENTIFY, service_type= DCP_REQUEST, option=255, sub_option=255, dcp_data_length=4)

    Example for a DCP Identify Response:
        Ether(dst=dst_mac) / ProfinetIO(frameID=DCP_IDENTIFY_RESPONSE_FRAME_ID) / ProfinetDCP(
                    service_id=DCP_SERVICE_ID_IDENTIFY, service_type=DCP_RESPONSE) / DCPNameOfStationBlock(name_of_station="device1")

    Example for a DCP Set Request:
        Ether(dst=mac)/ProfinetIO(frameID=DCP_GET_SET_FRAME_ID)/ProfinetDCP(service_id=DCP_SERVICE_ID_SET, service_type=DCP_REQUEST,
                    option=2, sub_option=2, dcp_data_length=14, dcp_block_length=10, name_of_station=name, response_delay=0)

    """

    name = "Profinet DCP"
    # a DCP PDU consists of some fields and 1..n DCP Blocks
    fields_desc = [
        ByteEnumField("service_id", 5, DCP_SERVICE_ID),
        ByteEnumField("service_type", 0, DCP_SERVICE_TYPE),
        XIntField("xid", 0x01000001),
        # XShortField('reserved', 0),
        ConditionalField(ShortField('response_delay', 1),
                         lambda pkt: pkt.service_type == 0),
        ConditionalField(ShortField('reserved', 0),
                         lambda pkt: pkt.service_type == 1),
        LenField("dcp_data_length", None),

        # DCP REQUEST specific
        ConditionalField(ByteEnumField("option", 2, DCP_OPTIONS),
                         lambda pkt: pkt.service_type == 0),
        ConditionalField(
            MultiEnumField("sub_option",
                           3,
                           DCP_SUBOPTIONS,
                           fmt='B',
                           depends_on=lambda p: p.option),
            lambda pkt: pkt.service_type == 0),

        # calculate the len fields - workaround
        ConditionalField(LenField("dcp_block_length", 0),
                         lambda pkt: pkt.service_type == 0),
        # ConditionalField(LenField("dcp_block_length", 12), lambda pkt: pkt.service_type == 0 and (pkt.option == 1 or pkt.option == 2) and pkt.sub_option == 2), # name
        # ConditionalField(LenField("dcp_block_length", 12), lambda pkt: pkt.service_type == 0 and pkt.option == 1 and pkt.sub_option == 2), # ip
        # TODO alias_name

        # DCP SET REQUEST #
        ConditionalField(
            ShortEnumField("block_qualifier", 1, BLOCK_QUALIFIERS),
            lambda pkt: pkt.service_id == 4 and pkt.service_type == 0),
        # Name Of Station
        ConditionalField(
            StrLenField("name_of_station",
                        "et200sp",
                        length_from=lambda x: x.dcp_block_length - 2),
            lambda pkt: pkt.service_id == 4 and pkt.service_type == 0 and pkt.
            option == 2 and pkt.sub_option == 2),

        # MAC
        ConditionalField(
            MACField("mac",
                     "00:00:00:00:00:00"), lambda pkt: pkt.service_id == 4 and
            pkt.service_type == 0 and pkt.option == 1 and pkt.sub_option == 1),
        # IP
        ConditionalField(
            IPField("ip", "192.168.0.2"), lambda pkt: pkt.service_id == 4 and
            pkt.service_type == 0 and pkt.option == 1 and pkt.sub_option == 2),
        ConditionalField(
            IPField("netmask",
                    "255.255.255.0"), lambda pkt: pkt.service_id == 4 and pkt.
            service_type == 0 and pkt.option == 1 and pkt.sub_option == 2),
        ConditionalField(
            IPField("gateway",
                    "192.168.0.1"), lambda pkt: pkt.service_id == 4 and pkt.
            service_type == 0 and pkt.option == 1 and pkt.sub_option == 2),

        # DCP IDENTIFY REQUEST #
        # Name of station
        ConditionalField(
            StrLenField("name_of_station",
                        "et200sp",
                        length_from=lambda x: x.dcp_block_length),
            lambda pkt: pkt.service_id == 5 and pkt.service_type == 0 and pkt.
            option == 2 and pkt.sub_option == 2),

        # Alias name
        ConditionalField(
            StrLenField("alias_name",
                        "et200sp",
                        length_from=lambda x: x.dcp_block_length),
            lambda pkt: pkt.service_id == 5 and pkt.service_type == 0 and pkt.
            option == 2 and pkt.sub_option == 6),

        # implement further REQUEST fields if needed ....

        # DCP RESPONSE BLOCKS #
        ConditionalField(
            PacketListField("dcp_blocks", [],
                            guess_dcp_block_class,
                            length_from=lambda p: p.dcp_data_length),
            lambda pkt: pkt.service_type == 1),
    ]

    def post_build(self, p, pay):

        # add padding to ensure min packet length

        padding = MIN_PACKET_LENGTH - (len(p + pay))
        pay += b"\0" * padding

        return Packet.post_build(self, p, pay)