Python Mi primer programa (en beta)

[Visitante]

Acabo de acabar mi primer programa propio en python que es capaz de encriptar y desencriptar información usando mi propio método de encriptación, lo dejo aquí porque me gustaría compartirlo con más gente y a ser posible decirme si hay algún bug.
Tengo que escribir el código porque no me deja subir el formato del archivo, ustedes lo que hacen es copiar y pegarlo en un bloc de notas, y guardarlo con la extensión .py, luego es abrirlo en python 2.7.3, el código es el siguiente:

print "Copyright malevolex 2015"
def decrypt():
    encrypted=raw_input("enter here the encrypted message:")
    encrypted=encrypted.strip()
    n=0
    z="Deencrypted message: "
    for letter in encrypted:
        if letter == " ":
            n=n+1
    while n>0:
        f=encrypted.find(" ")
        d=encrypted[:f]
        try:
            d=int(d)
        except: 
            print "enter a numerical encrypted message"
            break
        m=d%59
        if m==0:
            let=">"
        if m==1:
            let="a"
        if m==2:
            let="b"
        if m==3:
            let="c"
        if m==4:
            let="d"
        if m==5:
            let="e"            
        if m==6:
            let="f"        
        if m==7:
            let="g"        
        if m==8:
            let="h"            
        if m==9:
            let="i"        
        if m==10:
            let="j"        
        if m==11:
            let="k"        
        if m==12:
            let="l"        
        if m==13:
            let="m"        
        if m==14:
            let="n"        
        if m==15:
            let=" "
        if m==16:
            let="o"
        if m==17:
            let="p"
        if m==18:
            let="q"
        if m==19:
            let="r"
        if m==20:
            let="s"
        if m==21:
            let="t"
        if m==22:
            let="u"
        if m==23:
            let="v"
        if m==24:
            let="w"
        if m==25:
            let="x"
        if m==26:
            let="y"
        if m==27:
            let="z"
        if m==28:
            let="1"
        if m==29:
            let="2"
        if m==30:
            let="3"
        if m==31:
            let="4"
        if m==32:
            let="5"
        if m==33:
            let="6"
        if m==34:
            let="7"
        if m==35:
            let="8"
        if m==36:
            let="9"
        if m==37:
            let="^"
        if m==38:
            let="!"
        if m==39:
            let="["
        if m==40:
            let="?"
        if m==41:
            let="]"
        if m==42:
            let="#"
        if m==43:
            let="%"
        if m==44:
            let="&"
        if m==45:
            let="~"
        if m==46:
            let="("
        if m==47:
            let=")"
        if m==48:
            let="/"
        if m==49:
            let="*"
        if m==50:
            let="+"
        if m==51:
            let="-"
        if m==52:
            let="_"
        if m==53:
            m=="."
        if m==54:
            let=","
        if m==55:
            let=";"
        if m==56:
            let=":"
        if m==57:
            let="<"
        if m==58:
            let="@"
        z=z+let
        
        encrypted=encrypted[f+1:]
        n=n-1
    try:
        encrypted=float(encrypted)
        m=encrypted%59
        if m==0:
            let=">"
        if m==1:
            let="a"
        if m==2:
            let="b"
        if m==3:
            let="c"
        if m==4:
            let="d"
        if m==5:
            let="e"            
        if m==6:
            let="f"        
        if m==7:
            let="g"        
        if m==8:
            let="h"            
        if m==9:
            let="i"        
        if m==10:
            let="j"        
        if m==11:
            let="k"        
        if m==12:
            let="l"        
        if m==13:
            let="m"        
        if m==14:
            let="n"        
        if m==15:
            let=" "
        if m==16:
            let="o"
        if m==17:
            let="p"
        if m==18:
            let="q"
        if m==19:
            let="r"
        if m==20:
            let="s"
        if m==21:
            let="t"
        if m==22:
            let="u"
        if m==23:
            let="v"
        if m==24:
            let="w"
        if m==25:
            let="x"
        if m==26:    
            let="y"
        if m==27:
            let="z"
        if m==28:
            let="1"
        if m==29:
            let="2"
        if m==30:
            let="3"
        if m==31:
            let="4"
        if m==32:
            let="5"
        if m==33:
            let="6"
        if m==34:
            let="7"
        if m==35:
            let="8"
        if m==36:
            let="9"
        if m==37:
            let="^"
        if m==38:
            let="!"
        if m==39:
            let="["
        if m==40:
            let="?"
        if m==41:
            let="]"
        if m==42:
            let="#"
        if m==43:
            let="%"
        if m==44:
            let="&"
        if m==45:
            let="~"
        if m==46:
            let="("
        if m==47:    
            let=")"
        if m==48:
            let="/"
        if m==49:
            let="*"
        if m==50:
            let="+"
        if m==51:
            let="-"
        if m==52:
            let="_"
        if m==53:
            m=="."
        if m==54:
            let=","
        if m==55:
            let=";"
        if m==56:
            let=":"
        if m==57:
            let="<"
        if m==58:
            let="@"
        z=z+let
            print z
    except:
        print "Introduce a numerical encrypted message"
        
    
def encrypt():
    message=raw_input("Enter your message here")
    message=message.lower()
    while True:
        try:
            base=raw_input("Enter the base in numerical input")
            base=int(base)
            break
        except:
            print "please enter numerical input"
    n="encrypted data:"
    for letter in message:
        if letter==">":
            m=59*34*base
            m=str(m)
        if letter=="a":
            m=59*23*base+1
            m=str(m)
        if letter=="b":
            m=59*876*base+2
            m=str(m)
        if letter=="c":
            m=59*24*base+3
            m=str(m)
        if letter=="d":
            m=59*1243*base+4
            m=str(m)
        if letter=="e":
            m=59*234*base+5
            m=str(m)    
        if letter=="f":
            m=59*22*base+6
            m=str(m)
        if letter=="g":
            m=59*19*base+7
            m=str(m)
        if letter=="h":
            m=59*468*base+8
            m=str(m)
        if letter=="i":
            m=59*242*base+9
            m=str(m)
        if letter=="j":
            m=59*23*base+10
            m=str(m)
        if letter=="k":
            m=59*143*base+11
            m=str(m)
        if letter=="l":
            m=59*64*base+12
            m=str(m)
        if letter=="m":
            m=59*45*base+13
            m=str(m)
        if letter=="n":
            m=59*87*base+14
            m=str(m)
        if letter==" ":
            m=59*base+15
            m=str(m)
        if letter=="o":
            m=59*65*base+16
            m=str(m)
        if letter=="p":
            m=59*54*base+17
            m=str(m)
        if letter=="q":
            m=59*59*base+18
            m=str(m)
        if letter=="r":
            m=59*123*base+19
            m=str(m)
        if letter=="s":
            m=59*54*base+20
            m=str(m)
        if letter=="t":
            m=59*234*base+21
            m=str(m)
        if letter=="u":
            m=59*435*base+22
            m=str(m)
        if letter=="v":
            m=59*32*base+23
            m=str(m)
        if letter=="w":
            m=59*543*base+24
            m=str(m)
        if letter=="x":
            m=59*531*base+25
            m=str(m)
        if letter=="y":
            m=59*43*base+26
            m=str(m)
        if letter=="z":
            m=59*231*base+27
            m=str(m)
        if letter=="1":
            m=59*444*base+28
            m=str(m)
        if letter=="2":
            m=59*234*base+29
            m=str(m)
        if letter=="3":
            m=59*56*base+30
            m=str(m)
        if letter=="4":
            m=59*993*base+31
            m=str(m)
        if letter=="5":
            m=59*2349*base+32
            m=str(m)
        if letter=="6":
            m=59*9378*base+33
            m=str(m)
        if letter=="7":
            m=59*534*base+34
            m=str(m)
        if letter=="8":
            m=59*534*base+35
            m=str(m)
        if letter=="9":
            m=59*593*base+36
            m=str(m)
        if letter=="^":
            m=59*3452*base+37
            m=str(m)
        if letter=="!":
            m=59*3456*base+38
            m=str(m)
        if letter=="[":
            m=59*345*base+39
            m=str(m)
        if letter=="?":
            m=59*513*base+40
            m=str(m)
        if letter=="]":
            m=59*534*base+41
            m=str(m)
        if letter=="#":
            m=59*42*base+42
            m=str(m)
        if letter=="%":
            m=59*432*base+43
            m=str(m)
        if letter=="&":
            m=59*54*base+44
            m=str(m)
        if letter=="~":
            m=59*2*base+45
            m=str(m)
        if letter=="(":
            m=59*3*base+46
            m=str(m)
        if letter==")":
            m=59*4*base+47
            m=str(m)
        if letter=="/":
            m=59*431*base+48
            m=str(m)
        if letter=="*":
            m=59*951*base+49
            m=str(m)
        if letter=="+":
            m=59*143*base+50
            m=str(m)
        if letter=="-":
            m=59*544*base+51
            m=str(m)
        if letter=="_":
            m=59*12*base+52
            m=str(m)
        if letter==".":
            m=59*13*base+53
            m=str(m)
        if letter==",":
            m=59*243*base+54
            m=str(m)
        if letter==";":
            m=59*43*base+55
            m=str(m)
        if letter==":":
            m=59*2134*base+56
            m=str(m)
        if letter=="<":
            m=59*439*base+57
            m=str(m)
        if letter=="@":
            m=59*4315*base+58
            m=str(m)
        n=n+" "+m
    print n


while True:
    ask=raw_input("Wanna encrypt or decrypt? If you are done, then write finished: ")
    if ask=="encrypt":
        encrypt()
    if ask=="decrypt":
        decrypt()
    if ask=="finished":
        print "Done!"
        break
exit()

Saludos,
Malevolex

[Weip]

Re: Mi primer programa (en beta)

Lo primero, felicitarte por el programa. Tendrá sus contras y seguro que no es la mejor forma de hacerlo, pero te las has sabido apañar. Te animo a que aprendas más programación para poder optimizar tu código y mejorar también tu método para cifrar/descifrar mensajes.

Eso sí, quiero comentarte una cosa. El usuario no tiene porqué saber como está hecho el programa. Por lo tanto el usuario puede tener necesidad de cifrar \hola o | pero entonces sale un error. No digo que lo tengas que corregir, si no más bien pensar de cara al futuro que la presentación del programa de cara al usuario ha de ser la mejor posible. Has de cubrir todos los casos posibles y que salten los mensajes de error pertinentes hechos por ti mismo.

[Visitante]

Re: Mi primer programa (en beta)

Gracias, lo tendré en cuenta.
Estoy aprendiendo python en un curso y ya tengo nuevas ideas para mejorarlo, pero ahora con el final del trimestre tengo poco tiempo, cuando ya lo haya mejorado publicaré aquí la versión final, por ahora esta en beta.

[teclado]

Re: Mi primer programa (en beta)

No soy muy experto en Python pero a voz de pronto no le veo ningún fallo garrafal. Lo único que puedo decir es que al menos en la función decrypt() tienes demasiados condicionales uno detrás de otro, eso podría hacerse de forma más cómoda usando arrays. Primero defines un array global (si lo haces dentro de la función se llamaría cada vez que se llame, pero también valdría) con los valores desencriptados:

valores=["a","b","c",...]

Y en la función solo tienes que obtener la letra correspondiente por el índice:

let=valores[m]

No es ningún fallo, es más una cuestión de rendimiento, el acceso a un elemento de un array siempre será más rápido que evaluar tantas condiciones.

Saludos

- - - Actualizado - - -

Lo he estado probando y he encontrado un pequeño fallo de usabilidad. Si voy a desencriptar y separo los números por más de un espacio da un mensaje de error y no desencripta el mensaje. Esto es una exigencia considerable para el usuario que puedes arreglar fácilmente usando el método split() de la clase String, que devolvería un array con un número en cada posición. Luego en vez de hacer un while y decrementar n solo tendrías que recorrer este array con un for. Quedaría algo así:

    encrypted=raw_input("enter here the encrypted message:")
    encrypted=encrypted.strip().split()
    z="Deencrypted message: "
    for d in encrypted:
        try:
            d=int(d)
        except:
            print "enter a numerical encrypted message"
            break
........etc........

Además te ahorrarías el segundo try de esa función.

- - - Actualizado - - -

En cuanto a la encriptación, además de usar un array yo usaría un factor aleatorio con la función en lugar de uno fijo, pero tendrías que meterte a importar las librerías (se hace con import random en las primeras líneas, antes de definir las funciones y luego obteniendo un número aleatorio con random.randint(limite_inferior,limite_superior) en cada caso).

Además te animo a que investigues las funciones ord() y chr(), que puedes usar en lugar de la comprobación de cada letra por separado, teniendo en cuenta que chr(n) devuelve caracteres no imprimibles cuando n<32 o n=127.

- - - Actualizado - - -

Por lo demás me parece que para ser tu primer programa has hecho un trabajo excelente y te animo a que sigas aprendiendo xD.

[Visitante]

Re: Mi primer programa (en beta)

Mi conocimiento en Python es bastante reciente y limitado, lo que he hecho es lo que he aprendido en unas semanas y la verdad es que no conocía eso de arrays, investigaré el tema para mejorar el código, saludos.

[Visitante]

Re: Mi primer programa (en beta)

Hace tiempo prometí que compartiría la versión final. Por esta razón, hoy os enseño mi versión final del programa que tenía en beta capaz de encriptar y desencriptar información, el código es el siguiente:

print "Copyright Malevolex 2015 All rights reserved"
print "Malevolex 1.0"
print "This version is only compatible with python 2.7.3"
print "This version of Malevolex is for personal use only. It is important to understand that this version will not reflect the stability of a shipped Microsoft product."
print "WARNING: This computer program is protected by copyright law and international treaties. Unauthorized duplication or distribution of this program, or any portion of it, may result in severe civil or criminal penalties, and will be prosecuted to the maximum extent possible under the law."        
def decrypt():
    encrypted=raw_input("enter here the encrypted message: ")
    encrypted=encrypted.strip()
    encrypted=" "+encrypted
    z="Dencrypted message: "
    numbers=encrypted.split()
    for number in numbers:
            try:
                number=int(number)
                if number<0:
                    print "Numbers cannot be negative!!"
                    print "Try again with positive numbers!"
                    return
            except: 
                print "enter a numerical encrypted message and try again"
                return
            m=number%256
            let=chr(m)
            let=str(let)    
            print number,"is", let
            z=z+let        
    print z
def encrypt():
    message=raw_input("Enter your message here ")    
    d=raw_input("Introduce a limit to generate random numbers: ")
    try:
        d=int(d)
    except: 
        print "please enter a number"
        return
    if d<1:
        print "please enter a number above 0 and try again"
        return
    n="encrypted data: "
    for letter in message:
        import random
        randomnumber=random.randint(0,d)
        randomnumber=randomnumber*256+1
        asci=ord(letter)
        m=asci*randomnumber
        m=str(m)
        print letter,"is", m
        n=n+" "+m
    print n


def encryptfile():
    a=raw_input("Enter the file to open: ")
    try:
        file=open(a, "r")
    except:    
        print "file", a, "not found"
        return
    lines=file.readlines()    
    d=raw_input("Introduce a limit to generate random numbers: ")
    try:
        d=int(d)
    except: 
        print "please enter a number"
        return
    if d<1:
        print "please enter a number above 0 and try again"
        return
    n=""
    for line in lines:
        for letter in line:
            import random
            randomnumber=random.randint(0,d)
            randomnumber=randomnumber*256+1
            asci=ord(letter)
            m=asci*randomnumber
            m=str(m)
            print letter,"is", m
            n=n+" "+m
    file.close()
    file=open(a, "w")
    file.write(n)
    file.close()
    print "encrypted file:", n


def decryptfile():
    encrypted=raw_input("enter here the encrypted file: ")
    try:
        encrypted2=open(encrypted, "r")
    except:
        print "file", encrypted2, "not found"
        return
    lines=encrypted2.readlines()
    z=""
    for line in lines:
        numbers=line.split()
        numbers        
        for number in numbers:
                try:
                    number=int(number)
                except:
                    print number, "not a number"
                    continue
                if number<0:
                    print "Numbers cannot be negative!!"
                    print "Try again with positive numbers!"
                    return
            
                m=number%256
                let=chr(m)
                let=str(let)    
                print number,"is", let
                z=z+let    
    encrypted2.close()
    writemode=open(encrypted, "w")
    writemode.write(z)
    writemode.close()    
    print "decrypted file:", z
while True:
    agreement=raw_input("Do you agree? Type <<yes>> if you agree, <<no>> if you don`t: ")
    if agreement=="yes":
        print "Great!"
        print "Thanks for using the Malevolex machine!"
        print "First of all you must introduce your username and password"
        break
    if agreement=="no":
        print "What a pity!"
        exit()


while True:
    username=raw_input("Enter username: ")
    password=raw_input("Enter password: ")
    if password=="":
        print "Correct!"
        break
    else:
        print "wrong username or password"
        continue
print "Malevolex is waking up"
print "Malevolex is alive"
print "Malevolex is really alive!"
print "Welcome back", username
duda=raw_input("Type ? for further information. Type anything else if you are done with this step: ")
duda.strip()
if duda=="?":
    print "This program can encrypt and decrypt information, in order to go on with the proces,s you must write down the following when you are asked: "
    print "command <</encrypt>> encrypts information that you write down"
    print "command <</decrypt>> decrypts encrypted information that you write down (it must be a numerical input)"
    print "command <</encryptfile>> encrypts a file, then you will be asked for the file, you can write the path or the name of the file (for the name remember that the program must be in the same directory as the file executed), however, you can drag the file into the window"
    print "command <</decryptfile>> decrypts an encrypted file, then you will be asked for the file, you can write the path or the name of the file (for the name remember that the program must be in the same directory as the file executed), however, you can drag the file into the window"
    print "command <</finished>> to exit the program"
while True:
    ask=raw_input("Enter the command: ")
    ask.strip()
    if ask=="/encrypt":
        encrypt()
    if ask=="/decrypt":
        decrypt()
    if ask=="/finished":
        print "Done!"
        print "Have a nice day", username
        break
    if ask=="/encryptfile":
        encryptfile()
    if ask=="/decryptfile":
        decryptfile()
exit()

Lo bueno de esta versión es su nuevo algoritmo para encriptar la información usando congruencias. El otro a diferencia no usa la tabla ASCII, este usa dicha tabla y genera números aleatorios para evitar que dos palabras iguales se repitan, es decir, que es muy difícil de romper el mensaje si no se dispone de este programa.
Lo que tienen que hacer para abrirlo es copiar y pegar el código en un bloc de notas, luego cambiar la extensión de .txt a .py, una vez iniciado te pedirá que aceptes los términos de licencia, a continuación se te pedirá una contraseña y un nombre de usuario, la contraseña predeterminada es darle a enter y el nombre de usuario cualquiera. Si quieres cambiar la contraseña, simplemente escribe en el código tu contraseña donde pone:

if password=="":

Finalmente es cuestión de usar los comandos correctamente, dale al botón ? si no sabes.
Lo mejor es que puedes encriptar y desencriptar un texto en bloc de notas (solo en bloc de notas, es decir, .txt), así no tienes que estar escribiéndolo.

Todavía tengo que hacerle unas mejoras

Nota: por ahora es compatible en python 2.7.3, tengo que probarlo en python 3.

Pd: ¿saben si se puede vender aplicaciones propias a alguna empresa o algo por el estilo para ganar algún dinerillo?
Pd2: si encuentran algún bug avisen.

[Weip]

Re: Mi primer programa (en beta)

Hola, vengo a comentar algunas dudas acerca de tu programa. Aunque lo primero es felicitarte porque la verdad es que está mucho mejor que el primero de este hilo. Has mejorado en la dirección correcta. La verdad es que no sé nada de Python, así que la lectura del programa se me dificulta un poco.

Ahora sí, las dudas. Por lo que he visto tu algoritmo se basa en pasar el mensaje a letras mediante las equivalencias del ASCII pero después usas números pseudoaleatorios en vez de implementar un algoritmo de encriptación normal. Y luego para desencriptar no entiendo muy bien qué haces pero imagino que el número generado te lo has guardado para revertir el proceso. Agradecería que explicaras el algoritmo que usas matemáticamente. Sea como sea este proceso hace que tu criptosistema no sea seguro. Tampoco hace falta que lo sea, estás aprendiendo, pero tenlo en cuenta.

Pd: ¿saben si se puede vender aplicaciones propias a alguna empresa o algo por el estilo para ganar algún dinerillo?

Piensa que las empresas para proteger sus datos ya tienen a su disposición criptosistemas seguros y muy eficaces. Además las empresas no encargan estas cosas a personas externa a ellas sin titulación. Si te gusta programar haz videojuegos para móvil que con eso sí te puedes sacar un dinerillo y nadie cuestionará tu trabajo.

PD: Se me olvidaba, quería comentarte una cosa. Tu sabrás lo que haces pero este foro es público y no has de dar tu nombre así como así por internet. Además nadie va a usar tu programa con fines comerciales, tranquilo.

[Visitante]

Re: Mi primer programa (en beta)

Hola, vengo a comentar algunas dudas acerca de tu programa. Aunque lo primero es felicitarte porque la verdad es que está mucho mejor que el primero de este hilo. Has mejorado en la dirección correcta. La verdad es que no sé nada de Python, así que la lectura del programa se me dificulta un poco.

Ahora sí, las dudas. Por lo que he visto tu algoritmo se basa en pasar el mensaje a letras mediante las equivalencias del ASCII pero después usas números pseudoaleatorios en vez de implementar un algoritmo de encriptación normal. Y luego para desencriptar no entiendo muy bien qué haces pero imagino que el número generado te lo has guardado para revertir el proceso. Agradecería que explicaras el algoritmo que usas matemáticamente. Sea como sea este proceso hace que tu criptosistema no sea seguro. Tampoco hace falta que lo sea, estás aprendiendo, pero tenlo en cuenta.


Piensa que las empresas para proteger sus datos ya tienen a su disposición criptosistemas seguros y muy eficaces. Además las empresas no encargan estas cosas a personas externa a ellas sin titulación. Si te gusta programar haz videojuegos para móvil que con eso sí te puedes sacar un dinerillo y nadie cuestionará tu trabajo.

Mi método de encriptación es bastante sencillo, para encriptarlo primero se genera un número al azar dentro de un límite, dicho número se multiplica por 256 y se le suma 1 (La razón de añadir 1 la explico a continuación), luego obtiene la equivalencia numérica del carácter en la tabla ASCII y lo multiplica por el resultado de la operación anterior.
Para desencriptarlo, se ve con qué es congruente el número en clase 256, una vez visto la congruencia el programa devuelve la equivalencia en la tabla de ASCII, es decir, se divide el número entre 256 y lo que importa es el resto, después devuelves la equivalencia del resto en la tabla ASCII que será el equivalente numérico que se usó en la encriptación.
La razón de sumar 1 y multiplicarlo es que de este modo no se altera el resto original al dividir entre 256. Matemáticamente:

Sea n el número final, m la equivalencia numérica en ASCII, a un número al azar y z un número que sale de una operación que ahora explico, para encriptarlo matemáticamente:
z=256a+1
n=mz
Para desencriptarlo se ve que:
$n \equiv m mod (256)$
Y entonces devuelve la equivalencia de a.
Para demostrar que
$n \equiv m mod (256)$
Se ve que:
$z\equiv 1 mod(256)$ (evidentemente) y
$m\equiv m mod(256)$ porque m es un número menor que 256
si hacemos el producto entonces:
$mz\equiv 1*m mod(256)$
sustituyendo:
$n \equiv m mod (256)$

No se guarda ningún número, sin embargo, el número generado es pseudoaleatorio (no estoy seguro de lo que hace, pero lo hace python por una función que ya venía hecha) pero no creo que se guarde, simplemente se obtiene mediante algunas operaciones de las que no estoy seguro. Así se asegura que por ejemplo las letras l y l tengan números diferentes pero el mismo resto en clase 256. Creo que el método es seguro.

Y puede que haga algún juego para ganar dinero, así me es más fácil pagar la carrera.

[Weip]

Re: Mi primer programa (en beta)

Gracias por la explicación, como he dicho mis conocimientos de Python no son siquiera decentes.

Creo que el método es seguro.

Bueno para comprobar si tu criptosistema es seguro existen diferentes pruebas que ha de pasar. Lo ideal sería que aunque conociendo tu algoritmo, el mensaje a cifrar y el resultado del cifrado, no pudiéramos descifrarlo sin la clave. Un ejemplo es el RSA (con sus variantes). Si sabemos todo menos las claves, no existe forma (en la actualidad) de revertir el proceso. A esto me refiero con que no es seguro.

[Visitante]

Re: Mi primer programa (en beta)

Gracias por la explicación, como he dicho mis conocimientos de Python no son siquiera decentes.


Bueno para comprobar si tu criptosistema es seguro existen diferentes pruebas que ha de pasar. Lo ideal sería que aunque conociendo tu algoritmo, el mensaje a cifrar y el resultado del cifrado, no pudiéramos descifrarlo sin la clave. Un ejemplo es el RSA (con sus variantes). Si sabemos todo menos las claves, no existe forma (en la actualidad) de revertir el proceso. A esto me refiero con que no es seguro.

Entonces, el hecho de que digas que no es seguro es la clave? Es decir, ASCII es conocido por todo el mundo por lo que solo es cuestión de ver el algoritmo (cosa que creo difícil de averiguar si no sabes congruencias), pero si nosotros creamos y usamos nuestra propia tabla y no ASCII, sería seguro?

[Julián]

Re: Mi primer programa (en beta)

Te recomiendo Malevolex que cuando realices un programa hagas un diagrama de flujo que es la mejor manera de representar el algoritmo para poder visualizarlo, optimizarlo, seguir el flujo del programa, etc. Una vez que ya tienes lo que realizará el programa en cada paso, ahí si se pasa a código. El diagrama de flujo tiene la ventaja de que como es una representación de lo que hace el programa visualmente cualquier programador de cualquier lenguaje puede interpretarlo en si, sin tener que interpretar a su vez código y luego puede pasarse a cualquier lenguaje. Esto es lo que se realiza en las grandes empresas de software para trabajar entre varios programadores y en cierta forma al realizar grandes programas se hace necesario.

Otra práctica de programación recomendable es realizar comentarios al código y esto lo realizan hasta los mejores programadores. No solo te servirá para ubicarte en el código sino también para que los demás lo hagan y a su vez, como sabras, dicho código puedes implementarlo en una librería que quizás usarás en un futuro y si quieres modificarla y saber que argumentos se pasan los comentarios te ayudarán a recordar. A su vez la librería puede usarla otra persona y eso le servirá. Eso es una filosfía de la programación de alto nivel, la reutilización de código.
Por ejemplo el día de mañana quizás realices un programa que trabaja con sockets de internet mediante el protocolo HTTP/IP cliente y servidor y para seguridad informáticas quieres encriptar el mensaje que se enviará y ahi te acuerdas que una vez hiciste un código de encriptación, si está comentado lo recuerdas enseguida.

[FONT=Verdana]pero si nosotros creamos y usamos nuestra propia tabla y no ASCII, sería seguro?[/FONT]

Recuerda que estás trabajando en alto nivel, y ASCII es un estandar de codificación de código para 8 bits, ya dejado de usar en los sitemas de 32 y 64 por el unicode. Por supuesto que que al encriptar no usarás un estandar, ya que son 2 conceptos opuestos, el estandar es para modularidad y tener compatibilidad entre diferentes hardwares y software. Es decir, el SO trabaja con el estandar Unicode, por lo que tienes que pasar de Unicode a tu códificación y luego cuandos desencriptas de tu codificación a Unicode. Y como windows trabaja con Unicode los programas como word o editor de texto y la consola interpretan como códico a mostrar eso.
Lo que te refieres es que harás una correspondencia entre el código Unicode que es el que usa el editor de programa y la consola de windows y linux para cada símbolo con respecto a otra codificación numérica. Por ejemplo si modificas el valor que está en una variable de 2 byte, que en hexa es 64h pasandolo de dicho valor a quizás 7Ah. En la consola en vez de mostrar el @ se mostrará z. Ahora como haces corresponder cada valor del estandar a otro valor, eso es lo que hace a la encriptación.

http://en.wikipedia.org/wiki/Unicode...rosoft_Windows

Son solo sugerencias. Saludos.

[Weip]

Re: Mi primer programa (en beta)

Entonces, el hecho de que digas que no es seguro es la clave? Es decir, ASCII es conocido por todo el mundo por lo que solo es cuestión de ver el algoritmo (cosa que creo difícil de averiguar si no sabes congruencias), pero si nosotros creamos y usamos nuestra propia tabla y no ASCII, sería seguro?

No, no es el problema de utilizar ASCII. ASCII es sólo un estándar internacional para pasar de letras a números y al revés. Y debes usarlo. Pero por sí sólo es un criptosistema trivial. La cosa es que entremedias uses un proceso de encriptación para que nadie pueda desencriptar los mensajes a menos que sepa las claves.

Te explico el ejemplo del RSA (que por cierto estudiarlo tendría que ser tu próximo paso). Este criptosistema tiene un proceso que, en cierto momento, multiplica dos números, que son números primos muy pero que muy grandes. Si alguien que no sepa las claves quiere descrifrar un mensaje, sólo puede coger la clave pública, hacer unas cuantas cosas que no vienen a cuento y factorizar el número resultante del producto del que he hablado antes para saber los números primos. Una vez los tenga, descifrar todos los mensajes sería pan comido. El problema es que factorizar números enteros es muy caro en términos de tiempo de cálculo por ordenador. Podrías tardar siglos en factorizar tu número. RSA es seguro (hasta que nuestra capacidad para hacer cálculos por ordenador mejore mucho).

Como ves, este es un ejemplo de criptosistema seguro: por mucho que se conozca sobre el algoritmo, no se puede invertir porque tardaríamos mucho en hacerlo.

PD: Haz caso de Julián. Parece que no pero en un futuro lo agradecerás.

[Julián]

Re: Mi primer programa (en beta)

No, no es el problema de utilizar ASCII. ASCII es sólo un estándar internacional para pasar de letras a números y al revés. Y debes usarlo. Pero por sí sólo es un criptosistema trivial. La cosa es que entremedias uses un proceso de encriptación para que nadie pueda desencriptar los mensajes a menos que sepa las claves.

No es para pasar de letras a números y al revés sino que es una codificación. La memoria es un conjunto de registros, que almacenan datos binarios. Si la memoria es de una palabra de 8 bits (hoy en día son de 64 bits pero sigamos como comenzó el ASCII para datos de longitud de palabra de 8 bits) en dicha memoria se guardará fisicamente valores como 00101011 o 00111111. Es un número, pero a su vez cada número le podemso hacer corresponder algo, como manzanas, peras, etc. En este caso símbolos, ya que un código es la representación únicova de los elementos. El ASCII hace corresponde el valor 00101011 con el símbolo '+' y el 00111111 con '?'.
Como se estandarizó, los creadores de los SO lo usan para que los que realicen compiladores hagan que el compilador pase de 00101011 (+) al correspondiente opcode (instrucción para la suma) del micro para la suma, por ejemplo. Y para que los desarrolladores de los controladores de video hagan que 00101011 sea un + en la pantalla. Que por supuesto el 00101011 estará seguido de otros bytes que codifican el color RGB y la posición de la pantalla también estandarizados pero lo que codifica que símbolo es para mostrar es el 00101011.
porque sino habría que hacer un sistema operativo para cada máquina como era antes de los años 80,
Y los desarrolladores de los SO usan estandares así los creadores de compiladores saben como realizar el proceso de compilación y así los programadores usan su sistema operativo, si cambian el estandar los programas que se escribieron teniendo en cuenta el ASCII no funcionarán.

Por lo que no es simplemente pasar de letras a numeros. Aunque hace tiempo se usa el unicode, con la ventaja que el unicode toma el ASCII y lo completa.

[Weip]

Re: Mi primer programa (en beta)

Gracias por la corrección. Prefería dejarlo así porque Malevolex hasta hace poco no sabía la existencia de ASCII y eso es lo único por ahora que necesita saber para poder hacer criptografía en condiciones, pero soy consciente que la simplificación que he hecho es un crímen.

[Julián]

Re: Mi primer programa (en beta)

Se que en general las versiones de SO con núcleo GNU/linux usan la codificación Unicode UTF-8. Windows la verdad que no sé, siempre windows se reservó estas cosas para los desarrolladores de compiladores y de controladores de dispositivos. Que por supuesto eso hace al negocio.
Ahora bien malevolex, lo bueno es que esto no te tiene que importar, lo que tienes que hacer es tratar al caracter como algo numérico y aplicarle alguna modificación matemática que sea muy dificil de detectar y cuando el SO se lo pase al controlador de video, este lo trabajará con la codificación que use y mostrará lo que corresponda en su codificación, que ha sido alterada. Luego en el desencriptador haces la operación matemática inversa.