def __init__(self, fname, fid=None, signer=None,
create_if_notexisting=False):
self.fname = fname
self.fid = fid
self.signer = signer
self.cine = create_if_notexisting
self.seq = 0
self.pcap = pcap.PCAP(fname)
self.hprev = None
try:
self.pcap.open('r')
# find highest seq number:
w = self.pcap.read_backwards(True)
e = event.EVENT()
e.from_wire(w)
if fid != None and e.fid != fid:
print("feed ID mismatch:", e.fid, "instead of", fid)
self.pcap.close()
self.pcap = None
return
self.fid, self.seq = e.fid, e.seq
self.hprev = event.get_hash(e.metabits)
self.pcap.close()
except Exception as e:
if not self.cine:
self.pcap = None
print(f"error opening file {fname}")
else:
self.pcap.open('w')
self.pcap.close()
def __next__(self):
pkt = self.pcap.read()
if not pkt:
self.pcap.close()
raise StopIteration
e = event.EVENT()
e.from_wire(pkt)
return e
def dump(fname):
p = PCAP(fname)
p.open('r')
for w in p:
e = event.EVENT()
e.from_wire(w)
print(f"** fid={e.fid.hex()}, seq={e.seq}, ${len(w)} bytes")
print(f" hashref={e.get_ref()[1].hex()}")
print(f" content={e.content().__repr__()}")
p.close()
def write(self, c): # create new log extension with given content
if self.seq == 0:
self.hprev = None
e = event.EVENT(fid=self.fid, seq=self.seq+1,
hprev=self.hprev, content=c)
metabits = e.get_metabits(self.signer.get_sinfo())
signature = self.signer.sign(metabits)
w = e.to_wire(signature)
self._append(w)
self.hprev = event.get_hash(metabits)
return w
def sync_files(self, new_files=False, key=None, event_list=None):
if new_files and key is not None:
self.__old_file.fid = key
feed = FEED(self.__old_file.file, self.__old_file.fid, ED25519(), new_files)
if event_list is None:
event_list = pcap.get_meta_and_cont_bits(self.__new_file.file, self.__next_seq)
ev = event.EVENT()
ev.from_wire(event_list[0])
if feed.is_valid_extension(ev):
for i in event_list:
# TODO: Find a solution to not use a protected method
feed._append(i)
def createEvent(hfeed_name, vfeed_name, message):
# hfeed is the host feed of the virtual feed (vfeed)
hfeed_key_path = "data/" + hfeed_name + "-secret.key"
hfeed_pcap_path = "data/" + hfeed_name + "-feed.pcap"
vfeed_key_path = "data/virtual/" + vfeed_name + ".key"
vfeed_stats_path = "data/virtual/" + vfeed_name + ".stats"
#host_feed read out
with open(hfeed_key_path, 'r') as f:
key = eval(f.read())
hfeed_digestmod = "sha256"
hfeed_h = crypto.HMAC(hfeed_digestmod, key["private"], key["feed_id"])
hfeed_signer = crypto.HMAC(hfeed_digestmod,
bytes.fromhex(hfeed_h.get_private_key()))
with open(vfeed_key_path, 'rb') as f:
vfeed_privKey = f.read()
vfeed_h = crypto.HMAC(hfeed_digestmod, vfeed_privKey, vfeed_name)
vfeed_signer = crypto.HMAC(hfeed_digestmod, vfeed_privKey)
#shortpath file to get the sequence and the hash of the previous event, so we don't have to search all the hostfeeds till the end first
with open(vfeed_stats_path, 'r') as f:
key = eval(f.read())
vfeed_seq = key["vfeed_seq"]
vfeed_hprev = key["vfeed_hprev"]
vfeed_sig = key["vfeed_sig"]
if verifySign(vfeed_privKey, vfeed_sig, [vfeed_seq, vfeed_hprev]):
hfeed = feed.FEED(fname=hfeed_pcap_path,
fid=hfeed_h.get_feed_id(),
signer=hfeed_signer,
create_if_notexisting=True,
digestmod=hfeed_digestmod)
vfeed = feed.FEED(fname=hfeed_pcap_path,
fid=vfeed_h.get_feed_id(),
signer=vfeed_signer,
create_if_notexisting=True,
digestmod=hfeed_digestmod)
e = event.EVENT(fid=vfeed_h.get_feed_id(),
seq=vfeed_seq,
hprev=vfeed_hprev,
content=message,
digestmod=hfeed_digestmod)
metabits = e.mk_metabits(vfeed_signer.get_sinfo())
signature = vfeed_signer.sign(metabits)
w = e.to_wire(signature)
print("w:", w)
hfeed.write(w)
