def breakFixedNonce(ciphers):
stream = ""
result = []
for i in range(max([len(i) for i in ciphers])):
s = ""
bestResult = 0
byte = 0
for x in ciphers:
try:
s += x[i]
except:
pass
s = s.encode("hex")
for j in range(256):
res = analyseFrequency(xor(s, chr(j).encode("hex")).decode("hex"))
if res > bestResult:
bestResult = res
byte = chr(j).encode("hex")
stream += byte
for i in range(len(ciphers)):
result.append(
xor(ciphers[i].encode("hex"),
stream).decode("hex")[:len(ciphers[i])])
return result
def breakRandomAccessCTR(cipher, key):
plainPrime = "a" * (len(cipher) / 2)
edited = editCT(cipher, key, 0, plainPrime).encode("hex")
# Plaintext = plaintext' ^ ciphertext ^ ciphertext'
# this is because both ciphertext and ciphertext'
# have been xor'ed with the stream and so it cancels
return xor(xor(cipher, edited), plainPrime.encode("hex"))
def crack(input_string):
ciphertext = input_string.decode("hex")
length = len(ciphertext)
min_diff = 10**10 # too large to start
candidates = []
for k in string.printable:
pad = k * length
pt = xor(ciphertext, pad).decode("hex")
frequency, l1 = compute_frequency(pt)
bigram_frequency, l2 = compute_bigram_frequency(pt)
single_diff = histogram_difference(english_freqs, frequency)
bigram_diff = histogram_difference(bigram_freqs, bigram_frequency)
reduce1 = float(l1) / len(pt)
reduce2 = float(l2) / len(pt)
diff = (single_diff / reduce1) + (bigram_diff / reduce2)
diff = single_diff + bigram_diff
if all(map(lambda c: c in set(string.printable),
pt)) and diff < min_diff:
min_diff = diff
candidates.append((k, pt, diff))
return candidates
def score(message):
results = []
# ASCII range
for key in range(256):
# print("key: " + chr(key))
# create a string of characters in bytes to xor message against
xor_buffer = (chr(key) * len(message)).encode("ISO-8859-1")
xor_result = xor(unhexlify(message), xor_buffer)
# print("input: " + message)
# print("output: " + xor_buffer.decode("ISO-8859-1"))
# print("target: " + hexlify(target.encode("ISO-8859-1")).decode("ISO-8859-1"))
# print("xor hex: " + xor_result.hex())
# print("xor: " + xor_result.decode("ISO-8859-1"))
# print()
# calculate score based on frequency of characters in sentence
score = 0
for char in xor_result:
try:
score += frequency_table()[char]
except:
pass
results.append({
"score": score,
"message": xor_result.decode("ISO-8859-1"),
"key": chr(key),
})
return results
def HMAC_sha1(key, message):
# 64-byte blocks and 20-byte output for SHA1
blockSize = 64
outputSize = 20
if len(key) > blockSize:
key = sha1(key)
elif len(key) < blockSize:
key += b'\x00' * (blockSize - len(key))
o_key_pad = xor(key.encode("hex"), ("5c" * blockSize)).decode("hex")
i_key_pad = xor(key.encode("hex"), ("36" * blockSize)).decode("hex")
return sha1(o_key_pad +
sha1(i_key_pad + message).decode("hex"))[:outputSize * 2]
def HMAC_sha256(key, message):
# 64-byte blocks and 32-byte output for SHA256
blockSize = 64
outputSize = 32
if len(key) > blockSize:
key = sha256(key).hexdigest()
elif len(key) < blockSize:
key += b'\x00' * (blockSize - len(key))
o_key_pad = xor(key.encode("hex"), ("5c" * blockSize)).decode("hex")
i_key_pad = xor(key.encode("hex"), ("36" * blockSize)).decode("hex")
return sha256(o_key_pad +
sha256(i_key_pad + message).hexdigest().decode("hex")
).hexdigest()[:outputSize * 2]
def encryptAES_CTR(data, key, nonce):
result = ""
blockNumber = 0
for i in range(len(data) / 32 + 1):
block = data[32 * i:32 * (i + 1)]
streamData = (struct.pack("<q", nonce) +
struct.pack("<q", blockNumber)).encode("hex")
keystream = encryptAES_ECB(streamData, key).encode("hex")[:len(block)]
result += xor(block, keystream).decode("hex")
blockNumber += 1
return result
def test_challenge2(self):
# encrypted text in plain english
# print(self.buf_x_bytes)
# => b'\x1c\x01\x11\x00\x1f\x01\x01\x00\x06\x1a\x02KSSP\t\x18\x1c'
# encryption key in plain english
# print(self.buf_y_bytes)
# => b"hit the bull's eye"
# target string in plain english
# print(unhexlify(self.target))
# => b"the kid don't play"
xor_result = xor(self.buf_x_bytes, self.buf_y_bytes)
# xor result in plain english
# print(xor_result)
# => b"the kid don't play"
# target is plain ascii so convert result for testing..
self.assertEqual(self.target, hexlify(xor_result).decode("ASCII"))
def recoverKeyEqualsIvAES_CBC():
message = "HELLO MY FRIEND COME VAI ANDIAMO STASERA A MANGIARE INSIEME"
s1 = "http://example.com/?comment1=cooking%20MCs;userdata="
s2 = ";comment2=%20like%20a%20pound%20of%20bacon"
msg = s1 + message.replace(";", "").replace("=", "") + s2
server = serverAES_CBC()
encrypted = server.encrypt(msg)
firstBlock = encrypted[:32]
encrypted = firstBlock + "0" * 32 + firstBlock + encrypted[96:]
decrypted = server.decrypt(encrypted)
result = decrypted.split("is: ")[-1]
key = xor(result[:16].encode("hex"), result[32:48].encode("hex"))
assert key == server.key.encode("hex")
print "[*] Key successfully recovered: {}".format(key)
import sys
import binascii
import math
from xor import *
key = "ICE"
with open(sys.argv[1], 'r') as fh:
data = fh.read()
keypad = key * int(math.ceil(len(data) / float(3)))
ct = xor(data, keypad)
print ct
def hamming_distance(x, y):
diff = xor(x, y)
return reduce(lambda acc, b : acc + support(b), diff, 0)
from xor import *
txt = "aaabbbccc"
k = "#"
for char in txt:
newchar = xor(char, k, 8)
print newchar
from xor import *
chal = "8776459cf37d459fbb7b5ecfbb7f5fcfb23e478aaa3e4389f378439aa13e4e96a77b5fc1f358439df36a4486a03e4381b63e5580a66c0c8ebd6d5b8aa13e459cf34e4d9fa67f02cf90714288a17f589abf7f5886bc705fcfbc700c96bc6b5ecfb7775f8cbc68499daa3f"
key_bit_length = 32
for i in xrange(1, 2**32):
print i, xor(chal, i, key_bit_length)
def hamming_distance(x, y):
diff = xor(x, y)
return reduce(lambda acc, b: acc + support(b), diff, 0)
