def elli(key_size_bytes):
# Generate the key pair for Alice
a_private = urandom(key_size_bytes)
a_public = scalarmult_base(a_private)
# Generate the key pair for Bob
b_private = urandom(key_size_bytes)
b_public = scalarmult_base(b_private)
a_shared = scalarmult(a_private, b_public)
b_shared = scalarmult(b_private, a_public)
assert a_shared == b_shared
def test_dh():
a_priv = unhexlify(
'77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a')
a_pub = unhexlify(
'8520f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4e6a')
b_priv = unhexlify(
'5dab087e624a8a4b79e17f8b83800ee66f3bb1292618b6fd1c2f8b27ff88e0eb')
b_pub = unhexlify(
'de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f')
k = '4a5d9d5ba4ce2de1728e3bf480350f25e07e21c947d19e3376f09b3c1e161742'
assert hexlify(scalarmult_base(a_priv)) == hexlify(a_pub)
assert hexlify(scalarmult_base(b_priv)) == hexlify(b_pub)
assert hexlify(scalarmult(a_priv, b_pub)) == k
assert hexlify(scalarmult(b_priv, a_pub)) == k
def get_shared_secrets_by_rid(cls, config, mongo, rid):
from blockchainutils import BU
shared_secrets = []
dh_public_keys = []
dh_private_keys = []
txns = BU.get_transactions_by_rid(config,
mongo,
rid,
config.bulletin_secret,
rid=True)
for txn in txns:
if str(txn['public_key']) == str(
config.public_key
) and txn['relationship']['dh_private_key']:
dh_private_keys.append(txn['relationship']['dh_private_key'])
txns = BU.get_transactions_by_rid(config,
mongo,
rid,
config.bulletin_secret,
rid=True,
raw=True)
for txn in txns:
if str(txn['public_key']) != str(
config.public_key) and txn['dh_public_key']:
dh_public_keys.append(txn['dh_public_key'])
for dh_public_key in dh_public_keys:
for dh_private_key in dh_private_keys:
shared_secrets.append(
scalarmult(dh_private_key.decode('hex'),
dh_public_key.decode('hex')))
return shared_secrets
def compute(self, public):
result = scalarmult(self.secret, public)
if bad_result(result):
raise ValueError("Error computing Curve25519 shared secret")
return result
def run(self):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.settimeout(5.0)
try:
self.sock.connect((self.host, self.port))
except socket.timeout:
print("Timeout, host inacessivel")
connecter.config(state=NORMAL)
raise SystemExit(0)
print("Conectado ao peer:"+ self.host +
" on port: " + str(self.port))
# Curve25519 encryption scheme
# Usign a size-32 key
a = urandom(32)
a_pub = scalarmult_base(a)
# send public key
self.sock.send(a_pub)
b_pub = self.sock.recv(32)
secret = scalarmult(a, b_pub)
print("Private Key A: " +binascii.hexlify(a))
print("Public Key A: " +binascii.hexlify(a_pub))
print("Public Key B: " +binascii.hexlify(b_pub))
print("Shared key: " + binascii.hexlify(secret))
# Select loop for listen
while self.running == True:
def run(self):
HOST = ''
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((HOST,self.port))
s.listen(1)
self.conn, self.addr = s.accept()
# Curve25519 encryption scheme
# Usign a size-32 key
a = urandom(32)
a_pub = scalarmult_base(a)
# send public key
print(binascii.hexlify(a_pub))
self.conn.send(a_pub)
b_pub = self.conn.recv(32)
secret = scalarmult(a, b_pub)
print("Private Key A: " +binascii.hexlify(a))
print("Public Key A: " +binascii.hexlify(a_pub))
print("Public Key B: " +binascii.hexlify(b_pub))
print("Shared key: " + binascii.hexlify(secret))
# Select loop for listen
while self.running == True:
def run(self):
HOST = ''
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((HOST,self.port))
s.listen(1)
self.conn, self.addr = s.accept()
# Curve25519 encryption scheme
# Usign a size-32 key
a = urandom(32)
a_pub = scalarmult_base(a)
# send public key
print(binascii.hexlify(a_pub))
self.conn.send(a_pub)
b_pub = self.conn.recv(32)
secret = scalarmult(a, b_pub)
print("Private Key A: " +binascii.hexlify(a))
print("Public Key A: " +binascii.hexlify(a_pub))
print("Public Key B: " +binascii.hexlify(b_pub))
print("Shared key: " + binascii.hexlify(secret))
time.seep(tau - (time.clock() - t0))
count = 0
entries = api.liststreams()
for entry in entries:
count += 1
entry = entry['details']
if str(entry["context"]) == context and \
str(entry["userid"]) == str(peer_ip):
b_pub = binascii.unhexlify(entry["key"])
found = True
if (count > 2):
for entry in k_collection.find({"context":context}):
print(entry)
print("poisoned block, disconnect")
sys.exit()
secret = scalarmult(a, b_pub)
# Select loop for listen
while self.running == True:
def test_n(n, expected):
k = unhexlify(
'0900000000000000000000000000000000000000000000000000000000000000')
u = k
for i in xrange(n):
k, u = scalarmult(k, u), k
assert hexlify(k) == expected
def run(self):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.settimeout(5.0)
try:
self.sock.connect((self.host, self.port))
except socket.timeout:
print("Timeout, host inacessivel")
connecter.config(state=NORMAL)
raise SystemExit(0)
print("Conectado ao peer:"+ self.host +
" on port: " + str(self.port))
t0 = time.clock()
# Curve25519 encryption scheme
# Usign a size-32 key
a = urandom(32)
a_pub = scalarmult_base(a)
# send public key
self.sock.send(a_pub)
context = str(my_ip) + str(peer_ip) + str(i)
des.create('stream', contexto,True)
des.publish(contexto, {"userid":str(my_ip),
"context":context,
"key": binascii.hexlify(a_pub)})
time.seep(tau - (time.clock() - t0))
secret = scalarmult(a, b_pub)
count = 0
entries = api.liststreams()
for entry in entries:
count += 1
entry = entry['details']
if str(entry["context"]) == context and \
str(entry["userid"]) == str(peer_ip):
b_pub = binascii.unhexlify(entry["key"])
found = True
if (count > 2):
for entry in k_collection.find({"context":context}):
print(entry)
print("poisoned block, disconnect")
sys.exit()
print("Private Key A: " +binascii.hexlify(a))
print("Public Key A: " +binascii.hexlify(a_pub))
print("Public Key B: " +binascii.hexlify(b_pub))
print("Shared key: " + binascii.hexlify(secret))
# Select loop for listen
while self.running == True:
def get_shared_secrets_by_rid(self, rid):
shared_secrets = []
dh_public_keys = []
dh_private_keys = []
txns = self.get_transactions_by_rid(rid, self.config.bulletin_secret, rid=True)
for txn in txns:
if str(txn['public_key']) == str(self.config.public_key) and txn['relationship']['dh_private_key']:
dh_private_keys.append(txn['relationship']['dh_private_key'])
txns = self.get_transactions_by_rid(rid, self.config.bulletin_secret, rid=True, raw=True)
for txn in txns:
if str(txn['public_key']) != str(self.config.public_key) and txn['dh_public_key']:
dh_public_keys.append(txn['dh_public_key'])
for dh_public_key in dh_public_keys:
for dh_private_key in dh_private_keys:
shared_secrets.append(scalarmult(unhexlify(dh_private_key).decode('latin1'), unhexlify(dh_public_key).decode('latin1')).encode('latin1'))
return shared_secrets
class Chat_Client(threading.Thread):
"""Client thread"""
def __init__(self):
threading.Thread.__init__(self)
self.host = None
self.sock = None
self.port = None
self.running = 1
def run(self):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.settimeout(5.0)
try:
self.sock.connect((self.host, self.port))
except socket.timeout:
print("Timeout, host inacessivel")
connecter.config(state=NORMAL)
raise SystemExit(0)
print("Conectado ao peer:"+ self.host +
" on port: " + str(self.port))
t0 = time.clock()
# Curve25519 encryption scheme
# Usign a size-32 key
a = urandom(32)
a_pub = scalarmult_base(a)
# send public key
self.sock.send(a_pub)
context = str(my_ip) + str(peer_ip) + str(i)
k_collection = k_db['key_collection']
entry = {"userid":str(my_ip),
"context":context,
"key": binascii.hexlify(a_pub)}
k_collection.insert_one(entry)
self.send_context = True
time.seep(tau - (time.clock() - t0))
count = 0
entries = k_collection.find({"context":context})
for entry in entries:
count += 1
if str(entry["context"]) == context and \
str(entry["userid"]) == str(peer_ip):
b_pub = binascii.unhexlify(entry["key"])
found = True
if (count > 2):
for entry in k_collection.find({"context":context}):
print(entry)
print("poisoned block, disconnect")
sys.exit()
time.sleep(time.clock() - t0)
secret = scalarmult(a, b_pub)
print("Private Key A: " +binascii.hexlify(a))
print("Public Key A: " +binascii.hexlify(a_pub))
print("Public Key B: " +binascii.hexlify(b_pub))
print("Shared key: " + binascii.hexlify(secret))
# Select loop for listen
while self.running == True:
def test_kat(k, u, expected):
k = unhexlify(k)
u = unhexlify(u)
assert hexlify(scalarmult(k, u)) == expected
# # libraries required for implementation from os import urandom from eccsnacks.curve25519 import scalarmult, scalarmult_base import binascii # (l) is a random selected point for Reader RFID l = urandom(32) a = scalarmult_base(l) # (e) is a random seclected point for RFID tag e = urandom(32) b = scalarmult_base(e) # reference points defined by the scalar multiplication from the elliptic curve c = scalarmult(e, a) d = scalarmult(l, b) # Reader RFID and RFID tag private key values print "RFID private key: ",binascii.hexlify(e) print "Reader private key: ",binascii.hexlify(l) # printing value of A and B in function of (a) and (b) with the Binary ASCII print "A value: ",binascii.hexlify(a) print "B value: ",binascii.hexlify(b) # printing value of A and B in function of (c) and (d) with the Binary ASCII print "C value: ",binascii.hexlify(c) print "D value: ",binascii.hexlify(d) # Check that C is equal to D,
from os import urandom
from eccsnacks.curve25519 import scalarmult, scalarmult_base
import binascii
lamb = urandom(32)
a = scalarmult_base(lamb)
eps = urandom(32)
b = scalarmult_base(eps)
c = scalarmult(eps, a)
d = scalarmult(lamb, b)
print("RFID private key: ", binascii.hexlify(eps))
print("Reader private key: ", binascii.hexlify(lamb))
print("A value: ", binascii.hexlify(a))
print("B value: ", binascii.hexlify(b))
print("C value: ", binascii.hexlify(c))
print("D value: ", binascii.hexlify(d))
print "Tag Private Key: ",binascii.hexlify(t_private)
print "Tag Public Hash: ",t_public_hash
print "Tag Certificate: ",t_certificate
print
# Authenticate the tag's public key
expected_t_public_hash = encrypt(r_private, t_certificate, certificate_salt, False)
if t_public_hash == expected_t_public_hash:
print "Tag authenticated."
print
else:
print "Tag is not authentic."
exit()
# The reader and the tag generate the shared key, following an exchange of public keys
r_shared = scalarmult(r_private, t_public)
t_shared = scalarmult(t_private, r_public)
# Check that the transmitted values match
if r_shared == t_shared:
print "Keys exchanged."
print "Reader: ",binascii.hexlify(r_shared)
print "Tag: ",binascii.hexlify(t_shared)
print
else:
print "Error in key exchange."
exit()
# Generate a message for the tag to send to the reader
message = "Hello, I am T."
message_salt = urandom(32)
# dh_25519.py # Demonstrates generating keypair for Alice & Bob, and lastly # compute Diffie-Hellman and compare keys. from os import urandom from eccsnacks.curve25519 import scalarmult, scalarmult_base # Private keys in Curve25519 can be any 32-byte string. a = urandom(32) a_pub = scalarmult_base(a) b = urandom(32) b_pub = scalarmult_base(b) # perform Diffie-Hellman computation for alice and bob k_ab = scalarmult(a, b_pub) k_ba = scalarmult(b, a_pub) # keys should be the same assert k_ab == k_ba
print "PUB report recieved", controllerKey
print ''
ackSeq = res[12:14]
else:
res = ''
else:
print "No response, Resending report"
d.RFxmit(invert(PUBreport + chr(calculate_checksum(PUBreport))))
start = time.time()
#sendAck
sendAck(nodeId, ackSeq, d)
#Derive session key (Shared secret established via Curve25519)
sessionKey = scalarmult(pKey.decode("hex"),
controllerKey.decode("hex")).encode("hex")
print ''
print "Session key calculated:", sessionKey
print ''
#send Nonce Get
PUBreport = '\xC0\x1F\x9E\x67' + nodeId.decode(
"hex") + '\x41\x46\x0D\x01\x9F\x01\x00'
d.RFxmit(invert(PUBreport + chr(calculate_checksum(PUBreport))))
#wait for Nonce Report
start = time.time()
res = ''
while res == '':
end = time.time()
