def get_proof(self, if_id, epoch, prev_root, next_root): """ Obtain the proof for revoking a given interface at a given epoch. :param int if_id: ID of the interface to be revoked. :param int epoch: epoch for which the interface is to be revoked. :param bytes prev_root: hash of the previous root. :param bytes next_root: hash of the next root. """ assert if_id in self._if2idx.keys(), "if_id not found in AS" relative_epoch = epoch % HASHTREE_N_EPOCHS # Obtain the nonce for the (if_id, epoch) pair using the seed. raw_nonce = self._seed + struct.pack("!qq", if_id, relative_epoch) nonce = self._hash_func(raw_nonce) # Obtain the sibling hashes along with their left/right position info. siblings = [] idx = self._if2idx[if_id] + relative_epoch while idx > 0: if idx % 2 == 0: siblings.append((True, self._nodes[idx - 1])) else: siblings.append((False, self._nodes[idx + 1])) idx = (idx - 1) // 2 # Using the above fields, construct a RevInfo capnp as the proof. return RevocationInfo.from_values( self._isd_as, if_id, epoch, nonce, siblings, prev_root, next_root, self._hash_type)
def _issue_revocation(self, if_id, chain): """ Store a RevocationObject in ZK and send a revocation to all ERs. :param if_id: The interface that needs to be revoked. :type if_id: int :param chain: The hash chain corresponding to if_id. :type chain: :class:`lib.crypto.hash_chain.HashChain` """ # Only the master BS issues revocations. if not self.zk.have_lock(): return rev_info = RevocationInfo.from_values(chain.next_element()) logging.info("Storing revocation in ZK.") rev_obj = RevocationObject.from_values(if_id, chain.current_index(), chain.next_element()) entry_name = "%s:%s" % (chain.start_element(hex_=True), chain.next_element(hex_=True)) self.revobjs_cache.store(entry_name, rev_obj.pack()) logging.info("Issuing revocation for IF %d.", if_id) # Issue revocation to all ERs. info = IFStateInfo.from_values(if_id, False, chain.next_element()) pld = IFStatePayload.from_values([info]) state_pkt = self._build_packet() for er in self.topology.get_all_edge_routers(): state_pkt.addrs.dst.host = er.addr state_pkt.set_payload(pld.copy()) self.send(state_pkt, er.addr) self._process_revocation(rev_info, if_id)
def test_revoked(self): pcb = self._mk_pcb() inst = Mock() rev_info = RevocationInfo.from_values(ISD_AS("1-ff00:0:300"), 1, LinkType.PARENT, 1) srev_info = SignedRevInfo.from_values(rev_info.copy().pack(), ProtoSignType.ED25519, "src".encode()) rev_cache = Mock() rev_cache.get.return_value = srev_info inst.check_revoked_interface = SCIONElement.check_revoked_interface ntools.eq_(inst.check_revoked_interface(inst, pcb, rev_cache), False)
def from_values(cls, if_id, index, rev_token): """ Returns a RevocationInfo object with the specified values. :param int if_id: The interface id of the corresponding interface. :param int index: The index of the rev_token in the hash chain. :param bytes rev_token: revocation token of interface """ inst = cls() inst.if_id = if_id inst.hash_chain_idx = index inst.rev_info = RevocationInfo.from_values(rev_token) return inst
def _issue_revocations(self, revoked_ifs): """ Store a RevocationInfo in ZK and send a revocation to all BRs. :param list revoked_ifs: A list of interfaces that needs to be revoked. """ # Only the master BS issues revocations. if not self.zk.have_lock(): return # Process revoked interfaces. infos = [] for if_id in revoked_ifs: br = self.ifid2br[if_id] rev_info = RevocationInfo.from_values( self.addr.isd_as, if_id, br.interfaces[if_id].link_type, int(time.time()), self.REVOCATION_TTL) logging.info("Issuing revocation: %s", rev_info.short_desc()) if self._labels: REVOCATIONS_ISSUED.labels(**self._labels).inc() chain = self._get_my_cert() _, cert_ver = chain.get_leaf_isd_as_ver() src = DefaultSignSrc.from_values( rev_info.isd_as(), cert_ver, self._get_my_trc().version).pack() srev_info = SignedRevInfo.from_values(rev_info.copy().pack(), ProtoSignType.ED25519, src) srev_info.sign(self.signing_key) # Add to revocation cache self.if_revocations[if_id] = srev_info self._process_revocation(srev_info) infos.append(IFStateInfo.from_values(if_id, False, srev_info)) border_metas = [] # Add all BRs. for br in self.topology.border_routers: br_addr, br_port = br.int_addrs.public[0] border_metas.append( UDPMetadata.from_values(host=br_addr, port=br_port)) # Add local path server. ps_meta = [] if self.topology.path_servers: try: addr, port = self.dns_query_topo(ServiceType.PS)[0] except SCIONServiceLookupError: addr, port = None, None # Create a meta if there is a local path service if addr: ps_meta.append(UDPMetadata.from_values(host=addr, port=port)) self._send_ifstate_update(infos, border_metas, ps_meta)