def _create_scion_pkt(self, ext): """ Create a packet that uses a SCION path """ cmn_hdr, addr_hdr, udp_hdr, payload = self._create_hdrs() return SCIONL4Packet.from_values( cmn_hdr, addr_hdr, self.seg.get_path(True), [ext], udp_hdr, payload)
def _cached_entries_handler(self, raw_entries): """ Handles cached (through ZK) TRCs and Cert Chains. """ for entry in raw_entries: try: pkt = SCIONL4Packet(raw=entry) pkt.parse_payload() # FIXME(PSz): some checks are necessary, as filesystem may not # be synced with ZK. Also, when we change topology, new TRCs and # certs are generated, while old ones are still in ZK. It looks # to CS like an attack. This will be fixed when more elements # of trust infrastructure are specified and implemented (like # TRC cross-signing). except SCIONParseError: log_exception("Error parsing cached entry: %s" % entry, level=logging.ERROR) continue payload = pkt.get_payload() if isinstance(payload, CertChainReply): self.process_cert_chain_reply(pkt, from_zk=True) elif isinstance(payload, TRCReply): self.process_trc_reply(pkt, from_zk=True) else: logging.warning("Entry with unsupported type: %s" % entry)
def test(self, super_offset): inst = SCIONL4Packet() inst.l4_hdr = create_mock(["total_len"]) inst.l4_hdr.total_len = 12 super_offset.return_value = 42 # Call ntools.eq_(inst._get_offset_len(), 54)
def test_no_l4hdr(self, super_update): inst = SCIONL4Packet() inst._l4_proto = 47 # Call inst.update() # Tests super_update.assert_called_once_with(inst) ntools.eq_(inst._l4_proto, 47)
def _build_pkt(self): cmn_hdr, addr_hdr = build_base_hdrs(self.addr, self.dst) l4_hdr = self._create_l4_hdr() spkt = SCIONL4Packet.from_values(cmn_hdr, addr_hdr, SCIONPath(), [], l4_hdr) spkt.set_payload(self._create_payload(spkt)) spkt.update() return spkt
def _create_sibra_pkt(self, ext): """ Create a packet that uses a SIBRA path """ ext.setup = False ext.active_blocks = self.blocks[:1] cmn_hdr, addr_hdr, udp_hdr, payload = self._create_hdrs() return SCIONL4Packet.from_values(cmn_hdr, addr_hdr, SCIONPath(), [ext], udp_hdr, payload)
def _recv(self): try: packet = self.sock.recv()[0] except socket.timeout: return None except Exception as e: logging.critical("Error receiving packet: %s" % e) sys.exit(1) return SCIONL4Packet(packet)
def test(self, inner_values, pldraw, set_pld, upd_hdrs): inst = SCIONL4Packet.from_values("cmn hdr", "addr hdr", "path hdr", "ext hdrs", "l4 hdr") # Tests ntools.assert_is_instance(inst, SCIONL4Packet) inner_values.assert_called_once_with(inst, "cmn hdr", "addr hdr", "path hdr", "ext hdrs", "l4 hdr") set_pld.assert_called_once_with(inst, pldraw.return_value) upd_hdrs.assert_called_once_with(inst)
def _build_pkt(self, path=None): cmn_hdr, addr_hdr = build_base_hdrs(self.dst, self.addr) l4_hdr = self._create_l4_hdr() extensions = self._create_extensions() if path is None: path = self.path_meta.fwd_path() spkt = SCIONL4Packet.from_values(cmn_hdr, addr_hdr, path, extensions, l4_hdr) spkt.set_payload(self._create_payload(spkt)) spkt.update() return spkt
def test_l4hdr(self, super_update): inst = SCIONL4Packet() inst.addrs = create_mock(["src", "dst"]) inst._l4_proto = 47 inst.l4_hdr = create_mock(["TYPE", "update"]) # Call inst.update() # Tests inst.l4_hdr.update.assert_called_once_with(src=inst.addrs.src, dst=inst.addrs.dst) ntools.eq_(inst._l4_proto, inst.l4_hdr.TYPE)
def test(self, super_pack, super_pld): inst = SCIONL4Packet() inst.update = create_mock() super_pack.return_value = b"super" super_pld.return_value = b"pld" inst.l4_hdr = create_mock(["pack"]) inst.l4_hdr.pack.return_value = b"l4 hdr" # Call ntools.eq_(inst._inner_pack(), b"super" b"l4 hdr" b"pld") # Tests inst.update.assert_called_once_with() inst.l4_hdr.pack.assert_called_once_with(b"pld")
def test(self, super_values): inst = SCIONL4Packet() l4_hdr = MagicMock(spec_set=L4HeaderBase) l4_hdr.TYPE = 22 # Call inst._inner_from_values("cmn hdr", "addr hdr", "path hdr", "ext hdrs", l4_hdr) # Tests super_values.assert_called_once_with(inst, "cmn hdr", "addr hdr", "path hdr", "ext hdrs") ntools.eq_(inst.l4_hdr, l4_hdr) ntools.eq_(inst._l4_proto, 22)
def _setup(self, l4_type): inst = SCIONL4Packet() inst._parse_pld_ctrl = create_mock() inst._parse_pld_ctrl.return_value = "pld ctrl" inst._parse_pld_scmp = create_mock() inst._parse_pld_scmp.return_value = "pld scmp" inst.set_payload = create_mock() inst._payload = create_mock(["pack"]) if l4_type is not None: inst.l4_hdr = create_mock(["TYPE"]) inst.l4_hdr.TYPE = l4_type return inst
def _create_reg_pkt(self, type_, remote=False): if remote: dst_ia = self.remote path = self.seg.get_path(True) else: dst_ia = self.addr.isd_as path = SCIONPath() pcb = self._create_reg_pcb(remote) pld = PathRecordsReg.from_values({type_: [pcb]}) dest = SCIONAddr.from_values(dst_ia, SVCType.PS_A) cmn_hdr, addr_hdr = build_base_hdrs(self.addr, dest) udp_hdr = SCIONUDPHeader.from_values(self.addr, self._port, dest, 0) return SCIONL4Packet.from_values(cmn_hdr, addr_hdr, path, [], udp_hdr, pld)
def test(self, super_parse, parse_l4_hdr): inst = SCIONL4Packet() inst._l4_proto = 42 inst.addrs = create_mock(["src", "dst"]) data = create_mock() parse_l4_hdr.return_value.__len__.return_value = 8 # Call inst._inner_parse(data) # Tests super_parse.assert_called_once_with(inst, data) parse_l4_hdr.assert_called_once_with( 42, data, src=inst.addrs.src, dst=inst.addrs.dst, ) ntools.eq_(inst.l4_hdr, parse_l4_hdr.return_value)
def _setup(self, l4_type): inst = SCIONL4Packet() inst._parse_pld_ctrl = create_mock() inst._parse_pld_ctrl.return_value = "pld ctrl" inst._parse_pld_scmp = create_mock() inst._parse_pld_scmp.return_value = "pld scmp" inst.set_payload = create_mock() inst._payload = create_mock(["pack"]) if l4_type == L4Proto.UDP: inst.l4_hdr = create_mock_full({"TYPE": l4_type}) elif l4_type == L4Proto.SCMP: inst.l4_hdr = create_mock_full({"TYPE": l4_type, "class_": "scmp_class", "type": "scmp_type"}) return inst
def _check_known(self, class_, from_bytes, parse_pcb, parse_ifid, parse_cert, parse_path, parse_sibra): from_bytes.return_value = self._mk_proto_obj(class_) class_map = { PayloadClass.PCB: parse_pcb, PayloadClass.IFID: parse_ifid, PayloadClass.CERT: parse_cert, PayloadClass.PATH: parse_path, PayloadClass.SIBRA: parse_sibra, } handler = class_map[class_] inst = SCIONL4Packet() data = self._mk_data() # Call ntools.eq_(inst._parse_pld_ctrl(data), handler.return_value) # Tests handler.assert_called_once_with("inner")
def _build_packet(self, dst_host=None, path=None, ext_hdrs=(), dst_ia=None, payload=None, dst_port=0): if dst_host is None: dst_host = HostAddrNone() if dst_ia is None: dst_ia = self.addr.isd_as if path is None: path = SCIONPath() if payload is None: payload = PayloadRaw() dst_addr = SCIONAddr.from_values(dst_ia, dst_host) cmn_hdr, addr_hdr = build_base_hdrs(dst_addr, self.addr) udp_hdr = SCIONUDPHeader.from_values( self.addr, self._port, dst_addr, dst_port) return SCIONL4Packet.from_values( cmn_hdr, addr_hdr, path, ext_hdrs, udp_hdr, payload)
def _check_known(self, class_, parse_pcb, parse_ifid, parse_cert, parse_path, parse_sibra): class_map = { PayloadClass.PCB: parse_pcb, PayloadClass.IFID: parse_ifid, PayloadClass.CERT: parse_cert, PayloadClass.PATH: parse_path, PayloadClass.SIBRA: parse_sibra, } handler = class_map[class_] inst = SCIONL4Packet() data = create_mock(["pop"]) data.pop.side_effect = class_, 42 # Call ntools.eq_(inst._parse_pld_ctrl(data), handler.return_value) # Tests handler.assert_called_once_with(42, data)
def _parse_packet(self, packet): try: pkt = SCIONL4Packet(packet) except SCMPError as e: self._scmp_parse_error(packet, e) return None except SCIONBaseError: log_exception("Error parsing packet: %s" % hex_str(packet), level=logging.ERROR) return None try: pkt.validate(len(packet)) except SCMPError as e: self._scmp_validate_error(pkt, e) return None except SCIONChecksumFailed: logging.debug("Dropping packet due to failed checksum:\n%s", pkt) return pkt
def _recv(self): try: packet = self.sock.recv()[0] except socket.timeout: return None return SCIONL4Packet(packet)
def test_unknown(self, from_bytes): from_bytes.return_value = self._mk_proto_obj("unknown") inst = SCIONL4Packet() data = self._mk_data() # Call ntools.assert_raises(SCIONParseError, inst._parse_pld_ctrl, data)
def test_parse_error(self, from_bytes): inst = SCIONL4Packet() data = self._mk_data(4) from_bytes.side_effect = self._raise_parse_error # Call ntools.assert_raises(SCIONParseError, inst._parse_pld_ctrl, data)
def test_bad_len(self): inst = SCIONL4Packet() data = self._mk_data(3) # Call ntools.assert_raises(SCIONParseError, inst._parse_pld_ctrl, data)
def test_unknown(self): inst = SCIONL4Packet() data = create_mock(["pop"]) data.pop.return_value = 42 # Call ntools.assert_raises(SCIONParseError, inst._parse_pld_ctrl, data)