1
1) LFSR:
2
import numpy as np
3
from pylfsr import LFSR
4
 
5
state = [0,0,0,1,0]
6
fpoly = [5,3]
7
L = LFSR(fpoly=fpoly,initstate =state)
8
 
9
k=10
10
seq_k  = L.runKCycle(k)
11
 
12
print('10 bits')
13
print(L.arr2str(seq_k))
14
print('')
15
 
16
seq_full  = L.runFullPeriod()
17
 
18
print('Full period of LFSR = 31-cycles')
19
print(L.arr2str(seq_full))
20
 
21
L.Viz()
22
 
23
2) RC4 One
24
import codecs
25
 
26
MOD = 256
27
 
28
def KSA(key):
29
    key_length = len(key)
30
    S = list(range(MOD))
31
    j = 0
32
    for i in range(MOD):
33
        j = (j + S[i] + key[i % key_length]) % MOD
34
        S[i], S[j] = S[j], S[i]
35
    return S
36
 
37
def PRGA(S):
38
    i = 0
39
    j = 0
40
    while True:
41
        i = (i + 1) % MOD
42
        j = (j + S[i]) % MOD
43
        S[i], S[j] = S[j], S[i]
44
        K = S[(S[i] + S[j]) % MOD]
45
        yield K
46
 
47
def get_keystream(key):
48
    S = KSA(key)
49
    return PRGA(S)
50
 
51
def encrypt_logic(key, text):
52
    key = [ord(c) for c in key]
53
    keystream = get_keystream(key)
54
    res = []
55
    for c in text:
56
        val = ("%02X" % (c ^ next(keystream)))
57
        res.append(val)
58
    return ''.join(res)
59
 
60
def encrypt(key, plaintext):
61
    plaintext = [ord(c) for c in plaintext]
62
    return encrypt_logic(key, plaintext)
63
 
64
def decrypt(key, ciphertext):
65
    ciphertext = codecs.decode(ciphertext, 'hex_codec')
66
    res = encrypt_logic(key, ciphertext)
67
    return codecs.decode(res, 'hex_codec').decode('utf-8')
68
 
69
def main():
70
    key = 'not-so-random-key'
71
    plaintext = 'Good work! Your implementation is correct'
72
    ciphertext = encrypt(key, plaintext)
73
    print('plaintext:', plaintext)
74
    print('ciphertext:', ciphertext)
75
    ciphertext = '2D7FEE79FFCE80B7DDB7BDA5A7F878CE298615476F86F3B890FD4746BE2D8F741395F884B4A35CE979'
76
    decrypted = decrypt(key, ciphertext)
77
    print('decrypted:', decrypted)
78
    if plaintext == decrypted:
79
        print('\nCongrats ! You made it.')
80
    else:
81
        print('Shit! You pooped your pants ! .-.')
82
 
83
def test():
84
    assert(encrypt('Key', 'Plaintext')) == 'BBF316E8D940AF0AD3'
85
    assert(decrypt('Key', 'BBF316E8D940AF0AD3')) == 'Plaintext'
86
    assert(encrypt('Wiki', 'pedia')) == '1021BF0420'
87
    assert(decrypt('Wiki', '1021BF0420')) == 'pedia'
88
    assert(encrypt('Secret', 'Attack at dawn')) == '45A01F645FC35B383552544B9BF5'
89
    assert(decrypt('Secret', '45A01F645FC35B383552544B9BF5')) == 'Attack at dawn'
90
 
91
if __name__ == '__main__':
92
    main()
93
 
94
3) RC4 Two
95
def key_scheduling(key):
96
    sched = [i for i in range(256)]
97
    i = 0
98
    for j in range(256):
99
        i = (i + sched[j] + key[j % len(key)]) % 256
100
        sched[j], sched[i] = sched[i], sched[j]
101
    return sched
102
 
103
def stream_generation(sched):
104
    i = 0
105
    j = 0
106
    while True:
107
        i = (1 + i) % 256
108
        j = (sched[i] + j) % 256
109
        sched[j], sched[i] = sched[i], sched[j]
110
        yield sched[(sched[i] + sched[j]) % 256]
111
 
112
def encrypt(text, key):
113
    text = [ord(char) for char in text]
114
    key = [ord(char) for char in key]
115
    sched = key_scheduling(key)
116
    key_stream = stream_generation(sched)
117
    ciphertext = ''
118
    for char in text:
119
        enc = str(hex(char ^ next(key_stream))).upper()
120
        ciphertext += enc
121
    return ciphertext
122
 
123
def decrypt(ciphertext, key):
124
    ciphertext = ciphertext.split('0X')[1:]
125
    ciphertext = [int('0x' + c.lower(), 0) for c in ciphertext]
126
    key = [ord(char) for char in key]
127
    sched = key_scheduling(key)
128
    key_stream = stream_generation(sched)
129
    plaintext = ''
130
    for char in ciphertext:
131
        dec = chr(char ^ next(key_stream))
132
        plaintext += dec
133
    return plaintext
134
 
135
if __name__ == '__main__':
136
    ed = input('Enter E for Encrypt, or D for Decrypt: ').upper()
137
    if ed == 'E':
138
        plaintext = input('Enter your plaintext: ')
139
        key = input('Enter your secret key: ')
140
        result = encrypt(plaintext, key)
141
        print('Result:')
142
        print(result)
143
    elif ed == 'D':
144
        ciphertext = input('Enter your ciphertext: ')
145
        key = input('Enter your secret key: ')
146
        result = decrypt(ciphertext, key)
147
        print('Result:')
148
        print(result)
149
    else:
150
        print('Error in input - try again.')
151
 
152
4) A5 One
153
import numpy as np
154
 
155
reg_1 = np.empty
156
reg_2 = np.empty
157
reg_3 = np.empty
158
 
159
def user_input():
160
    usrinput = np.array(list(map(int, input("Enter the 64 bit key with space between the elements").strip().split())), dtype=bool)
161
    print(usrinput)
162
    print(type(usrinput))
163
    if len(usrinput) == 64:
164
        return usrinput
165
    else:
166
        while len(usrinput) != 64:
167
            usrinput = np.array(list(map(int, input("Enter the 64 bit key with space between the elements").strip().split())), dtype=bool)
168
        return usrinput
169
 
170
def load_key(key):
171
    global reg_1, reg_2, reg_3
172
    reg_1 = key[0:19]
173
    reg_2 = key[19:41]
174
    reg_3 = key[41:64]
175
    print("registers loaded successfully")
176
 
177
def get_majority(a, b, c):
178
    return int(a) + int(b) + int(c) > 1
179
 
180
def clock_a5(clocking):
181
    global reg_1, reg_2, reg_3
182
    c = clocking
183
    while c != 0:
184
        majority = get_majority(reg_1[8], reg_2[10], reg_3[10])
185
        if reg_1[8] == majority:
186
            first_bit = int(reg_1[18]) ^ int(reg_1[17]) ^ int(reg_1[16]) ^ int(reg_1[13])
187
            temp_arr1 = np.empty_like(reg_1)
188
            temp_arr1[0] = first_bit
189
            temp_arr1[1:] = reg_1[:18]
190
            reg_1 = temp_arr1
191
        if reg_2[10] == majority:
192
            first_bit = int(reg_2[20]) ^ int(reg_2[21])
193
            temp_arr2 = np.empty_like(reg_2)
194
            temp_arr2[0] = first_bit
195
            temp_arr2[1:] = reg_2[:21]
196
            reg_2 = temp_arr2
197
        if reg_3[10] == majority:
198
            first_bit = int(reg_3[20]) ^ int(reg_3[21]) ^ int(reg_3[22])
199
            temp_arr3 = np.empty_like(reg_3)
200
            temp_arr3[0] = first_bit
201
            temp_arr3[1:] = reg_3[:22]
202
            reg_3 = temp_arr3
203
        output = int(reg_1[18]) ^ int(reg_2[21]) ^ int(reg_3[22])
204
        print(int(output), end='')
205
        c -= 1
206
 
207
def main():
208
    key = user_input()
209
    load_key(key)
210
    clocking = int(input("Please enter the number of times to clock the Stream Generator"))
211
    clock_a5(clocking)
212
 
213
main()
214
 
215
# 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
216
 
217
5) A5 Two
218
import re
219
import copy
220
import sys
221
 
222
x_length = 19
223
y_length = 22
224
z_length = 23
225
key_one = ""
226
x = []
227
y = []
228
z = []
229
 
230
def load_registers(key):
231
    i = 0
232
    while i < x_length:
233
        x.insert(i, int(key[i]))
234
        i += 1
235
    j = 0
236
    p = x_length
237
    while j < y_length:
238
        y.insert(j, int(key[p]))
239
        p += 1
240
        j += 1
241
    k = y_length + x_length
242
    r = 0
243
    while r < z_length:
244
        z.insert(r, int(key[k]))
245
        k += 1
246
        r += 1
247
 
248
def set_key(key):
249
    if len(key) == 64 and re.match("^([01])+", key):
250
        key_one = key
251
        load_registers(key)
252
        return True
253
    return False
254
 
255
def get_key():
256
    return key_one
257
 
258
def to_binary(plain):
259
    s = ""
260
    for i in plain:
261
        binary = str(' '.join(format(ord(x), 'b') for x in i))
262
        j = len(binary)
263
        while j < 8:
264
            binary = "0" + binary
265
            s += binary
266
            j += 1
267
    binary_values = []
268
    for k in range(len(s)):
269
        binary_values.insert(k, int(s[k]))
270
    return binary_values
271
 
272
def get_majority(x, y, z):
273
    return 1 if (x + y + z > 1) else 0
274
 
275
def get_keystream(length):
276
    x_temp = copy.deepcopy(x)
277
    y_temp = copy.deepcopy(y)
278
    z_temp = copy.deepcopy(z)
279
    keystream = []
280
    for i in range(length):
281
        majority = get_majority(x_temp[8], y_temp[10], z_temp[10])
282
        if x_temp[8] == majority:
283
            new = x_temp[13] ^ x_temp[16] ^ x_temp[17] ^ x_temp[18]
284
            x_temp = [new] + x_temp[:-1]
285
        if y_temp[10] == majority:
286
            new_one = y_temp[20] ^ y_temp[21]
287
            y_temp = [new_one] + y_temp[:-1]
288
        if z_temp[10] == majority:
289
            new_two = z_temp[7] ^ z_temp[20] ^ z_temp[21] ^ z_temp[22]
290
            z_temp = [new_two] + z_temp[:-1]
291
        keystream.append(x_temp[18] ^ y_temp[21] ^ z_temp[22])
292
    return keystream
293
 
294
def to_str(binary):
295
    s = ""
296
    for i in range(0, len(binary) - 8, 8):
297
        s += chr(int(binary[i:i + 8], 2))
298
    return str(s)
299
 
300
def encrypt(plain):
301
    s = ""
302
    binary = to_binary(plain)
303
    keystream = get_keystream(len(binary))
304
    for i in range(len(binary)):
305
        s += str(binary[i] ^ keystream[i])
306
    return s
307
 
308
def decrypt(cipher):
309
    s = ""
310
    binary = []
311
    keystream = get_keystream(len(cipher))
312
    for i in range(len(cipher)):
313
        binary.append(int(cipher[i]))
314
        s += str(binary[i] ^ keystream[i])
315
    return to_str(s)
316
 
317
def inp_key():
318
    tha_key = str(input('Enter a 64-bit key: '))
319
    while len(tha_key) != 64 or not re.match("^([01])+", tha_key):
320
        tha_key = str(input('Enter a valid 64-bit key: '))
321
    return tha_key
322
 
323
def choice():
324
    inp = str(input('\n[1]: Implement A51 Cipher\n[2]: Exit\nOption: '))
325
    while inp not in ['1', '2']:
326
        inp = str(input('\n[1]: Implement A51 Cipher\n[2]: Exit\nOption: '))
327
    return inp
328
 
329
def text():
330
    try:
331
        inp = str(input('Enter the plaintext: '))
332
    except:
333
        inp = str(input('Try again: '))
334
    return inp
335
 
336
def main():
337
    key = inp_key()
338
    set_key(key)
339
    first_choice = choice()
340
    if first_choice == '1':
341
        plaintext = text()
342
        print("\nPlainText:", plaintext)
343
        a = encrypt(plaintext)
344
        print("\nEncrypted Text:", a)
345
        print("\nDecrypted Text:", decrypt(a))
346
    elif first_choice == '2':
347
        print("\nTerminal Closed")
348
        sys.exit(0)
349
 
350
main()
351
 
352
# 1101011001010010110101110001100101101001001000110110110010110111