First commit

Author: VersusJH

Cryptopals/HextoB64.py

@@ -0,0 +1,5 @@
+import base64
+instr = input()
+bytestr = bytes.fromhex(instr)
+b64output = base64.b64encode(bytestr)
+print(b64output)

Cryptopals/RepeatXor.py

@@ -0,0 +1,18 @@
+from binascii import hexlify
+
+plaintext = b"Burning 'em, if you ain't quick and nimble I go crazy when I hear a cymbal"
+key = b"ICE"
+def repeat_encrypt(plaintext, key):
+    cyphtxt = b''
+    i = 0
+    while i < len(plaintext):
+        k = i%len(key)
+        value = plaintext[i] ^ key[k]
+        cyphtxt += bytes([value])
+        i += 1
+    crypto = str(hexlify(cyphtxt))
+    print(crypto)
+
+repeat_encrypt(plaintext, key)
+
+

Cryptopals/RepeatXorCrack.py

@@ -0,0 +1,29 @@
+str1= b'this is a test'
+str2 = b'wokka wokka!!!'
+def hamming_distance(binary_seq_1, binary_seq_2):
+    
+    dist = 0
+    print(zip(binary_seq_1, binary_seq_2))
+    for bit1, bit2 in zip(binary_seq_1, binary_seq_2):
+        diff = bit1 ^ bit2
+        print(bin(diff))
+        dist += sum([1 for bit in bin(diff) if bit == '1'])
+
+    return dist
+
+def counter(string):
+    bytecount = 0
+    for byte in string:
+        bytecount += bin(byte).count('1')
+    return bytecount
+
+def edit_distance (str1, str2):
+    count1 = counter(str1)
+    count2 = counter(str2)
+    print(count1, count2)
+    dist = abs(count1-count2)
+    return dist
+
+distance = hamming_distance(str1, str2)
+print(distance)
+    

Cryptopals/singlexor.py

@@ -0,0 +1,65 @@
+CHARACTER_FREQ = {
+    'a': 0.0651738, 'b': 0.0124248, 'c': 0.0217339, 'd': 0.0349835, 
+    'e': 0.1041442, 'f': 0.0197881, 'g': 0.0158610, 'h': 0.0492888, 
+    'i': 0.0558094, 'j': 0.0009033, 'k': 0.0050529, 'l': 0.0331490, 
+    'm': 0.0202124, 'n': 0.0564513, 'o': 0.0596302, 'p': 0.0137645, 
+    'q': 0.0008606, 'r': 0.0497563, 's': 0.0515760, 't': 0.0729357, 
+    'u': 0.0225134, 'v': 0.0082903, 'w': 0.0171272, 'x': 0.0013692, 
+    'y': 0.0145984, 'z': 0.0007836, ' ': 0.1918182
+}
+def main():
+    cyph_array = [bytes.fromhex(line.strip()) for line in open("strings.txt")]
+
+    plain_array = []
+    for cyph in cyph_array:
+        result = singlechar_xor(cyph)
+        plain_array.append(result)
+    sorted_results = sorted(plain_array, key=lambda c: c['score'], reverse=True)[0]
+    pretty_print_result(sorted_results)
+# for x in array:
+# singlexor()
+#
+def acquire_array_from_file(filename):
+    ciphtxts_array = open(filename, 'r').readlines()
+    for ciphtxt in ciphtxts_array:
+        ciphtxt = bytes.fromhex(ciphtxt)
+    return ciphtxts_array
+def pretty_print_result(result):
+    """Prints the given resulting candidate in a pretty format."""
+    print(result['plaintext'].decode().rstrip(), "\tScore:", "{0:.2f}".format(result['score']),
+          "\tKey:", chr(result['key']))
+
+
+
+
+#must take a single string and try against all possible values.
+#returns best.
+def singlechar_xor(CYPH):  
+    best_score = 0
+    for possible_key in range(256):
+        output = b''
+
+        for char in CYPH:
+            output += bytes([char ^ possible_key])
+
+        score = scoring_function(output)
+        if score > best_score:
+            best_score = score
+
+            result = {
+                'key': possible_key,
+                'score': score,
+                'plaintext': output
+            }
+    return result
+
+
+#takes a single plaintext and scores it.
+def scoring_function(plaintext):
+    score = 0
+    for single_byte in plaintext:
+        score += CHARACTER_FREQ.get(chr(single_byte).lower(), 0)
+    return score
+
+
+main()

Cryptopals/strings.txt

@@ -0,0 +1,67 @@
+CHARACTER_FREQ = {
+    'a': 0.0651738, 'b': 0.0124248, 'c': 0.0217339, 'd': 0.0349835, 
+    'e': 0.1041442, 'f': 0.0197881, 'g': 0.0158610, 'h': 0.0492888, 
+    'i': 0.0558094, 'j': 0.0009033, 'k': 0.0050529, 'l': 0.0331490, 
+    'm': 0.0202124, 'n': 0.0564513, 'o': 0.0596302, 'p': 0.0137645, 
+    'q': 0.0008606, 'r': 0.0497563, 's': 0.0515760, 't': 0.0729357, 
+    'u': 0.0225134, 'v': 0.0082903, 'w': 0.0171272, 'x': 0.0013692, 
+    'y': 0.0145984, 'z': 0.0007836, ' ': 0.1918182
+}
+def get_english_score(input_bytes):
+    #Returns a score which is the sum of the probabilities in how each letter of the input data 
+    #appears in the English language. Uses the above probabilities.
+
+    score = 0
+
+    for byte in input_bytes:
+        score += CHARACTER_FREQ.get(chr(byte).lower(), 0)
+
+    return score
+
+
+def singlechar_xor(input_bytes, key_value):
+    #XORs every byte of the input with the given key_value and returns the result.
+    output = b''
+
+    for char in input_bytes:
+        output += bytes([char ^ key_value])
+
+    return output
+
+
+def singlechar_xor_brute_force(ciphertext):
+    """Tries every possible byte for the single-char key, decrypts the ciphertext with that byte
+    and computes the english score for each plaintext. The plaintext with the highest score
+    is likely to be the one decrypted with the correct value of key.
+    """
+    candidates = []
+
+    for key_candidate in range(256):
+        plaintext_candidate = singlechar_xor(ciphertext, key_candidate)
+        candidate_score = get_english_score(plaintext_candidate)
+
+        result = {
+            'key': key_candidate,
+            'score': candidate_score,
+            'plaintext': plaintext_candidate
+        }
+
+        candidates.append(result)
+
+    # Return the candidate with the highest English score
+    
+    return sorted(candidates, key=lambda c: c['score'], reverse=True)[0]
+
+def pretty_print_result(result):
+    """Prints the given resulting candidate in a pretty format."""
+    print(result['plaintext'].decode().rstrip(), "\tScore:", "{0:.2f}".format(result['score']),
+          "\tKey:", chr(result['key']))
+
+
+
+def main():
+    ciphertext = bytes.fromhex("1b37373331363f78151b7f2b783431333d78397828372d363c78373e783a393b3736")
+    most_likely_plaintext = singlechar_xor_brute_force(ciphertext)
+    pretty_print_result(most_likely_plaintext)
+
+main()

Cryptopals/xor.py

@@ -0,0 +1,65 @@
+#TO DO: parameters for: used Symbolsets, keys starting from 1 or 0and run all keys. Optimize Warpararound .
+
+#symbolsets; add array for used symbolsets.
+ALBET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+albet = 'abcdefghijklmnopqrstuvwxyz'
+nums  = '0123456789'
+
+SYMBOLS = [ALBET, albet, nums]
+
+cyphtxt = ''
+#INPUT
+clrtxt= input('Enter your message\n')
+key= input('Enter numeric key to decrypt. Skip to brute-force.\n')
+mode= input('Enter (E)ncrypt or (D)ecrypt\n')
+print(key)
+#Single symbol en/dec function.
+
+
+
+#check if selected mode is correct
+if mode == 'E':
+#||'e'||'Encrypt'||'encrypt':
+    mode = 1
+elif mode =='D':
+#||'d'||'Decrypt'||'decrypt':
+    mode = -1
+else:
+    mode = 0
+    print('Not a valid mode. Enter encrypt/decrypt')
+
+#Run caesar. To be updated with funcion and symbolsets for cicle and isset.
+if mode:
+    if key == '':
+        for key in range(len(ALBET)):
+            for symbol in clrtxt:
+                checkset= len(cyphtxt)
+                for symset in SYMBOLS:
+                    if symbol in symset:
+                        symIndex = symset.find(symbol)
+                        cyphindex = int(symIndex) + int(key*mode)
+                        if cyphindex >= len(symset):
+                            cyphindex = cyphindex - len(symset)
+                        elif cyphindex < 0:
+                            cyphindex = cyphindex + len(symset)
+                        cyphtxt = cyphtxt + symset[cyphindex]
+                if checkset == len(cyphtxt):
+                    cyphtxt = cyphtxt + symbol
+            print('Key ' + str(key) +': '+ cyphtxt) 
+            cyphtxt= ''
+    else:
+        for symbol in clrtxt:
+            checkset= len(cyphtxt)
+            for symset in SYMBOLS:
+                if symbol in symset:
+                    symIndex = symset.find(symbol)
+                    cyphindex = int(symIndex) + int(key*mode)
+                    if cyphindex >= len(symset):
+                        cyphindex = cyphindex - len(symset)
+                    elif cyphindex < 0:
+                        cyphindex = cyphindex + len(symset)
+                    cyphtxt = cyphtxt + symset[cyphindex]
+            if checkset == len(cyphtxt):
+                cyphtxt = cyphtxt + symbol
+        print('Key ' + str(key) +': '+ cyphtxt) 
+

PythonCyphers/CaesarCypher.py

@@ -0,0 +1,5 @@
+#!/usr/bin/python3.6
+print('Hullo, world!')
+print("What's yer name, fella?")
+yername= input()
+print("pleas'd ta meetcha, " + yername)

PythonCyphers/Hulloworld.py

@@ -0,0 +1,9 @@
+clrtxt = input('\nReverseCypher works both for encoding and decoding.\nEnter message:\n') 
+cyphtxt = ''
+
+i = len(clrtxt) - 1
+while i >= 0:
+    cyphtxt = cyphtxt +clrtxt[i]
+    i = i - 1
+    
+print('\nOutput:\n'+ cyphtxt)

PythonCyphers/ReverseCipher.py

@@ -0,0 +1,9 @@
+def main():
+    clrtxt= input()
+    key = input()
+    cyphtxt = transEncrypt(key, clrtxt)
+
+    print(cyphtxt + '|')
+
+def transEncrypt(mkey, mclrtxt)
+    cyphtxt = [''] * key