Francois Lesueur
2 years ago
2 changed files with 381 additions and 0 deletions
@ -0,0 +1,131 @@ |
|||
#!/usr/bin/env python3 |
|||
|
|||
import time |
|||
import sys |
|||
from toolbox import * |
|||
|
|||
# You should tweak these values during the work |
|||
nblogins = 10 # would be larger in real-life |
|||
nbpasswords = 1000000 # would be larger in real-life |
|||
nbiterations = 10 # 10000 is currently recommended, should be adapted to the usecase and changed with time (improvement of computation power), like a key size |
|||
|
|||
|
|||
############################################ |
|||
# Part of the script to edit # |
|||
############################################ |
|||
|
|||
# Hint : you can call decrypt(key,data) to decrypt data using key |
|||
def crackencrypted(database): |
|||
key = readfile("enckey")[0] |
|||
crackeddb = [] |
|||
for i in database: |
|||
# i[0] is the login, i[1] is the encrypted password |
|||
#... |
|||
crackeddb.append((i[0],i[1])) # second argument should contain cleartext password |
|||
return crackeddb |
|||
|
|||
# Hint : - genshahashes(passwords) returns all the hashes of passwords dictionary |
|||
# - getpassfromshahash(hashes, hash) returns the password which hashed as "hash" in hashes |
|||
def cracksha(database): |
|||
global nbpasswords |
|||
passwords = getPassDict(nbpasswords) # passwords contains a dictionary of passwords |
|||
#... |
|||
crackeddb = [] |
|||
for i in database: |
|||
# i[0] is the login, i[1] is the hashed password |
|||
#... |
|||
crackeddb.append((i[0],i[1])) # second argument should contain cleartext password |
|||
return crackeddb |
|||
|
|||
# Hint : salthash(password, salt) return the salted hash of password |
|||
def cracksaltedsha(database): |
|||
global nbpasswords |
|||
passwords = getPassDict(nbpasswords) |
|||
crackeddb = [] |
|||
for i in database: |
|||
# i[0] is the login, i[1] is the hashed password, i[2] is the salt |
|||
#... |
|||
crackeddb.append((i[0],i[1])) # second argument should contain cleartext password |
|||
return crackeddb |
|||
|
|||
# Hint : pbkdf2(password, salt, nbiterations) returns the pbkdf2 of password using salt and nbiterations |
|||
def crackpbkdf2(database): |
|||
global nbpasswords |
|||
passwords = getPassDict(nbpasswords) |
|||
crackeddb = [] |
|||
for i in database: |
|||
# i[0] is the login, i[1] is the hashed password, i[2] is the salt, i[3] is the iteration count |
|||
#... |
|||
crackeddb.append((i[0],i[1])) # second argument should contain cleartext password |
|||
return crackeddb |
|||
|
|||
|
|||
|
|||
############################################ |
|||
# Nothing to change after this line ! # |
|||
############################################ |
|||
|
|||
|
|||
if __name__ == '__main__': |
|||
# When called with init |
|||
if len(sys.argv) > 1 and sys.argv[1] == "init": |
|||
initworkspace(nblogins,nbpasswords,nbiterations) |
|||
print("Workspace initialized in files/ subdirectory") |
|||
exit(0) |
|||
|
|||
# Test whether init has been called before |
|||
try : |
|||
readfile("plain") |
|||
except FileNotFoundError: |
|||
initworkspace(nblogins,nbpasswords,nbiterations) |
|||
print("Workspace initialized in files/ subdirectory") |
|||
|
|||
# test plain DB |
|||
print("\n============\nPlain storage:") |
|||
plaindb = readfile("plain") |
|||
print("Plain DB is : " + str(plaindb)) |
|||
print("Authenticating with plain DB : " + str(authplain(plaindb[0][0],plaindb[0][1],plaindb))) |
|||
|
|||
#test encrypted db |
|||
print("\n============\nEncrypted storage:") |
|||
encdb = readfile("enc") |
|||
print("Encrypted DB is " + str(encdb)) |
|||
print("Authenticating with encrypted DB : " + str(authencrypted(plaindb[1][0],plaindb[1][1],encdb))) |
|||
start = time.time() |
|||
crackedenc = crackencrypted(encdb) |
|||
end = time.time() |
|||
print("Time to crack encrypted DB : " + str(end-start) + " seconds") |
|||
print("Cracked encrypted DB is " + str(crackedenc)) |
|||
|
|||
#test SHA db |
|||
print("\n============\nSHA storage:") |
|||
shadb = readfile("sha") |
|||
print("SHA DB is " + str(shadb)) |
|||
print("Authenticating with SHA DB : " + str(authsha(plaindb[0][0],plaindb[0][1],shadb))) |
|||
start = time.time() |
|||
crackedsha = cracksha(shadb) |
|||
end = time.time() |
|||
print("Time to crack SHA DB : " + str(end-start) + " seconds") |
|||
print("Cracked SHA DB is " + str(crackedsha)) |
|||
|
|||
#test Salted SHA db |
|||
print("\n============\nSalted SHA storage:") |
|||
saltedshadb = readfile("saltedsha") |
|||
print("Salted SHA DB is " + str(saltedshadb)) |
|||
print("Authenticating with Salted SHA DB : " + str(authsaltedsha(plaindb[0][0],plaindb[0][1],saltedshadb))) |
|||
start = time.time() |
|||
crackedsaltedsha = cracksaltedsha(saltedshadb) |
|||
end = time.time() |
|||
print("Time to crack salted SHA DB : " + str(end-start) + " seconds") |
|||
print("Cracked salted SHA DB is " + str(crackedsaltedsha)) |
|||
|
|||
# test PBKDF2 DB |
|||
print("\n============\nPBKDF2 storage:") |
|||
pbkdf2db = readfile("pbkdf2") |
|||
print("PBKDF2 DB is " + str(pbkdf2db)) |
|||
print("Authenticating with PBKDF2 DB : " + str(authpbkdf2(plaindb[0][0],plaindb[0][1],pbkdf2db))) |
|||
start = time.time() |
|||
crackedpbkdf2 = crackpbkdf2(pbkdf2db) |
|||
end = time.time() |
|||
print("Time to crack PBKDF2 DB : " + str(end-start) + " seconds") |
|||
print("Cracked PBKDF2 DB is " + str(crackedpbkdf2)) |
|||
@ -0,0 +1,250 @@ |
|||
#!/usr/bin/env python3 |
|||
|
|||
# Avoir une lib avec des briques prêtes |
|||
# Avoir un script qui crée les fichiers de password SHA/PB/etc. pour pouvoir les manipuler en texte |
|||
# TD : associer les briques pour évaluer les attaques sur un pass / une base |
|||
# mettre un « except ImportError » et ressayer avec « Cryptodome » a la place de « Crypto » |
|||
|
|||
import re |
|||
import time |
|||
import random |
|||
import hashlib |
|||
# tweak to (try to) handle different crypto lib naming across systems (Linux, Mac, Win) |
|||
try: |
|||
from Crypto.Cipher import AES |
|||
from Crypto import Random |
|||
except ImportError: |
|||
try: |
|||
from crypto.Cipher import AES |
|||
from crypto import Random |
|||
except ImportError: |
|||
from Cryptodome.Cipher import AES |
|||
from Cryptodome import Random |
|||
import base64 |
|||
import os |
|||
import urllib.request |
|||
import string |
|||
|
|||
# returns an array of a dictionary of passwords |
|||
def getPassDict(nbpasswords): |
|||
try: |
|||
f = open("files/passwords.txt") |
|||
except FileNotFoundError: |
|||
print("Downloading a passwords list...") |
|||
urllib.request.urlretrieve("https://github.com/danielmiessler/SecLists/blob/master/Passwords/Common-Credentials/10-million-password-list-top-1000000.txt?raw=true", "files/passwords.txt") |
|||
print("Done !") |
|||
f = open("files/passwords.txt") |
|||
passwords = [] |
|||
#nbpasswords = 10000 |
|||
passtogen = nbpasswords |
|||
for password in f: |
|||
passwords.append(password.strip()) |
|||
passtogen-=1 |
|||
if passtogen == 0: |
|||
break |
|||
return passwords |
|||
|
|||
def genRandomPassword(): |
|||
length = 6 |
|||
chars = string.ascii_letters + string.digits |
|||
return ''.join(random.choice(chars) for i in range(length)) |
|||
|
|||
# reads/writes shadow-style files |
|||
def readfile(filename): |
|||
f = open("files/"+filename) |
|||
res = [] |
|||
for line in f: |
|||
output = line.strip().split(":") |
|||
res.append(output) |
|||
return res |
|||
|
|||
def writeFile(filename, array): |
|||
f = open("files/"+filename,'w') |
|||
for line in array: |
|||
towrite = "" |
|||
for item in line: |
|||
towrite+=item + ":" |
|||
towrite = towrite[:-1] |
|||
f.write(towrite) |
|||
f.write('\n') |
|||
|
|||
|
|||
# Plain storage |
|||
def genplain(nblogins,nbpasswords): |
|||
passwords = getPassDict(nbpasswords) |
|||
logins = [] |
|||
for i in range(0,nblogins): |
|||
login = "user" + str(i) |
|||
if (random.randint(0,10) < 4): |
|||
logins.append((login,passwords[random.randint(0,len(passwords)-1)])) |
|||
else: |
|||
logins.append((login,genRandomPassword())) |
|||
return logins |
|||
|
|||
def authplain(login, passwd, database): |
|||
for i in database: |
|||
if i[0] == login: |
|||
current = i[1] |
|||
return (current == passwd) |
|||
|
|||
# Encrypted storage |
|||
def genencrypted(logins): |
|||
encdb = [] |
|||
key = Random.new().read(16) |
|||
iv = Random.new().read(AES.block_size) |
|||
f = open("files/enckey",'wb') |
|||
f.write((base64.b64encode(key))) |
|||
f.write(b":") |
|||
#f = open("files/enciv",'wb') |
|||
f.write((base64.b64encode(iv))) |
|||
for i in logins: |
|||
cipher = AES.new(key, AES.MODE_CFB, iv) |
|||
enc = (base64.b64encode(cipher.encrypt(i[1].encode('utf-8')))).decode("utf-8") |
|||
encdb.append((i[0],enc)) |
|||
#print(enc) |
|||
return encdb |
|||
|
|||
def authencrypted(login, passwd, database): |
|||
for i in database: |
|||
if i[0] == login: |
|||
current = i[1] |
|||
keyiv = readfile("enckey")[0] |
|||
key = base64.b64decode(keyiv[0]) |
|||
iv = base64.b64decode(keyiv[1]) |
|||
#key = base64.b64decode(readfile("enckey")[0][0]) |
|||
#iv = base64.b64decode(readfile("enciv")[0][0]) |
|||
cipher = AES.new(key, AES.MODE_CFB, iv) |
|||
return (passwd == cipher.decrypt(base64.b64decode(current)).decode('utf-8')) |
|||
|
|||
def decrypt(keyiv,data): |
|||
key = base64.b64decode(keyiv[0]) |
|||
iv = base64.b64decode(keyiv[1]) |
|||
cipher = AES.new(key, AES.MODE_CFB, iv) |
|||
return cipher.decrypt(base64.b64decode(data)).decode('utf-8') |
|||
|
|||
|
|||
# SHA storage |
|||
def gensha(logins): |
|||
db = [] |
|||
for i in logins: |
|||
csum = hashlib.sha256(i[1].encode('utf-8')).hexdigest() |
|||
db.append((i[0],csum)) |
|||
return db |
|||
|
|||
def authsha(login, passwd, database): |
|||
for i in database: |
|||
if i[0] == login: |
|||
current = i[1] |
|||
return (current == hashlib.sha256(passwd.encode('utf-8')).hexdigest()) |
|||
|
|||
def genshahashes(passwords): |
|||
hashes = [] |
|||
for passwd in passwords: |
|||
hashes.append([hashlib.sha256(passwd.encode('utf-8')).hexdigest(),passwd]) |
|||
return hashes |
|||
|
|||
def getpassfromshahash(hashes, hash): |
|||
for j in hashes: |
|||
if j[0] == hash: |
|||
return j[1] |
|||
return None |
|||
|
|||
# Salted SHA storage |
|||
def gensaltedsha(logins): |
|||
db = [] |
|||
for i in logins: |
|||
salt = str(random.randint(0,65535)) |
|||
csum = hashlib.sha256((i[1]+salt).encode('utf-8')).hexdigest() |
|||
db.append((i[0],csum,salt)) |
|||
return db |
|||
|
|||
def authsaltedsha(login, passwd, database): |
|||
for i in database: |
|||
if i[0] == login: |
|||
current = i[1] |
|||
salt = i[2] |
|||
return (current == hashlib.sha256((passwd+salt).encode('utf-8')).hexdigest()) |
|||
|
|||
def salthash(password,salt): |
|||
return hashlib.sha256((password+str(salt)).encode('utf-8')).hexdigest() |
|||
|
|||
# PBKDF2 storage |
|||
def genpbkdf2(logins,nbiterations): |
|||
db = [] |
|||
for i in logins: |
|||
salt = str(random.randint(0,65535)) |
|||
csum = base64.b64encode(hashlib.pbkdf2_hmac('sha256',i[1].encode('utf-8'),str(salt).encode('utf-8'),nbiterations)).decode('utf-8') |
|||
db.append((i[0],csum,salt,str(nbiterations))) |
|||
return db |
|||
|
|||
def authpbkdf2(login, passwd, database): |
|||
for i in database: |
|||
if i[0] == login: |
|||
current = i[1] |
|||
salt = i[2] |
|||
nbiterations = int(i[3]) |
|||
return (base64.b64decode(current) == hashlib.pbkdf2_hmac('sha256',passwd.encode('utf-8'),str(salt).encode('utf-8'),nbiterations)) |
|||
|
|||
def pbkdf2(password,salt,nbiterations): |
|||
nbiterations = int(nbiterations) |
|||
return base64.b64encode(hashlib.pbkdf2_hmac('sha256',password.encode('utf-8'),str(salt).encode('utf-8'),nbiterations)).decode('utf-8') |
|||
|
|||
|
|||
# Generate shadow-style files |
|||
def initworkspace(nblogins,nbpasswords,nbiterations): |
|||
print("Generating " + str(nblogins) + " logins and " + str(nbpasswords) + " passwords") |
|||
try : |
|||
os.mkdir("files") |
|||
except FileExistsError: |
|||
pass |
|||
plaindb = genplain(nblogins,nbpasswords) |
|||
writeFile("plain", plaindb) |
|||
encdb = genencrypted(plaindb) |
|||
writeFile("enc", encdb) |
|||
shadb = gensha(plaindb) |
|||
writeFile("sha", shadb) |
|||
saltedshadb = gensaltedsha(plaindb) |
|||
writeFile("saltedsha", saltedshadb) |
|||
pbkdf2db = genpbkdf2(plaindb,nbiterations) |
|||
writeFile("pbkdf2", pbkdf2db) |
|||
|
|||
|
|||
|
|||
# Unit tests |
|||
if __name__ == '__main__': |
|||
# create shadow files |
|||
initworkspace(10,100,1000) |
|||
|
|||
print("======\nUnit tests of the toolbox, you must work in skeleton.py\n=========") |
|||
|
|||
# test plain DB |
|||
print("\n============\nPlain storage:") |
|||
plaindb = readfile("plain") |
|||
print("Plain DB is : " + str(plaindb)) |
|||
print("Authenticating with plain DB : " + str(authplain(plaindb[0][0],plaindb[0][1],plaindb))) |
|||
|
|||
#test encrypted db |
|||
print("\n============\nEncrypted storage:") |
|||
encdb = readfile("enc") |
|||
print("Encrypted DB is " + str(encdb)) |
|||
print("Authenticating with encrypted DB : " + str(authencrypted(plaindb[1][0],plaindb[1][1],encdb))) |
|||
|
|||
#test SHA db |
|||
print("\n============\nSHA storage:") |
|||
shadb = readfile("sha") |
|||
print("SHA DB is " + str(shadb)) |
|||
print("Authenticating with SHA DB : " + str(authsha(plaindb[0][0],plaindb[0][1],shadb))) |
|||
|
|||
#test Salted SHA db |
|||
print("\n============\nSalted SHA storage:") |
|||
saltedshadb = readfile("saltedsha") |
|||
print("Salted SHA DB is " + str(saltedshadb)) |
|||
print("Authenticating with Salted SHA DB : " + str(authsaltedsha(plaindb[0][0],plaindb[0][1],saltedshadb))) |
|||
|
|||
# test PBKDF2 DB |
|||
print("\n============\nPBKDF2 storage:") |
|||
pbkdf2db = readfile("pbkdf2") |
|||
print("PBKDF2 DB is " + str(pbkdf2db)) |
|||
print("Authenticating with PBKDF2 DB : " + str(authpbkdf2(plaindb[0][0],plaindb[0][1],pbkdf2db))) |
|||
|
|||
print("\n======\nUnit tests of the toolbox, you must work in skeleton.py\n=========") |
|||
Loading…
Reference in new issue