cgacryptpy 0.1.0__tar.gz

cgacryptpy-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+dist/
+build/
+*.egg-info/
+.venv/
+.env

cgacryptpy-0.1.0/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.

cgacryptpy-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,67 @@
+# 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/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pycryptlib"]
+
+[project]
+name = "cgacryptpy"
+version = "0.1.0"
+description = "This library contains a multitude of cryptography functions that can be used in python."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Seth Bacher", email = "sethrider02@gmail.com" }]
+dependencies = []
+classifiers = [
+    "Programming Language :: Python :: 3",
+]
+
+[project.urls]
+Homepage = "https://github.com/SethRider02/pycryptlib"

cgacryptpy-0.1.0/src/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

cgacryptpy-0.1.0/src/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)

cgacryptpy-0.1.0/src/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")

cgacryptpy-0.1.0/src/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

cgacryptpy-0.1.0/src/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
+
+