예제 #1
0
def rsa(mensaje, clave, opcion, opcion2,usuario):
    if opcion == 1:
        c_publica,c_privada = crear_claves()
        Archivos.arc_histo_rsa_llaves(c_publica,c_privada,usuario)
        return c_publica, c_privada
    if opcion == 0:
        if opcion2 == 'enc':
            mensaje = list(mensaje)
            clave_publi = clave.split(",")
            cad = encriptar_RSA(mensaje,clave_publi)
            #se guarda el historial
            Archivos.arch_historial(mensaje,clave_publi,cad,usuario)
            if len(cad) > 40:
                Archivos.arch_texto(cad,usuario)
                cad = "Debido a la longitud del mensaje se creo un archivo en la carpeta Texto."
            return cad
        if opcion2 == 'des':
            mensaje = mensaje.split(",")
            clave_privi = clave.split(",")
            cad = desencriptar_RSA(mensaje,clave_privi)
            #se guarda el historial
            Archivos.arch_historial(mensaje,clave_privi,cad,usuario)
            if len (cad) > 40:
                Archivos.arch_texto(cad,usuario)
                cad = "Debido a la longitud del mensaje se creo un archivo en la carpeta Texto."
            return cad
예제 #2
0
def main(entrada, usuario):
    """ 
    Funcion main
    param: string entrada: entrada es igual a cadena de a
    param: variable indic: llama a la funcion matroz
    param: variable a: llama a transformacion con parametros entrada, indic en posicion 0 y 1
    param: variable b: llama a que_quieres con parametros a, indic en posicion 0 y 1
    param: variable c: llama Vigenere con parametros b en posiciones [0,4] e indic en posicion 0 y 1
    param: variable d: llama act_llave con parametros b en posicion 1, c , b en posicion 2 y 3 e indic en posicion 0 y 1
    return: d
    """
    #entrada = a
    #usuario = 'Sergio'
    indic = matroz()
    a = transformacion(entrada, indic[0], indic[1])
    b = que_quieres(a, indic[0], indic[1])
    c = Vigenere(b[0], b[1], b[2], b[3], indic[0], indic[1])
    d = act_llave(b[1], c, b[2], b[3], indic[0], indic[1])
    mensaje = b[1]
    clave = b[0]
    if d != mensaje :
        Archivos.arch_historial(mensaje,clave,d,usuario)
        # escribir mensaje desencriptado

    if len(d) > 40:
        Archivos.arch_texto(d,usuario)
        d = "Debido a la longitud del mensaje se creo un archivo en la carpeta Texto."
    return d, mensaje, clave, usuario
예제 #3
0
def Desencriptar_Cesar(cadena1, mov, usuario):
    """
    Desencriptar_Cesar esta funcion se encarga de hacer la desencriptacion en base al algorimo Cesar
    :param string cadena1: El texto o mensaje que se desea desencriptar.
    :param int mov: El numero de movimientos que desea que se mueva cada elemento de la cadena.
    :return:  mensaje encriptado.
    """
    cadena2 = ""
    if mov > 25 or mov < 0:
        mov = mov % 26
    for i in range(len(cadena1)):
        val = ord(cadena1[i])
        if cadena1[i] == " ":
            cadena2 = cadena2 + " "
        elif val >= 65 and val <= 90:
            val = val - 65 - mov
            if val < 0:
                val = 26 + val
            if val > 25:
                val = val % 26

            val = val + 65
            cadena2 = cadena2 + chr(val)
        elif val >= 97 and val <= 122:
            val = val - 97 - mov
            if val < 0:
                val = 26 + val
            if val > 25:
                val = val % 26
            val = val + 97
            cadena2 = cadena2 + chr(val)
    if len(cadena2) > 40:
        Archivos.arch_texto(cadena2, usuario)
        cadena2 = "Debido a la longitud del mensaje se creo un archivo en la carpeta Texto."
    return cadena2
def desencriptar_Solitario(cadena, clave, usuario):
    """
    Dncriptar_Solitario esta funcion se encarga de hacer la desencriptacion en base al algorimo Solitario
    :param string cadena1: El texto o mensaje que se desea desencriptar.
    :param string clave: la clave con la cual es mensaje se restara para generar el mensaje desencriptado.
    :return:  mensaje desencriptado.
    """
    cadenaaux = ""
    for i in range(len(cadena)):
        c1 = buscar(cadena[i])
        z1 = buscar(clave[i])
        op = c1 - z1
        if op < 0:
            op = 114 + op
        pos = entregar(op)
        cadenaaux += pos
    if len(cadenaaux) >= 40:
        Archivos.arch_texto(cadenaaux, usuario)
        cadenaaux = "Debido a la longitud del mensaje se creo un archivo en la carpeta Texto."
    return cadenaaux
def encriptar_Solitario(cadena, clave, clave_inicial, usuario):
    """
    Encriptar_Solitario esta funcion se encarga de hacer la encriptacion en base al algorimo Solitario
    :param string cadena1: El texto o mensaje que se desea encriptar.
    :param string clave: la clave con la cual es mensaje se sumara para generar el mensaje encriptado.
    :return:   mensaje encriptado.
    """
    cadenaaux = ""
    for i in range(len(cadena)):
        c1 = buscar(cadena[i])
        z1 = buscar(clave[i])
        op = c1 + z1
        if op > 115:
            op = op % 115
        pos = entregar(op)
        cadenaaux += pos
    # llama a la funcion para guardar en el historial
    Archivos.arch_historial(cadena, clave_inicial, cadenaaux, usuario)
    if len(cadenaaux) >= 40:
        Archivos.arch_texto(cadenaaux, usuario)
        cadenaaux = "Debido a la longitud del mensaje se creo un archivo en la carpeta Texto."

    return cadenaaux
예제 #6
0
def encriptar(mensaje, clave, clave_inicial, usuario):
    """
    encriptar recibe el mensaje para encriptar y su respectiva clave, le aplica la tabla de verdad XOR a los codigos binarios de estos
    :param strign x: mensaje en mayuscula
    :param strign y: clave en maniscula
    :param lista mensaje_binario: codigos binarios del mensaje
    :param lista clave_binario: codigos binarios de la clave
    :param lista mensaje_encriptado: lista de codigos binarios 
    :param string string_encriptada: string despues de realizar la encriptación con el metodo Vernam
    :return: retorna cadena de caracteres encriptados
    """
    x = mensaje.upper()
    y = clave.lower()
    mensaje_binario = s2b(x)
    clave_binario = s2b(y)
    mensaje_encriptado = []
    for i in range(0, len(mensaje_binario)):
        res = ""
        for j in range(0, 8):
            x = mensaje_binario[i]
            y = x[j]
            x2 = clave_binario[i]
            y2 = x2[j]
            if x == "01000000":
                res += "01000000"
                break
            elif y == y2:
                res += "0"
            else:
                res += "1"
        mensaje_encriptado.append(res)
    string_encriptada = b2s(mensaje_encriptado)
    Archivos.arch_historial(mensaje, clave_inicial, string_encriptada, usuario)
    if len(mensaje) > 40:
        Archivos.arch_texto(string_encriptada, usuario)
        string_encriptada = "Debido a la longitud del mensaje se creo un archivo en la carpeta Texto."
    return string_encriptada