En criptografía , el generador de reducción es una forma de generador de números pseudoaleatorios destinado a ser utilizado en un cifrado de flujo . Fue publicado en Crypto 1993 por Don Coppersmith , Hugo Krawczyk y Yishay Mansour. [1]
El generador de contracción utiliza dos registros de desplazamiento de retroalimentación lineal . Una, llamada secuencia A , genera bits de salida, mientras que la otra, llamada secuencia S , controla su salida. Tanto A como S están sincronizados; si el bit S es 1, entonces se emite el bit A ; si el bit S es 0, el bit A se descarta, no se genera nada y los registros se sincronizan nuevamente. Esto tiene la desventaja de que la tasa de salida del generador varía irregularmente y de una manera que insinúa el estado de S ; Este problema se puede superar almacenando en un búfer la salida. La secuencia aleatoria generada por LFSR no puede garantizar la imprevisibilidad en un sistema seguro y se han propuesto varios métodos para mejorar su aleatoriedad [2]
A pesar de esta simplicidad, actualmente no se conocen ataques mejores que la búsqueda exhaustiva cuando los polinomios de retroalimentación son secretos. Sin embargo, si se conocen los polinomios de retroalimentación, el ataque más conocido requiere menos de A • S bits de salida. [3]
Una variante es el generador autorretráctil .
Este ejemplo utiliza dos LFRS de Galois para producir el flujo de bits pseudoaleatorio de salida. El código Python se puede utilizar para cifrar y descifrar un archivo o cualquier flujo de bytes.
#!/usr/bin/env python3 sistema de importación# ------------------------------------------------- --------------------------- # Las funciones de Crypto4o comienzan aquí # ----------------- -------------------------------------------------- ---------clase GLFSR : """Registro de desplazamiento de retroalimentación lineal de Galois.""" def __init__ ( self , polinomio , valor_inicial ): imprime "Usando el polinomio 0x %X , valor inicial: 0x %X ". % ( polinomio , valor_inicial ) ser . polinomio = polinomio | 1 yo . datos = valor_inicial tmp = polinomio self . máscara = 1 mientras que tmp ! = 0 : si tmp y self . máscara != 0 : tmp ^= self . mascarilla si tmp == 0 : romper ser . máscara <<= 1 def estado_siguiente ( yo ): yo . datos <<= 1 recuperación = 0 si uno mismo . datos y uno mismo . máscara ! = 0 : recuperación = 1 self . datos ^= yo . polinomio devolución de retornoclase SPRNG : def __init__ ( self , polynom_d , init_value_d , polynom_c , init_value_c ): imprime "GLFSR D0:" , self . glfsr_d = GLFSR ( polynom_d , init_value_d ) imprime "GLFSR C0:" , self . glfsr_c = GLFSR ( polinom_c , valor_inicial_c ) def next_byte ( self ): byte = 0 bitpos = 7 mientras que Verdadero : bit_d = self . glfsr_d . next_state () bit_c = self . glfsr_c . siguiente_estado () si bit_c ! = 0 : bit_r = bit_d byte |= bit_r << bitpos bits pos -= 1 si bitpos < 0 : romper byte de retorno# ------------------------------------------------- --------------------------- # Las funciones de Crypto4o terminan aquí # ----------------- -------------------------------------------------- ---------def principal (): prng = SPRNG ( int ( sys . argv [ 3 ], 16 ), int ( sys . argv [ 4 ], 16 ), int ( sys . argv [ 5 ], 16 ), int ( sys . argv [ 6 ], 16 ), ) con open ( sys . argv [ 1 ], "rb" ) como f , open ( sys . argv [ 2 ], "wb" ) como g : while True : input_ch = f . leer ( 1 ) si input_ch == "" : romper canal_aleatorio = prng . next_byte () y 0xFF g . escribir ( chr ( ord ( entrada_ch ) ^ random_ch ))si __nombre__ == "__main__" : principal ()