def test_RSA(inverse,
message="The quick brown fox jumps over the lazy dog.",
bit_length=4096,
e=65537,
powmodn=bit_pow_mod_n):
print("Generating ", bit_length, "-bit primes...")
scheme = RSA(powmodn=powmodn, inverse=inverse, gmp=True)
(p, q, n, l, e, d, public_key,
private_key) = scheme.generate_keys(bit_length, e)
print("\nOriginal plaintext message: ", message)
m = string2int(message)
print("\nEncrypting message...")
c = scheme.rsa_encrypt(m, public_key)
ciphertext = int2string(c)
print(" Ciphertext: ", ciphertext)
print("\nDecrypting message...")
[m2, running_time] = rt2(scheme.rsa_decrypt, c, private_key)
message2 = int2string(m2)
print(" Message decrypted by rsa_decrypt: ", message2)
print(" Running time for rsa_decrypt: ", running_time)
print("\nDecrypting message using Chinese Remainder Theorem...")
[m3, running_time] = rt4(scheme.CRT_rsa_decrypt, c, private_key, p, q)
message3 = int2string(m3)
print(" Message decrypted by CRT_rsa_decrypt: ", message3)
print(" Running time for CRT_rsa_decrypt: ", running_time)
return (p, q, n, l, e, d, public_key, private_key, m, c, message,
ciphertext)
def main():
# input as found in Exercise7_in7_to_student_Crowley.txt
# first prime p
p = 13
# second prime q
q = 149
# encryption exponent e
e = 257
# encrypted message r
r = 1907
print("Running RSA Algorithms to find the RSA Modulus (n), the decryption exponent (d), and the decrypted message (s) for the given input:")
print('')
print(f"first prime p: {p}")
print(f"second prime q: {q}")
print(f"encryption exponent e: {e}")
print(f"encrypted message r: {r}")
print("")
print("Initializing RSA class with the given input...")
test = RSA(p, q, e)
n = test.getPublicKeyPair()[0]
d = test._d
s = test.decryptMessage(r)
print("\nResults")
print("~*" * 8)
print(f"RSA Modulus n: {n}")
print(f"Decryption exponent d (this should be private!): {d}")
print(f"Decrypted message s: {s}")
print(f"n, d, s = {n}, {d}, {s}")
print("~*" * 8)
def disp_ring_data(self):
acc=RSA()
temp = self.head
print("------- Node", temp.key,"-------")
for entry in temp.data:
print("\t<---->")
print(">>FILE NAME:\n", entry.name)
print(">>PUBLIC KEY:\n", entry.pubkey)
content=entry.content
if not users_df[users_df['user']==curr_user][entry.name].isna().values[0]:
print("Decrypting with private key...")
print(">>CONTENT:\n", acc.decipher_text(content,int(users_df[users_df['user']==curr_user][entry.name].values[0]),entry.pubkey))
else:
print("Unable to decrypt without private key.")
print(">>ENCRYPTED CONTENT:\n", entry.content)
print("\t<---->\n")
while(temp.next != self.head):
temp = temp.next
print("------- Node", temp.key,"-------")
for entry in temp.data:
print("\t<---->")
print(">>FILE NAME:\n", entry.name)
print(">>PUBLIC KEY:\n", entry.pubkey)
content=entry.content
if not users_df[users_df['user']==curr_user][entry.name].isna().values[0]:
print("Decrypting with private key...")
print(">>CONTENT:\n", acc.decipher_text(content,int(users_df[users_df['user']==curr_user][entry.name].values[0]),entry.pubkey))
else:
print("Unable to decrypt without private key.")
print(">>ENCRYPTED CONTENT:\n", entry.content)
print("\t<---->\n")
def create_decrypt_running_time_table(message,
e,
start,
stop,
step,
trials,
inverse,
powmodn=bit_pow_mod_n):
scheme = RSA(powmodn=powmodn, inverse=inverse)
m = string2int(message)
print("bit_length,Naïve_fast_exponentiation,CRT_fast_exponentiation")
for bit_length in range(start, stop + 1, step):
sum_rt = sum_rt_crt = 0
for i in range(trials):
(p, q, n, l, e, d, public_key,
private_key) = scheme.generate_keys(bit_length, e)
c = scheme.rsa_encrypt(m, public_key)
# Accumulate naïve recursive running times across trials
sum_rt += rt2(scheme.rsa_decrypt, m, private_key)[1]
# ditto for CRT
sum_rt_crt += rt4(scheme.CRT_rsa_decrypt, c, private_key, p, q)[1]
print(bit_length, sum_rt / trials, sum_rt_crt / trials, sep=',')
def initServer(self):
self.serverSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.serverSock.bind((self.UDP_IP_ADDRESS, self.UDP_PORT_NO))
self.RSA = RSA()
print("Monitorando o endereço: " + self.UDP_IP_ADDRESS + ":" +
str(self.UDP_PORT_NO))
threading.Thread(target=self.listenMessages).start()
def encrypt(self):
"""
Encryption method.
:return: symmetric algorithm object
"""
# message is encrypted by the given symmetric algorithm
if self._algorithm == "AES":
sym_alg = AES_DES3(self._key_type, self._message, self._mode)
self._path = Constants.aes_secret_key_path
else:
sym_alg = AES_DES3(self._key_type, self._message, self._mode,
False)
self._path = Constants.des3_secret_key_path
# encryption
key, cipher = sym_alg.encrypt()
self._cipher = cipher
# key is encrypted by the RSA asymmetric algorithm
rsa = RSA(self._rsa_key, key, True)
crypt_key = rsa.encrypt()
self._crypt_key = crypt_key
Helper.write_envelope([self._algorithm, 'RSA'], [key, crypt_key],
base64.b64encode(cipher), bytes.hex(crypt_key),
Constants.envelope_path)
return sym_alg
class ISO_RSA:
def __init__(self, l): # l is the length of p and q
self.l = l
self.p = 0
self.q = 0
self.N = 0
self.public_key = 0
self.secret_key = 0
self.rsa = RSA(l)
def gen(self, fixed_public_key=False):
self.rsa.gen(fixed_public_key)
self.p = self.rsa.p
self.q = self.rsa.q
self.N = self.rsa.N
self.public_key = self.rsa.public_key
self.secret_key = self.rsa.secret_key
def enc(self, m):
x = generate_x(self.N)
y = prime.exp_mod(x, self.public_key, self.N)
k = sha256(x.to_bytes(TEXT_SIZE, byteorder='big')).digest()
iv = urandom(BLOCK_SIZE)
encryption_suite = AES.new(k, AES.MODE_CBC, iv)
c = encryption_suite.encrypt(m.to_bytes(
TEXT_SIZE, byteorder='big')) # using AES-256
return y, c, iv
def dec(self, y, c, iv):
x = prime.exp_mod(y, self.secret_key, self.N)
k = sha256(x.to_bytes(TEXT_SIZE, byteorder='big')).digest()
decryption_suite = AES.new(k, AES.MODE_CBC, iv)
return int.from_bytes(decryption_suite.decrypt(c),
byteorder='big') # using AES-256
def run_RSA_block(s):
r = RSA(16)
print(r._p)
print(r._q)
c = r.encrypt_block(s)
print(c.hex())
m = r.decrypt_block(c)
assert s.hex() == m.hex()
def __init__(self, l): # l is the length of p and q
self.l = l
self.p = 0
self.q = 0
self.N = 0
self.public_key = 0
self.secret_key = 0
self.rsa = RSA(l)
def test_code_decode(self):
user1 = RSA.RSAGKP(10)
publickey = user1[0]
privkey = user1[1]
message = 1122334455
secret = RSA.RSAEP(publickey, message)
# print("len(secret) = " + str(len(str(secret))))
self.assertEqual(message, RSA.RSADP(privkey, secret))
def __init__(self):
self.p = p
self.q = q
self.n = RSA.find_n(self, p, q)
self.totient = RSA.find_totient(self, p, q)
self.e = RSA.find_totient_coprime(self, self.totient)
self.d = RSA.find_inverse(self, self.e, self.totient)
self.public_key = (n, e)
def __init__(self, n=128):
self._n = n
self._k0 = 4
self._k1 = 4
self._block_size = self._n - self._k0 - self._k1
self.hash = SHA256()
self.rsa = RSA(self._n)
def verify_ciphers():
rsa = RSA()
for i in range(100):
for cipher_name, ciphers in cipher_list.items():
if not ciphers.verify("test"):
print(f"{cipher_name} failed!")
break
if not rsa.verify("test"):
print("RSA failed!")
break
def __init__(self, nbits=512, outpath=None, keypath=None):
self.a = RSA()
if keypath != None:
self.a.inputKey(keypath)
self.mode = self.a.mode
return
if outpath == None:
outpath = 'PublickeyCipher\\'
self.a.generateKey(nbits)
self.a.outputPublicKey(outpath)
self.a.outputPrivateKey(outpath)
def __init__(self, keySize: int = 1024):
self.filePath = "/data/data.dat"
self.mainWindow = Tk()
self.mainWindow.geometry("630x500")
#self.mainWindow.configure(background = "black")
self.mainWindow.title("RSA Encrypter-Decrypter")
self.mainWindow.grid_columnconfigure(0, minsize=10)
self.mainWindow.grid_rowconfigure(10, minsize=20)
self.keySize = keySize
#Instantiate RSA class, Key will be 1024 by default
self.rsa = RSA(self.keySize)
self.option = IntVar(0)
def test_encdec(self):
'''
Test regular encoding and decoding of numbers
'''
a = DynamInt()
a.setData("25")
rsa = RSA(0)
rsa.p.setData("11")
rsa.q.setData("3")
rsa.e.setData("3")
rsa.n.setData("33")
rsa.phi.setData("20")
rsa.d.setData("7")
d = rsa.powmod(a,rsa.e,rsa.n)
f = rsa.powmod(d,rsa.d,rsa.n)
self.assertEqual(a.data, f.data)
def setUp(self):
self.p= DynamInt(10)
self.q = DynamInt(10)
#self.p.setData("821089628001493")
#self.q.setData("1872967539195764008553239")
self.rsa = RSA(0)
self.rsa.createkeys(self.p, self.q)
def send():
msg = my_msg.get()
my_msg.set("")
msg = NAME + ": " + msg
print(Fore.BLUE, end='')
print(msg)
msg_list.insert(tkinter.END, msg)
msg = RSA.encrypt(msg, public_key_1)
CLIENT.send(msg.encode("utf8"))
def send():
messageS = my_msg.get()
my_msg.set("")
messageS = NAME + ": " + messageS
print(Fore.BLUE, end='')
print(messageS)
msg_list.insert(tkinter.END, messageS)
messageS = RSA.encrypt(messageS, public_key_2)
CLIENT.send(messageS.encode("utf8"))
def authenticate(self, sock):
data = sock.recv(4096)
username = data.decode()
print(username)
f = open('Users.txt', 'rb')
users = pickle.load(f)
f.close()
currUser = ''
for user in users:
if user.username == username:
currUser = username
break
if currUser == '':
sock.sendall('Username not in record'.encode())
return False
sock.sendall('Username Received'.encode())
data = b''
payload_size = struct.calcsize("L")
print("Expecting Password")
while len(data) < payload_size:
data += sock.recv(4096)
packed_msg_size = data[:payload_size]
data = data[payload_size:]
msg_size = struct.unpack("L", packed_msg_size)[0]
while len(data) < msg_size:
data += sock.recv(4096)
block_data = data[:msg_size]
data = data[msg_size:]
password = pickle.loads(block_data)
rsa = RSA()
password = rsa.getDecryption(password, prKey[0], prKey[1])
f = open('Users.txt', 'rb')
users = pickle.load(f)
f.close()
for user in users:
if user.username == username:
currUser = user
break
hashedPT = hashlib.sha256(password.encode()).hexdigest()
if not hashedPT == user.password:
return False
return True
def calculation(message,
n,
e,
d,
p,
q,
startzustand=[1, 1, 1, 1, 0, 0, 0, 0],
verbose=False):
### Alice ###
## 1,
a = bitarray(startzustand)
start_lfsr_alice = LFSR.lfsr(a, [0, 1, 3, 4])
key = [next(start_lfsr_alice) for _ in range(120)]
key = "".join(str(x) for x in startzustand + key)
print("--ALICE--------")
print("LFSR-Key: {}".format(helper.get_split_string_from_list(list(key))))
## 2,
rsa = RSA(p="", q="", n=n, e=e)
if verbose:
rsa.print_stats()
c_1 = rsa.short_public_exponent_encrypt(int("".join(
str(i) for i in startzustand),
base=2),
verbose=verbose)
print("RSA Ciphertext: {}".format(c_1))
## 3,
aes = AES(key)
c_2 = aes.encrypt(message, verbose=verbose)
print("AES Ciphertext: {}".format(c_2))
### Bob ###
## 1,
rsa = RSA(p=p, q=q, e=e, private_key=d)
print("--BOB----------")
print("Decryption....")
bin_str = bin(rsa.chinese_decrypt(c_1, verbose=verbose))[2:]
print("RSA Plaintext: {}".format(
helper.get_split_string_from_list(list(bin_str))))
## 2,
a = bitarray(bin_str)
start_lfsr_bob = LFSR.lfsr(a, [0, 1, 3, 4])
key_bob = [next(start_lfsr_bob) for _ in range(120)]
key_bob = "".join(str(x) for x in list(bin_str) + key_bob)
print("LFSR-Key: {}".format(
helper.get_split_string_from_list(list(bin_str))))
## 3,
aes = AES(key_bob)
corresponding_message = aes.decrypt(c_2, verbose=verbose)
print("Message: {}".format(corresponding_message))
return message
class TestRSAOperations(unittest.TestCase):
def setUp(self):
self.p= DynamInt(10)
self.q = DynamInt(10)
#self.p.setData("821089628001493")
#self.q.setData("1872967539195764008553239")
self.rsa = RSA(0)
self.rsa.createkeys(self.p, self.q)
def test_encdec(self):
'''
Test regular encoding and decoding of numbers
'''
a = DynamInt()
a.setData("25")
rsa = RSA(0)
rsa.p.setData("11")
rsa.q.setData("3")
rsa.e.setData("3")
rsa.n.setData("33")
rsa.phi.setData("20")
rsa.d.setData("7")
d = rsa.powmod(a,rsa.e,rsa.n)
f = rsa.powmod(d,rsa.d,rsa.n)
self.assertEqual(a.data, f.data)
def test_disguise(self):
strr = "iamaboy"
rsa = RSA(0)
num=rsa.disguise(strr)
self.assertEqual("iamaboy", rsa.reveal(num))
def test_encryptionDecryption(self):
# make sure we can encrypt and decrypt
crypted = self.rsa.encrypt("iam")
result = self.rsa.decrypt(crypted)
temp=''
for i in result:
temp = temp+i
self.assertEqual("iam", temp)
def console_mode():
print 'Welcome to RSA!'
p, q = _get_primes_from_user()
if not p or not q:
bit_len = _get_bit_len_from_user()
else:
bit_len = max(p, q).bit_length()
keys = key_gen.get_RSA_keys(bit_len, p, q)
rsa_instance = RSA(n=keys[0][1], public_key=keys[0][0], private_key=keys[1][0], key_size=bit_len)
while True:
msg = _get_msg_to_enc()
if msg == 'exit':
break
try:
enc = rsa_instance.encrypt(msg)
print 'Enc msg is: {}'.format(enc)
dec = rsa_instance.decrypt(enc)
print 'Dec msg is: {}'.format(dec)
except Exception as e:
print e
def setKey(self, message, new_bits): #generate the RSA ans IDs
self.message = message
self.bits = new_bits
self.e_RSA = 65537 # this value is given
self.demoRSA = RSA()
self.demoRSA.RSA(self.bits, self.e_RSA)
self.demoRSA.sigGeneration(self.message)
self.updateRSAKeys()
self.IDs = int(1780119054 *
random.random()) #not necessary to generate
self.serverID = 1780119054 #just give -> can change any numbers
def receive():
msg_list.insert(tkinter.END, "Usuario: %s " % NAME)
msg_list.insert(tkinter.END, "Conexion exitosa")
while True:
try:
messageR = CLIENT.recv(BUFFER_SIZE).decode("utf8")
messageR = RSA.deEncrypt(messageR, private_key_1)
print(Fore.YELLOW, end='')
print(">" + messageR)
msg_list.insert(tkinter.END, messageR)
except OSError:
break
class DSA:
def __init__(self, P, Q):
self.P = P
self.Q = Q
self.encryptor = RSA(self.P, self.Q)
self.e, self.d, self.n = self.encryptor.generate_keys()
def get_hash(self, message):
hash_input = bytes(message, "utf-8")
hash_digest = SHA1HASH(hash_input).final_hash()
return hash_digest
def sign_document(self, input_file):
with open(input_file) as f:
message = f.read()
hash_digest = self.get_hash(message)
print("Public keys are e:{}, n:{}".format(self.e, self.n))
print("Private keys are d:{}, n:{}".format(self.d, self.n))
ciphertext = self.encryptor.encrypt(hash_digest)
return ciphertext
def verify_document(self, input_file, ciphertext):
with open(input_file) as f:
message = f.read()
hash_digest = self.get_hash(message)
plaintext = self.encryptor.decrypt(ciphertext)
if plaintext == hash_digest:
return False
else:
return True
def sign(self):
"""
Signing method.
:return: signature
"""
_hash = SHA_2(self._sha, self._message).hash()
rsa = RSA(self._rsa_key, None)
self._rsa = rsa
# sign
signature = pkcs1_15.new(self._rsa.private_key).sign(_hash)
# write signature to the file
Helper.write_signature(['SHA-2', 'RSA'], [hex(int(self._sha)), hex(self._rsa.private_key.size_in_bits())], signature, Constants.signature_path)
self._signature = signature
def command_line():
'''Command line wrapper for RSA.py.'''
parser = argparse.ArgumentParser(
description='Command line interface for RSA encryption')
parser.add_argument('-n',
'--new-keys',
action='store_true',
help='Whether or not new keys should be generated.')
parser.add_argument('-m',
'--message',
action='store',
type=str,
help='Message to be encoded.')
parser.add_argument('-c',
'--coded-message',
action='store',
type=str,
help='Location of message to be decoded.')
parser.add_argument('-k',
'--key-files',
action='store',
type=str,
help='TODO')
parser.add_argument('-s',
'--store-keys',
action='store',
type=str,
help='Desired file location for output of keys')
arguments = parser.parse_args()
if arguments.new_keys:
rsa = RSA(arguments.store_keys)
rsa.RSA_keygen()
if arguments.message:
rsa = RSA(arguments.store_keys)
rsa.RSA_encode(arguments.message, arguments.key_files)
if arguments.coded_message:
rsa = RSA(arguments.store_keys)
message = rsa.RSA_decode(arguments.coded_message, arguments.key_files)
print(message)
def test2():
rsa = RSA()
rsa.e = 3
rsa.d = 2011
rsa.n = 3127
message = "hello"
print("Test known values e={}, d={}, n={}".format(rsa.e, rsa.d, rsa.n))
print("Message: " + message)
enc = rsa.encrypt(message)
print("Encrypted message: " + enc)
dec = rsa.decrypt(enc)
print("Decrypted message: " + dec)
sig = "andres"
print("Signature: " + sig)
dec2 = rsa.decrypt(sig, True)
print("Generated Signature: " + dec2)
auth = rsa.encrypt(dec2, True)
print("After Authentication: " + auth)
def test():
rsa = RSA()
rsa.e = 3
rsa.d = 2011
rsa.n = 3127
message = "hello"
print("Test known values e={}, d={}, n={}".format(rsa.e, rsa.d, rsa.n))
print("Message to encrypt/decrypt: " + message)
enc = rsa.encrypt(message)
print("Encrypted message: " + enc)
dec = rsa.decrypt(enc)
print("Decrypted message: " + dec)
class Bob:
def __init__(self,y,keys):
self.y = y
self.rsa = RSA(keys)
self.util = Utilities()
def computation(self,c1,m1,p):
m2 = list()
for i in range(xr+1):
if i ==0:
m2.append(-1)
continue
m2.append(self.rsa.decrypt(c1+i))
self.m2 = m2
count = 1
random.seed(datetime.now())
while count != 0:
count = 0
self.p =p
# input("p ki toh")
z= list(range(xr+1))
for i in range(1,xr+1):
z[i] = self.m2[i] %self.p
for i in range(1,xr+1):
for j in range(1,xr+1):
if(abs(z[i]-z[j]) < 2 and i!=j ):
print(i , " ",j )
count += 1
input("enter to contuneue")
break
if count >0:
break
self.z = z
for i in range(1,xr+1):
if i>y:
self.z[i] = self.z[i]+1
return (self.z,self.p)
def getZ(self):
return self.z
def getResult(self, response):
if response:
print("Value of Alice is greater than Bob's")
else:
print("Bob's value is greater than Alice's")
def run(self):
global Globalvariable
while 1:
message_recu = self.connexion.recv(1024).decode("Utf8")
if message_recu[0:14] == "##Rsapubkeyis#":
if not Globalvariable['RSA_Recieved']:
message = message_recu[14:].split("#")
Globalvariable['OtherRsaE'], Globalvariable[
'OtherRsaN'] = int(message[0]), int(message[1])
self.connexion.send("##YesRsa".encode("Utf8"))
Rsa = RSA()
Globalvariable["EncRC4Key"] = Rsa.crypt(
Globalvariable["OtherRsaE"],
Globalvariable["OtherRsaN"], Globalvariable["RC4Key"])
Globalvariable['RSA_Recieved'] = True
color_print(
"Public Anahtarı -->" +
str(Globalvariable["OtherRsaE"]) +
str(Globalvariable["OtherRsaN"]), 'red')
color_print(
"RC4 Private Anahtarı -->" + Globalvariable["RC4Key"],
'red')
color_print(
"Şifrelenmiş Anahtar -->" +
str(Globalvariable["EncRC4Key"]), 'red')
else:
self.connexion.send("##YesRsa".encode("Utf8"))
elif message_recu == "##YesRsa":
Globalvariable['RSA_Sent'] = True
elif message_recu[:6] == "##RC4#":
if Globalvariable["OtherRC4"] == "":
Rsa = RSA()
Globalvariable["OtherRC4"] = Rsa.decrypt(
Globalvariable["d"], Globalvariable["n"],
int(message_recu[6:]))
self.connexion.send("##YesRC4".encode("Utf8"))
else:
self.connexion.send("##YesRC4".encode("Utf8"))
elif message_recu == "##YesRC4":
if not Globalvariable["RC4_sent"]:
Globalvariable["RC4_sent"] = True
elif Globalvariable['RSA_Sent'] and Globalvariable[
'RSA_Recieved'] and message_recu[
0:
14] != "##Rsapubkeyis#" and message_recu != "##YesRsa" and message_recu != "##YesRC4":
Rc44 = RC4()
Rc44.shuffle(str(Globalvariable["OtherRC4"]))
message = Rc44.Crypt(message_recu)
color_print("Mesaj -->" + message, 'yellow')
color_print("Şifrelenmiş Mesaj -->" + message_recu, 'blue')
class Alice:
def __init__(self,x,keys):
self.x = x
self.rsa = RSA(keys)
self.util = Utilities()
def computation(self,bobKey,m1):
self.m1 = m1
self.c = self.rsa.encrypt(self.m1,PUKY=bobKey)
self.c1 = self.c - self.x
return self.c1
def generateResults(self,z,p):
if z[self.x ]%p == self.m1 % p :
return False
return True
def __init__(self, HOST, PORT, NICK):
super(ClientThread, self).__init__()
self.ONLINE_LIST = []
self.nick = NICK
self.cbox = None
self.RSA_Scheme = RSA()
self.BREA_Scheme = BREA()
self.receiver = "broadcast"
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sep = chr(7)
self.broadcast = 1
self.HOST = socket.gethostbyname(str(HOST))
self.PORT = PORT
self.isconnected = 1
self.root = 0
self.online_list = []
try:
self.sock.connect((self.HOST, self.PORT))
except:
self.isconnected = 0
'''
Created on 26 nov. 2015
@author: yo
'''
from RSA import RSA
import time
if __name__ == '__main__':
rsa = RSA()
#truc=rsa.primeFactorsDecomposition(1234567890123456789)
a={1:2,3:9}
a=5
truc=0
start_time = time.time()
#truc=rsa.pollard(26915353)
elapsed_time = time.time() - start_time
print(elapsed_time)
print(truc)
start_time = time.time()
truc=rsa.quadraticSieve(10585477741304331)
elapsed_time = time.time() - start_time
print(truc)
print(elapsed_time)
def test_disguise(self):
strr = "iamaboy"
rsa = RSA(0)
num=rsa.disguise(strr)
self.assertEqual("iamaboy", rsa.reveal(num))
class ClientThread(Thread):
def __init__(self, HOST, PORT, NICK):
super(ClientThread, self).__init__()
self.ONLINE_LIST = []
self.nick = NICK
self.cbox = None
self.RSA_Scheme = RSA()
self.BREA_Scheme = BREA()
self.receiver = "broadcast"
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sep = chr(7)
self.broadcast = 1
self.HOST = socket.gethostbyname(str(HOST))
self.PORT = PORT
self.isconnected = 1
self.root = 0
self.online_list = []
try:
self.sock.connect((self.HOST, self.PORT))
except:
self.isconnected = 0
def reconnect(self):
try:
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.connect((self.HOST, self.PORT))
self.sock.send('2' + self.sep + self.nick + self.sep + self.RSA_Scheme.getPublicKey())
data = self.sock.recv(4096)
self.online_list = data.split(self.sep)
if self.online_list[0] == '2':
for i in range(1, len(self.online_list), 2):
self.cbox.online.addItem(self.online_list[i])
self.ONLINE_LIST.append((self.online_list[i], self.online_list[i+1]))
except:
pass
def run(self):
while True:
try:
msg = self.sock.recv(4096)
except:
self.ONLINE_LIST = []
self.online_list = []
self.cbox.online.clear()
self.reconnect()
continue
ins = msg.split(self.sep)
if ins[0] == '1':
if self.cbox.connected.text() == "Connected to " + ins[1]:
self.cbox.connected.setText("Connected to <No User>")
for i in range(self.cbox.online.count()):
if self.cbox.online.item(i).text() == ins[1]:
self.cbox.online.takeItem(i)
break
for i in self.ONLINE_LIST:
if i[0] == ins[1]:
self.ONLINE_LIST.remove(i)
break
elif ins[0] == '2':
for i in range(1, len(ins), 2):
self.cbox.online.addItem(ins[i])
self.ONLINE_LIST.append((ins[i], ins[i+1]))
elif ins[0] == '3':
if ins[2] == self.nick or self.root == 1:
key = ins[4]
msg = self.BREA_Scheme.decrypt(ins[3], self.RSA_Scheme.decrypt(key))
self.cbox.win.append("[" + ins[1] + "] " + msg)
elif ins[0] == "4":
self.cbox.win.append("[" + ins[1] + "] " + ins[2])
def nickValidate(self, txt):
sent = "2" + self.sep + txt + self.sep + self.RSA_Scheme.getPublicKey()
self.sock.send(sent)
ret = self.sock.recv(4096)
ret = ret.split(self.sep)
self.online_list = ret
return ret
