Esempio n. 1
0
    def make_key_exchange(self):
        self.PAG = DiffieHellman.make_random_prime_and_g()
        self.__PRIVATE_key = DiffieHellman.make_own_private_key()

        # 값 계산 p, g, (g^개인키) mod p
        p = self.PAG[0]
        g = self.PAG[1]
        sharekey = (g ** self.__PRIVATE_key) % p

        self.client_connection.send(('[PAG]' + str(p) + ' ' + str(self.PAG[1])).encode('utf-8'))
        self.client_connection.send(('[MOD]' + str(sharekey)).encode('utf-8'))
Esempio n. 2
0
def key_exchange():
    # Diffie Hellman
    privatekey = DiffieHellman.serverValues()
    baseMod = (0, 0)
    #Recieving base and modulo from client
    bytesAddressPair = UDPServerSocket.recvfrom(bufferSize)
    baseMod = pickle.loads(bytesAddressPair[0])
    #Calculating serverside dh-value and sending it
    serverValue = DiffieHellman.calc_dh(baseMod[0], privatekey, baseMod[1])
    UDPServerSocket.sendto(pickle.dumps(serverValue), bytesAddressPair[1])
    #Recieving clientside DH-value
    bytesAddressPair = UDPServerSocket.recvfrom(bufferSize)
    clientValue = pickle.loads(bytesAddressPair[0])
    #Calculating real DH-value
    dh_value = DiffieHellman.calc_dh(clientValue, privatekey, baseMod[1])
    return dh_value
Esempio n. 3
0
def key_exchange():
    # Diffie Hellman
    privatekey = DiffieHellman.clientValues()
    baseMod = (0,0)
    baseMod = DiffieHellman.sharedValues(baseMod[0], baseMod[1])
    #Sending public base and modulo
    UDPClientSocket.sendto(pickle.dumps(baseMod), serverAddressPort)
    #Recieving calculated value from server
    bytesAddressPair = UDPClientSocket.recvfrom(bufferSize)
    serverValue = pickle.loads(bytesAddressPair[0])
    #Sending clientside DH-value
    clientValue = DiffieHellman.calc_dh(baseMod[0], privatekey, baseMod[1])
    UDPClientSocket.sendto(pickle.dumps(clientValue), serverAddressPort) 
    #Calculating real DH-value
    dh_value = DiffieHellman.calc_dh(serverValue, privatekey, baseMod[1])

    print(dh_value)
    return dh_value
Esempio n. 4
0
    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))
Esempio n. 5
0
    def run_server(self, ui_mode_chat_chatlog_box):
        print('서버 생성, 1:1 클라이언트 연결 기다리는 중...')
        self.server_connection = socket(AF_INET, SOCK_STREAM)
        self.server_connection.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)

        self.server_connection.bind((self.server_ip, self.server_port))
        self.server_connection.listen(5)
        self.server_socket, addr = self.server_connection.accept()

        self.__PRIVATE_key = DiffieHellman.make_own_private_key()
        # 반드시 소켓이 수립된 후 진행되어야 할 쓰레드
        # 수신 쓰레드 새로 생성
        start_new_thread(self.recvthread, (ui_mode_chat_chatlog_box, ))
Esempio n. 6
0
def malicious_g_attack():
    p = DiffieHellman.DEFAULT_P

    for g in [1, p, p - 1]:

        alice = DiffieHellman()
        bob = DiffieHellman(g=g)

        A = alice.get_public_key()

        B = bob.get_public_key()

        _msg = b'Hello, how are you?'
        _a_key = unhexlify(sha1(str(alice.get_shared_secret_key(B)).encode()))[:16]
        _a_iv = Random.new().read(AES.block_size)
        a_question = aes_cbc_encrypt(_msg, _a_key, _a_iv) + _a_iv

        mitm_a_iv = a_question[-AES.block_size:]

        if g == 1:
            mitm_hacked_key = unhexlify(sha1(b'1').encode())[:16]
            mitm_hacked_message = aes_cbc_decrypt(a_question[:-AES.block_size], mitm_hacked_key, mitm_a_iv)

        elif g == p:
            mitm_hacked_key = unhexlify(sha1(b'0').encode())[:16]
            mitm_hacked_message = aes_cbc_decrypt(a_question[:-AES.block_size], mitm_hacked_key, mitm_a_iv)

        else:

            for candidate in [str(1).encode(), str(p - 1).encode()]:
                mitm_hacked_key = unhexlify(sha1(candidate).encode())[:16]
                mitm_hacked_message = aes_cbc_decrypt(a_question[:-AES.block_size], mitm_hacked_key,
                                                      mitm_a_iv, unpad=False)

                if is_pkcs7_padded(mitm_hacked_message):
                    mitm_hacked_message = pkcs7_unpad(mitm_hacked_message)
                    break

        assert _msg == mitm_hacked_message
Esempio n. 7
0
def main():
    alice = DiffieHellman()
    bob = DiffieHellman()
    parameter_injection_attack(alice, bob)
Esempio n. 8
0
                continue

host = '192.168.43.125'
port = 5000
size = 1024
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host,port))
username = raw_input("insert your username: ")

try:
    server = Server(s)
    server.start()
    threads.append(server)

    config = Config()
    diffie_hellman = DiffieHellman.KeyExchange()

    # Proses Pengiriman
    while True:
        config.message = raw_input()
        config.sending_state = True

        secret_a = 6
        public_a = diffie_hellman.generatePublicNumber(secret_a)
        public_a = str(public_a)

        s.send(public_a)

except KeyboardInterrupt:
    s.close()
    for s in threads:
Esempio n. 9
0
import socket
from binascii import hexlify
import DiffieHellman
import nacl.secret
import nacl.utils

while True:
    # Initialize Diffie Hellman object so private and public keys are generated.
    server = DiffieHellman.D_H()

    # This string we use to cat with the incoming msg and send to cat'd string back.
    echoString = "I have received | "

    # Create a TCP/IP socket.
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # Bind the socket to a port
    server_address = ('localhost', 5555)
    sock.bind(server_address)

    # Listen for incoming connections.
    sock.listen(1)

    # Accepting the incoming traffic on server socket.
    connection, client_address = sock.accept()
    print('Connection from IP:', client_address)

    # Receive clients public key so we can generate the final (secret) key.
    client_Pubkey = connection.recv(9000)

    # Send our (server) public key.
Esempio n. 10
0
import DiffieHellman

print(DiffieHellman.algoritmoManInTheMiddle(1222))
Esempio n. 11
0
import socket
import DiffieHellman
import nacl.secret
import nacl.utils
from binascii import hexlify

# Initialize Diffie Hellman object so private and public keys are generated.
client = DiffieHellman.D_H()

# 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', 5555)
sock.connect(server_address)
print("Connected to %s on port %s" % server_address)

# Send Client's public key to the server so the Diffie hellman key exchange can happen.
# And cast the key over to string so we can send it over the socket.
sock.sendall(str(client.pubKey))

# Receive servers public key so we can generate the final (secret) key.
data = sock.recv(9000)

# Generate the secret key and cast the incoming key to int from str.
client.genKey(int(data))
print("Secret key:", hexlify(client.getKey()))

# Initialize the SALT object and pass in the secret key.
box = nacl.secret.SecretBox(client.getKey())
Created on Jul 7, 2015

@author: mewolot
'''
import DiffieHellman as dh
import random as rand

p = 37
g_1 = 1
g_2 = p
g_3 = p-1

a = rand.randrange(0,p-1)
b = rand.randrange(0,p-1)

A_1 = dh.genPub(p, g_1, a)
A_2 = dh.genPub(p, g_2, a)
A_3 = dh.genPub(p, g_3, a)

B_1 = dh.genPub(p, g_1, b)
B_2 = dh.genPub(p, g_2, b)
B_3 = dh.genPub(p, g_3, b)

s1_A = dh.getShared(p, B_1, a) 
s2_A = dh.getShared(p, B_2, a)
s3_A = dh.getShared(p, B_3, a)

s1_B = dh.getShared(p, A_1, b)
s2_B = dh.getShared(p, A_2, b)
s3_B = dh.getShared(p, A_3, b)
Created on Jul 7, 2015

@author: mewolot
'''
import DiffieHellman as dh
import random as rand
from Set4.Sha1 import sha1
from Crypto.Cipher import AES
import os
from string import join
from Set2.Padding import pad, unPad

p_A = 37
g_A = 5
a = rand.randrange(0,p_A - 1)
A = dh.genPub(p_A, g_A, a)

print "A -> B"
print "Send p, g, A"

p_B = p_A
g_B = g_A
A_B = A
b = rand.randrange(0,p_B - 1)
B = dh.genPub(p_B, g_B, b)

print "B -> A"
print "Send B"

B_A = B
s_A = dh.getShared(p_A, B_A, a)
Esempio n. 14
0
Created on Jul 7, 2015

@author: mewolot
'''
import DiffieHellman as dh
import random as rand

p = 37
g_1 = 1
g_2 = p
g_3 = p - 1

a = rand.randrange(0, p - 1)
b = rand.randrange(0, p - 1)

A_1 = dh.genPub(p, g_1, a)
A_2 = dh.genPub(p, g_2, a)
A_3 = dh.genPub(p, g_3, a)

B_1 = dh.genPub(p, g_1, b)
B_2 = dh.genPub(p, g_2, b)
B_3 = dh.genPub(p, g_3, b)

s1_A = dh.getShared(p, B_1, a)
s2_A = dh.getShared(p, B_2, a)
s3_A = dh.getShared(p, B_3, a)

s1_B = dh.getShared(p, A_1, b)
s2_B = dh.getShared(p, A_2, b)
s3_B = dh.getShared(p, A_3, b)
# --->
# Voor gebruik in IDLE (Windows):
# --->
import sys
import os
z = os.path.dirname(os.path.abspath(__file__))
sys.path.append(z)
# <---

# Bundeling van de verscheidene klassen, centraal punt voor uitvoering van de scripts gerelateerd aan het Diffie-Hellman protocol.

from ElliptischeKromme import *
from DiffieHellman import *

# Start van het script

K = ElliptischeKromme(1, 1, 5)
k = Punt(K, 0, 1)
DH = DiffieHellman(K, k)
print(DH)
a = int(input('λ? '))
publiekeSleutelA = DH.publiekeSleutel(a)
print('De publieke sleutel van persoon A is %s' % publiekeSleutelA)
b = int(input('μ? '))
publiekeSleutelB = DH.publiekeSleutel(b)
print('De publieke sleutel van persoon B is %s' % publiekeSleutelB)
gedeeldeSleutelA = DH.priveSleutel(publiekeSleutelB, a)
gedeeldeSleutelB = DH.priveSleutel(publiekeSleutelA, b)
print('De gedeelde geheime sleutel is [A] %s == %s [B]' % (gedeeldeSleutelA, gedeeldeSleutelB))
Esempio n. 16
0
 def __init__(self, debugflag):
     self.dh = DiffieHellman.DH()
     self.debugflag = debugflag
Esempio n. 17
0
#!/usr/bin/env python
#coding=utf-8
import binascii
#import DES_code
import DiffieHellman
from RSA2 import RSA_encryption, RSA_decryption
from RC4_DH import RC4_encryption, RC4_decryption
#from DES_code import DES_encryption,DES_decryption
from DiffieHellman import DiffieHellman
import hashlib

#修改私钥! 源码见DH_2
#DH协商密钥

a = DiffieHellman(group=5, keyLength=256)
b = DiffieHellman(group=5, keyLength=256)

a.genKey(b.publicKey)
b.genKey(a.publicKey)

if (a.getKey() == b.getKey()):
    #print("密钥协商完成")
    #print("Key:", binascii.b2a_hex(a.key).decode('utf-8')) #字符串转ascii hexlify('abc')     # '616263'
    with open("RC4_key.txt", "w") as f:
        f.write(binascii.b2a_hex(a.key).decode('utf-8'))
'''
以下是接口函数
'''


def ret0():
Esempio n. 18
0
import socket
import parametri
import DiffieHellman
import random

ADDRESS = "0.0.0.0"
parametri.PORT = 1984

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((ADDRESS, parametri.PORT))
s.listen()

conn, clientAddress = s.accept()
print("Connesso con ", conn)

b = random.randint(0, parametri.N)

strToSend = str(DiffieHellman.generaValore(b))
conn.sendall(strToSend.encode())

A = int(conn.recv(4096).decode())
print("\n>client %s: %s" % (clientAddress, A))

print(f"Il valore è {(A**b)%parametri.N}")

conn.close()
s.close()