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)
def load_keyfile(self,fn,mod):
with open(fn, 'r') as f:
key = eval(f.read())
if key['type'] == 'hmac_'+mod :
fid = binascii.unhexlify(key['feed_id'])
signer = crypto.HMAC(mod,binascii.unhexlify(key['private']))
return fid, signer
def __init__(self):
self.sensor_fid = binascii.unhexlify(b'028140a0502894ca')
self.sensor_signer = crypto.HMAC(
"md5", binascii.unhexlify(b'1c0e070381c0e0f0783c9e4f27130904'))
self.control_fid = binascii.unhexlify(b'4c261309040281c0')
self.control_signer = crypto.HMAC(
"md5", binascii.unhexlify(b'1b0d060381c0e0f0783c1e8fc7633198'))
self.sensor_feed = feed.FEED("Sensor_Feed.pcap", self.sensor_fid, None,
True)
self.control_feed = feed.FEED("Control_Feed.pcap", self.control_fid,
self.control_signer, True)
self.test_callback = 0
def load_keyfile(self, fn):
with open(fn, 'r') as f:
key = eval(f.read())
if key['type'] == 'hmac_md5':
#fid = bytes.fromhex(key['feed_id'])
fid = binascii.unhexlify(key['feed_id'])
#signer = crypto.HMAC256(bytes.fromhex(key['private']))
signer = crypto.HMAC("md5", binascii.unhexlify(key['private']))
return fid, signer
def create_feed(self,type,kfile,fname):
#self.create_keyfile(kfile)
#[fid,signer] = self.load_keyfile(kfile)
#f = feed.FEED(fname, fid,signer, True)
#hardcoded
if type == 0:
fid = binascii.unhexlify(b'028140a0502894ca')
signer = crypto.HMAC("md5", binascii.unhexlify(b'1c0e070381c0e0f0783c9e4f27130904'))
if type == 1:
fid = binascii.unhexlify(b'4c261309040281c0')
signer = crypto.HMAC("md5", binascii.unhexlify(b'1b0d060381c0e0f0783c1e8fc7633198'))
#new Feeds are generatet (True)
f = feed.FEED(fname, fid, signer, True)
return f,fid,signer
def new_key(self,key_file,mod):
h = crypto.HMAC(mod)
h.create()
print("# new "+mod+" key: share it ONLY with trusted peers")
print('{\n '+(',\n '.join(h.as_string().split(','))[1:-1])+'\n}')
key = '{\n '+(',\n '.join(h.as_string().split(','))[1:-1])+'\n}'
f = open(key_file, 'w')
f.write(key)
f.close()
def create_keyfile(self,kfile):
h = crypto.HMAC("md5")
h.create()
print("# new HMAC_MD5: share it ONLY with trusted peers")
print('{\n '+(',\n '.join(h.as_string().split(','))[1:-1])+'\n}')
keyfile = '{\n '+(',\n '.join(h.as_string().split(','))[1:-1])+'\n}'
f = open(kfile, 'w')
f.write(keyfile)
f.close()
def generateOwnFeed(self):
if not os.path.isdir("data"):
os.mkdir("data")
if not os.path.isdir("data/" + self.name):
os.mkdir("data/" + self.name)
# Generate a key pair
# generate a feed
digestmod = "sha256"
h, signer = None, None
# Generate a Key if non exists
if not os.path.isfile("data/" + self.name + "/" + self.name +
"-secret.key"):
print("Create " + self.name + "'s key pair at data/" + self.name +
"/" + self.name + "-secret.key")
h = crypto.HMAC(digestmod)
h.create()
with open("data/" + self.name + "/" + self.name + "-secret.key",
"w") as f:
f.write('{\n ' +
(',\n '.join(h.as_string().split(','))[1:-1]) + '\n}')
signer = crypto.HMAC(digestmod, h.get_private_key())
print("Read " + self.name + "'s secret key.")
with open("data/" + self.name + "/" + self.name + "-secret.key",
'r') as f:
key = eval(f.read())
h = crypto.HMAC(digestmod, key["private"], key["feed_id"])
signer = crypto.HMAC(digestmod, bytes.fromhex(h.get_private_key()))
print("Create or load " + self.name + "'s feed at data/" + self.name +
"/" + self.name + "-feed.pcap")
self.myFeed = feed.FEED(fname="data/" + self.name + "/" + self.name +
"-feed.pcap",
fid=h.get_feed_id(),
signer=signer,
create_if_notexisting=True,
digestmod=digestmod)
self.id = h.get_feed_id()
def load_keyfile(fn):
with open(fn, 'r') as f:
key = eval(f.read())
if key['type'] == 'ed25519':
fid = bytes.fromhex(key['public'])
signer = crypto.ED25519(bytes.fromhex(key['private']))
digestmod = 'sha256'
elif key['type'] in ['hmac_sha256', 'hmac_sha1', 'hmac_md5']:
fid = bytes.fromhex(key['feed_id'])
digestmod = key['type'][5:]
signer = crypto.HMAC(digestmod, bytes.fromhex(key['private']))
return fid, signer, digestmod
def createVirtualKeypair():
vfeed_digestmod = "sha256"
vfeed_h = crypto.HMAC(vfeed_digestmod)
vfeed_h.create()
di = '{\n ' + (',\n '.join(vfeed_h.as_string().split(','))[1:-1]) + "\n}"
key = eval(di)
vfeed_id = key["feed_id"]
print("vfeed_name:", key["feed_id"])
vfeed_path = "data/virtual/" + vfeed_id + ".key"
print("Create virtual key pair at", vfeed_path)
print("write key: ", key["private"])
with open(vfeed_path, "wb") as f:
f.write(vfeed_h.get_private_key())
return vfeed_id
def create_device(self):
# use HMAC class from crypto
vfeed = crypto.HMAC("sha256")
vfeed.create()
self.thisDevId = vfeed.get_feed_id().hex()
with open(os.path.join(self.pathToVirtual, self.thisDevId + '.key'),
"wb") as f:
f.write(vfeed.get_private_key())
self.thisDevName = 'Device_' + getpass.getuser()
# update dictionary
self.devDict = {
self.thisDevId: {
'deviceName': self.thisDevName,
'feedList': []
}
}
self.write_to_json()
if not os.path.isdir("data"):
os.mkdir("data")
os.mkdir("data/alice")
os.mkdir("data/bob")
# Generate a key pair
## Alice
alice_digestmod = "sha256"
alcie_h, alice_signer = None, None
if not os.path.isfile("data/alice/alice-secret.key"):
print("Create Alice's key pair at data/alice/alice-secret.key")
alice_h = crypto.HMAC(alice_digestmod)
alice_h.create()
with open("data/alice/alice-secret.key", "w") as f:
f.write('{\n ' + (',\n '.join(alice_h.as_string().split(','))[1:-1]) +
'\n}')
alice_signer = crypto.HMAC(alice_digestmod, alice_h.get_private_key())
print("Read Alice's secret key.")
with open("data/alice/alice-secret.key", 'r') as f:
print("Create Alice's key pair at data/alice/alice-secret.key")
key = eval(f.read())
alice_h = crypto.HMAC(alice_digestmod, key["private"], key["feed_id"])
alice_signer = crypto.HMAC(alice_digestmod,
bytes.fromhex(alice_h.get_private_key()))
print("Create or load Alice's feed at data/alice/alice-feed.pcap")
