cgacryptpy 0.1.0__py3-none-any.whl

cgacryptpy-0.1.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.5
+Name: cgacryptpy
+Version: 0.1.0
+Summary: This library contains a multitude of cryptography functions that can be used in python.
+Project-URL: Homepage, https://github.com/SethRider02/pycryptlib
+Author-email: Seth Bacher <sethrider02@gmail.com>
+License: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# pycryptlib
+
+Multiple cryptologic functions ranging from a simple caesar cipher up to DES!
+
+[![PyPI](https://img.shields.io/pypi/v/pycryptlib)](https://pypi.org/project/pycryptlib/)
+[![Python](https://img.shields.io/pypi/pyversions/pycryptlib)](https://pypi.org/project/pycryptlib/)
+[![License](https://img.shields.io/pypi/l/pycryptlib)](LICENSE)
+
+> **Security notice:** This library has not been independently audited.
+> It is intended for learning and experimentation. For production systems,
+> use a well-established library such as `cryptography`.
+
+## Features
+
+- Affine Cipher
+- Viginere Cipher
+- LFSR
+- KidRSA
+- RSA
+- DES
+
+## Installation
+
+```bash
+pip install pycryptlib
+```
+
+Requires Python 3.9 or newer.
+
+## Quick start
+
+```python
+from pycryptlib.lfsr import lfsr_encrypt
+
+seed_3 = [1,0,0,0,1]
+
+ciphertext, keystream = lfsr_encrypt("ACADEMY", seed_3)
+print("7. Ciphertext bits:", ciphertext)
+print("7. Keystream:", keystream)
+
+
+## Supported algorithms
+
+| Algorithm | Module |     Notes     |
+|-----------|--------|---------------|
+| DES       | `pycryptlib.des`       | 64-bit keys         |
+| LSFR      | `pycryptlib.lsfr`      |                     |
+| Classical | `pycryptlib.classical` | Caesar, stream, etc |
+| KidRSA    | `pycryptlib.rsa`       |
+|   RSA     | `pycryptlib.rsa`       |
+
+## Feedback / Security Concerns
+If you have any concerns regarding usage or issues (ie. function not working or not helpful explanation.),
+feel free to email me or message me at sethrider02@gmail.com
+
+## Development
+
+```bash
+git clone https://github.com/SethRider02/pycryptlib
+cd pycryptlib
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+MIT. See [LICENSE](LICENSE).

cgacryptpy-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+pycryptlib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pycryptlib/classical.py,sha256=ygwLmWq0dt87mUJew8S-GrovOlQ5MdhIxUuHXinETPc,3747
+pycryptlib/des.py,sha256=OTcAg8Kq39YTAoeDLGcpzEM-WWOrbNu6r9NNhUj4Flo,3114
+pycryptlib/encoding.py,sha256=euDo_dAXUGOZbC1eBY74II7gTL7mgdW5p0QnD-l-Cts,2567
+pycryptlib/lfsr.py,sha256=O-zprfWBR6o3xsuIrZOTagZqx4Ov5KPlSeqKhi1o2JI,2734
+pycryptlib/numtheory.py,sha256=9OPIMAfBhJPLfrVhSEz13MAhsQ5Qcr6EAU3mXo6FHWo,1837
+pycryptlib/rsa.py,sha256=uPAwEHKZVjWQt__SzHL5l5lVMprpV7QsgiucohWXB6w,1946
+pycryptlib/stream_otp.py,sha256=l9EDTq30lkSrs-YYIz-bkjxSISLVyL6YGqMT0gNMP-Q,1606
+pycryptlib/tables.py,sha256=bSA93zrL50-jSkfIGtA164MNZFgXWAqYXt_eH1n7Mhc,3265
+cgacryptpy-0.1.0.dist-info/METADATA,sha256=IG1uKB1-fnMZsbr_BK1ngjO0r-ymDeQzOouCMr10AFE,2082
+cgacryptpy-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+cgacryptpy-0.1.0.dist-info/licenses/LICENSE,sha256=lJ6Pt7Rq6prNDSdmuUO2RcyGuogj8gLN_T-WqOAySpg,1089
+cgacryptpy-0.1.0.dist-info/RECORD,,

cgacryptpy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cgacryptpy-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SethRider02
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pycryptlib/classical.py

@@ -0,0 +1,137 @@
+from .encoding import digitize, undigitize
+from .numtheory import mod_inverse
+import math
+
+#==================================#
+#      SHIFT CIPHER FUNCTIONS      #
+#==================================#
+
+def shift_encrypt(plaintext, key):
+    """Encrypts plaintext using a shift key from 0 to 25. Returns the ciphertext."""
+    cnumbs = []
+    for n in digitize(plaintext):
+        cnumbs.append((n+key)%26)
+    return undigitize(cnumbs)
+
+
+def shift_decrypt(ciphertext, key):
+    """Decrypts ciphertext when the shift key is known. Returns the plaintext."""
+    pnumbs = []
+    for n in digitize(ciphertext):
+        pnumbs.append((n-key)%26)
+    return undigitize(pnumbs)
+
+
+def brute_force_shift(ciphertext):
+    """Returns all 26 possible keys and corresponding plaintext outputs."""
+    bruteval = ""
+    for maykey in range(0,26):
+        pnumbs = shift_decrypt(ciphertext,maykey)
+        bruteval = bruteval+f"{pnumbs} Key = {maykey}\n"
+    return bruteval
+
+#==================================#
+#     AFFINE CIPHER FUNCTIONS      #
+#==================================#
+
+def affine_encrypt(plaintext, a, b):
+    """Encrypts plaintext with affine key (a, b). Returns ciphertext upon success."""
+    if math.gcd(a,26) != 1:
+        return None
+
+    dctext = []
+    for numb in digitize(plaintext):
+        dctext.append((a*numb + b)%26)
+
+    return undigitize(dctext)
+
+
+def affine_decrypt(ciphertext, a, b):
+    """Decrypts ciphertext with a known affine key (a, b). Returns plaintext upon success."""
+    if math.gcd(a,b) != 1:
+        return None
+
+    dptext = []
+    a_inv = mod_inverse(a,26)
+
+    if a_inv == None:
+        return None
+
+    for numb in digitize(ciphertext):
+        dptext.append(a_inv * (numb-b) % 26)
+
+    return undigitize(dptext)
+
+
+def brute_force_affine(ciphertext):
+    """
+    Returns every valid affine key and its candidate plaintext.
+    Valid a values are exactly those for which gcd(a, 26) == 1.
+    """
+    bruteval = ''
+    for a in range(26):
+        for b in range(26):
+            plaintext = affine_decrypt(ciphertext,a,b)
+            if plaintext != None:
+                bruteval = bruteval + f'{plaintext} Key = ({a},{b})\n'
+    return bruteval
+
+
+#==================================#
+#    VIGENERE CIPHER FUNCTIONS     #
+#==================================#
+
+def vigenere_encrypt(plaintext, key):
+    """Encrypts plaintext using a Vigenere key. Returns the ciphertext."""
+    dkey = digitize(key)
+    dctext = []
+    i = 0
+
+    for number in digitize(plaintext):
+        dctext.append((number+dkey[i%len(key)])%26)
+        i = i+1
+
+    return undigitize(dctext)
+
+
+def vigenere_decrypt(ciphertext, key):
+    """Decrypt ciphertext when the Vigenere key is known. Return plaintext."""    
+    dkey = digitize(key)
+    dptext = []
+    i = 0
+
+    for number in digitize(ciphertext):
+        dptext.append((number-dkey[i%len(key)])%26)
+        i = i+1
+
+    return undigitize(dptext)
+
+
+def brute_force_vigenere(ciphertext, known_word):
+    """
+    Tries every three-letter key and print candidates containing known_word.
+    Return both the key and candidate plaintext when a match is found.
+    WARNING: Only works with 3 letter Vigenere keys!
+    """
+    pptext = ''
+    pkey = [0,0,0]
+    key = ''
+
+    while pkey[0] != 26:
+
+        if known_word in pptext:
+            break
+        
+        key = undigitize(pkey)
+        pptext = vigenere_decrypt(ciphertext,key)
+        if pkey[2] == 25:
+            pkey[1]+=1
+            pkey[2] = 0
+        else:
+            pkey[2]+=1
+
+        if pkey[1] == 25:
+            pkey[0]+=1
+            pkey[1] = 0
+
+    return key, pptext

pycryptlib/des.py

@@ -0,0 +1,92 @@
+# Contains functions required for DES (Data Encryption Standard)
+import tables as T
+
+
+
+def xor_bits(left, right):
+    """Provided helper: bitwise XOR of two equal-length binary strings."""
+    return ''.join('1' if a != b else '0' for a, b in zip(left, right))
+
+
+def permute(bits, table):
+    """Return bits reordered using the given permutation table. Use [T.] before your table
+    to correctly grab from the tables file."""
+    permutation = ""
+    for index in table:
+        permutation = f"{permutation}{bits[index-1:index]}"
+    return permutation
+
+
+def sbox_substitution(bits48):
+    """Takes a 48 bit string and passes them through all S Boxes. Returns 32 bit string."""
+    sbox_output = ""
+    i = 0
+    for table in T.SBOXES:
+        block = bits48[i*6:(i+1)*6]
+        
+        sbox_row = f"{block[0:1]}{block[5:]}"
+        sbox_row = int(sbox_row,2)
+
+        sbox_col = f"{block[1:5]}"
+        sbox_col = int(sbox_col,2)
+        
+        sbox_index = table[sbox_row][sbox_col]
+        bin_value = bin(sbox_index)[2:]
+
+        while len(bin_value) < 4:
+            bin_value = f"0{bin_value}"
+        sbox_output = f"{sbox_output}{bin_value}"
+
+        i = i+1
+
+    return sbox_output
+
+
+def feistel(right32, round_key48):
+    """Takes the right 32 bits and specified round key through a feistal round. Returns the right
+    32 bits after primitive permutation (P) function."""
+    E_right48 = permute(right32,T.E)
+    xor48 = xor_bits(E_right48,round_key48)
+    S_right32 = sbox_substitution(xor48)
+    P_right32 = permute(S_right32,T.P)
+    return P_right32
+
+
+def rotate_left(bits, steps):
+    """Shifts bits left by X amount of steps. Shift loops (ie. 1st bit becomes 32nd bit).
+    Returns result of shifting."""
+    return bits[steps:] + bits[:steps]
+
+
+def des_round_keys(key64):
+    """Generate round keys given the original 64-bit key. Returns list of keys."""
+    key56 = permute(key64, T.PC1)
+    c, d = key56[:28], key56[28:]
+    keys = []
+    for shift in T.SHIFTS:
+        c = rotate_left(c, shift)
+        d = rotate_left(d, shift)
+        keys.append(permute(c + d, T.PC2))
+    return keys
+
+
+def des_encrypt_block(plain64, key64):
+    """Takes a 64-bit block and encrypts with a 64-bit key. Returns cipher of 64-bits."""
+    initial = permute(plain64, T.IP)
+    left, right = initial[:32], initial[32:]
+    for round_key in des_round_keys(key64):
+        left, right = right, xor_bits(left, feistel(right, round_key))
+    # DES swaps final halves before the inverse initial permutation.
+    return permute(right + left, T.IP_INV)
+
+
+def des_decrypt_block(cipher64,key64):
+    """Decrypts a 64-bit cipher block with a given key. Returns 64-bit plaintext."""
+    cipher64 = permute(cipher64,T.IP)
+    left, right = cipher64[:32], cipher64[32:]
+    reverse_keys = des_round_keys(key64)
+    for i in range(0,16):
+        # print('Using Key: ',(-1-i)%16)
+        round_key = reverse_keys[-1-i]
+        left, right = right, xor_bits(left, feistel(right, round_key))
+    return permute(right+left,T.IP_INV)

pycryptlib/encoding.py

@@ -0,0 +1,80 @@
+# Contains various encoding schemes used in cryptography
+
+
+def digitize(my_string):
+    """Convert uppercase A-Z text into integers: A=0, ..., Z=25."""
+    num_list = []
+    for char in my_string:
+        if not "A" <= char <= "Z":
+            raise ValueError("Only uppercase letters A-Z are allowed.")
+        num_list.append(ord(char) - ord("A"))
+    return num_list
+
+
+def undigitize(num_list):
+    """Convert a list of integers from 0 to 25 into uppercase text."""
+    my_string = ""
+    for value in num_list:
+        if not 0 <= value <= 25:
+            raise ValueError("Each recovered letter value must be 0 through 25.")
+        my_string += chr(int(value) + ord("A"))
+    return my_string
+
+
+def text_to_bits(text):
+    """Encodes a string as UTF-8 and returns its bits as a list of 0s and 1s."""
+    return [
+        (byte >> shift) & 1
+        for byte in text.encode("utf-8")
+        for shift in range(7, -1, -1)
+    ]
+
+
+def bits_to_text(bits):
+    """Converts a bit list whose length is a multiple of 8 back into text."""
+    if len(bits) % 8 != 0:
+        raise ValueError("The number of bits must be a multiple of 8.")
+
+    byte_values = []
+    for start in range(0, len(bits), 8):
+        value = 0
+        for bit in bits[start:start + 8]:
+            value = (value << 1) | bit
+        byte_values.append(value)
+
+    return bytes(byte_values).decode("utf-8")
+
+
+def ascii_to_bits(ascii_string):
+    """Converts given ascii text into a string of bits. Returns full string of bits with no delimeter."""
+    ascii_bytes = ' '.join(format(ord(c),'08b') for c in ascii_string)
+    ascii_bytes = ascii_bytes.replace(' ','')
+    return ascii_bytes
+
+
+def bits_to_ascii(bits):
+    """Converts a string of bits into an ASCII string. Returns ASCII string if successful, or None if unsuccessful."""
+    if len(bits) % 8 != 0:
+        return None
+
+    ascii_string = ''
+    byte_size = int(len(bits)/8)
+    ascii_list = []
+    for i in range(0,byte_size):
+        ascii_bin = bits[i*8:(i+1)*8]
+        ascii_list.append(int(ascii_bin,2))
+
+    for code in ascii_list:
+        ascii_string = f'{ascii_string}{format(code,'c')}'
+
+    return ascii_string
+
+
+def hex_to_bits(hex_string, width=64):
+    """Given hexadecimal text, return exactly width binary characters."""
+    return format(int(hex_string, 16), f"0{width}b")
+
+
+def bits_to_hex(bits):
+    """Given binary text, return uppercase hexadecimal text (with leading zeros)."""
+    return format(int(bits, 2), f"0{len(bits) // 4}X")

pycryptlib/lfsr.py

@@ -0,0 +1,89 @@
+# Contains various functions dealing with Linear Feedback Shift Registers (LFSR's)
+
+def text_to_bits(text):
+    """Convert uppercase A-Z text into one flat list of 5-bit values."""
+    bits = []
+    for char in text:
+        value = ord(char) - ord("A")
+        if value < 0 or value > 25:
+            raise ValueError("Only uppercase letters A-Z are allowed.")
+        bits.extend([
+            (value >> 4) & 1,
+            (value >> 3) & 1,
+            (value >> 2) & 1,
+            (value >> 1) & 1,
+            value & 1
+        ])
+    return bits
+
+
+def bits_to_text(bits):
+    """Convert a flat list of 5-bit letter values back into uppercase text."""
+    if len(bits) % 5 != 0:
+        raise ValueError("The number of bits must be a multiple of 5.")
+
+    text = ""
+    for i in range(0, len(bits), 5):
+        group = bits[i:i + 5]
+        value = (
+            group[0] * 16 + group[1] * 8 + group[2] * 4
+            + group[3] * 2 + group[4]
+        )
+        if value > 25:
+            raise ValueError("5-bit value does not represent A-Z.")
+        text += chr(value + ord("A"))
+    return text
+
+
+def clock_lfsr(seed, clocks):
+    """Shifts a 5-bit seed 'clocks' amount of clock cycles. Returns shifted bits as a list."""
+    cipher = []
+    for i in range(len(seed)):
+        cipher.append(seed[i])
+
+    for i in range(clocks):
+        tempbit = (cipher[2] + cipher[0]) % 2
+        cipher.append(tempbit)
+        cipher.pop(0)
+
+    
+    return cipher
+
+
+def lfsr(seed, length):
+    """Generates a key of a specified length given a seed. Returns the keystream as a list of bits."""
+    keystream = []
+    for i in range(len(seed)):
+        keystream.append(seed[i])
+
+    for i in range(5,length):
+        tempbit = (keystream[i-5] + keystream[i-3]) % 2
+        keystream.append(tempbit)
+
+    return keystream
+
+
+def lfsr_encrypt(plaintext, seed):
+    """Encrypts a string plaintext with a seed list of five bits. Returns tuple with ciphertext as a list
+     of bits and keystream as a list of bits."""
+    plainbits = text_to_bits(plaintext)
+    cipherbits = []
+    keystream = lfsr(seed,(len(plainbits)))
+
+    for i in range(0,len(plainbits)):
+        tempbit = (plainbits[i] + keystream[i]) % 2
+        cipherbits.append(tempbit)
+
+    return (cipherbits,keystream)
+
+
+def lfsr_decrypt(ciphertext_bits, keystream):
+    """Decrypts a list of ciphertext bits using a keystream list of bits. Returns a string of text."""
+    plainbits = []
+    for i in range(0,len(ciphertext_bits)):
+        tempbit = (ciphertext_bits[i] + keystream[i]) % 2
+        plainbits.append(tempbit)
+
+    plaintext = bits_to_text(plainbits)
+
+    return plaintext

pycryptlib/numtheory.py

@@ -0,0 +1,67 @@
+# Contains various functions pertaining to number theory.
+import math
+
+def mod_inverse(a, n):
+    """Finds mod inverse of a mod(n). Returns inverse if found or none if not found."""
+    gcd = math.gcd(a,n)
+    if gcd == 1:
+        for x in range(1,n):
+            inverse = (a*x)%n
+            if inverse == 1:
+                break
+            else:
+                continue
+    else:
+        return None
+    return x
+
+
+def bin_exp(exponent):
+    """Calculates the binary expansion of a given exponent. Returns a list of the power of 2's for the exponent."""
+    twopower = []
+    while(exponent != 0):
+        i = 0
+        while(exponent >= (2**i)):
+            i=i+1
+        i=i-1
+        twopower.append(2**i)
+        exponent = exponent - (2**i)
+
+    return twopower
+
+
+def fast_mod_exp(base, exponent, modulus):
+    """Calculates a value given a base, positive exponent, and a modulus. Returns the value in the respective modulus."""
+    if modulus <= 0:
+        raise ValueError("modulus must be a positive integer.")
+    if exponent < 0:
+        raise ValueError("exponent must be nonnegative.")
+    
+    powers = bin_exp(exponent)
+    result = 1
+    current_power = 1
+    current_value = base % modulus
+
+    while current_power <= exponent:
+        if current_power in powers:
+            result = (result * current_value) % modulus
+        current_value = (current_value * current_value) % modulus
+        current_power = current_power * 2
+
+    return result % modulus
+
+
+def euler_totient(n):
+    """Returns factors from 1 to n that are relatively prime to n."""
+    factors = []
+    for a in range(1,n):
+        gcd = math.gcd(a,n)
+        if gcd == 1:
+            factors.append(a)
+        else:
+            continue
+
+    phi = len(factors)
+    return phi
+
+

pycryptlib/rsa.py

@@ -0,0 +1,72 @@
+# Contains functions for both KidRSA and RSA
+from .encoding import digitize, undigitize
+from .numtheory import mod_inverse
+
+def kidrsa_keygen(a, b, a0, b0):
+    """Takes given KidRSA components to compute M, e, d, and n. Returns tuple of values in the same order."""
+    if a * b <= 1:
+        raise ValueError("a*b must be greater than 1.")
+
+    M = a*b - 1
+    e = a0*M + a
+    d = b0*M + b
+    n = (e*d-1)/M
+
+    return (M, e, d, n)
+
+
+def kidrsa_encrypt(message, e, n):
+    """Encrypts a string message given e and n. Returns ciphertext as a list of encoded values."""
+    dmess = digitize(message)
+    cmess = []
+    for num in dmess:
+        newnum = (e*num)%n
+        cmess.append(newnum)
+
+    return cmess
+
+
+def kidrsa_decrypt(ciphertext, d, n):
+    """Decrypts a list of encoded integers using d and n. Returns plaintext as a string."""
+    pmess = []
+    for num in ciphertext:
+        newnum = (num*d)%n
+        pmess.append(newnum)
+
+    return undigitize(pmess)
+
+
+def rsa_keygen(p, q, e):
+    """Generates RSA key values given p, q, and e. Returns a tuple with n, e, and d."""
+    n = p*q
+    phi_n = (p-1)*(q-1)
+    d = mod_inverse(e,phi_n)
+    return (n,e,d)
+
+
+def rsa_encrypt(plaintext,p,q,e):
+    """Encrypts plaintext list of integers using RSA. Returns ciphertext as list of integers."""
+    keys = rsa_keygen(p,q,e)
+    n = keys[0]
+    e = keys[1]
+    ciphertext = []
+
+    for i in range(0,len(plaintext)):
+        m = plaintext[i]
+        c = pow(m,e,n)
+        ciphertext.append(c)
+
+    return ciphertext
+
+
+def rsa_decrypt(ciphertext,p,q,e):
+    """Decrypts ciphertext list of integers using RSA. Returns plaintext as list of integers."""
+    keys = rsa_keygen(p,q,e)
+    n = keys[0]
+    d = keys[2]
+    recovered_plaintext = []
+
+    for i in range(0,len(ciphertext)):
+        c = ciphertext[i]
+        m = pow(c,d,n)
+        recovered_plaintext.append(m)

pycryptlib/stream_otp.py

@@ -0,0 +1,50 @@
+from .encoding import text_to_bits, bits_to_text
+import secrets
+
+
+def xor_bits(data_bits, keystream_bits):
+    """Take two streams of bits and xors them. Returns the resulting stream of bits."""
+    if len(data_bits) != len(keystream_bits):
+        raise ValueError("Data and keystream must have the same length.")
+    if not all(bit in (0, 1) for bit in data_bits + keystream_bits):
+        raise ValueError("Data and keystream must contain only 0s and 1s.")
+
+    i = 0
+    cipherbits = []
+    while i < len(data_bits):
+        if data_bits[i] != keystream_bits[i]:
+            cipherbits.append(1)
+        else:
+            cipherbits.append(0)
+        i = i+1
+
+    return cipherbits
+
+
+def generate_one_time_pad(length):
+    """Generates a one time pad of a specified length using Python's secret module."""
+    if length < 0:
+        raise ValueError("Length cannot be negative.")
+
+    i = 0
+    rand_pad = []
+    while i < length:
+        rand_pad.append(secrets.randbits(1))
+        i = i+1
+
+    return rand_pad
+
+
+def otp_encrypt(plaintext):
+    """Encrypts the plaintext using an OTP"""
+    bit_text = text_to_bits(plaintext)
+    ot_pad = generate_one_time_pad(len(bit_text))
+    cbit_text = xor_bits(bit_text, ot_pad)
+    return (cbit_text,ot_pad)
+
+
+def otp_decrypt(ciphertext_bits, otp):
+    """XORs the ciphertext bit list with the one-time pad (keystream) used to encrypt the ciphertext, and converts the resulting bit list back to an ASCII plaintext string.
+    """
+    pbit_text = xor_bits(ciphertext_bits,otp)
+    return bits_to_text(pbit_text)

pycryptlib/tables.py

@@ -0,0 +1,89 @@
+# This file contains all the tables necessary for DES!
+
+IP = [
+    58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,
+    62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8,
+    57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3,
+    61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7
+]
+IP_INV = [
+    40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31,
+    38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29,
+    36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27,
+    34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25
+]
+E = [
+    32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9,
+    8, 9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,
+    16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25,
+    24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32, 1
+]
+P = [
+    16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10,
+    2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25
+]
+PC1 = [
+    57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,
+    10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36,
+    63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,
+    14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4
+]
+PC2 = [
+    14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10,
+    23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2,
+    41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
+    44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32
+]
+SHIFTS = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]
+
+# Each S-box contains four rows of 16 integers (0-15)
+SBOXES = [
+    [
+        [14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7],
+        [0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8],
+        [4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0],
+        [15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13]
+    ],
+    [
+        [15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10],
+        [3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5],
+        [0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15],
+        [13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9]
+    ],
+    [
+        [10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8],
+        [13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1],
+        [13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7],
+        [1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12]
+    ],
+    [
+        [7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15],
+        [13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9],
+        [10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4],
+        [3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14]
+    ],
+    [
+        [2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9],
+        [14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6],
+        [4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14],
+        [11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3]
+    ],
+    [
+        [12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11],
+        [10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8],
+        [9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6],
+        [4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13]
+    ],
+    [
+        [4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1],
+        [13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6],
+        [1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2],
+        [6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12]
+    ],
+    [
+        [13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7],
+        [1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2],
+        [7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8],
+        [2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11]
+    ]
+]