def DH(self, client, cipher):
print '\n############### STARTING D-H ##################'
myDH = DiffieHellman()
# Receive value from client
recvDH = client.recv(1024).strip()
# Decrypt received value from client
publicVal = cipher.decrypt(recvDH)
print 'Received encrypted value: ', recvDH.encode('hex')
print '\n'
print 'g^a mod p value is: ', publicVal
print '\n'
# Encrypt DH's public key AES using shared cipher
sendDH = cipher.encrypt(str(myDH.public_key))
print 'g^b mod p value is: ', myDH.public_key
print '\n'
print 'Sending encrypted value: ', sendDH.encode('hex')
print '\n'
# Send computed DH to client
client.send(str(sendDH))
# Compute shared key
myDH.calc_shared_key(long(publicVal))
print 'Calculated session key:', myDH.key
self.sessionKey = myDH.key
print '################## D-H OVER ###################\n'
def DH(self, sharedKey):
print '\n############### STARTING D-H ##################'
# Create AES object with shared key
cipher = AESCipher(sharedKey)
#generate key to send to server
myDiffieHellman = DiffieHellman()
print 'g^a mod p value is: ', myDiffieHellman.public_key
print '\n'
#send key to server
sendDH = cipher.encrypt(str(myDiffieHellman.public_key))
print 'Sending encrypted value: ', sendDH.encode('hex')
self.send(str(sendDH))
print '\n'
recvDH = self.waitToRec()
#decrypt received DH value
reply = cipher.decrypt(recvDH)
print 'Received encrypted value: ', recvDH.encode('hex')
print '\n'
print 'g^b mod p value is: ', reply
print '\n'
#calculate session key
myDiffieHellman.calc_shared_key(long(reply))
print "Calculated session key:", myDiffieHellman.key
self.sessionKey = myDiffieHellman.key
print '################## D-H OVER ###################\n'
def __establish_session(self, con):
generator, prime = self.__receive_generator_and_prime(con)
diffie_hellman = DiffieHellman(generator, prime)
result = diffie_hellman.get_result()
result_from_client = int(con.recv(1024))
con.send(bytes(str(result), 'utf8'))
self.__key = diffie_hellman.calculate_shared_secret(result_from_client)
self.__session_estabilished = True
print("Session key: " + str(self.__key))
self.__key = self.__key.to_bytes(32, byteorder = "big")
self.__aes = pyaes.AESModeOfOperationCTR(self.__key)
def __init__(self):
super(Client, self).__init__()
# Server connection variables
try:
self.server_ip = "127.0.0.1"
self.server_port = 8080
self.socket = socket(AF_INET, SOCK_STREAM)
self.socket.connect((self.server_ip, self.server_port))
except Exception as e:
log_error("Error connecting with the server\n")
raise
return
self.cc = CC_Interaction()
try:
self.uuid = self.cc.get_pubkey_hash_int()
except ValueError:
log_error("Error getting uuid\n")
raise
return
self.id = None
self.sessionKeys = DiffieHellman()
#assimetrica gerada por nos (nao do cc)
self.AsyCypher = Asy_Cyphers(self.uuid)
self.blockChain = None
self.certCertificate = None
def establish_session(self):
generator, prime = Math.generate_generator_and_prime(256)
self.__tcp_client.send(bytes(str(generator), 'utf8'))
self.__tcp_client.send(bytes(str(prime), 'utf8'))
diffie_hellman = DiffieHellman(generator, prime)
result = diffie_hellman.get_result()
self.__tcp_client.send(bytes(str(result), 'utf8'))
result_from_server = int(self.__tcp_client.recv(1024))
self.__key = diffie_hellman.calculate_shared_secret(result_from_server)
print("Session key: " + str(self.__key))
self.__key = self.__key.to_bytes(32, byteorder="big")
self.__aes = pyaes.AESModeOfOperationCTR(self.__key)
def handle(self):
self.__debugflag = self.server.conn
self.__dh = DiffieHellman.DH()
# print the Client-IP
print("[{}] Client connected.".format(self.client_address[0]))
# init
self.initDiffieHellman()
print("> The secret key is {}\n".format(self.__dh.key))
def __init__(self,
comm,
compress=False,
addr="\x00\x00",
psk="",
dh_callback=None):
self.compress = compress
self.addr = addr
self.last_iv = 0x00
self.last_seq = 0x00
self.comm = comm
self.streams = []
self.stream_cnt = 0
self.pub_key = 0
self._psk = psk
self.dh_callback = dh_callback
self._secret = ""
if not self._secret:
INFO("Calculating diffie hellman public key")
self.dh = DiffieHellman()
def test_diffie_hellman_exchange(self):
"""
Simulates a diffie-hellman key exchange
"""
# Alice and Bob agree for a secure generator and prime
base, modulus = Math.generate_generator_and_prime(128)
alice = DiffieHellman(base, modulus)
bob = DiffieHellman(base, modulus)
# Alice calculates her exponentiation
alice_result = alice.get_result()
# Bob calculates his exponentiation
bob_result = bob.get_result()
# so, they exchange the result and calculates the shared secret
secret_alice = alice.calculate_shared_secret(bob_result)
secret_bob = bob.calculate_shared_secret(alice_result)
# And if right, both secrets must be equal.
self.assertEqual(secret_alice, secret_bob)
def __init__(self, socket, addr):
self.socket = socket
self.bufin = ""
self.bufout = ""
self.addr = addr
self.id = None
self.uuid = None
self.sa_data = None
self.sessionKeys = DiffieHellman()
self.blockChain = None
self.clientCertificate = None
try:
pub = b""
priv = b""
pub_file = "Seguranca_Signed.pem"
private_file = "NovaKey.pem"
with open(pub_file, "rb") as key_file:
pub = key_file.read()
with open(private_file, "rb") as key_file:
priv = key_file.read()
self.certServe = Cert_Sign(pub, priv)
except Exception as e:
print(e)
from DiffieHellman import DiffieHellman
from binascii import hexlify
if __name__ == "__main__":
alisa = DiffieHellman()
bob = DiffieHellman()
print('Alisa:')
alisa_key = alisa.generateSharedKey(bob.getPublicKey(), show_results=True)
print('\n')
print('Bob:')
bob_key = bob.generateSharedKey(alisa.getPublicKey(), show_results=True)
print('\n')
print(f'Kljucevi su isti: {alisa_key == bob_key}')
print('\n')
if alisa_key == bob_key:
print(
f'Kljuc koji se moze koristiti za AES sifru: {hexlify(alisa_key)}')
print(f'Duzina kljuca je {len(alisa_key)*8} bitova')
def __init__(self, debugflag):
self.__dh = DiffieHellman.DH()
self.__debugflag = debugflag
from binascii import hexlify
from DiffieHellman import DiffieHellman
a = DiffieHellman()
b = DiffieHellman()
a.genKey(b.publicKey)
b.genKey(a.publicKey)
#a.showParams()
#a.showResults()
#b.showParams()
#b.showResults()
if(a.getKey() == b.getKey()):
print("Shared keys match.")
print("Key:", hexlify(a.key))
else:
print("Shared secrets didn't match!")
print("Shared secret A: ", a.genSecret(b.publicKey))
print("Shared secret B: ", b.genSecret(a.publicKey))
from DiffieHellman import DiffieHellman
Alice = DiffieHellman()
Bob = DiffieHellman()
Alice.generate_secret()
Bob.generate_secret()
print('Alice secret', Alice.get_secret())
print('Bob secret', Bob.get_secret())
A = Alice.get_public()
B = Bob.get_public()
print('Alice public', A)
print('Bob public', B)
Alice.set_other_public(B)
Bob.set_other_public(A)
Alice.generate_shared_private_key()
Bob.generate_shared_private_key()
print('shared1', Alice.get_shared_private_key())
print('shared2', Bob.get_shared_private_key())
def __init__(self, state):
self.state = state
self.dh = DiffieHellman()
class UserChat:
def __init__(self, state):
self.state = state
self.dh = DiffieHellman()
def handleMsg(self, resp):
header = resp.split(';')[0]
if header == 'e':
self.state = 'lead'
raise toSChatError(resp.split(';')[1])
if self.state == 'syn':
self.handleOkResp(resp)
if self.state == 'wait':
#self.handleSynReq(resp)
raise SChatError('Unknown Error')
if self.state == 'okSent':
self.handleGrResp(resp)
def handleSynReq(self, resp, serverKey):
header = resp.split(';')[0]
if header != 'h':
raise SChatError(
'Got invalid msg(header) while in \'wait\' state!')
try:
token, self.encData = resp.split(';')[1:]
return binascii.unhexlify(
AESCipher(serverKey).decrypt(token)).split(
';') #username,sharedKey
except Exception as err:
raise SChatError(
'Invalid content in Hi request, problem with decryption! - ' +
str(err))
def sendOkMsg(self, peer):
self.peer = peer
dhKey, self.nounce = self.peer.aes.decrypt(self.encData).split(';')
self.peer.send(
'o;' +
self.peer.aes.encrypt(self.nounce + ';' + str(self.dh.publicKey))
) #+';'+str(peer.sport)))
self.dh.genKey(int(dhKey))
self.peer.aes = AESCipher(binascii.hexlify(self.dh.getKey()))
self.state = 'okSent'
def handleGrResp(self, resp):
#expect the next message (g - ack)
header = resp.split(';')[0]
if header != 'g':
raise SChatError(
'Got invalid msg(header) while in \'okSent\' state!')
recvNounce = int(self.decryptAes(resp.split(';')[1]))
if recvNounce != int(self.nounce) + 1:
raise SChatError(
'Received nounce sent back by the peer isn\'t compatible with the\n nounce number sent originally by you... \nYou may be under attack if this error continue to apper!'
)
self.state = 'ready'
def decryptAes(self, msg):
try:
return self.peer.aes.decrypt(msg)
except Exception as er:
raise SChatError(
'Invalid msg, can\'t decrypt the data, maybe wrong key or unauthorized source! - '
+ str(er))
def handleOkResp(self, respAddr):
resp = respAddr[0]
addr = respAddr[1]
header = resp.split(';')[0]
if header != 'o':
raise SChatError('Got invalid msg(header) while in \'syn\' state!')
nounce, DHKey = self.decryptAes(resp.split(';')[1]).split(';')
self.peer.changePort(addr[1])
self.dh.genKey(int(DHKey))
self.peer.aes = AESCipher(binascii.hexlify(self.dh.getKey()))
if nounce != self.nounce:
raise SChatError(
'Received nounce sent back by the peer isn\'t compatible with the\n nounce number sent originally by you... \nYou may be under attack if this error continue to apper!'
)
self.peer.send('g;' + self.peer.aes.encrypt(str(int(self.nounce) + 1)))
#self.peer.send('g;' + self.peer.aes.encrypt(str(int(self.nounce) + 1)))
self.state = 'ready'
def sendSyn(self, peer, token):
self.peer = peer
if self.state != 'lead':
raise SChatError(
'Can\'t start chat without getting info from the server about the unknown user!'
)
self.nounce = str(randint(1, 65555))
self.peer.send(
'h;' + token + ';' +
self.peer.aes.encrypt(str(self.dh.publicKey) + ';' + self.nounce))
self.state = 'syn'
from DiffieHellman import DiffieHellman dhAlice = DiffieHellman() g, p, publicKey = dhAlice.getBaseAndModulusAndPublicKey() dhBob = DiffieHellman(g, p, publicKey) print(dhBob.sharedSecret == dhAlice.calcSecret(dhBob.publicKey))
def initDiffieHellman(self):
new_window = DiffieHellman.Diffie_HellmanApp(self)
new_window.show()
header = data['header']
body = data['data']
toSend = {}
print('received: %s' % data)
if header == "DH":
if (verifyMsg(body['publicKey'], body['hasz'],
body['signature'])):
print('>>> DIGITAL SIGNATURE VERIFIED! <<<')
g, p, alicePublicKey = body['message'].split(':')
g = int(g)
p = int(p)
alicePublicKey = int(alicePublicKey)
dhBob = DiffieHellman(g, p, alicePublicKey)
toSend['header'] = 'DH'
toSend['data'] = str(dhBob.publicKey)
print('Bob SharedSecret(%d): %d' %
(dhBob.sharedSecret.bit_length(),
dhBob.sharedSecret))
aesOBJ = AESCipher(str(dhBob.sharedSecret))
else:
print('DIGITAL SIGNATURE NOT VERIFIED!')
elif header == "AES":
decryptedBody = aesOBJ.decrypt(body)
print("RESPONSE: %s" % decryptedBody)
inpt = input('Your message > ')
enc = aesOBJ.encrypt(inpt)
toSend['header'] = 'AES'
toSend['data'] = enc
print 'times to decrypt N Bytes: '
pprint( dict(zip([1, 10, 100, 1000, 10000], dtimes)) )
# decrypting M times
M = 1000
N = 100
# generate a random secret key
key = Random.new().read(KEY_SIZE)
# generate a random IV
iv_bytes = Random.new().read(BLOCK_SIZE)
# create a cipher object using the random key and IV
cipher = AES.new(key, mode, iv_bytes)
# decode the encoded string
encoded = EncodeAES(cipher, 'c' * N)
stmt='''
for i in xrange(M):
decoded = DecodeAES(cipher, iv_bytes + encoded)[len(iv_bytes):]
'''
print 'time to decrypt ' + str(M) + ' messages, each of ' + str(N) + ' Bytes of plaintext size: ' , \
timeit(stmt, setup="from __main__ import DecodeAES, cipher, iv_bytes, encoded, M", number=rep) / rep
## Diffie Hellman benchmark
a = DiffieHellman()
b = DiffieHellman()
a.genKey(b.publicKey)
b.genKey(a.publicKey)
# compute timing of performing modular exponentiation
print 'time to perform modular exponentiation: ', \
timeit("pow(b.publicKey, a.privateKey, a.prime)", setup="from __main__ import a, b", number=rep) / rep
while len(data) < n:
sock.settimeout(20)
packet = sock.recv(n - len(data))
if not packet:
print("Timeout")
return None
data += packet
return data
while True:
try:
# sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock = socket.create_connection((TCP_IP, TCP_PORT), 10)
a = DiffieHellman()
msg = b64encode(str(a.publicKey).encode())
sys.stdout.flush()
print("Len: ", len(msg))
sock.sendall(msg)
m = recvall(sock, 2468)
msg = b64decode(m)
print("Alice Pub: ", str(a.publicKey))
a.genKey(int(msg))
a.showResults()
print("Key {}".format(a.key))
aes = AESCipher(a.key)
f = open('script.txt')
count = 0
from RSAdigitalSignature import signMsg
aesOBJ = object()
# Create a TCP/IP socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Connect the socket to the port where the server is listening
server_address = ('localhost', 9998)
print('connecting to %s port %s' % server_address)
sock.connect(server_address)
try:
# Diffie Hellman
dhAlice = DiffieHellman()
aliceSharedSecret = ''
g, p, alicePublicKey = dhAlice.getBaseAndModulusAndPublicKey()
message = str(g) + ':' + str(p) + ':' + str(alicePublicKey)
# Send data
toSend = {}
toSend['header'] = 'DH'
toSend['data'] = signMsg(message)
print('sending: %s' % toSend)
sock.sendall(pickle.dumps(toSend))
while True:
# Look for the response
amount_received = 0
amount_expected = len(message)
bob_port = 5005
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((TCP_IP, TCP_PORT))
server.listen(1)
print("Listening on {}:{}".format(TCP_IP, TCP_PORT))
sys.stdout.flush()
while True:
try:
alice, addr = server.accept()
data = b64decode(alice.recv(4096).decode()) # buffer size is 1024 bytes
a = DiffieHellman()
msg = b64encode(str(a.publicKey).encode())
alice.sendall(msg)
a.genKey(int(data))
bob = socket.create_connection((bob_ip, bob_port), 30)
b = DiffieHellman()
msg = b64encode(str(b.publicKey).encode())
bob.sendall(msg)
msg = b64decode(bob.recv(4096).decode())
b.genKey(int(msg))
aes_a = AESCipher(a.key)
aes_b = AESCipher(b.key)
while True:
while True:
try:
print("Waiting for conn")
sys.stdout.flush()
conn, addr = sock.accept()
m = recvall(conn, 2468)
# m = conn.recv(10000).decode()
print("Recvd: ", m)
print("Len: ", len(m))
sys.stdout.flush()
data = b64decode(m) # buffer size is 1024 bytes
print("Recved pub key")
sys.stdout.flush()
b = DiffieHellman()
msg = b64encode(str(b.publicKey).encode())
conn.sendall(msg)
b.genKey(int(data))
print("Generated private key")
sys.stdout.flush()
# ciphertext = conn.recv(4096)
aes = AESCipher(b.key)
f = open('script.txt')
count = 0
for line in f:
# print("In loop")
