| # MIT License |
| |
| # Copyright (c) 2018 Jose Amores |
| |
| # Permission is hereby granted, free of charge, to any person obtaining a copy |
| # of this software and associated documentation files (the "Software"), to deal |
| # in the Software without restriction, including without limitation the rights |
| # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| # copies of the Software, and to permit persons to whom the Software is |
| # furnished to do so, subject to the following conditions: |
| |
| # The above copyright notice and this permission notice shall be included in |
| # all copies or substantial portions of the Software. |
| |
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| # SOFTWARE. |
| |
| # This file is part of Scapy |
| # See http://www.secdev.org/projects/scapy for more information |
| # Copyright (C) Sebastian Baar <[email protected]> |
| # This program is published under a GPLv2 license |
| |
| ########## |
| ########## |
| |
| |
| + Basic operations |
| |
| = Load module |
| load_contrib("automotive.someip", globals_dict=globals()) |
| |
| + SOME/IP operation |
| |
| = Basic build |
| p = SOMEIP() |
| pstr = bytes(p) |
| binstr = b"\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x01\x01\x00\x00" |
| assert pstr == binstr |
| |
| = Build with empty payload |
| p.payload = Raw(b"") |
| pstr = bytes(p) |
| binstr = b"\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x01\x01\x00\x00" |
| assert pstr == binstr |
| |
| = Build with non-empty payload |
| p.payload = Raw(b"\xde\xad\xbe\xef") |
| pstr = bytes(p) |
| binstr = b"\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x01\x01\x00\x00\xde\xad\xbe\xef" |
| assert pstr == binstr |
| |
| = Dissect EVENT_ID packet |
| p = SOMEIP(b"\x11\x11\x81\x11\x00\x00\x00\x08\x33\x33\x44\x44\x02\x03\x04\x05") |
| |
| assert p.srv_id == 0x1111 |
| assert p.sub_id == 0x8111 |
| assert p.client_id == 0x3333 |
| assert p.session_id == 0x4444 |
| assert p.proto_ver == 0x02 |
| assert p.iface_ver == 0x03 |
| assert p.msg_type == 0x04 |
| assert p.retcode == 0x05 |
| |
| |
| = Dissect METHOD_ID packet |
| p = SOMEIP(b"\x11\x11\x01\x11\x00\x00\x00\x08\x33\x33\x44\x44\x02\x03\x04\x05") |
| |
| assert p.srv_id == 0x1111 |
| assert p.sub_id == 0x0111 |
| assert p.client_id == 0x3333 |
| assert p.session_id == 0x4444 |
| assert p.proto_ver == 0x02 |
| assert p.iface_ver == 0x03 |
| assert p.msg_type == 0x04 |
| assert p.retcode == 0x05 |
| |
| + SOME/IP-TP operation |
| |
| = Build TP |
| p = SOMEIP() |
| p.msg_type = 0x20 |
| |
| pstr = bytes(p) |
| print(pstr) |
| binstr = b'\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x01\x01\x20\x00\x00\x00\x00\x00' |
| assert pstr == binstr |
| |
| p.more_seg = 1 |
| pstr = bytes(p) |
| binstr = b'\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x01\x01\x20\x00\x00\x00\x00\x01' |
| assert pstr == binstr |
| |
| p.msg_type = 0x00 |
| pstr = bytes(p) |
| binstr = b'\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x01\x01\x00\x00' |
| assert pstr == binstr |
| |
| = Dissect TP |
| p = SOMEIP(b'\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x01\x01\x21\x00\x00\x00\x00\x01') |
| |
| assert p.msg_type == 0x21 |
| assert p.more_seg == 1 |
| assert p.len == 12 |
| |
| p.msg_type = 0x00 |
| |
| pstr = bytes(p) |
| binstr = b"\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x01\x01\x00\x00" |
| assert pstr == binstr |
| |
| = Build TP fragmented |
| p = SOMEIP() |
| p.msg_type = 0x20 |
| p.add_payload(Raw("A"*1400)) |
| |
| f = p.fragment() |
| |
| assert f[0].len == 1404 |
| assert f[1].len == 20 |
| assert f[0].payload == Raw("A"*1392) |
| assert f[1].payload == Raw("A"*8) |
| assert f[0].more_seg == 1 |
| assert f[1].more_seg == 0 |
| |
| + SD Entry Service |
| |
| = Check packet length on empty build |
| p = SDEntry_Service() |
| assert len(bytes(p)) == SDENTRY_OVERALL_LEN |
| |
| = Build 1 |
| p = SDEntry_Service(type = SDENTRY_TYPE_SRV_OFFERSERVICE, |
| index_1 = 0x11, index_2 = 0x22, srv_id = 0x3333, |
| inst_id = 0x4444, major_ver = 0x55, |
| ttl = 0x666666, minor_ver = 0xdeadbeef) |
| p_str = bytes(p) |
| bin_str = b"\x01\x11\x22\x00\x33\x33\x44\x44\x55\x66\x66\x66\xde\xad\xbe\xef" |
| assert p_str == bin_str |
| assert len(p_str) == SDENTRY_OVERALL_LEN |
| |
| = Build 2 |
| p = SDEntry_Service(n_opt_1 = 0xf1, n_opt_2 = 0xf2) |
| p_str = bytes(p) |
| bin_str = b"\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" |
| assert p_str == bin_str |
| assert len(p_str) == SDENTRY_OVERALL_LEN |
| |
| = Dissect |
| p = SDEntry_Service( |
| b"\x01\x22\x33\x00\x44\x44\x55\x55\x66\x77\x77\x77\xde\xad\xbe\xef") |
| assert p.type == SDENTRY_TYPE_SRV_OFFERSERVICE |
| assert p.index_1 == 0x22 |
| assert p.index_2 == 0x33 |
| assert p.srv_id == 0x4444 |
| assert p.inst_id == 0x5555 |
| assert p.major_ver == 0x66 |
| assert p.ttl == 0x777777 |
| assert p.minor_ver == 0xdeadbeef |
| |
| + SD Entry Eventgroup |
| |
| = Check packet length on empty build |
| p = SDEntry_EventGroup() |
| assert len(bytes(p)) == SDENTRY_OVERALL_LEN |
| |
| = Build |
| p = SDEntry_EventGroup(index_1 = 0x11, index_2 = 0x22, srv_id = 0x3333, |
| inst_id = 0x4444, major_ver = 0x55, ttl = 0x666666, |
| cnt = 0x7, eventgroup_id = 0x8888) |
| p_str = bytes(p) |
| bin_str = b"\x06\x11\x22\x00\x33\x33\x44\x44\x55\x66\x66\x66\x00\x07\x88\x88" |
| assert p_str == bin_str |
| assert len(bytes(p)) == SDENTRY_OVERALL_LEN |
| |
| = Dissect |
| p = SDEntry_EventGroup( |
| b"\x06\x11\x22\x00\x33\x33\x44\x44\x55\x66\x66\x66\x00\x07\x88\x88") |
| assert p.index_1 == 0x11 |
| assert p.index_2 == 0x22 |
| assert p.srv_id == 0x3333 |
| assert p.inst_id == 0x4444 |
| assert p.major_ver == 0x55 |
| assert p.ttl == 0x666666 |
| assert p.cnt == 0x7 |
| assert p.eventgroup_id == 0x8888 |
| |
| + SD Flags |
| |
| = Build and check flags |
| p = SD() |
| p.flags = "REBOOT" |
| assert p.flags == 0x80 |
| |
| p.flags = "" |
| assert p.flags == 0x00 |
| |
| p.flags = "UNICAST" |
| assert p.flags == 0x40 |
| |
| p.flags = "" |
| assert p.flags == 0x00 |
| |
| p.flags = "EXPLICIT_INITIAL_DATA_CONTROL" |
| assert p.flags == 0x20 |
| |
| p.flags = "" |
| assert p.flags == 0x00 |
| |
| p.flags = "REBOOT+UNICAST+EXPLICIT_INITIAL_DATA_CONTROL" |
| assert p.flags == 0xe0 |
| |
| + SD Get SOME/IP Packet |
| |
| = Build empty |
| p = SOMEIP() / SD() |
| assert len(bytes(p)) == SOMEIP._OVERALL_LEN_NOPAYLOAD + 12 |
| |
| = Verify constants against spec TR_SOMEIP_00250 |
| assert SD.SOMEIP_MSGID_SRVID == 0xffff |
| assert SD.SOMEIP_MSGID_SUBID == 0x8100 |
| assert SD.SOMEIP_CLIENT_ID == 0x0000 |
| assert SD.SOMEIP_MINIMUM_SESSION_ID == 0x0001 |
| assert SD.SOMEIP_PROTO_VER == 0x01 |
| assert SD.SOMEIP_IFACE_VER == 0x01 |
| assert SD.SOMEIP_MSG_TYPE == 0x02 |
| assert SD.SOMEIP_RETCODE == 0x00 |
| |
| = check that values are bound |
| assert p[SOMEIP].srv_id == SD.SOMEIP_MSGID_SRVID |
| assert p[SOMEIP].sub_id == SD.SOMEIP_MSGID_SUBID |
| assert p[SOMEIP].client_id == SD.SOMEIP_CLIENT_ID |
| assert p[SOMEIP].session_id != 0x0000 |
| assert p[SOMEIP].session_id >= SD.SOMEIP_MINIMUM_SESSION_ID |
| assert p[SOMEIP].proto_ver == SD.SOMEIP_PROTO_VER |
| assert p[SOMEIP].iface_ver == SD.SOMEIP_IFACE_VER |
| assert p[SOMEIP].msg_type == SD.SOMEIP_MSG_TYPE |
| assert p[SOMEIP].retcode == SD.SOMEIP_RETCODE |
| |
| # FIXME: Service Discovery messages shell be transported over UDP |
| # (TR_SOMEIP_00248) |
| # FIXME: The port 30490 (UDP and TCP as well) shall be only used for SOME/IP-SD |
| # and not used for applications communicating over SOME/IP (TR_SOMEIP_00020) |
| |
| + SD |
| |
| = Check length of package without entries nor options |
| p = SD() |
| assert len(bytes(p)) == 12 |
| |
| = Check entries to array and size check |
| p.set_entryArray([SDEntry_Service(), SDEntry_EventGroup()]) |
| assert struct.unpack("!L", bytes(p)[4:8])[0] == 32 |
| |
| p.set_entryArray([]) |
| assert struct.unpack("!L", bytes(p)[4:8])[0] == 0 |
| |
| = Check Options to array and size check |
| p.set_optionArray([SDOption_IP4_EndPoint(), SDOption_IP4_EndPoint()]) |
| assert struct.unpack("!L", bytes(p)[8:12])[0] == 24 |
| |
| p.set_optionArray([]) |
| assert struct.unpack("!L", bytes(p)[8:12])[0] == 0 |
| |
| = Check Entries & Options to array and size check |
| p.set_entryArray([SDEntry_Service(), SDEntry_EventGroup()]) |
| p.set_optionArray([SDOption_IP4_EndPoint(), SDOption_IP4_EndPoint()]) |
| |
| assert struct.unpack("!L", bytes(p)[4:8])[0] == 32 |
| assert struct.unpack("!L", bytes(p)[40:44])[0] == 24 |
| |
| |
| + Git issue 2348: SOME/IP-SD Entry-Array is broken by building it from RAW |
| |
| = Single SD entry |
| # offer service |
| ea1 = SDEntry_Service() |
| ea1.type = 1 |
| ea1.srv_id = 0x1234 |
| ea1.inst_id = 0x5678 |
| ea1.ttl = 0x333333 |
| |
| # subscribe eventgroup |
| ea2 = SDEntry_EventGroup() |
| ea2.type = 0x6 |
| ea2.srv_id = 0x8765 |
| ea2.inst_id = 0x4321 |
| ea2.ttl = 0x222222 |
| ea2.eventgroup_id = 0x1357 |
| |
| sd1 = SD() |
| sd1.set_entryArray([ea1]) |
| # this is computed on build, but we need it sooner for the assert |
| sd1.len_entry_array = 16 |
| sd1.len_option_array = 0 |
| |
| assert sd1.show(dump=True) == SD(sd1.build()).show(dump=True) |
| |
| = Double SD entry |
| sd2 = SD() |
| sd2.set_entryArray([ea2,ea1]) |
| # this is computed on build, but we need it sooner for the assert |
| sd2.len_entry_array = 32 |
| sd2.len_option_array = 0 |
| |
| assert sd2.show(dump=True) == SD(sd2.build()).show(dump=True) |
| |
| = Flipped double SD entry |
| # flip the order |
| sd2.set_entryArray([ea1,ea2]) |
| assert sd2.show(dump=True) == SD(sd2.build()).show(dump=True) |
| |
| |
| |
| |
| |
| + SD Options (individual) |
| = Verifying constants against spec |
| assert SDOPTION_CFG_TYPE == 0x01 |
| assert SDOPTION_LOADBALANCE_TYPE == 0x02 |
| assert SDOPTION_LOADBALANCE_LEN == 0x05 |
| assert SDOPTION_IP4_ENDPOINT_TYPE == 0x04 |
| assert SDOPTION_IP4_ENDPOINT_LEN == 0x0009 |
| assert SDOPTION_IP4_MCAST_TYPE == 0x14 |
| assert SDOPTION_IP4_MCAST_LEN == 0x0009 |
| assert SDOPTION_IP4_SDENDPOINT_TYPE == 0x24 |
| assert SDOPTION_IP4_SDENDPOINT_LEN == 0x0009 |
| assert SDOPTION_IP6_ENDPOINT_TYPE == 0x06 |
| assert SDOPTION_IP6_ENDPOINT_LEN == 0x0015 |
| assert SDOPTION_IP6_MCAST_TYPE == 0x16 |
| assert SDOPTION_IP6_MCAST_LEN == 0x0015 |
| assert SDOPTION_IP6_SDENDPOINT_TYPE == 0x26 |
| assert SDOPTION_IP6_SDENDPOINT_LEN == 0x0015 |
| |
| ### SDOption_Config |
| = SDOption_Config: Verify make_string() method from dict |
| data = { "hello": "world" } |
| out = SDOption_Config.make_string(data) |
| assert out == b"\x0bhello=world\x00" |
| |
| = SDOption_Config: Verify make_string() method from list |
| data = [ |
| ("x", "y"), |
| ("abc", "def"), |
| ("123", "456") |
| ] |
| out = SDOption_Config.make_string(data) |
| assert out == b"\x03x=y\x07abc=def\x07123=456\x00" |
| |
| = SDOption_Config: Build and dissect empty |
| opt = SDOption_Config() |
| optraw = opt.build() |
| assert optraw == b"\x00\x02\x01\x00\x00" |
| |
| opt = SDOption_Config(optraw) |
| assert opt.len == 0x2 |
| assert opt.type == SDOPTION_CFG_TYPE |
| assert opt.res_hdr == 0x0 |
| assert opt.cfg_str == b"\x00" |
| |
| = SDOption_Config: Build and dissect spec example |
| tststr = b"\x05abc=x\x07def=123\x00" |
| opt = SDOption_Config(cfg_str=tststr) |
| optraw = opt.build() |
| assert optraw == b"\x00\x10\x01\x00" + tststr |
| |
| opt = SDOption_Config(optraw) |
| assert opt.len == 0x10 |
| assert opt.type == SDOPTION_CFG_TYPE |
| assert opt.res_hdr == 0x00 |
| assert opt.cfg_str == tststr |
| |
| = SDOption_Config: Build and dissect fully populated |
| tststr = b"abcdefghijklmnopqrstuvwxyz" |
| opt = SDOption_Config(len=0x1234, type=0x56, res_hdr=0x78, cfg_str=tststr) |
| optraw = opt.build() |
| assert optraw == b"\x12\x34\x56\x78" + tststr |
| |
| opt = SDOption_Config(optraw) |
| assert opt.len == 0x1234 |
| assert opt.type == 0x56 |
| assert opt.res_hdr == 0x78 |
| assert opt.cfg_str == tststr |
| |
| |
| ### SDOption_LoadBalance |
| = SDOption_LoadBalance: Build and dissect empty |
| opt = SDOption_LoadBalance() |
| optraw = opt.build() |
| assert optraw == b"\x00\x05\x02\x00\x00\x00\x00\x00" |
| |
| opt = SDOption_LoadBalance(optraw) |
| assert opt.len == SDOPTION_LOADBALANCE_LEN |
| assert opt.type == SDOPTION_LOADBALANCE_TYPE |
| assert opt.res_hdr == 0x0 |
| assert opt.priority == 0x0 |
| assert opt.weight == 0x0 |
| |
| = SDOption_LoadBalance: Build and dissect example |
| opt = SDOption_LoadBalance(priority=0x1234, weight=0x5678) |
| optraw = opt.build() |
| assert optraw == b"\x00\x05\x02\x00\x12\x34\x56\x78" |
| |
| opt = SDOption_LoadBalance(optraw) |
| assert opt.len == SDOPTION_LOADBALANCE_LEN |
| assert opt.type == SDOPTION_LOADBALANCE_TYPE |
| assert opt.res_hdr == 0x00 |
| assert opt.priority == 0x1234 |
| assert opt.weight == 0x5678 |
| |
| = SDOption_LoadBalance: Build and dissect fully populated |
| opt = SDOption_LoadBalance(len=0x1234, type=0x56, res_hdr=0x78, priority=0x9abc, weight=0xdef0) |
| optraw = opt.build() |
| assert optraw == b"\x12\x34\x56\x78\x9a\xbc\xde\xf0" |
| |
| opt = SDOption_LoadBalance(optraw) |
| assert opt.len == 0x1234 |
| assert opt.type == 0x56 |
| assert opt.res_hdr == 0x78 |
| assert opt.priority == 0x9abc |
| assert opt.weight == 0xdef0 |
| |
| |
| ### SDOption_IP4_EndPoint |
| = SDOption_IP4_EndPoint: Build and dissect empty |
| opt = SDOption_IP4_EndPoint() |
| optraw = opt.build() |
| assert optraw == b"\x00\x09\x04\x00\x00\x00\x00\x00\x00\x11\x00\x00" |
| |
| opt = SDOption_IP4_EndPoint(optraw) |
| assert opt.len == SDOPTION_IP4_ENDPOINT_LEN |
| assert opt.type == SDOPTION_IP4_ENDPOINT_TYPE |
| assert opt.res_hdr == 0x0 |
| assert opt.addr == "0.0.0.0" |
| assert opt.res_tail == 0x0 |
| assert opt.l4_proto == 0x11 |
| assert opt.port == 0x0 |
| |
| |
| = SDOption_IP4_EndPoint: Build and dissect example |
| opt = SDOption_IP4_EndPoint(addr = "192.168.123.45", l4_proto = "TCP", port = 0x1234) |
| optraw = opt.build() |
| assert optraw == b"\x00\x09\x04\x00\xc0\xa8\x7b\x2d\x00\x06\x12\x34" |
| |
| opt = SDOption_IP4_EndPoint(optraw) |
| assert opt.len == SDOPTION_IP4_ENDPOINT_LEN |
| assert opt.type == SDOPTION_IP4_ENDPOINT_TYPE |
| assert opt.res_hdr == 0x00 |
| assert opt.addr == "192.168.123.45" |
| assert opt.res_tail == 0x0 |
| assert opt.l4_proto == 0x06 |
| assert opt.port == 0x1234 |
| |
| = SDOption_IP4_EndPoint: Build and dissect fully populated |
| opt = SDOption_IP4_EndPoint(len=0x1234, type=0x56, res_hdr=0x78, addr = "11.22.33.44", res_tail = 0x9a, l4_proto = 0xbc, port = 0xdef0) |
| optraw = opt.build() |
| assert optraw == b"\x12\x34\x56\x78\x0b\x16\x21\x2c\x9a\xbc\xde\xf0" |
| |
| opt = SDOption_IP4_EndPoint(optraw) |
| assert opt.len == 0x1234 |
| assert opt.type == 0x56 |
| assert opt.res_hdr == 0x78 |
| assert opt.addr == "11.22.33.44" |
| assert opt.res_tail == 0x9a |
| assert opt.l4_proto == 0xbc |
| assert opt.port == 0xdef0 |
| |
| |
| ### SDOption_IP4_Multicast |
| = SDOption_IP4_Multicast: Build and dissect empty |
| opt = SDOption_IP4_Multicast() |
| optraw = opt.build() |
| assert optraw == b"\x00\x09\x14\x00\x00\x00\x00\x00\x00\x11\x00\x00" |
| |
| opt = SDOption_IP4_Multicast(optraw) |
| assert opt.len == SDOPTION_IP4_MCAST_LEN |
| assert opt.type == SDOPTION_IP4_MCAST_TYPE |
| assert opt.res_hdr == 0x0 |
| assert opt.addr == "0.0.0.0" |
| assert opt.res_tail == 0x0 |
| assert opt.l4_proto == 0x11 |
| assert opt.port == 0x0 |
| |
| |
| = SDOption_IP4_Multicast: Build and dissect example |
| opt = SDOption_IP4_Multicast(addr = "192.168.123.45", l4_proto = "TCP", port = 0x1234) |
| optraw = opt.build() |
| assert optraw == b"\x00\x09\x14\x00\xc0\xa8\x7b\x2d\x00\x06\x12\x34" |
| |
| opt = SDOption_IP4_Multicast(optraw) |
| assert opt.len == SDOPTION_IP4_MCAST_LEN |
| assert opt.type == SDOPTION_IP4_MCAST_TYPE |
| assert opt.res_hdr == 0x00 |
| assert opt.addr == "192.168.123.45" |
| assert opt.res_tail == 0x0 |
| assert opt.l4_proto == 0x06 |
| assert opt.port == 0x1234 |
| |
| = SDOption_IP4_Multicast: Build and dissect fully populated |
| opt = SDOption_IP4_Multicast(len=0x1234, type=0x56, res_hdr=0x78, addr = "11.22.33.44", res_tail = 0x9a, l4_proto = 0xbc, port = 0xdef0) |
| optraw = opt.build() |
| assert optraw == b"\x12\x34\x56\x78\x0b\x16\x21\x2c\x9a\xbc\xde\xf0" |
| |
| opt = SDOption_IP4_Multicast(optraw) |
| assert opt.len == 0x1234 |
| assert opt.type == 0x56 |
| assert opt.res_hdr == 0x78 |
| assert opt.addr == "11.22.33.44" |
| assert opt.res_tail == 0x9a |
| assert opt.l4_proto == 0xbc |
| assert opt.port == 0xdef0 |
| |
| |
| ### SDOption_IP4_SD_EndPoint |
| = SDOption_IP4_SD_EndPoint: Build and dissect empty |
| opt = SDOption_IP4_SD_EndPoint() |
| optraw = opt.build() |
| assert optraw == b"\x00\x09\x24\x00\x00\x00\x00\x00\x00\x11\x00\x00" |
| |
| opt = SDOption_IP4_SD_EndPoint(optraw) |
| assert opt.len == SDOPTION_IP4_SDENDPOINT_LEN |
| assert opt.type == SDOPTION_IP4_SDENDPOINT_TYPE |
| assert opt.res_hdr == 0x0 |
| assert opt.addr == "0.0.0.0" |
| assert opt.res_tail == 0x0 |
| assert opt.l4_proto == 0x11 |
| assert opt.port == 0x0 |
| |
| |
| = SDOption_IP4_SD_EndPoint: Build and dissect example |
| opt = SDOption_IP4_SD_EndPoint(addr = "192.168.123.45", l4_proto = "TCP", port = 0x1234) |
| optraw = opt.build() |
| assert optraw == b"\x00\x09\x24\x00\xc0\xa8\x7b\x2d\x00\x06\x12\x34" |
| |
| opt = SDOption_IP4_SD_EndPoint(optraw) |
| assert opt.len == SDOPTION_IP4_SDENDPOINT_LEN |
| assert opt.type == SDOPTION_IP4_SDENDPOINT_TYPE |
| assert opt.res_hdr == 0x00 |
| assert opt.addr == "192.168.123.45" |
| assert opt.res_tail == 0x0 |
| assert opt.l4_proto == 0x06 |
| assert opt.port == 0x1234 |
| |
| = SDOption_IP4_SD_EndPoint: Build and dissect fully populated |
| opt = SDOption_IP4_SD_EndPoint(len=0x1234, type=0x56, res_hdr=0x78, addr = "11.22.33.44", res_tail = 0x9a, l4_proto = 0xbc, port = 0xdef0) |
| optraw = opt.build() |
| assert optraw == b"\x12\x34\x56\x78\x0b\x16\x21\x2c\x9a\xbc\xde\xf0" |
| |
| opt = SDOption_IP4_SD_EndPoint(optraw) |
| assert opt.len == 0x1234 |
| assert opt.type == 0x56 |
| assert opt.res_hdr == 0x78 |
| assert opt.addr == "11.22.33.44" |
| assert opt.res_tail == 0x9a |
| assert opt.l4_proto == 0xbc |
| assert opt.port == 0xdef0 |
| |
| ### SDOption_IP6_EndPoint |
| = SDOption_IP6_EndPoint: Build and dissect empty |
| opt = SDOption_IP6_EndPoint() |
| optraw = opt.build() |
| assert optraw == b"\x00\x15\x06\x00" + b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + b"\x00\x11\x00\x00" |
| |
| opt = SDOption_IP6_EndPoint(optraw) |
| assert opt.len == SDOPTION_IP6_ENDPOINT_LEN |
| assert opt.type == SDOPTION_IP6_ENDPOINT_TYPE |
| assert opt.res_hdr == 0x0 |
| assert opt.addr == "::" |
| assert opt.res_tail == 0x0 |
| assert opt.l4_proto == 0x11 |
| assert opt.port == 0x0 |
| |
| |
| = SDOption_IP6_EndPoint: Build and dissect example |
| opt = SDOption_IP6_EndPoint(addr = "2001:cdba::3257:9652", l4_proto = "TCP", port = 0x1234) |
| optraw = opt.build() |
| assert optraw == b"\x00\x15\x06\x00" + b"\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52" + b"\x00\x06\x12\x34" |
| |
| opt = SDOption_IP6_EndPoint(optraw) |
| assert opt.len == SDOPTION_IP6_ENDPOINT_LEN |
| assert opt.type == SDOPTION_IP6_ENDPOINT_TYPE |
| assert opt.res_hdr == 0x00 |
| assert opt.addr == "2001:cdba::3257:9652" |
| assert opt.res_tail == 0x0 |
| assert opt.l4_proto == 0x06 |
| assert opt.port == 0x1234 |
| |
| = SDOption_IP6_EndPoint: Build and dissect fully populated |
| opt = SDOption_IP6_EndPoint(len=0x1234, type=0x56, res_hdr=0x78, addr = "1234:5678:9abc:def0:0fed:cba9:8765:4321", res_tail = 0x9a, l4_proto = 0xbc, port = 0xdef0) |
| optraw = opt.build() |
| assert optraw == b"\x12\x34\x56\x78" + b"\x12\x34\x56\x78\x9a\xbc\xde\xf0\x0f\xed\xcb\xa9\x87\x65\x43\x21" + b"\x9a\xbc\xde\xf0" |
| |
| opt = SDOption_IP6_EndPoint(optraw) |
| assert opt.len == 0x1234 |
| assert opt.type == 0x56 |
| assert opt.res_hdr == 0x78 |
| assert opt.addr == "1234:5678:9abc:def0:fed:cba9:8765:4321" |
| assert opt.res_tail == 0x9a |
| assert opt.l4_proto == 0xbc |
| assert opt.port == 0xdef0 |
| |
| |
| ### SDOption_IP6_Multicast |
| = SDOption_IP6_Multicast: Build and dissect empty |
| opt = SDOption_IP6_Multicast() |
| optraw = opt.build() |
| assert optraw == b"\x00\x15\x16\x00" + b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + b"\x00\x11\x00\x00" |
| |
| opt = SDOption_IP6_Multicast(optraw) |
| assert opt.len == SDOPTION_IP6_MCAST_LEN |
| assert opt.type == SDOPTION_IP6_MCAST_TYPE |
| assert opt.res_hdr == 0x0 |
| assert opt.addr == "::" |
| assert opt.res_tail == 0x0 |
| assert opt.l4_proto == 0x11 |
| assert opt.port == 0x0 |
| |
| |
| = SDOption_IP6_Multicast: Build and dissect example |
| opt = SDOption_IP6_Multicast(addr = "2001:cdba::3257:9652", l4_proto = "TCP", port = 0x1234) |
| optraw = opt.build() |
| assert optraw == b"\x00\x15\x16\x00" + b"\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52" + b"\x00\x06\x12\x34" |
| |
| opt = SDOption_IP6_Multicast(optraw) |
| assert opt.len == SDOPTION_IP6_MCAST_LEN |
| assert opt.type == SDOPTION_IP6_MCAST_TYPE |
| assert opt.res_hdr == 0x00 |
| assert opt.addr == "2001:cdba::3257:9652" |
| assert opt.res_tail == 0x0 |
| assert opt.l4_proto == 0x06 |
| assert opt.port == 0x1234 |
| |
| = SDOption_IP6_Multicast: Build and dissect fully populated |
| opt = SDOption_IP6_Multicast(len=0x1234, type=0x56, res_hdr=0x78, addr = "1234:5678:9abc:def0:0fed:cba9:8765:4321", res_tail = 0x9a, l4_proto = 0xbc, port = 0xdef0) |
| optraw = opt.build() |
| assert optraw == b"\x12\x34\x56\x78" + b"\x12\x34\x56\x78\x9a\xbc\xde\xf0\x0f\xed\xcb\xa9\x87\x65\x43\x21" + b"\x9a\xbc\xde\xf0" |
| |
| opt = SDOption_IP6_Multicast(optraw) |
| assert opt.len == 0x1234 |
| assert opt.type == 0x56 |
| assert opt.res_hdr == 0x78 |
| assert opt.addr == "1234:5678:9abc:def0:fed:cba9:8765:4321" |
| assert opt.res_tail == 0x9a |
| assert opt.l4_proto == 0xbc |
| assert opt.port == 0xdef0 |
| |
| |
| ### SDOption_IP6_SD_EndPoint |
| = SDOption_IP6_SD_EndPoint: Build and dissect empty |
| opt = SDOption_IP6_SD_EndPoint() |
| optraw = opt.build() |
| assert optraw == b"\x00\x15\x26\x00" + b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + b"\x00\x11\x00\x00" |
| |
| opt = SDOption_IP6_SD_EndPoint(optraw) |
| assert opt.len == SDOPTION_IP6_SDENDPOINT_LEN |
| assert opt.type == SDOPTION_IP6_SDENDPOINT_TYPE |
| assert opt.res_hdr == 0x0 |
| assert opt.addr == "::" |
| assert opt.res_tail == 0x0 |
| assert opt.l4_proto == 0x11 |
| assert opt.port == 0x0 |
| |
| |
| = SDOption_IP6_SD_EndPoint: Build and dissect example |
| opt = SDOption_IP6_SD_EndPoint(addr = "2001:cdba::3257:9652", l4_proto = "TCP", port = 0x1234) |
| optraw = opt.build() |
| assert optraw == b"\x00\x15\x26\x00" + b"\x20\x01\xcd\xba\x00\x00\x00\x00\x00\x00\x00\x00\x32\x57\x96\x52" + b"\x00\x06\x12\x34" |
| |
| opt = SDOption_IP6_SD_EndPoint(optraw) |
| assert opt.len == SDOPTION_IP6_SDENDPOINT_LEN |
| assert opt.type == SDOPTION_IP6_SDENDPOINT_TYPE |
| assert opt.res_hdr == 0x00 |
| assert opt.addr == "2001:cdba::3257:9652" |
| assert opt.res_tail == 0x0 |
| assert opt.l4_proto == 0x06 |
| assert opt.port == 0x1234 |
| |
| = SDOption_IP6_SD_EndPoint: Build and dissect fully populated |
| opt = SDOption_IP6_SD_EndPoint(len=0x1234, type=0x56, res_hdr=0x78, addr = "1234:5678:9abc:def0:0fed:cba9:8765:4321", res_tail = 0x9a, l4_proto = 0xbc, port = 0xdef0) |
| optraw = opt.build() |
| assert optraw == b"\x12\x34\x56\x78" + b"\x12\x34\x56\x78\x9a\xbc\xde\xf0\x0f\xed\xcb\xa9\x87\x65\x43\x21" + b"\x9a\xbc\xde\xf0" |
| |
| opt = SDOption_IP6_SD_EndPoint(optraw) |
| assert opt.len == 0x1234 |
| assert opt.type == 0x56 |
| assert opt.res_hdr == 0x78 |
| assert opt.addr == "1234:5678:9abc:def0:fed:cba9:8765:4321" |
| assert opt.res_tail == 0x9a |
| assert opt.l4_proto == 0xbc |
| assert opt.port == 0xdef0 |
| |
| = verify building and parsing of multiple SDOptions |
| def _opts_check(opts): |
| optslen = sum([len(o) for o in opts]) |
| sd = SD() |
| sd.set_optionArray(opts) |
| sd.len_entry_array = 0 |
| sd.len_option_array = optslen |
| sd.show() |
| SD(sd.build()).show() |
| assert sd.show(dump=True) == SD(sd.build()).show(dump=True) |
| |
| # options are built and reparsed, to make sure all is calculated |
| opts = [ |
| SDOption_Config(SDOption_Config(cfg_str="hello world").build()), |
| SDOption_LoadBalance(SDOption_LoadBalance().build()), |
| SDOption_IP4_EndPoint(SDOption_IP4_EndPoint().build()), |
| SDOption_IP4_Multicast(SDOption_IP4_Multicast().build()), |
| SDOption_IP4_SD_EndPoint(SDOption_IP4_SD_EndPoint().build()), |
| SDOption_IP6_EndPoint(SDOption_IP6_EndPoint().build()), |
| SDOption_IP6_Multicast(SDOption_IP6_Multicast().build()), |
| SDOption_IP6_SD_EndPoint(SDOption_IP6_SD_EndPoint().build()), |
| ] |
| _opts_check(opts[0:0]) |
| _opts_check(opts[0:2]) |
| _opts_check(opts) |
| _opts_check(opts[::-1]) |
| _opts_check(opts + opts[::-1]) |
| |
| |
| = build test SOMEIP/TP |
| |
| p = SOMEIP(srv_id=1234, sub_id=4321, msg_type=0xff, retcode=0xff, offset=4294967040, data=[Raw(b"deadbeef")]) |
| |
| assert p.data[0].load == b"deadbeef" |
