def authenticating_server():
client_id = request.headers.get('id')
print('Request from Client ID ' + str(client_id))
client = Clients.query.filter_by(id=client_id).scalar()
if not client:
return make_response('Client not valid, dropping connection', 400)
tgs = TGS.query.filter_by(is_available=1).scalar()
if not tgs:
return make_response('Client not valid, dropping connection', 400)
client_secret_key = hashlib.md5(client.password.encode('utf-8'))
print(client_secret_key)
global tgs_secret_key
tgs_secret_key = hashlib.md5(tgs.password.encode('utf-8'))
sk1 = "".join(
random.choice(string.ascii_uppercase + string.ascii_lowercase +
string.digits) for _ in range(16))
print("Session key 1 " + sk1)
encryption_obj = AES.new(client_secret_key.hexdigest().encode(),
AES.MODE_CBC,
client_secret_key.hexdigest()[:16].encode())
# encrypted_sk1 = encryption_obj.encrypt(sk1)
life_span = 1000
tgt = "".join(
str(client_id) + ' ' + str(request.remote_addr) + ' ' +
str(life_span) + ' ' + str(datetime.now()) + ' ' + sk1)
print("Generating TGT")
print(tgt)
encryption_obj = AES.new(tgs_secret_key.hexdigest().encode(), AES.MODE_CBC,
tgs_secret_key.hexdigest()[:16].encode())
padded_tgt = Padding.appendPadding(tgt, AES.block_size, mode='CMS')
encrypted_tgt = encryption_obj.encrypt(padded_tgt)
response = {"sk1": sk1, "tgt": base64.b64encode(encrypted_tgt).decode()}
encryption_obj = AES.new(client_secret_key.hexdigest().encode(),
AES.MODE_CBC,
client_secret_key.hexdigest()[:16].encode())
padded_response = Padding.appendPadding(json.dumps(response),
AES.block_size,
mode='CMS')
encrypted_response = encryption_obj.encrypt(padded_response)
print(response)
return make_response(
{'data': base64.b64encode(encrypted_response).decode()}, 200)
def tgs():
data = request.headers
encrypted_authenticator = base64.b64decode(data.get('authenticator'))
encrypted_tgt = base64.b64decode(data.get('tgt'))
decryption_obj = AES.new(tgs_secret_key.hexdigest().encode(), AES.MODE_CBC,
tgs_secret_key.hexdigest()[:16].encode())
tgt = decryption_obj.decrypt(encrypted_tgt).decode()
sk1 = tgt.split(' ')[-1]
sk1 = sk1[:16]
decryption_obj = AES.new(sk1, AES.MODE_CBC, sk1)
authenticator = decryption_obj.decrypt(
encrypted_authenticator).decode().strip()[1:]
if (tgt.split(' ')[0] != authenticator.split(' ')[0]) or (
tgt.split(' ')[1] != authenticator.split(' ')[1]):
return make_response('Client not valid, dropping connection', 400)
sk2 = "".join(
random.choice(string.ascii_uppercase + string.ascii_lowercase +
string.digits) for _ in range(16))
print("Session key 2 " + sk2)
service_ticket = "".join(
str(tgt.split(' ')[0]) + ' ' + str(tgt.split(' ')[1]) + ' ' +
str(datetime.now()) + ' ' + sk2)
print("Generating Service ticket")
print(service_ticket)
encryption_obj = AES.new(server_secret_key.hexdigest().encode(),
AES.MODE_CBC,
server_secret_key.hexdigest()[:16].encode())
padded_service_ticket = Padding.appendPadding(service_ticket,
AES.block_size,
mode='CMS')
encrypted_service_ticket = encryption_obj.encrypt(padded_service_ticket)
response = {
"sk2": sk2,
"service_ticket": base64.b64encode(encrypted_service_ticket).decode()
}
encryption_obj = AES.new(sk1, AES.MODE_CBC, sk1)
padded_response = Padding.appendPadding(json.dumps(response),
AES.block_size,
mode='CMS')
encrypted_response = encryption_obj.encrypt(padded_response)
print(response)
return make_response(
{'data': base64.b64encode(encrypted_response).decode()}, 200)
def encrypt_header(self):
key = "@xyzprinting.com"
iv = chr(0) * 16
aes = AESCipher(key, mode=MODE_CBC, IV=iv)
text = self.gcode.header_text
header = Padding.appendPadding(text)
return aes.encrypt(header)
def encrypt(self):
key = "@[email protected]"
iv = chr(0) * 16
aes = AESCipher(key, mode=MODE_ECB, IV=iv)
fulltext = self.gcode.text
padded = Padding.appendPadding(fulltext)
enc_text = aes.encrypt(padded)
magic = "3DPFNKG13WTW"
magic2 = struct.pack("8B", 1, 2, 0, 0, 0, 0, 18, 76)
blanks = chr(0) * 4684
tag = "TagEJ256"
magic3 = struct.pack("4B", 0, 0, 0, 68)
crc32 = binascii.crc32(enc_text)
crcstr = struct.pack(">l", crc32)
encrypted_header = self.encrypt_header()
bio = BytesIO()
bio.write(magic)
bio.write(magic2)
bio.write(blanks)
bio.write(tag)
bio.write(magic3)
bio.write(crcstr)
bio.write((chr(0) * (68 - len(crcstr))))
log.debug("Length of encrypted header: {}".format(
len(encrypted_header)))
if len(encrypted_header) > (8192 - bio.tell()):
log.error("Header is too big to fit file format!")
bio.write(encrypted_header)
left = 8192 - bio.tell()
bio.write((chr(0) * left))
bio.write(enc_text)
return bio.getvalue()
def encrypt(plaintext='', key=llave, iv=vector):
if plaintext != '':
plaintext = Padding.appendPadding(plaintext,
blocksize=Padding.AES_blocksize,
mode=0)
encobj = AES.new(key, AES.MODE_OFB, iv)
return (binascii.b2a_base64(encobj.encrypt(plaintext)))
else:
return plaintext
def encrypt(key, plaintext):
assert key
if plaintext == "":
return ""
aes = AES.new(key, AES.MODE_CBC, b"Polychart AES IV")
padded = Padding.appendPadding(plaintext)
cipherbytes = aes.encrypt(padded)
return urlsafe_b64encode(cipherbytes)
def encrypt(key, plaintext):
assert key
if plaintext == "":
return ""
aes = AES.new(key, AES.MODE_CBC, b"Polychart AES IV")
padded = Padding.appendPadding(plaintext)
cipherbytes = aes.encrypt(padded)
return urlsafe_b64encode(cipherbytes)
def encrypt(self, data): # TODO
import Padding
output = ''
passwd = CONFIG.master_passwd
# now, encrypt
padded_data = Padding.appendPadding(data)
iv = ''.join(chr(random.randint(0, 0xff)) for i in range(16)) # random vector
encryptor = AES.new(hashlib.sha256(passwd).digest(), AES.MODE_CBC, iv)
size = len(data)
output += iv
output += encryptor.encrypt(padded_data)
return output
def encrypt(self, data): # TODO
import Padding
output = ''
passwd = CONFIG.master_passwd
# now, encrypt
padded_data = Padding.appendPadding(data)
iv = ''.join(chr(random.randint(0, 0xff))
for i in range(16)) # random vector
encryptor = AES.new(hashlib.sha256(passwd).digest(), AES.MODE_CBC, iv)
size = len(data)
output += iv
output += encryptor.encrypt(padded_data)
return output
def talker():
pub = rospy.Publisher('chatter1', String, queue_size=10)
rospy.init_node('talker_new', anonymous=True)
rate = rospy.Rate(50) # 10hz
a = ""
for i in range(0,size):
a = a + "a"
rospy.loginfo(sys.getsizeof(a))
while not rospy.is_shutdown():
a = ""
for i in range(0,size):
a = a + "a"
time = rospy.get_time()
hello_str = str(encrypt(Padding.appendPadding(a,mode='CMS'), key, AES.MODE_CBC, salt)) + "|" + str(time)
rospy.loginfo(hello_str)
pub.publish(hello_str)
def cipherBlock(tag):
if tag not in block.keys():
return redirect(url_for('index'))
from base64 import b64encode, b64decode
tmp, src, dest, key, iv = '', '', '', b'', b''
if request.method == 'POST':
tmp = src = request.form['src']
key = request.form['key'].encode()
iv = request.form['iv'].encode()
mode = request.form['mode']
padding = request.form['padding']
c = block[str(tag)]
try:
if mode == 'ECB' or mode == 'CBC' or mode == 'CFB':
src = Padding.appendPadding(src, c.block_size, padding)
cipher = c.new(key, cipherMode[mode], iv)
if 'encrypt' in request.url:
dest = cipher.encrypt(src.encode())
dest = b64encode(dest).decode()
else:
src = b64decode(src.encode())
dest = cipher.decrypt(src).decode()
dest = Padding.removePadding(dest)
except Exception as e:
dest = e
if 'encrypt' in request.url:
return render_template('cipherBlock.html',
tag=escape(tag.upper()),
flag='Encrypt',
src=escape(tmp),
dest=escape(dest),
key=escape(key.decode()),
iv=escape(iv.decode()))
else:
return render_template('cipherBlock.html',
tag=escape(tag.upper()),
flag='Decrypt',
src=escape(tmp),
dest=escape(dest),
key=escape(key.decode()),
iv=escape(iv.decode()))
def handleSendChat(self):
if self.serverStatus == 0:
self.setStatus("Set server address first")
return
msg = self.chatVar.get().replace(' ', ' ').encode('cp1252')
iv = '0123456789ABCDEF'
senha = 'secretkey'
senha1 = hashlib.sha256(senha).digest()
aes1 = AES.new(senha1, AES.MODE_CFB, iv)
plaintext = Padding.appendPadding(msg,
blocksize=Padding.AES_blocksize,
mode=0)
cipher_text = aes1.encrypt(plaintext)
if msg == '':
return
self.addChat("me", msg)
for client in self.allClients.keys():
client.send(cipher_text)
def talker():
pub = rospy.Publisher('cam_data', CompressedImage, queue_size=10)
pub_enc = rospy.Publisher('cam_data_enc', CompressedImage, queue_size=10)
rospy.init_node('drone_cam', anonymous=True)
# rate = rospy.Rate(50) # 10hz
# a = ""
# for i in range(0,size):
# a = a + "a"
# rospy.loginfo(sys.getsizeof(a))
while not rospy.is_shutdown():
msg = CompressedImage()
msg.header.stamp = rospy.Time.now()
msg.format = "jpeg"
msg.data = np.zeros((10, 10)).tostring()
pub.publish(msg)
msg_enc = CompressedImage()
msg_enc.header.stamp = rospy.Time.now()
msg_enc.format = "jpeg"
msg_enc.data = encrypt(
Padding.appendPadding(np.zeros((10, 10)).tostring(), mode='CMS'),
key, AES.MODE_CBC, salt)
pub_enc.publish(msg_enc)
def encrypt(plain_text, key, mode):
enc_obj = AES.new(key, mode)
return enc_obj.encrypt(plain_text)
def decrypt(cipher_text, key, mode):
enc_obj = AES.new(key, mode)
return (enc_obj.decrypt(cipher_text))
print "\nAES"
key = hashlib.sha256(password).digest()
plain_text = Padding.appendPadding(plain_text,
blocksize=Padding.AES_blocksize,
mode='CMS')
print "After padding (CMS): " + binascii.hexlify(bytearray(plain_text))
cipher_text = encrypt(plain_text, key, AES.MODE_ECB)
print "Cipher (ECB): " + binascii.hexlify(bytearray(cipher_text))
plain_text = decrypt(cipher_text, key, AES.MODE_ECB)
plain_text = Padding.removePadding(plain_text, mode='CMS')
print " decrypt: " + plain_text
plain_text = Padding.appendPadding(plain_text,
blocksize=Padding.AES_blocksize,
mode='Null')
print "After padding (Null): " + binascii.hexlify(bytearray(plain_text))
'''
URL: https://pypi.python.org/pypi/Padding
Description: Padding methods for password based encryption
'''
import Padding
msg = 'this'
DES_BS = Padding.DES_blocksize
AES_BS = Padding.AES_blocksize
print "DES has fixed block size of %d bits = %d bytes" % (DES_BS * 8, DES_BS)
padded_msgDES = Padding.appendPadding(msg, DES_BS)
print padded_msgDES.encode('hex'), len(padded_msgDES)
msgDES = Padding.removePadding(padded_msgDES)
print msgDES, len(msgDES)
print
print "AES has fixed block size of %d bits = %d bytes" % (AES_BS * 8, AES_BS)
padded_msgAES = Padding.appendPadding(msg)
print padded_msgAES.encode('hex'), len(padded_msgAES)
msgAES = Padding.removePadding(padded_msgAES)
print msgAES, len(msgAES)
original_message = "Hola mundo"
key = "llavemagica"
salt = "241fa86763b85341"
if (len(sys.argv)>1):
original_message = str(sys.argv[1])
if (len(sys.argv)>2):
key = str(sys.argv[2])
if (len(sys.argv)>3):
salt = str(sys.argv[3])
print ("Mensaje:", original_message)
print ("Key:", key)
print ("Salt:", salt)
paded_original_message = Padding.appendPadding(original_message)
def getKeyIv(key, salt):
ascii_key = key.encode('ascii')
hex_salt = bytearray.fromhex(salt)
mdf = hashlib.md5(ascii_key+hex_salt)
keyiv = mdf.digest()
tmp = [keyiv]
while len(tmp) < 32 + 16:
tmp.append( hashlib.md5(tmp[-1] + ascii_key + hex_salt).digest() )
keyiv += tmp[-1] # append the last byte
key = keyiv[:32]
iv = keyiv[32:32+16]
return key, iv
def encryptAes(msg, key, aes_mode, salt):
encobj = AES.new(key,mode) #Una vez recibidos los parámentros por el costructor, se recoge el key, modo y se le asigna a la variable.
return(encobj.encrypt(plaintext)) #Devolvemos el resultado del cifrado.
def decrypt(ciphertext,key, mode): #Función para encriptar los datos donde recibimos los parámentros del constructor.
encobj = AES.new(key,mode) #Una vez recibidos los parámentros por el costructor, se recoge el key, modo y se le asigna a la variable.
return(encobj.decrypt(ciphertext)) #Devolvemos el resultado del cifrado.
key = hashlib.sha256(password).digest() #Hasheamos la constraseña con sha-256, con la función digest en binario.
iv = hex(ival)[2:8].zfill(16) #Convierte el valor ival a hexadecimal, tomamos los caráracteres incluyendo el 2 caracter y excluyendo el 8 caracter,
#luego se rellena de 0 la cadena hasta completar 16 carácteres.
print("IV: "+iv)
plaintext = Padding.appendPadding(plaintext, blocksize = Padding.AES_blocksize, mode=0) #Rellenamos el texto a cifrar con el bloque de AES.
print("Input data (CMS): " + bytearray(plaintext)) #Nos devuelve una matriz de bytes.
ciphertext = encrypt(plaintext, key, AES.MODE_ECB) #Llamamos la función de encrypt y le pasamos por constructor, el texto a cifrar, la llave del cifrado y
#el modo de cifrado en AES (Hay varios tipos de cifrados para AES.)
print("Cipher (ECB): " + bytearray(b64encode(ciphertext))) #Volvemos a obtener la matriz de bytes del texto ya cifrado pero con formato base64.
plaintext = decrypt(ciphertext, key, AES.MODE_ECB) #Llamamos la función de descifrado y le pasamos por constructor, el texto cifrado, la llave del cifrado y
#el modo de cifrado en AES(Hay varios tipos de cifrados para AES.)
plaintext = Padding.removePadding(plaintext, mode = 0) #Se elimina el relleno de bloques de AES y se elimina el modo de cifrado.
print(" decrypt: " + plaintext)
text = "help"
k = "00000000000000000000"
if (len(sys.argv) > 1):
text = str(sys.argv[1])
if (len(sys.argv) > 2):
k = str(sys.argv[2])
print('Text:\t' + text)
print('Key:\t' + k)
print('--------')
print
key = bytes.fromhex(k)
text = Padding.appendPadding(text, blocksize=8, mode='CMS')
cipher = Present(key)
#start=time.perf_counter()
start1 = time.perf_counter_ns()
encrypted = cipher.encrypt(text.encode())
#end=time.perf_counter()
end1 = time.perf_counter_ns()
#print ("Encrypt time(sec): ",(end-start))
print("Encrypt time(ms): ", ((end1 - start1) / 1000000))
print('Cipher(Hex Encoded):\t' + encrypted.hex())
#start=time.perf_counter()
start1 = time.perf_counter_ns()
except UnicodeDecodeError:
return None, None
def encrypt(plaintext,key, mode,salt):
key,iv=get_key_and_iv(key,salt.decode('hex'))
encobj = AES.new(key,mode,iv)
return(encobj.encrypt(plaintext))
def decrypt(ciphertext,key, mode,salt):
key,iv=get_key_and_iv(key,salt.decode('hex'))
encobj = AES.new(key,mode,iv)
return(encobj.decrypt(ciphertext))
print "Plaintext:\t",plaintext
print "Passphrase:\t",key
print "Salt:\t\t",salt
plaintext = Padding.appendPadding(plaintext,mode='CMS')
ciphertext = encrypt(plaintext,key,AES.MODE_CBC,salt)
ctext = b'Salted__' + salt.decode('hex') + ciphertext
print "\nCipher (CBC): "+base64.b64encode(ctext)
print "Cipher in binary:",ctext
plaintext = decrypt(ciphertext,key,AES.MODE_CBC,salt)
plaintext = Padding.removePadding(plaintext,mode='CMS')
print "\nDecrypted:\t"+plaintext
def text_pad(text, pad_mode):
return Padding.appendPadding(text,
blocksize=Padding.DES_blocksize,
mode=pad_mode)
'''
URL: https://pypi.python.org/pypi/Padding
Description: Padding methods for password based encryption
'''
import Padding
msg = 'this'
DES_BS = Padding.DES_blocksize
AES_BS = Padding.AES_blocksize
print "DES has fixed block size of %d bits = %d bytes" % (DES_BS*8, DES_BS)
padded_msgDES = Padding.appendPadding(msg, DES_BS)
print padded_msgDES.encode('hex'), len(padded_msgDES)
msgDES = Padding.removePadding(padded_msgDES)
print msgDES, len(msgDES)
print
print "AES has fixed block size of %d bits = %d bytes" % (AES_BS*8, AES_BS)
padded_msgAES = Padding.appendPadding(msg)
print padded_msgAES.encode('hex'), len(padded_msgAES)
msgAES = Padding.removePadding(padded_msgAES)
print msgAES, len(msgAES)
print("Compressed public key: ", toProperKey(bankPublicECKey).hex())
# BANK PUBLIC KEY IS SENT TO SGX, THIS HAPPENS IN SGX
ephimeralPrivateKey = 39224536263752937319809063883144929125312957084276525785186738781563829874778 # RANDOM GENERATED
AESSymmetricKey = cv.mul_point(ephimeralPrivateKey, bankPublicECKey).x
print("AES Key in hex:" + hex(AESSymmetricKey))
message = "Scoring A PLUS"
formatedAESSymmetricKey = hashlib.sha256(str(AESSymmetricKey).encode()).digest()
message = Padding.appendPadding(message,blocksize=Padding.AES_blocksize,mode=0)
ciphertext = encrypt(message.encode(),formatedAESSymmetricKey,AES.MODE_ECB) # Change this AES mode to a better one
ephimeralPublicKey = cv.mul_point(ephimeralPrivateKey, g) # TODO RSA
hex_ephemeralPubKey_x = hex(ephimeralPublicKey.x)[2:]
hex_ephemeralPubKey_y = hex(ephimeralPublicKey.y)[2:]
while len(hex_ephemeralPubKey_x) < 64:
hex_ephemeralPubKey_x = "0" + hex_ephemeralPubKey_x
while len(hex_ephemeralPubKey_y) < 64:
hex_ephemeralPubKey_y = "0" + hex_ephemeralPubKey_y
hex_ephemeralPubKey_x = "0x" + hex_ephemeralPubKey_x
hex_ephemeralPubKey_y = "0x" + hex_ephemeralPubKey_y
return cipher.encrypt(pt)
def dec(ct, key, iv):
cipher = AES.new(key, AES.MODE_CBC, iv)
return cipher.decrypt(ct)
key_raw = 'YELLOW SUBMARINE'
block_size = len(key_raw)
iv = chr(0) * block_size
#f = open("cp2-10.txt","ro")
#enc_b64 = ''.join(f.read().strip().split('\n'))
#enc_raw = b64decode(enc_b64)
#print Padding.removePadding(pt, blocksize=block_size, mode='CMS')
#print Padding.removePadding(pt, mode=0)
pt = "Well that's my DJ Deshay cuttin' all them Z's"
#pt = pad_PKCS7(pt, block_size)
pt = Padding.appendPadding(pt, mode=0)
enc_b64 = enc(pt, key_raw, iv)
enc_raw = b64decode(enc_b64)
pt = dec(enc_raw, key_raw, iv)
pt = Padding.removePadding(pt, mode=0)
print enc_b64
print pt
def encrypt(plaintext,key,iv):
plaintext = Padding.appendPadding(plaintext,blocksize=Padding.AES_blocksize,mode=0)
encobj = AES.new(key,AES.MODE_OFB,iv)
return(binascii.b2a_base64(encobj.encrypt(plaintext)))
def solve(user : User, id_challenge):
"""
Runs an attempt of user to solve the challenge
Args:
user (User): User
id_challenge (int): ID of Challenge
"""
challenge = ChallengeCypher.APP.getDBController().getCypherChallenge(id_challenge)
if challenge is None:
crt.writeError("This challenge does not exist.")
crt.pause()
return
crt.writeMessage(f"Submitted by: {challenge['username']}")
crt.writeMessage(f"Algorithm: {challenge['algorithm']}")
crt.writeMessage(f"Crypto: {challenge['answer']}")
crt.writeMessage(f"Plaintext: {challenge['plaintext']}")
crt.writeMessage(f"Tip: {challenge['tip']}")
crt.newLine()
id_user = user.getUserID()
last_try = ChallengeCypher.APP.getDBController().getCypherLastTry(id_user, id_challenge)
curr_time = Clock.now()
if not (last_try is None or Clock.isAfter(curr_time, Clock.addSeconds(last_try, 15))):
crt.writeWarning("Too soon to try again.")
crt.pause()
return None
challenge['plaintext'] = Padding.appendPadding(challenge['plaintext'], blocksize=Padding.AES_blocksize, mode=0)
if challenge['algorithm'] == Cypher.Caesar.TYPE:
proposal_caesar = Read.tryAsInt("Insert your answer (number): ")
proposal = str(proposal_caesar)
else:
proposal = Read.asString("Insert your answer: ")
key = hashlib.md5(proposal.encode()).digest()
iv = challenge['iv']
hmacdb = challenge['hmac']
hmackey = ChallengeCypher.APP.getDBController().getHMACKey()
if challenge['algorithm'] == Cypher.ECB.TYPE:
plaintext = Cypher.ECB.decrypt(base64.b64decode(challenge['answer']), key, AES.MODE_ECB)
elif challenge['algorithm'] == Cypher.CBC.TYPE:
plaintext = Cypher.CBC.decrypt(base64.b64decode(challenge['answer']), key, AES.MODE_CBC, iv.encode())
elif challenge['algorithm'] == Cypher.CTR.TYPE:
plaintext = Cypher.CTR.decrypt(base64.b64decode(challenge['answer']), key, AES.MODE_CTR, iv.encode())
elif challenge['algorithm'] == Cypher.Caesar.TYPE:
plaintext = Cypher.Caesar.decrypt(base64.b64decode(challenge['answer']), proposal_caesar)
elif challenge['algorithm'] == Cypher.OTP.TYPE:
plaintext = Cypher.OTP.decrypt(base64.b64decode(challenge['answer']), proposal)
elif challenge['algorithm'] == Cypher.Vigenere.TYPE:
plaintext = Cypher.Vigenere.decrypt(base64.b64decode(challenge['answer']), proposal).lower()
try:
plaintext = Padding.removePadding(plaintext.decode(),mode=0)
except:
()
msgHMAC = hmac.new(hmackey, plaintext.encode(), hashlib.sha256)
# crt.writeDebug(f"{msgHMAC.hexdigest()} == {hmacdb}")
if (msgHMAC.hexdigest() == hmacdb):
if ChallengeCypher.APP.getDBController().updateCypherChallengeTry(id_user, id_challenge, Clock.now(), True):
crt.writeSuccess("YOU DID IT!")
else:
crt.writeError("You got it, but I could not save the answer.")
else:
if ChallengeCypher.APP.getDBController().updateCypherChallengeTry(id_user, id_challenge, Clock.now(), False):
crt.writeMessage("Better luck next time :(")
else:
crt.writeError("You did NOT got it, but I could not save the answer.")
crt.pause()
def plainTextToByte(plaintext):
plaintext = Padding.appendPadding(plaintext,blocksize=Padding.AES_blocksize,mode=0)
plaintext_byte = plaintext.encode('utf-8')
blockList_byte = [plaintext_byte[i:i+16] for i in range(0, len(plaintext_byte), 16)]
return blockList_byte
def encrypt(plaintext, key, mode):
encobj = AES.new(key, mode)
return (encobj.encrypt(plaintext))
def decrypt(ciphertext, key, mode):
encobj = AES.new(key, mode)
return (encobj.decrypt(ciphertext))
key = hashlib.sha256(password.encode()).digest()
plaintext = Padding.appendPadding(plaintext,
blocksize=Padding.AES_blocksize,
mode='CMS')
print("After padding (CMS): ", binascii.hexlify(bytearray(plaintext.encode())))
ciphertext = encrypt(plaintext.encode(), key, AES.MODE_ECB)
print("Cipher (ECB): ", binascii.hexlify(bytearray(ciphertext)))
plaintext = decrypt(ciphertext, key, AES.MODE_ECB)
plaintext = Padding.removePadding(plaintext.decode(), mode='CMS')
print(" decrypt: ", plaintext)
plaintext = val
plaintext = Padding.appendPadding(plaintext,
def add(user : User, algorithm):
"""
Adds Challenge.
Args:
user (User): Author
algorithm (str): given type of algorithm
Returns:
bool: if not logged in returns false
"""
if not user.isLoggedIn():
return False
val = Read.asString("Message: ")
if algorithm == Cypher.Caesar.TYPE:
password_caesar = Read.tryAsInt("Cypher key (number): ")
password = str(password_caesar)
else:
while True:
password = Read.asString("Cypher key: ")
if (algorithm == Cypher.OTP.TYPE) and (len(val) != len(password)):
crt.writeWarning("Message and cypher key must have same length!")
else:
break
tip = Read.asString("[Optional] Tip / Help: ")
plaintext = val
key = hashlib.md5(password.encode()).digest()
iv = secrets.token_hex(8)
hmackey = ChallengeCypher.APP.getDBController().getHMACKey()
msgHMAC = hmac.new(hmackey, val.encode(), hashlib.sha256).hexdigest()
if algorithm == Cypher.ECB.TYPE:
plaintext = Padding.appendPadding(plaintext, blocksize=Padding.AES_blocksize, mode=0)
ciphertext = Cypher.ECB.encrypt(plaintext.encode(), key, AES.MODE_ECB)
elif algorithm == Cypher.CBC.TYPE:
plaintext = Padding.appendPadding(plaintext, blocksize=Padding.AES_blocksize, mode=0)
ciphertext = Cypher.CBC.encrypt(plaintext.encode(), key, AES.MODE_CBC, iv.encode())
elif algorithm == Cypher.CTR.TYPE:
plaintext = Padding.appendPadding(plaintext,blocksize=Padding.AES_blocksize,mode=0)
ciphertext = Cypher.CTR.encrypt(plaintext.encode(), key, AES.MODE_CTR, iv.encode())
elif algorithm == Cypher.Caesar.TYPE:
ciphertext = Cypher.Caesar.encrypt(plaintext, password_caesar)
elif algorithm == Cypher.OTP.TYPE:
ciphertext = Cypher.OTP.encrypt(plaintext, password)
elif algorithm == Cypher.Vigenere.TYPE:
ciphertext = Cypher.Vigenere.encrypt(plaintext, password)
msg = base64.b64encode(bytearray(ciphertext)).decode()
if ChallengeCypher.APP.getDBController().addCypherChallenge(user.getUserID(), tip, msg, val, iv, msgHMAC, algorithm):
crt.writeSuccess("Challenge submitted successfully!")
else:
crt.writeError("The challenge could not be submitted for unknown reasons.")
crt.pause()
val='hello'
password='******'
plaintext=val
def encrypt(plaintext,key, mode):
encobj = AES.new(key,mode)
return(encobj.encrypt(plaintext))
def decrypt(ciphertext,key, mode):
encobj = AES.new(key,mode)
return(encobj.decrypt(ciphertext))
key = hashlib.sha256(password.encode()).digest()
plaintext = Padding.appendPadding(plaintext,blocksize=Padding.AES_blocksize,mode='CMS')
print("After padding (CMS): ",binascii.hexlify(bytearray(plaintext.encode())))
ciphertext = encrypt(plaintext.encode(),key,AES.MODE_ECB)
print("Cipher (ECB): ",binascii.hexlify(bytearray(ciphertext)))
plaintext = decrypt(ciphertext,key,AES.MODE_ECB)
plaintext = Padding.removePadding(plaintext.decode(),mode='CMS')
print(" decrypt: ",plaintext)
plaintext=val
def init_connection(self, message_tuple):
all_sent_msgs = ''
all_recv_msgs = ''
cert = self.readCertificate(SERVERCERT)
clientNonce = message_tuple[1]
initNonce = keyutils.generate_nonce(28)
if AUTHMETHOD == 'ClientAuth':
reqClientCert = 'CertReq'
else:
reqClientCert = ''
print 'Initiating handshake...'
initMsg = ('ServerInit', initNonce, message_tuple[2], cert,
reqClientCert)
initMsg = pickle.dumps(initMsg)
all_sent_msgs += initMsg
self.smartSend(self.client_sock, initMsg)
data = self.smartRecv(self.client_sock)
all_recv_msgs += data
initResponse = pickle.loads(data)
# VALIDATING CERTIFICATE #
if reqClientCert:
if not self.validate_certificate(initResponse[RECV_CERT]):
print 'Bad Certificate!'
self.client_sock.close()
exit()
return
# DERIVING PUBLIC KEY FROM CERTIFICATE + PRIVATE KEY#
private_key = \
keyutils.read_privkey_from_pem(self.readCertificate(SERVERPRIVKEY))
# COMPUTING SECRET #
rsa_cipher = PKCS1_OAEP.new(private_key)
aes_key = rsa_cipher.decrypt(initResponse[3])
aes_cipher = AES.new(aes_key, AES.MODE_CFB, initResponse[2])
secret = aes_cipher.decrypt(initResponse[1])
# DERIVING KEYS FROM SECRET #
session_key_one = keyutils.create_hmac(secret, initNonce
+ clientNonce + '00000000')
session_key_two = keyutils.create_hmac(secret, initNonce
+ clientNonce + '11111111')
if not self.verifyHash(session_key_two, all_sent_msgs,
initResponse[RECV_CERT - 1]):
print 'BAD HASH'
return
finalMsg = keyutils.create_hmac(session_key_two, all_sent_msgs)
all_sent_msgs += finalMsg
self.smartSend(self.client_sock, finalMsg)
print 'Handshake was succesful. Waiting for command...'
data = self.smartRecv(self.client_sock)
command = pickle.loads(data)
if command[0] == 'GET':
# FINAL STEP #
print 'Received GET command.'
file = open(PAYLOAD, 'r')
file_data = file.read()
init_vector = keyutils.generate_random(16)
aes_cipher = AES.new(session_key_one, AES.MODE_CFB,
init_vector)
file_data = Padding.appendPadding(file_data)
print 'Encrypting file...'
encrypted_data = aes_cipher.encrypt(file_data)
pickle_payload = (init_vector, encrypted_data)
print 'Pickleing payload...'
pickle_payload = pickle.dumps(pickle_payload)
print 'Sending payload...'
self.smartSend(self.client_sock, pickle_payload)
print 'File sent to client.'
