code.kerkeslager.com Git - sandbox/blob - cryptopals-python/cryptopals.py

   1 import codecs
   2 import unittest
   3
   4 def base64_from_hex(_hex):
   5     return codecs.encode(bytes.fromhex(_hex), 'base64').decode('utf-8')
   6
   7 def xor_bytes(bytes0, bytes1):
   8     return bytes(b0 ^ b1 for b0, b1 in zip(bytes0, bytes1))
   9
  10 def xor_hex(hex0, hex1):
  11     assert len(hex0) == len(hex1)
  12     bytes0 = bytes.fromhex(hex0)
  13     bytes1 = bytes.fromhex(hex1)
  14     return codecs.encode(xor_bytes(bytes0, bytes1), 'hex').decode('utf-8')
  15
  16 def get_character_frequencies(source):
  17     frequencies = {}
  18
  19     for source_character in source:
  20         frequencies[source_character] = frequencies.get(source_character, 0) + 1
  21
  22     return frequencies
  23
  24 def compare_frequency_deviation(base_frequency, comparison_frequency):
  25     return sum(
  26         abs(frequency - comparison_frequency.get(character, 0))
  27         for character, frequency in base_frequency.items()
  28     ) / len(base_frequency)
  29
  30 with open('sample.txt','r') as sample_file:
  31     sample_text = sample_file.read()
  32
  33 SAMPLE_FREQUENCIES = get_character_frequencies(sample_text)
  34
  35 def encrypt_with_repeating_xor(plaintext, key):
  36     plaintext_bytes = plaintext.encode('utf-8')
  37     key_bytes = key.encode('utf-8')
  38
  39     return xor_bytes(
  40         plaintext_bytes,
  41         (key_bytes * ((len(plaintext_bytes) // len(key_bytes)) + 1))[:len(plaintext_bytes)],
  42     )
  43
  44 class Set1Challenge1Tests(unittest.TestCase):
  45     def test_converts_hex_to_base64(self):
  46         expected = 'SSdtIGtpbGxpbmcgeW91ciBicmFpbiBsaWtlIGEgcG9pc29ub3VzIG11c2hyb29t\n'
  47         actual = base64_from_hex('49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d')
  48         self.assertEqual(expected, actual)
  49
  50 class Set1Challenge2Tests(unittest.TestCase):
  51     def test_xors_hex_strings(self):
  52         hex0 = '1c0111001f010100061a024b53535009181c'
  53         hex1 = '686974207468652062756c6c277320657965'
  54
  55         expected = '746865206b696420646f6e277420706c6179'
  56         actual = xor_hex(hex0, hex1)
  57
  58         self.assertEqual(expected, actual)
  59
  60 class Set1Challenge3Tests(unittest.TestCase):
  61     def test_gets_message(self):
  62         xored_string = bytes.fromhex('1b37373331363f78151b7f2b783431333d78397828372d363c78373e783a393b3736')
  63
  64         lowest_frequency_deviation_string = None
  65         lowest_frequency_deviation = None
  66
  67         for i in range(128):
  68             key_char = bytes([i]).decode('utf-8')
  69             key = bytes([i]) * len(xored_string)
  70             try_string = xor_bytes(xored_string, key).decode('utf-8')
  71             try_string_frequency_deviation = compare_frequency_deviation(
  72                 SAMPLE_FREQUENCIES,
  73                 get_character_frequencies(try_string),
  74             )
  75
  76             if lowest_frequency_deviation is None or try_string_frequency_deviation < lowest_frequency_deviation:
  77                 lowest_frequency_deviation_string = try_string
  78                 lowest_frequency_deviation = try_string_frequency_deviation
  79
  80
  81         expected = "Cooking MC's like a pound of bacon"
  82         actual = lowest_frequency_deviation_string
  83
  84         self.assertEqual(expected, actual)
  85
  86 class Set1Challenge4Tests(unittest.TestCase):
  87     def test_gets_message(self):
  88         with open('set1challenge4.txt','r') as f:
  89             lines = f.readlines()
  90
  91
  92         lowest_frequency_deviation_string = None
  93         lowest_frequency_deviation = None
  94
  95         for line in lines:
  96             line_bytes = bytes.fromhex(line)
  97
  98             for i in range(128):
  99                 key_char = bytes([i]).decode('utf-8')
 100                 key = bytes([i]) * len(line_bytes)
 101
 102                 try:
 103                     try_string = xor_bytes(line_bytes, key).decode('utf-8')
 104                     try_string_frequency_deviation = compare_frequency_deviation(
 105                         SAMPLE_FREQUENCIES,
 106                         get_character_frequencies(try_string),
 107                     )
 108
 109                     if lowest_frequency_deviation is None or try_string_frequency_deviation < lowest_frequency_deviation:
 110                         lowest_frequency_deviation_string = try_string
 111                         lowest_frequency_deviation = try_string_frequency_deviation
 112                 except:
 113                     pass
 114
 115         expected = 'Now that the party is jumping\n'
 116         actual = lowest_frequency_deviation_string
 117
 118         self.assertEqual(expected, actual)
 119
 120 class Set1Challenge5Tests(unittest.TestCase):
 121     def test_encrypts_with_repeating_xor(self):
 122         plaintext = "Burning 'em, if you ain't quick and nimble\nI go crazy when I hear a cymbal"
 123         key = 'ICE'
 124
 125         expected = '0b3637272a2b2e63622c2e69692a23693a2a3c6324202d623d63343c2a26226324272765272a282b2f20430a652e2c652a3124333a653e2b2027630c692b20283165286326302e27282f'
 126         actual = encrypt_with_repeating_xor(plaintext, key).hex()
 127
 128         self.assertEqual(expected, actual)
 129
 130 if __name__ == '__main__':
 131     unittest.main()