def main():
#replace g with 1, p, p-1...
#just watch the generated secret key result
#1 : all secret keys are 1
#p : all secret keys are 0
#p-1: half secret keys are 1
# half secret keys are p-1
dh = DiffieHellman(DiffieHellman.p, 1)
a_pri, a_pub, a_p, a_g = dh.gen_key_pair()
b_pri, b_pub, b_p, b_g = dh.gen_key_pair()
a_sk = dh.gen_sec_key(b_pub, a_pri)
key_a = sha1.sha1(str(a_sk))[:16]
print a_sk
print binascii.hexlify(key_a)
dh = DiffieHellman(DiffieHellman.p, DiffieHellman.p)
a_pri, a_pub, a_p, a_g = dh.gen_key_pair()
b_pri, b_pub, b_p, b_g = dh.gen_key_pair()
a_sk = dh.gen_sec_key(b_pub, a_pri)
key_a = sha1.sha1(str(a_sk))[:16]
print a_sk
print binascii.hexlify(key_a)
dh = DiffieHellman(DiffieHellman.p, DiffieHellman.p-1)
a_pri, a_pub, a_p, a_g = dh.gen_key_pair()
b_pri, b_pub, b_p, b_g = dh.gen_key_pair()
a_sk = dh.gen_sec_key(b_pub, a_pri)
key_a = sha1.sha1(str(a_sk))[:16]
print a_sk
print binascii.hexlify(key_a)
def create_dh() -> DiffieHellman:
p = 233970423115425145524320034830162017933
curve = WeierstrassCurve(p, -95051, 11279326)
point = (182, 85518893674295321206118380980485522083)
point_order = 29246302889428143187362802287225875743
return DiffieHellman(curve, point, point_order)
def __init__(self, PORT):
self.client_port, self.server_port = PORT
self.serv_secret = random.randint(500, 1500)
self.target_server_port = ''
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.proto_sock = Protocol(sock)
self.proto_sock.start(self.server_port)
self.hellman = DiffieHellman()
def __init__(self):
super(MainWindow, self).__init__()
loadUi(os.getcwd() + '/gui.ui', self)
self.constraint_input()
self.connect_buttons()
self.elgamal = Elgamal()
self.rsa = RSA()
self.dh = DiffieHellman()
self.mode = None
self.format = None
def __init__(self, port):
self.server_port = ''
self.port = port
self.client_secret = random.randint(500, 1500)
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.read_sock = Protocol(sock)
self.read_sock.start(port)
self.hellman = DiffieHellman()
self.write_sock = Protocol(
socket.socket(socket.AF_INET, socket.SOCK_DGRAM))
self.main()
def test_map():
curve = MontgomeryCurve(p, 534, 1)
w_curve = WeierstrassCurve(p, -95051, 11279326)
point = (4, 85518893674295321206118380980485522083)
dh = DiffieHellman(curve, point, point_order=given_point_order)
expected = (182, 85518893674295321206118380980485522083)
assert m_point_to_w_curve(point) == expected
alice_keypair = dh.generate_keypair()
alice_public = alice_keypair.public
assert curve.is_identity(curve.scalar_mult(alice_public,
given_point_order))
assert w_curve.is_identity(
w_curve.scalar_mult(m_point_to_w_curve(alice_public),
given_point_order))
async def on_message(message):
#Ignore MSGs if they're not DMs
#TODO implement end-to-end group chatting
if message.author == bot.user or not isinstance(message.channel, discord.DMChannel):
return
#database['chats'][str(message.author.id)].append(message.content)
if message.content.startswith("===KEYEXCH==="):
# Perform a Diffie-Hellman key exchange
print(f"Key exchange started with {message.author.name}")
k2 = message.content.find("value:")
df = DiffieHellman()
k1 = df.generate_k()
key = df.generate_full_key(k2)
database['users'][str(message.author.id)]['key'] = df
print("Key with user: "******" is ", database['users'][str(message.author.id)]['key'].key)
await message.author.send(f"===KEYACK===\nvalue:{k1}")
elif message.content.startswith("===KEYACK==="):
value = message.content.find("value:")
k2 = message.content[value+6:]
df = database['users'][str(message.author.id)]['key']
df.generate_full_key(k2)
database['users'][str(message.author.id)]['key'] = df
print("Key with user: "******" is ", database['users'][str(message.author.id)]['key'].key)
elif message.content.startswith("===MSG==="):
# Recieve a message:
content = message.content[9:]
try:
key = database['users'][str(message.author.id)]['key'].key
aes = AESCipher( key )
decrypted = aes.decrypt(content)
except:
print("Error while decrypting message")
return
print(content)
print(decrypted)
# 0 - Sent by someone
# 1 - Sent by you
database['chats'][str(message.author.id)].append( [0, decrypted] )
async def on_ready():
print("-" * 40)
print('Started the bot as:', bot.user)
print("BOT:", database)
users = bot.users
for user in users:
print(user)
df = DiffieHellman()
k1 = df.generate_k()
database['chats'][str(user.id)] = []
database['users'][str(user.id)] = {
'name': user.name,
'key': df
}
print("Sending to:", user)
u = await bot.fetch_user(user.id)
try:
await u.send(f'===KEYEXCH===\nvalue:{k1}')
except:
print("Erorr sending key-exchange to:", user)
print("-" * 40)
except:
print "Unable to open port %d" % client_port
sys.exit()
try:
conn_server.connect(server_ip, server_port)
except:
print "Unable to connect to %s at port %d" % (server_ip, server_port)
# Key exchange: Later can be added some other variants too.#######
p_server = int(get_line(conn_server))
g_server = int(get_line(conn_server))
A_server = int(get_line(conn_server))
dh_server = DiffieHellman(p_server, g_server)
_, _, B_server = dh_server.generate_public_broadcast()
conn_server.send(str(B_server))
crypto_protocol_server = CryptoProtocol(dh_server.get_shared_secret(A_server))
p_client = p_server
g_client = g_server
dh_client = DiffieHellman(p_server, g_server)
_, _, A_client = dh_client.generate_public_broadcast()
conn_client.send(str(p_client))
conn_client.send(str(g_client))
conn_client.send(str(A_client))
B_client = int(get_line(conn_client))
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# pylint: disable=C0330
"""key_exchange.py
Test script for Diffie-Hellman implemented within this folder.
"""
from __future__ import absolute_import
from random import getrandbits
from diffie_hellman import DiffieHellman
XA, XB = getrandbits(512), getrandbits(512)
for i in [
(589_559_306_225_789_680_238_449, 99_848_060_646_461_381_236_408),
(1_076_504_068_900_685_093_590_721, 594_761_277_746_183_138_644_459),
]:
alice = DiffieHellman(XA, *i)
bob = DiffieHellman(XB, *i)
A = alice.gen_shared_secret(bob.gen_public_key())
B = bob.gen_shared_secret(alice.gen_public_key())
assert A == B
def get_line():
line = None
while line is None:
line = conn.recv()
return line
if len(sys.argv) == 2: # server
try:
conn.listen(int(sys.argv[1]))
except:
print "Unable to open port %d" % int(sys.argv[1])
sys.exit()
dh = DiffieHellman()
p, g, A = dh.generate_public_broadcast()
conn.send(str(p))
conn.send(str(g))
conn.send(str(A))
B = int(get_line())
crypto_protocol = CryptoProtocol(dh.get_shared_secret(B))
elif len(sys.argv) == 3: # client
try:
conn.connect(sys.argv[1], int(sys.argv[2]))
except:
print "Unable to connect to %s at port %d" % (sys.argv[1],
int(sys.argv[2]))
sys.exit()
p = int(get_line())
g = int(get_line())
def setUp(self): # sharedSecret = 17 base = 5 modulo = 23 self.alice = DiffieHellman(modulo, base) self.bob = DiffieHellman(modulo, base)
from sha1 import SHA1 from diffie_hellman import DiffieHellman from rsa_dsa import RSADSA # RSA DSA keys = rsa_keys.generate_rsa_keys(256) rsa_dsa = RSADSA(keys['n']) sign = rsa_dsa.sign(SHA1, 'ARTYOM', keys['d']) print(rsa_dsa.verify(SHA1, sign, keys['e'])) curve = EllipticCurve(67) # Diffie-Hellman dh = DiffieHellman(curve, curve.points[3]) a_private = 7 a_public = dh.gen_public(a_private) b_private = 13 b_public = dh.gen_public(b_private) secret = dh.gen_secret(a_private, b_public) print(dh.gen_secret(a_private, b_public) == dh.gen_secret(b_private, a_public)) # EC DSA point = curve.prime_order_point() ec_dsa = ECDSA(curve, point) private = 4
def __init__(self, q, alpha):
self.__tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.__s_des = SimpleDes()
self.__rc4 = RC4()
self.__encryption = None
self.__diffie_hellman = DiffieHellman(q, alpha)
try:
bogus_point = curve.find_point_of_order(r, curve_order)
confused_response = bob_keypair.compute_secret(bogus_point)
# brute for which r for confused response
current_point = bogus_point
for x in range(1, r):
if current_point == confused_response:
yield (x, r)
break
current_point = curve.add_points(current_point, bogus_point)
except ValueError as err:
continue
if __name__ == "__main__":
dh = DiffieHellman(given_curve, point, point_order=given_order)
alice_keypair = dh.generate_keypair()
bob_keypair = dh.generate_keypair()
alice_key = alice_keypair.compute_secret(bob_keypair.public)
bob_key = bob_keypair.compute_secret(alice_keypair.public)
assert alice_key == bob_key, 'Key should have been shared'
# Begin Subgroup Confinement Attack
bad_curve1 = WeierstrassCurve(p, -95051, 210)
order_curve1 = 233970423115425145550826547352470124412
bad_curve2 = WeierstrassCurve(p, -95051, 504)
order_curve2 = 233970423115425145544350131142039591210
bad_curve3 = WeierstrassCurve(p, -95051, 727)
order_curve3 = 233970423115425145545378039958152057148
