def main():
tag, message = create_msg()
print("Old tag is ", tag)
# keep increasing your test length by a byte and see if it succeeds
# [key] [original msg] | [padd]
for i in range(1, POSSIBLE_BLOCKS):
new_digest = SHA1.SHA1()
new_digest.update_hashes(tag, POSSIBLE_BLOCKS)
new_digest.Update(new_msg)
new_tag = new_digest.Sum()
print("New tag is ", new_tag)
for j in range(1, SHA1.PROCESS_LIMIT):
try_msg_blocks = SHA1.padd_message(message, j + len(original_msg))
try_msg = 0
for idx, try_block in enumerate(try_msg_blocks):
try_msg += (try_block) << (512 *
(len(try_msg_blocks) - 1 - idx))
try_msg = try_msg.to_bytes((try_msg.bit_length() + 7) // 8,
byteorder='big')
try_msg += str.encode(new_msg)
if validate_msg_for_key(try_msg, new_tag):
print("Message validated successfully")
print(try_msg)
return
else:
print("Message try failed")
print("FAILED")
return
def HMAC_SHA(key, message):
key_to_use = bytearray()
if len(key) * 8 > SHA1.BLOCK_SIZE:
key_for_sha = SHA1.SHA1()
key_for_sha.Update(key)
key_to_use = key_for_sha.Sum()
else:
if type(key) is bytes:
key_to_use = bytearray(key)
else:
key_to_use = key_to_use + str.encode(key, encoding='utf-8')
key_to_use = key_to_use + bytearray(SHA1.PROCESS_LIMIT -
len(key_to_use))
inner_hmac = SHA1.SHA1()
inner_msg = bytearray()
for i in range(SHA1.PROCESS_LIMIT):
inner_msg.append(key_to_use[i] ^ ipad_byte[i])
inner_hmac.Update(inner_msg + str.encode(message))
outer_hmac = SHA1.SHA1()
outer_msg = bytearray()
for i in range(SHA1.PROCESS_LIMIT):
outer_msg.append(key_to_use[i] ^ opad_byte[i])
outer_hmac.Update(outer_msg + inner_hmac.Sum())
return outer_hmac.Sum()
def generate(key, message):
blk_size = SHA1.block_size
if (len(key) > blk_size):
key = SHA1.digest(key)
if (len(key) < blk_size):
key = key + bytes([0x00] * (blk_size - len(key)))
o_key_pad = xor_bytes(bytes([0x5c] * blk_size), key)
i_key_pad = xor_bytes(bytes([0x36] * blk_size), key)
return SHA1.digest(o_key_pad + SHA1.digest(i_key_pad + message))
def main():
for x in (list(
SHA1.keyed_hash(
b'PASSWORD',
b'The quick brown fox jumps over the lazy cog The quick brown fox jumps over the lazy cog'
))):
print(hex(x))
def main():
# Perform keyed hash of original msg
original_msg = b'comment1=cooking%20MCs;userdata=foo;comment2=%20like%20a%20pound%20of%20bacon'
original_mac= encryption_oracle(original_msg)
print('Original msg = ', original_msg)
print('Orignal msg MAC = ', bytes_hexstr(original_mac))
print('Origianal msg verify passed = ', verify_mac(encryption_oracle, original_msg, original_mac))
# Re-create SHA state from hash value
print ('---------------')
print ('Trying to forge')
# Reverse SHA state
h = reverse_SHA_state(original_mac)
# Set string that we want to append
forged_str=b';admin=true'
# Try all key lengthes
for keylen in range(1,100):
forged_msg=original_msg + SHA1.padding(original_msg, len(original_msg) + keylen) + forged_str
forged_str_len=len(forged_msg)+keylen
forged_mac=SHA1.digest(forged_str,h[0],h[1],h[2],h[3],h[4], forged_str_len)
if verify_mac(encryption_oracle, forged_msg, forged_mac):
break;
print('Forged msg = ', forged_msg)
print('Forged msg MAC = ', bytes_hexstr(forged_mac))
print('Forged msg verify passed = ', verify_mac(encryption_oracle, forged_msg, forged_mac))
def main(insecure_delay=0.05, server_retries=10, num_of_threads=64):
# Starting server
server_start(insecure_delay)
# File to attack
attack_file = 'README.md'
# Generate one signature and perform 1 dummy connection
sig = bytearray(SHA1.digest(b''))
sig = bytearray([0] * len(sig))
# Brute-force each byte in the signature
for j in range(len(sig)):
test_connection_multithreaded(attack_file, sig, j, num_of_threads,
server_retries)
# Verify signature
code, time, text = test_connection(attack_file, sig, 1)
print(text)
def Hash_SHA1():
h = SHA1.new()
h.update(b'Cryptography and Blockchain Technology')
print('SHA1: ' + h.hexdigest())
genkey_rsa 47 61 publicKey.txt privateKey.txt
"""
)
else:
if sys.argv[1] == "get_hash":
# считать данные
try:
file = open(sys.argv[2], "r")
text = file.read()
finally:
file.close
# подсчитать хеш
(h0, h1, h2, h3, h4) = SHA1.sha1(text)
print("%8x%8x%8x%8x%8x" % (h0, h1, h2, h3, h4))
# записть хеш в файл
file = open(sys.argv[3], "w")
file.write("%8x%8x%8x%8x%8x" % (h0, h1, h2, h3, h4))
file.close()
if sys.argv[1] == "check_hash":
# читаем файл
file = open(sys.argv[2], "r")
text = file.read()
file.close()
# сгенерируем хеш
def encryption_oracle(msg):
return SHA1.keyed_hash(secret_key, msg)
def sign(self, message):
sha = SHA1.SHA1()
message = self.key + message
sha.update(message)
return sha.hexdigest()
def create_SHA_with_state(state):
sha1_instance = SHA1.SHA1()
sha1_instance.H = state
return sha1_instance
def key_from_DH(number):
iv = ''.append(chr(random.choice(string.ascii)) for x in range(16))
sha1 = SHA1.SHA1()
def verify_message(secret_key, tag, message):
hash_func2 = SHA1.SHA1()
hash_func2.Update(secret_key + message)
check_val = hash_func2.Sum()
return check_val == tag
def tag_message(secret_key, message):
hash_func = SHA1.SHA1()
hash_func.Update(secret_key + message)
tag = hash_func.Sum()
return tag
#инициализация
import GetValuesForEC, EllipticCurve, SHA1, random
ec_= GetValuesForEC.EC(int(sys.argv[3]))
ec_.setAB((int(sys.argv[4]),int(sys.argv[5])))
ec = EllipticCurve.EC(int(sys.argv[4]), int(sys.argv[5]), int(sys.argv[3]))
g,_= ec.at(0)
eg = EllipticCurve.ElGamal(ec, g)
dsa = EllipticCurve.DSA(ec, g)
# читаем файл
file=open(sys.argv[2],"r")
text=file.read()
file.close()
# сгенерируем хеш
hash_text=int(''.join([str(hex(h)[2:]).replace("L","") for h in SHA1.sha1(text)]),16)
# генерируем ЭЦП
while(True):
private_key = random.randrange(1,int(sys.argv[3])-1)
if ec_.isPrime(private_key):
public_key = eg.gen(private_key)
print("Private key: %d" % private_key)
print("Public key: (%d,%d)" % public_key)
r = public_key[0] % int(sys.argv[3])
if r==0:
continue
else:
break
#r = 20 # 53 5 17
sig=dsa.sign(hash_text, private_key, r)
from SHA1 import *
f = SHA1("test")
print(f)
