RSA blokový převod – Python – Fórum – Programujte.com

 Potřeboval bych pomoct snažim se pro RSA šifrovaní, aby fungovalo misto šifrovaní po znacích tak bude šifrovat bloky, pro jeden blok mi převod funguje, ale pokud se vytvoří další tak převod nefunguje a nevím jak to opravit

def text_to_numeric_binary_blocks(text):
    block_size = 10
    numeric_decimal_blocks = []

    for i in range(0, len(text), block_size):
        block = text[i:i + block_size]
        numeric_decimal_block = int(''.join(format(ord(char), '010b') for char in block), 2)
        numeric_decimal_blocks.append(numeric_decimal_block)

    numeric_binary_blocks = [format(block, '010b') for block in numeric_decimal_blocks]

    # Join binary blocks into a single string without separators
    binary_representation = ''.join(numeric_binary_blocks)

    return numeric_decimal_blocks, binary_representation

def numeric_to_text_binary_blocks(numeric_decimal_blocks, block_size):
    # Convert each numeric block to a string and then concatenate them
    numeric_representation = ''.join(map(str, numeric_decimal_blocks))

    # Convert the combined string to an integer
    numeric_representation = int(numeric_representation)

    # Convert the integer to binary representation
    binary_representation = format(numeric_representation, 'b')

    # Pad the binary representation to ensure a multiple of block_size for ASCII conversion
    binary_representation = binary_representation.rjust(((len(binary_representation) + block_size - 1) // block_size) * block_size, '0')

    # Split the binary representation into blocks of size block_size
    binary_blocks = [binary_representation[i:i + block_size] for i in range(0, len(binary_representation), block_size)]

    # Convert each block back to an integer and then to its ASCII character
    text = ''.join(chr(int(block, 2)) for block in binary_blocks)

    # Remove any extra null characters at the end
    text = text.rstrip('\x00')

    return text, numeric_decimal_blocks

def test_conversion(message):
    numeric_decimal_blocks, binary_representation = text_to_numeric_binary_blocks(message)
    converted_text, _ = numeric_to_text_binary_blocks(numeric_decimal_blocks, 10)

    print(f"Original message: {message}")
    print(f"Numeric Decimal Blocks: {numeric_decimal_blocks}")
    print(f"ASCII Values: {[ord(char) for char in message]}")
    print(f"Binary Blocks: {binary_representation}")
    print(f"Converted message: {converted_text}")

if __name__ == "__main__":
    test_conversion("1234567890")
    test_conversion("12345678901")

Před spojováním těch bloků musíš zajistit, aby všechny měly stejnou délku, jinak se ti je nepodaří správně rozdělit.

Ty konverze na inty a stringy jsou všechny blbě. Na implementaci samotného RSA můžeš použít inty, ale do ničeho jiného je nemíchej a zpracovávej to jako binární bloky.

#2 gna

 Už jsem to opravil a přidal prvky šifrovaní, jen někdy výstup se spravně dešifruje a někdy ne. A funguje jen pro 8 bity, ale chtěl bych, aby fungoval i pro č,ě,ř což je 9 bitu ale nevím jak to udělat. Nevíte prosím?

import random
from math import gcd
from sympy import mod_inverse, isprime

class SimpleRSA:
    def __init__(self):
        self.public_key = None
        self.private_key = None

    def generate_keypair(self):
        if self.public_key is not None and self.private_key is not None:
            return

        p = self.generate_large_prime()
        q = self.generate_large_prime()

        n = p * q
        phi = (p - 1) * (q - 1)

        e = random.randint(2, phi - 1)
        while gcd(e, phi) != 1:
            e = random.randint(2, phi - 1)

        d = mod_inverse(e, phi)

        self.public_key = (n, e)
        self.private_key = (n, d)

        return self.public_key, self.private_key

    def generate_large_prime(self):
        lower_limit = 10 ** 11
        upper_limit = 10 ** 12
        potential_prime = random.randint(lower_limit, upper_limit)
        while not isprime(potential_prime):
            potential_prime = random.randint(lower_limit, upper_limit)
        return potential_prime

    def encrypt(self, message):
        n, e = self.public_key
        binary_blocks = self.text_to_numeric_binary_blocks(message)

        print(f"binary_blocks: {binary_blocks}")

        encrypted_blocks = [pow(int(block, 2), e, n) for block in binary_blocks]

        print(f"encrypted_blocks: {encrypted_blocks}")

        return encrypted_blocks

    def decrypt(self, encrypted_blocks):
        n, d = self.private_key

        decrypted_blocks = [format(pow(block, d, n), '0b') for block in encrypted_blocks]

        print(f"decrypted_blocks: {decrypted_blocks}")

        decrypted_message = self.numeric_to_text_binary_blocks(decrypted_blocks)

        print(f"decrypted_message: {decrypted_message}")

        return decrypted_message


    def text_to_numeric_binary_blocks(self, text, block_size=10):
        binary_blocks = [
            ''.join(format(ord(char), '08b') for char in text[i:i + block_size]).rjust(block_size * 8, '0')
            for i in range(0, len(text), block_size)
        ]
        return binary_blocks

    def numeric_to_text_binary_blocks(self, binary_blocks):
        bytes_list = [int(block, 2).to_bytes((len(block) + 7) // 8, 'big') for block in binary_blocks]
        text = b''.join(bytes_list).decode(errors='replace')
        return text


def test_encryption_decryption(message):
    rsa = SimpleRSA()
    public_key, private_key = rsa.generate_keypair()

    print(f"Original message: {message}")

    # Encryption
    encrypted_blocks = rsa.encrypt(message)
    print(f"Encrypted blocks: {encrypted_blocks}")

    # Decryption
    decrypted_message = rsa.decrypt(encrypted_blocks)
    print(f"Decrypted message: {decrypted_message}")

if __name__ == "__main__":

    test_encryption_decryption("Hello Wolr")

chyba bude asi v tom šifrovacím a dešifrovacím kliči, ne? Umí ten klíč zpracovat 9-bitové znaky? Nebo to je tak, že 9.bit odkazuje na tabulku speciálních 8-bitových znaků kde je č ěř ... ? V tom případě nutno tomu šifrovacímu klíči nejprve říci v které tabulce má hledat.

Viděl jsi někdy slovník japonských kanji znaků? To jsou stovky stran tabulek. Na každé straně je tabulka se znaky. Každý znak (japonsky se nazývají "kanji") má různé čtení a různé významy. Představ si, že je máš dešifrovat. Musíš tomu dešifrátoru říci nejprve v které tabulce má hledat. Potom, když dešifrátor najde tu tabulku, musíš mu říci kód znaku ( to je těch tvých 8 bitů). Potom ten dešifrátor vybere správný znak.

A když už jsem u tohoto, dešifrování po písmenech je hloupost, Šifruj po slovech. Dívej se na slova, že to jsou "znaky" obdoba japonských kanji. Písmen je sotva 30, ale slov, tedy znaků jsou tisíce a mnoho z nich má různý význam. Pravděpodobnost náhodného dešifrování, nalezení klíče, se významně zmenší.

Ty konverze na binární stringy jsou k ničemu, ale budiž...

Kóduj to po bajtech, ne po znacích, aby se ti to vešlo do těch 8 bitů.

Místo rjust dej ljust, protože s tím pak pracuješ jako big-endian intem, tak ať to zarovnání máš na konci.

Použij kratší bloky, nebo uprav generovaní klíčů pro větší.

def text_to_numeric_binary_blocks(self, text, block_size=8):
    text = text.encode()
    binary_blocks = [
        ''.join(format(byte, '08b') for byte in text[i:i + block_size]).ljust(block_size * 8, '0')
        for i in range(0, len(text), block_size)
    ]
    return binary_blocks

def numeric_to_text_binary_blocks(self, binary_blocks, block_size=8):
    bytes_list = [int(block, 2).to_bytes(block_size, 'big') for block in binary_blocks]
    text = b''.join(bytes_list).decode(errors='replace').rstrip("\x00")
    return text

#5 gna
zase děkujiii moooc, cele dny jsem na to nemohl přijit, ale už mi to funguje podle toho.

#6 Paragoon2
#5 gna
Pro délku 8 znaku to funguje.Jen mam striktně zadaný že block_size musí být po 10 a klíč musí mít lower_limit = 10 ** 11 upper_limit = 10 ** 12