Mensajes

Buen dia.

Entiendo lo que dices, en su momento yo tambien no entendia los apuntadores pero como lo mencione es una de las mejores caracteristicas del lenguaje.

Asumi erroneamente por tu pregunta (Dobles apuntadores) que ya sabias lo que es un apunador.

Un apuntador independientemente del tipo de variable que sea, es una variable que apunta a una direccion de memoria.

Un beneficio de utilizar dobles puntero dependiendo de lo que vallas a hacer con tu programa es hacer mejor uso de memoria dinamica.

Hace unos dias participe en el siguiente tema    
Re: Sistema de cifrado por lote de texto plano

Deje el codigo y utliza dobles punteros para almacenar unas listas de longitud dinámica cada lista.

El detalle que si los usas mal y/o no asginas y/o liberas memoria incorrectamente terminaras haciendo un completo desmadre y posiblemente el programa termine colgándose.

Imaginate esto, quieres hacer un programa que almacene las calificaciones de todos los alumnos de una escuela para despues hacer cualquier otro proceso con ellos.

Código (c) [Seleccionar] Expandir


int **calificaciones;

Estamos de acuerdo que la instrucción anterior solo "reserva" en la pila un espacio para guardar un apuntador.

Código (c) [Seleccionar] Expandir


int i,j;
int *alumnosXsalon;
int **calificaciones;

Mientras tanto en la pila se muestra asi (Uso 4 bytes para los int, y para los apuntadores asumo que estamos en un sistema x86):

Pila:

Código [Seleccionar] Expandir


[4 bytes variable calificaciones] << === Un apuntador doble
[4 bytes variable alumnosXsalon] <<=== Un apuntador
[4 bytes variable j]
[4 bytes variable i]



Asignamos memoria para nuestra variable calificaciones Asumimos que son 30 salones, incluso se podria ser variable menos salones o mas salones incluso mil o un millon suponiendo que hay memoria suficiente no sera problema reservarla.

Código (c) [Seleccionar] Expandir


calificaciones = calloc(30,sizeof(int*));


Como mencione si el apuntador es de 4 bytes, se nos devolvera una direccion de memoria de longitud 30x4 bytes y como es la funcion calloc la memoria esta limpia esto es los 120 bytes estaran en 0 cada uno.

calificaciones => [Bloque de 120 continuos]

ahora bien la variable calificaciones apunta a un espacio en memoria de 120 bytes donde podemos guardar lo que queramos, pero siguiendo con el ejemplo de apuntadores damos por hecho que cada 4 bytes es un apuntador a otra direccion de memoria (Actualmente no apuntan a ningun lugar ya que no hemos inicializado esos 30 apuntadores).

Como es un ejemplo didactico supondre que alumnosXsalon ya esta inicializado y es un arreglo 30 de enteros y cada uno indica la cantidad de alumnos en cada salon por ejemplo

alumnosXsalon = {20, 30, 10 , 24, 12, 3, 8, 18 , .....}

Ahora vamos a inicializar esos 30 apuntadores:

Código (c) [Seleccionar] Expandir


i = 0
while(i < 30) {
calificaicones[i] = calloc(alumnosXsalon[i],sizeof(int));
i++;
}


Con esto logramos reservamos la memoria para todas las calificaciones.

calificaciones ==>> [120 bytes, cada 4 bytes es un apuntador a otra segmento de memoria]

o ma claro aun

calificaciones => [[1ros apuntador => 20 enteros],[2do apuntador => 30 enteros], .... ]

Y ahora solo queria escribir las cientos de calificaciones en sus respectivos espacios asignados

Para entenderlo mejor ha que aprender a depurar un poco el código y mostrar las direcciones de memoria sus valores antes y depues asi como a donde estan apuntando.

Si dominas esto entenderas muy bien los apuntadores lo cual es una de las mejores caracteristicas del lenguaje C

Ejemplo comentado:

Código (c) [Seleccionar] Expandir


#include<stdio.h>
#include<stdlib.h>

int main() {
int i,j;
int alumnosXsalon[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30};
int **calificacion;
printf("i esta en 0x%.8x: [%i]\n",&i,i);
printf("j esta en 0x%.8x: [%i]\n",&j,j);
printf("alumnosXsalon esta en 0x%.8x: => %X\n",&alumnosXsalon,alumnosXsalon);
printf("calificacion esta en 0x%.8x: => %X aun no se reserva memori\n",&calificacion,calificacion);
calificacion = calloc(30,sizeof(int*));
printf("calificacion esta en 0x%.8x: => %X ya se reservo la memoria\n",&calificacion,calificacion);
i=0;
while(i < 30) {
printf("Reservado %i bytes\n",(alumnosXsalon[i]*sizeof(int)));
calificacion[i] = calloc(alumnosXsalon[i],sizeof(int));
printf("calificacion[%i] esta en 0x%.8x: => %X un segmento de %i bytes \n",i,calificacion + i,calificacion[i],(alumnosXsalon[i]*sizeof(int)));
i++;
}
}


Salida

Código [Seleccionar] Expandir


i esta en 0xbfbfe834: [0]
j esta en 0xbfbfe830: [0]
alumnosXsalon esta en 0xbfbfe7b8: => BFBFE7B8
calificacion esta en 0xbfbfe7b4: => 1 aun no se reserva memori
calificacion esta en 0xbfbfe7b4: => 2880B080 ya se reservo la memoria
Reservado 4 bytes
calificacion[0] esta en 0x2880b080: => 2880D050 un segmento de 4 bytes
Reservado 8 bytes
calificacion[1] esta en 0x2880b084: => 2880D058 un segmento de 8 bytes
Reservado 12 bytes
calificacion[2] esta en 0x2880b088: => 2880E030 un segmento de 12 bytes
Reservado 16 bytes
calificacion[3] esta en 0x2880b08c: => 2880E040 un segmento de 16 bytes
Reservado 20 bytes
calificacion[4] esta en 0x2880b090: => 2880F020 un segmento de 20 bytes
Reservado 24 bytes
calificacion[5] esta en 0x2880b094: => 2880F040 un segmento de 24 bytes
Reservado 28 bytes
calificacion[6] esta en 0x2880b098: => 2880F060 un segmento de 28 bytes
Reservado 32 bytes
calificacion[7] esta en 0x2880b09c: => 2880F080 un segmento de 32 bytes
Reservado 36 bytes
calificacion[8] esta en 0x2880b0a0: => 28810040 un segmento de 36 bytes
Reservado 40 bytes
calificacion[9] esta en 0x2880b0a4: => 28810070 un segmento de 40 bytes
Reservado 44 bytes
calificacion[10] esta en 0x2880b0a8: => 288100A0 un segmento de 44 bytes
Reservado 48 bytes
calificacion[11] esta en 0x2880b0ac: => 288100D0 un segmento de 48 bytes
Reservado 52 bytes
calificacion[12] esta en 0x2880b0b0: => 28811040 un segmento de 52 bytes
Reservado 56 bytes
calificacion[13] esta en 0x2880b0b4: => 28811080 un segmento de 56 bytes
Reservado 60 bytes
calificacion[14] esta en 0x2880b0b8: => 288110C0 un segmento de 60 bytes
Reservado 64 bytes
calificacion[15] esta en 0x2880b0bc: => 28811100 un segmento de 64 bytes
Reservado 68 bytes
calificacion[16] esta en 0x2880b0c0: => 28812060 un segmento de 68 bytes
Reservado 72 bytes
calificacion[17] esta en 0x2880b0c4: => 288120B0 un segmento de 72 bytes
Reservado 76 bytes
calificacion[18] esta en 0x2880b0c8: => 28812100 un segmento de 76 bytes
Reservado 80 bytes
calificacion[19] esta en 0x2880b0cc: => 28812150 un segmento de 80 bytes
Reservado 84 bytes
calificacion[20] esta en 0x2880b0d0: => 28813040 un segmento de 84 bytes
Reservado 88 bytes
calificacion[21] esta en 0x2880b0d4: => 288130A0 un segmento de 88 bytes
Reservado 92 bytes
calificacion[22] esta en 0x2880b0d8: => 28813100 un segmento de 92 bytes
Reservado 96 bytes
calificacion[23] esta en 0x2880b0dc: => 28813160 un segmento de 96 bytes
Reservado 100 bytes
calificacion[24] esta en 0x2880b0e0: => 28814080 un segmento de 100 bytes
Reservado 104 bytes
calificacion[25] esta en 0x2880b0e4: => 288140F0 un segmento de 104 bytes
Reservado 108 bytes
calificacion[26] esta en 0x2880b0e8: => 28814160 un segmento de 108 bytes
Reservado 112 bytes
calificacion[27] esta en 0x2880b0ec: => 288141D0 un segmento de 112 bytes
Reservado 116 bytes
calificacion[28] esta en 0x2880b0f0: => 2880B100 un segmento de 116 bytes
Reservado 120 bytes
calificacion[29] esta en 0x2880b0f4: => 2880B180 un segmento de 120 bytes


Respondiendo tus preguntas:

Por ahí leí que los punteros dobles se asemejan a los array de 2 dimensiones, es esto cierto y porque?.

No del todo, depende de como se usen.
Si declaras un array de 2 dimenciones por ejemplo 15x10 es y sera siempre de 15x10.
En cambio si apuntador lo declaras de 15 x 10 es en ese momento de 15x10 y se podria quedar asi o modificarse, liberar la memoria asginar algunos elementos (digamos los primeros 5) a una longitud de solo 7 por ejemplo. Si se asemejan paro para fines didacticos pero los apuntadores son mejores. Ve el ejemplo anterior tengo un apuntador dinamico de 30 apuntadores apuntado a 1, 2, 3, 4, .. respectivamente,

[Cifrar y descifrar la eterna lucha]

Cifrar y descifrar la eterna lucha.

Lista de Decrypter:

• Petya

Si bien la llegada al Internet de un nuevo malware de la clase de los ransomware no es nada nuevo.

Lo que es motivo de celebrar es que cada vez mas se escucha sobre herramientaa que decrifran los archivos sin nececidad de pagar a los ciber-extorcionadores.

Leyendo hoy las noticias salta que ya hay metodo conocido para recuperar el MBR infectado por PETYA esta.

¿Falla de Petya?
Dejar las llaves de decifrado en el disco duro.

Petya se caracteriza por dejar intactos los archivos pero inhabilitar el acceso a la computadora pidiendo pago a cambio de la clave.

Si bien este tipo de tecnica (alterar el MBR) era mas conocida hace una o dos decadas debido al gran flujo de uso de diskttes ya que eran mas propensos a infectarse de ese tipo de virus de arranque. Pues la tecnica volvio con PETYA, si bien ya sea por flojera de utilizar alguna libreria para el cifrado o facilidad de implementar codigo en ensamblador para modificar el MBR

Se cometio la pereza de dejar la llave en el disco.

¿Como se puede mejorar PETYA?
Implementar algunas rutinas critograficas en ensamblador.
Creo que para este tipo de ransomware no es vital utilizar llaves RSA de gran cantidad de bits asi que implementar algo utilizando una menor cantidad de bits no parace mala idea.

La otra y mas importante es No dejar las llaves en el disco duros si bien este ha sido el talon de Aquiles de muchos ransomwares mal diseñados, parece ser que dada la vida tan corta que tienen los servidores de control dejar las llaves en el disco a sido necesario.

[¿Cual es la mejor forma de generar un ID?]

Buen dia.

¿Cual es la mejor forma de generar un ID?

Les dejo mi metodo y si ustedes tienen otro podria ser muy didactivo explicarlo por aqui

En el proyecto en el que estoy trabajando necesita generar un ID por usuario que instale la aplicacion.

-Muiltiplataforma
-Comunicacion cifrada end-to-end (Lo que esta de moda)

En fin el programa genera  un unico par de claves RSA para la criptografia asimetrica y genero llaves aleatorias para la criptografia simetrica en fin...

Genero un sha512 iterativo N cantidad de veces (mas de 4000) del archivo de la clave publica y este devuelve 64 bytes. Esta es mi ID del usuario y en teoria  no deberia de repetirse nuca...  

Tal como lei en el documento de whatsapp ellos hacen una conversion solo de los ultimos 30 bytes de la clave y luego pasan cada 5 bytes a un entero sin signo y a ese entero le sacan modulo 100000.

Yo por mi parte copio de 8 en 8 bytes al entero sin signo:

Código (c) [Seleccionar] Expandir


int main() {
int j;
unsigned char *temp;
unsigned long long t;
temp = md_file(GCRY_MD_SHA512,"llavePublica");
j = 0;
printf("ID: ");
while(j < 64) {
printf("%.2x",temp[j++]);
}
printf("\n");
printf("long long :%i\n",sizeof(unsigned long long));
j = 0;
t = 0;
while(j < 8) {
memcpy(&t,temp + (j*8),8);
printf("%llu\n",t);
t = 0;
j++;
}
free(temp);
}


Salida:

Código [Seleccionar] Expandir


ID: d97a302e486bd15f55d4a2e6f7eba511042b0ee4ae118596584393e002103dd65e9d1c822963d945e17d4c24d9b7b6ad0fd54a7a03acea32bf899e22c7c0576b
long long :8
6904417661492427481
1271681919760913493
10846094720439823108
15437512702239654744
5033163088490962270
12517394357567651297
3668933977383294223
7734862846543956415


Si bien recuerdo solo hay que recompilar el kernel qgregando el driver para realtek en el archivo de configuracion.

Comparte la noticia para nos de gracia tambien a nosotros.

Whatsapp a sido muy criticado por su falta de seguridad, desde aquellos dias que podias ver los mensajes en texto plano entre otras cosas.

whatsapp podria a ver detectado una disminucion de usuarios y se puso las pilas en ese tema.
El caso de FBI vs Apple demostro que las organizaciones gubernamentales no pueden hacer mucho contra un sistema criptografico bien implementado.

Ahora whatapp solo ofrece seguridad mas no anonimato, todavia quien esta hablando con quien..

para anonimato los sistemas no deberian de pedirte un numero que te identifique.

ahh! es que todo pasa en claro? yo estoy asumiendo que el Message Key pasa por asimetrico! :s

Era mi duda, yo asumo que pasa por asimetro al igual que tu y con las claves publicas Curve25519 lo decifran. En la lectura no lo especifican, me imagino que lo dan por hecho.

Bueno ya que nos quitamos la duda teóricamente todo esta bien.

Acabo de hacer un programa en C usando libgcrypt para ejemplicar esto.

El programa hace lo siguiente.

• Crea un archivo llamada AAAA.txt de 512 bytes lleno de AAAAAAAAAA's para ejempliciar el plain text.
• Genera un par de llaves RSA (Parte tardada)
• Guarda las claves creadas en archivo en archivo para su posterior uso
• Genera apartir de la llave publica y algunos otros datos 5  "Key Message" para fines didacticos solo usaremos el ultimo
• usa el campo pass del KeyMessage para cifrar el AES en modo CBC con el iv correspondiente
• Guarda la salida en un archivo llamada AAES.txt

Todavia no me queda muy claro como utilizar HMAC pero leyendo la API y los RFC correspondientes aprendere.

Muestro la salida y al final el codigo del programa que la produce.

Archivo >>>>>>>>AAES <<<<<<<<<<<de salida

Código [Seleccionar] Expandir


Key df9701195198737faf7c163298704e2c5b583532cf8fc20595c8512b5b65e8db2ef1683d4e7399132d719a38cdf14b32d100a73e84f338ae4d8c43dc43c408222e2278d005332bca737d55b5a7a24897
Key b858d2f07d002deeb2afd730078b8f38904725e37f98d31dd15c11a404e22777c1813ea5982db9324e9fc8f85b60720fa709f62baaab81034f9090cf4ad37609858b5d5c7b285f8f0baf241fcd405c28
Key 4df7986bfb598832b552860e7e03bb67a661c75d6a571656ac6b5e31ea60755f984964eafaf78e79e83a66589c2993dd7fc67de37467c6c3e56a565e8167305271079d6902c6cbfdd7ee8c3799d58b79
Key a8d81e45dfcec1e6cb5b9be014626311f42c38f88ceb6f4ef6494d4c7281c92c0e92cdc6cb296231322909b8634af89b15807235b7fcd27c7103e4df89e6163cf809a342ce4004145e3d7f19643d2133
Key 420341bb215e4393c4fb364ed05331bb4ab51e81355d767fe7ac4fe33012c15fcc66740840cc8b0981a9d6e98b925f408e9c16e0b559993b368fb749f337bae3dfe9797fdced844f1d227dbce12bda05



Algunas funciones del programa fueron implementadas de forma rapida y puede fallar.

Código (c) [Seleccionar] Expandir


/*
twitter: @albertobsd
cc -o ejemplos ejemplos.c `libgcrypt-config --cflags --libs`
*/

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<gcrypt.h>

void libgcrypt_init();
int createRSA_4096(char *prefix,char *bufferPkey);
unsigned char *my_kdf(char *passphrase,size_t passphraselen,unsigned int iterations,size_t keysize);
int encrypt(char *buffer,char *pass,char *iv,int length);



typedef struct str_KeyMessage {
unsigned char pass[32];
unsigned char hmac[32];
unsigned char iv[16];
}*KeyMessage;

int main() {

FILE *archivo = NULL;
char *buffer = NULL;
char *pkey = NULL;
char *digest = NULL;
unsigned char *key = NULL;
int length,i,j;
buffer = calloc(512,1);
if(!buffer) {
printf("calloc\n");
exit(0);
}
memset(buffer,'A',512);
archivo = fopen("AAAA.txt","w");
if(!archivo) {
printf("calloc\n");
exit(0);
}
fwrite(buffer,1,512,archivo);
fclose(archivo);
libgcrypt_init();
pkey = calloc(2048,1);
length = createRSA_4096("UsuarioA",pkey);
j = 0;
while(j < 5) {
key = my_kdf(pkey,length,1024,80);
if(!key) {
printf("my_kdf\n");
exit(0);
}
printf("Key ");
i = 0;
while(i < 80) {
printf("%.2x",key[i]);
i++;
}
printf("\n");
j++;
}
KeyMessage km = (KeyMessage)key;
encrypt(buffer,(char*)km->pass,(char*)km->iv,512);
archivo = fopen("AAES.txt","w");
if(!archivo) {
printf("fopen 2");
exit(0);
}
fwrite(buffer,1,512,archivo);
fclose(archivo);

}

void libgcrypt_init() {
if(!gcry_check_version(GCRYPT_VERSION)) {
fprintf(stderr,"libgrypt version mismatch %s\n",GCRYPT_VERSION);
exit(0);
}
gcry_control(GCRYCTL_SUSPEND_SECMEM_WARN);
gcry_control(GCRYCTL_INIT_SECMEM,1638,0);
gcry_control(GCRYCTL_INITIALIZATION_FINISHED,0);
if(!gcry_control(GCRYCTL_INITIALIZATION_FINISHED_P)) {
fprintf(stderr,"libgrypt has not been initialized\n");
exit(0);
}
}

int createRSA_4096(char *prefix,char *publickey) {
FILE *p;
FILE *s;
gcry_sexp_t rsa_parms = NULL;
gcry_sexp_t rsa_keypair = NULL;
gcry_sexp_t rsa_skey = NULL;
gcry_sexp_t rsa_pkey = NULL;
gcry_error_t err = 0;
int temp = 0;
char *nombre_p,*nombre_s;
size_t length = 2048;
size_t offset = 0;
char *bufferkey;
nombre_p = calloc(strlen(prefix) + 2,sizeof(char));
nombre_s = calloc(strlen(prefix) + 2,sizeof(char));
sprintf(nombre_p,"%sp",prefix);
sprintf(nombre_s,"%ss",prefix);
err = gcry_sexp_build(&rsa_parms, NULL, "(genkey (rsa (nbits 4:4096)(rsa-use-e 1:1)))");
if(err) {
fprintf(stderr,"gcry_sexp_build: failed to build\n");
fclose(stderr);
exit(0);
}
err = gcry_pk_genkey(&rsa_keypair, rsa_parms);
gcry_sexp_release(rsa_parms);
if(err) {
fprintf(stderr,"gcry_pk_genkey: failed to genkey\n");
fclose(stderr);
exit(0);
}
rsa_pkey = gcry_sexp_find_token(rsa_keypair, "public-key", 0);
rsa_skey = gcry_sexp_find_token(rsa_keypair, "private-key", 0);
gcry_sexp_release(rsa_keypair);
bufferkey = calloc(length,sizeof(char));
if(bufferkey == NULL) {
fprintf(stderr,"unable to alloc memory\n");
fclose(stderr);
exit(0);
}
offset = gcry_sexp_sprint(rsa_pkey,GCRYSEXP_FMT_CANON,bufferkey,length);
gcry_sexp_release(rsa_pkey);
p = fopen(nombre_p,"w");
if(p == NULL) {
fprintf(stderr,"unable to create file\n");
fclose(stderr);
exit(0);
}
temp = offset;
memcpy(publickey,bufferkey,offset);
fwrite(bufferkey,sizeof(char),offset,p);
fclose(p);
memset(bufferkey,0,length);
offset = gcry_sexp_sprint(rsa_skey,GCRYSEXP_FMT_CANON,bufferkey,length);
gcry_sexp_release(rsa_skey);
s = fopen(nombre_s,"w");
if(s == NULL) {
fprintf(stderr,"unable to create file\n");
fclose(stderr);
exit(0);
}
fwrite(bufferkey,sizeof(char),offset,s);
fclose(s);
memset(bufferkey,0,length);
return temp;
}

unsigned char *my_kdf(char *passphrase,size_t passphraselen,unsigned int iterations,size_t keysize) {
gpg_error_t err;
unsigned char *bufferkey = NULL;
char *salt = NULL;
bufferkey = calloc(keysize,1);
salt = calloc(8,1);
gcry_randomize(salt,8,GCRY_VERY_STRONG_RANDOM);
err = gcry_kdf_derive(passphrase,passphraselen,GCRY_KDF_ITERSALTED_S2K,GCRY_MD_SHA512,salt,8,iterations,keysize,bufferkey);
if(err != 0) {
free(bufferkey);
free(salt);
return NULL;
}
else {
free(salt);
return bufferkey;
}
}


int encrypt(char *buffer,char *pass,char *iv,int length) {
gcry_error_t err = 0;
gcry_cipher_hd_t aes_hd;
gcry_cipher_open(&aes_hd, GCRY_CIPHER_AES256,GCRY_CIPHER_MODE_CBC, GCRY_CIPHER_SECURE);
err = gcry_cipher_setkey(aes_hd, pass, 32);
if (err) {
fprintf(stderr,"gcry_cipher_setkey(): could not set cipher key\n");
fclose(stderr);
exit(0);
}
err = gcry_cipher_setiv(aes_hd, iv, 16);
if (err) {
fprintf(stderr,"gcry_cipher_setiv(): could not set cipher initialization vector\n");
fclose(stderr);
exit(0);
}
err = gcry_cipher_encrypt(aes_hd, (unsigned char*) buffer, length, NULL, 0);
if (err) {
fprintf(stderr,"gcry_cipher_encrypt(): unable to encrypt file\n");
fclose(stderr);
exit(0);
}
err = gcry_cipher_reset(aes_hd);
gcry_cipher_close(aes_hd);
return err;
}




pasas la clave por asimetrico (RSA, ECDHE)

Tu mismo lo dices pasas la "clave" por asimetrico y ya una vez descifrada con tu clave privada pasas a descifrar lo que pasastes por AES256 o por chacha20 o el algoritmo que acordaran

tengo estos 3 mensajes, clave 123

Código [Seleccionar] Expandir

K7xGlZ3okW+uE4jiqTt0jE4FGkSwRRUKC9maBAHdsXl8A8+7bZVX/mp85Rmkf2EV

Código [Seleccionar] Expandir

vmd1WLXCAEI1YMaAWvtQsyf6/1Bsiuw5cYTo8jedjGNOW0hgmsvjbcELP/jjBE1S

Código [Seleccionar] Expandir

2zybZUeUJZ8cdGncA+1VczXAJUw7nx4WN3YQcW6BV+SxmSy9K802ATQBJXtSYkE6
y las 3 son el mismo mensaje

Claro por el IV o por el modo de empleo del del AES o también puede cambiar dependido si es modo CFB, CBC etc..

En lo que tenga un chance publicare un ejemplo en C.

la llave publica es para ser pasada en plano, no tiene sentido protegerla XD para protegerla solo harías una llave publica de una llave publica...

la llave publica es como mandar un candado abierto, solo puede ser usada para cerrar el mensaje... no puede hacerse más nada con ella

Claro, cuando se genera un PAR de llaves una es publica y la otra privada. La llave publica se envia a las personas con las que te quieres comunicar entiendo eso y si la llave publica se tranmite en texto plano

Tengo muy claro eso.

Ahora si leemos la documentaion El Message Key contiene un total de 80 de los cuales esta didivido en 3 secciones.

• 32 bytes AES password
• 32 bytes HMAC
• 16 bytes IV

Entonces eso solo compone el Message Key.
El mensaje Cifrado es otra parte de la Data enviada y de nada serviria mandar algo cifrado si tambien vamos a mandar la llave en los 80 bytes anteriores. Recordemos que AES es un sistema para cifrado simetrico.

Y por lo tanto supongo que esos 80 bytes se mandan cifrados con criptografia asimetrica..

Insito en esto por que estoy programando un projecto con necesidades similares y me gustaria tomar las mejores ideas, no se tal vez no me explico bien y/o estoy omitiendo algo en la lectura o en mis bases criptograficas. Omito cosas con mucha facilidad.

Whatsapp no es de codigo abierto.

[Line]

hasta Line creo que empezó cifrando su mensajería.

a mi me gusta más Line que whatsapp, pero por donde vivo no es popular.

La verdad Whatsapp gano mucho terreno. Frente a otros que ya existian incluso ve el Google Hangouts que en su momento era Talk

Por lo que estoy leyendo del protocolo este manda el mensaje cifrado con AES256 y firmado por HMAC256 esto es y lo que manda cifrado con la llave publica, es a lo que entiendo el Message Key.

Por se se me haria inseguro por no decir otra palabra mandar el Message Key en texto plano para que en el remoto caso de alguien intercepte ese paquete tenga acceso a la clave de descifrado.

La lectura no indica este punto claramente o por lo menos yo no lo he visto o no lo entiendo al 100

Segun yo se manda lo siguiente:

Código [Seleccionar] Expandir


<Message Key>
<CLAVE: 32 Bytes clave de decifrado AES256><HMAC: 32 Bytes firma HMAC><IV: 16 bytes Vector de Inicializacion para el modo CBC del mensaje cifrado>
</Message Key>
<Message>
Mensaje cifrado con AES256  con la clave "CLAVE" en modo CBC con el vector de de inicializacion "IV"
</Message>


Donde en teoria se manda el "Message Key" cifrado con la llave publica.