ACYNOS (Tomillo)

#!/usr/bin/python
"""
Criptosistema ACYMOS2 por Agustin, Kriptopolis
 

Notas:
 "~" representa la "enye"
 Los comentarios estan sin acentos y caracteres especiales


by xiscu [en] email [punto] de
"""

import re
from decimal import *
from math import *

###############################################################################
# CONFIGURACION Y CONSTANTES

## El alfabeto basico
ALFABETO_BASE = list('ABCDEFGHIJKLMN~OPQRSTUVWXYZ_')
ALFA_N = len(ALFABETO_BASE)


## Traducciones 
espacio = re.compile(' ')     # 1
enye = re.compile('\xc3\x91') # 2
retorno = re.compile('\n')    # 3


## Numero de Cifras decimales
ND = 10
DIEZ_DECIMALES = Decimal(10) ** -ND


## Fichero con numeros primeros
FICHERO_PRIMOS = '100000_primos.txt'
PRIMOS=[]


###############################################################################
# FUNCIONES INTERNAS

def lee_primos():
    f=None
    try:
        f=open(FICHERO_PRIMOS)
        for linea in f:
            primos_texto=linea.split()
            for p in primos_texto:
                PRIMOS.append(int(p))
    except:
        raise
    
    finally:
        if f:
            f.close() 

## Lee los primos
lee_primos()

## Constante PI_DECIMAL
PI_DEC = Decimal('3.1415926536')


###############################################################################
# FUNCIONES EXPORTADAS

def texto_a_ascii(texto):
    """Traduce un texto a ascii
    """
    tt = espacio.sub('_', texto) # 1
    tt = enye.sub('~', tt)       # 2
    tt = retorno.sub('', tt)     # 3
    
    return tt

    
def lan(alfabeto, letras):
    """Traduce una o una lista de letras a numeros segun el orden del alfabeto
    """
    index_mas1 = lambda letra: alfabeto.index(letra) + 1
    if len(letras)==1:
        return index_mas1(letras)
    else:
        return map(index_mas1, letras)


def primo_n(n):
    """Retorna el primo numero n, empezando a contar por 0
    """
    return PRIMOS[n]


def s_alfa(clave):
    """Calcula la semilla para contruir el alfabeto derivado con la clave dada
    """
    s=Decimal(0)
    pn=0
    for c in clave:
        n=lan(ALFABETO_BASE, c) 
        s+=n * Decimal(primo_n(pn)).log10()
        pn+=1

    # Desplazamiento
    d=s.adjusted()+1
    s=s/Decimal(10**d)

    return s.quantize(DIEZ_DECIMALES)


def s_cifra(clave):
    """Calcula la semilla para contruir el cifrado (Ai) con la clave dada
    """
    s=Decimal(0)
    alfa_derivado=alfa_k(clave)
    pn=0
    for c in clave:
        n=lan(alfa_derivado, c)
        s+=n * Decimal(primo_n(pn)).log10()
        pn+=1

    # Desplazamiento
    d=s.adjusted()+1
    s=s/Decimal(10**d)

    return s.quantize(DIEZ_DECIMALES)


def pseudo(s):
    """Calcula el siguiente numero pseudo aleatorio
    """
    resto = divmod((PI_DEC + s)**2, Decimal(1))[1]
    
    return resto.quantize(DIEZ_DECIMALES)


def fn_a(l, s):
    """Funcion A para el calculo de la siguiente letra en el alfabeto
    derivado
    """
    n = s * (l-1)+1
    
    # Solo la parte entera
    return int(n.quantize(1))


def alfa_k(clave):
    """Calcula el alfabeto derivado para la clave dada
    """
    s = s_alfa(clave)
    alfa_act = list(ALFABETO_BASE)
    alfa_derivado = []
    for n in range(ALFA_N):
        # Numero pseudoaleatorio
        s = pseudo(s)                             
        
        # L (Longitud restante)
        l = ALFA_N - n

        # Funcion A (el "-1" es para el siguiente indexado)
        p = fn_a(l, s) - 1 

        # Nueva letra
        alfa_derivado.append(alfa_act[p])

        # Resto alfabeto
        alfa_act = alfa_act[0:p] + alfa_act[p+1::]  
    
    return alfa_derivado
    


def ldist(letra, pos):
    """Toma una letra a distancia "x" del alfabeto base
    """
    nueva_letra = (ALFABETO_BASE.index(letra) + pos) % NUM_LETRAS

    return ALFABETO_BASE[nueva_letra]


def codifica(clave, texto, formato_s='t'):
    """Codifica un texto con la clave

    Uso: codifica(clave, texto, formato)
    Donde los parametros son:
    - clave: clave usada para cifrar (en mayusculas)
    - texto: texto a cifrar (en mayusculas y ya traducido)
    - formato_s: formato de salida. 't' texto (por defecto) y 'n' numerico
    """

    # Alfabeto derivado
    alfa_d = alfa_k(clave)

    # Tamano de la clave
    clave_n = len(clave)

    # Posiciones de las letras de la clave en el alfabeto derivado
    clave_ki = lan(alfa_d, clave)

    # Semilla aleatoria para la el calculo del cifrado
    s0 = s_cifra(clave)

    # Cifrado
    cifra = []
    sa = s0
    for n, ca in enumerate(texto):
        sa = pseudo(sa)
        a = fn_a(ALFA_N, sa)
        k = clave_ki[n % clave_n]
        p = lan(alfa_d, ca)
        c = (a + p + k) % ALFA_N
        if c == 0:
            c = ALFA_N

        cifra.append(c)
    
    # Formato de salida en texto ?
    if formato_s == 't':
        pos_menos1 = lambda pos: alfa_d.__getitem__(pos-1)
        return ''.join(map(pos_menos1, cifra))
    
    return cifra


def decodifica(clave, texto, formato_s='t'):
    """ Decodifica un texto con la clave

    Uso: decodifica(clave, texto, formato)
    Donde los parametros son:
    - clave: clave para descifrar (en mayusculas)
    - texto: texto a descifrar (en mayusculas)
    - formato_s: formato de salida. 't' texto (por defecto) y 'n' numerico
    """
    
    # Alfabeto derivado
    alfa_d = alfa_k(clave)

    # Tamano de la clave
    clave_n = len(clave)

    # Posiciones de las letras de la clave en el alfabeto derivado
    clave_ki = lan(alfa_d, clave)

    # Semilla aleatoria para la el calculo del cifrado
    s0 = s_cifra(clave)

    # Cifrado
    claro = ''
    sa = s0
    for n, ca in enumerate(texto):
        sa = pseudo(sa)
        a = fn_a(ALFA_N, sa)
        k = clave_ki[n % clave_n]
        c = lan(alfa_d, ca)
        p = (c - a - k) % ALFA_N
        p = p % ALFA_N
        if p == 0:
            p = ALFA_N
         
        claro += alfa_d[p-1]
    
    # Formato de salida numerico ?
    if formato_s == 'n':
        index_mas1 = lambda pos: ALFABETO_BASE.index(pos) + 1
        claro = map(index_mas1, claro)

    return claro 


###############################################################################
# Ejecucion directa del modulo: Ejecuta los tests
#
if __name__ == '__main__' :
    
    import unittest
    
    ###########################################################################
    # Definicion de los tests
    class TestACYNOS2(unittest.TestCase):

        def test_letra_a_numero(self):
	        self.assertEqual(lan('ABC', 'A'), 1)
	        self.assertEqual(lan('ABC', 'C'), 3)
	        self.assertRaises(ValueError, lan, 'ABC', 'D')


        def test_traduccion(self):
            self.assertEqual(texto_a_ascii('ABCDE'), 'ABCDE')
            self.assertEqual(texto_a_ascii(''), '')
            self.assertEqual(texto_a_ascii('\xc3\x91'), '~')
            self.assertEqual(texto_a_ascii(' '), '_')
            self.assertEqual(texto_a_ascii('\n'), '')


        def test_lee_primos(self):
            self.assertEqual(primo_n(0), 2)
            self.assertEqual(primo_n(1), 3)
            self.assertEqual(primo_n(100007), 1299827)


        def test_semilla_alfabeto(self):
            self.assertEqual(s_alfa(''), Decimal(0))
            self.assertEqual(s_alfa('VALE'), Decimal("0.2001394141")) 


        def test_pi_decimal(self):
            self.assertEqual(PI_DEC, Decimal("3.1415926536"))


        def test_pseudo(self):
            self.assertEqual(
                pseudo(Decimal("0.2001394141")),
                Decimal("0.1671732123")) 

            self.assertEqual(
                pseudo(Decimal("0.1671732123")),
                Decimal("0.9479315553")) 
           
            sa=Decimal("0.2001394141")
            for s in range(28):
                sa=pseudo(sa) 
             
            self.assertEqual(sa, Decimal("0.3376494172")) 


        def test_fn_a(self):
            s = Decimal("0.1671732123")
            self.assertEqual(fn_a(28, s), 6) 
            
            s = Decimal("0.9479315553")
            self.assertEqual(fn_a(27, s), 26)

            s = Decimal("0.7242082552")
            self.assertEqual(fn_a(26, s), 19)

            s = Decimal("0.9444166665")
            self.assertEqual(fn_a(25, s), 24)


        def test_alfa_derivado(self):
            alfa_derivado = alfa_k('VALE')
            self.assertEqual(ALFA_N, len(alfa_derivado))
            self.assertEqual(
                alfa_derivado,
                list('FZSYQRXNDAVGBWLUKHEPOMIJT~_C'))
       

        def test_semilla_cifrado(self):
            self.assertEqual(s_cifra(''), Decimal(0))
            
            s0_cifrado=Decimal("0.3462395532") 
            self.assertEqual(s_cifra('VALE'), s0_cifrado)
            
            s115 = Decimal("0.4232082654")
            si = s0_cifrado
            for i in range(115):
                si=pseudo(si)

            self.assertEqual(si, s115)
        

        def test_de_claro_a_pi(self):
            clave = 'VALE'
            claro = "LA_HEROICA_CIUDAD_DORMIA"
            pi = [15,10,27,18,19,06,21,23,28,10,\
                  27,28,23,16, 9,10, 9,27, 9,21,\
                  06,22,23,10]
            
            r = lan(alfa_k(clave), claro)
            for n, (c, p) in enumerate(zip(r, pi)):
                self.assertEqual(c, p, "C: %d, P: %d, N: %d"% (c, p, n))


        def test_cifrado(self):
            # cifrado vacio
            self.assertEqual('', codifica('', ''))
            self.assertEqual([], codifica('', '', 'n'))

            clave = 'VALE'
            claro = 'LA_HEROICA_CIUDAD_DORMIA'
            cin = [ 3,18, 3,11, 6, 7,20, 1,22, 2,\
                   13,16,11,18,19,18,23,16, 8, 4,\
                   14,10,13,13]

            cit = 'SHSVRXPFMZBUVHEHIUNYWABB' 

            r = codifica(clave, claro, 'n')
            
            self.assertEqual(len(r), len(claro))
            
            for n, (c, p) in enumerate(zip(r, cin)):
                self.assertEqual(c, p, "C: %d, P: %d, N: %d"% (c, p, n))

            r = codifica(clave, claro)
            for n, (c, p) in enumerate(zip(r, cit)):
                self.assertEqual(c, p, "C: %s, P: %s, N: %d"% (c, p, n))


        def test_descifrado(self):
            # cifrado vacio
            self.assertEqual('', decodifica('', ''))
            self.assertEqual([], decodifica('', [], 'n'))

            clave = 'VALE'
            claro = 'LA_HEROICA_CIUDAD_DORMIA'
            
            lan_alfabase = lambda letra: lan(ALFABETO_BASE, letra)
            claro_num = map(lan_alfabase, claro)
            
            cit = 'SHSVRXPFMZBUVHEHIUNYWABB' 
           
            # Formato de salida numerico
            r = decodifica(clave, cit, 'n')
            self.assertEqual(len(r), len(claro))

            for n, (c_desc, c_claro) in enumerate(zip(r, claro_num)):
                self.assertEqual(c_desc, c_claro,
                    "Caracter descifrado: %s, Caracter claro: %s, N: %d" % 
                    (c_desc, c_claro, n))

            # Formato de salida texto
            r = decodifica(clave, cit)
            self.assertEqual(len(r), len(claro))
            for n, (c_desc, c_claro) in enumerate(zip(r, claro)):
                self.assertEqual(c_desc, c_claro,
                    "Caracter descifrado: %s, Caracter claro: %s, N: %d" % 
                    (c_desc, c_claro, n))


    ###########################################################################
    # Ejecucion de los tests
    unittest.main()