Buenas, reestructuraré la pregunta:

Utilizo un archivo donde guardo datos, esos datos me interesa que estén cifrados, para ello siempre que escribo algo en el (un grupo de datos) lo cifro antes de escribirlo en él.

Cuando escribo datos paso un tuple<u_char*,int> "bytes", pues AES necesita el tamaño para cifrarlo, lo escribe en el archivo y al final siempre deja un "\0", a veces cuando va a escribir por segunda vez (sobre lo escrito anteriormente) salta un error en ejecución, sobre la línea del ofstream.write : "se produjeron daños en un montón".

Código:

void almacen::escribir_cifrado(bytes _datos)
{
	ofstream archivo;
	archivo.open(directorio, ofstream::app | ofstream::binary);
	_datos = cifrador.encriptar_AES(get<CONTENIDO>(_datos), get<TAMAÑO>(_datos));
	-> archivo.write((char*)&(get<CONTENIDO>(_datos)[0]), get<TAMAÑO>(_datos));
	archivo.close();
}

Aparte al descifrarlo, leo todo el archivo en binario, y lo mando descifrar, pero solo descifra el primer bloque de datos, he mostrado todos los bytes como ints y me cortaba en el primer '\0', he probado a suprimirlos y persiste el problema, ¿que puede ser? ¿dónde está el fallo?.

string almacen::leer_descifrado()
{
	ifstream archivo;
	archivo.open(directorio, ifstream::in | ifstream::binary);
	archivo.seekg(0, ifstream::end);
	streampos tamaño = archivo.tellg();
	char *contenido = new char[tamaño]();
	archivo.seekg(0, ifstream::beg);
	archivo.read(contenido, tamaño);
	archivo.close();
	string ret = cifrador.desencriptar_AES((u_char*)contenido, tamaño);
	delete contenido;
	return ret;
}

Una pregunta:

¿Los sucesivos montones de datos que meto cifrados tengo que descifrarlos uno a uno (pues estan separados por \0), o puedo leerlo todo pasarlo a descifrar y ya lo debería de hacer?, ¿ambas funcionan? ¿tengo que descifrar por bloques?. Es AES.

Saludos y gracias.

EDICION DELICATESSE:

string encriptador_AES::desencriptar_AES(u_char *_entrada, int _tamaño)
{
	int p_len = _tamaño, f_len = 0;
	u_char *salida = (u_char*)malloc(p_len);
	EVP_DecryptInit_ex(&de, NULL, NULL, NULL, NULL);
	EVP_DecryptUpdate(&de, salida, &p_len, _entrada, _tamaño);
	EVP_DecryptFinal_ex(&de, salida + p_len, &f_len);
	for (int i = 0; i < _tamaño; i++)
		cout << salida[i];
	return string((char*)salida);
}

Al pasar salida a (char*) en el primer \0 se corta la cadena y por eso mostraba solo el primer bloque, porque al final de cada bloque se añade un \0, solucionado pues era una chorrada, pero costo un poco encontrarla XD.

Eso al menos salió en los medios occidentales (pero porque se atacaron a ellos mismos sino...).

Y hace poco han afirmado que van a continuar con el bloqueo a Cuba unos 55 años de bloqueo y continúan, son el extractor de sangre del mundo XD

Gracias engelx lo he estado mirando y está muy bien, entre otras cosas he aprendido que la clave pública solo cifra, yo pensaba que tambien descifraba lo que le mandaba el servidor, pero parece que no.


Según dices no hace falta clave si uso un protocolo.. pero como.. ya se verá supongo.

Saludos y gracias.

Quizás podía pasarle los parámetros y generarlo el usuario, pero claro con los mismos parametros generaría la privada XD, no pensé en ello.


Claro, debería de haber 2 programas distintos, el de usuario y el del administrador.
Pero si hacen ingeniería inversa al usuario, sacarían la clave con la que cifra ¿no?, y entonces podría acceder a claves públicas del administrador mmm..

La idea entonces sería el administrador crear clave privada y cuando un cliente solicita conexión decide si aceptarla o no, en tal caso, le manda una cadena de bytes al azar entonces el cliente lo cifra y lo manda al admin, es correcto, entonces le mando una clave pública y ¿comenzamos una conexión segura? (le pasaría la clave pública..).

Pero algo fatal puede pasar: que creen un programa administrador que mande bytes aleatorios les acepte conexión independientemente de la respuesta (o si han hecho ing inversa al cliente podrían cojer la respuesta buena), y reconectar a los clientes.

Sería una grave brecha.

Hay que partir de que se puede hacer ingeniería inversa del cliente, entonces van a conocer sus claves con las que se conectan o aceptan comandos y supongo si hacen eso siempre podrán sustituir el adminsitrador, el control de los clientes pasaría de un lado a otro.

Ah vale, es que pense que como ponías lo del "a.cpp" y "b.cpp", pensé que lo necesitaban ok.

Saludos y gracias XP

Si quieres persistencia, haz lo que dice drvy, tu idea de primeras es sencilla y eficaz, pero no es buena, lo mejor sería crear un servicio que le de persistencia a el ejecutable, o hacer dll inyection,

Saludos.

Si es lo que tenía pensado engelx, entonces yo creo la clave privada y reparto mis claves públicas ¿no?, y como hago para que un usuario de la red no acepte claves públicas de extraños y que solo acepten las mías?, pues si va otro y manda la pública como yo entra a la red e interactúa con ellos.

Entonces las claves públicas se crean a la vez que la privada ¿no?, pensaba que se generaban al establecer la conexion, pero parece que son ellos las que las mandan, luego tenemos una clave privada y tenemos que ser capaces de generar claves públicas que tenemos que distribuir entre los usuarios, y las vamos cambiando entre los mismos mejor.

Saludos y gracias.

Ya veo, aunque hay que incluit los código fuente o cabeceras en el código fuente que queramos usar la variable, luego es lo mismo que si declaramos una variable en un header y vamos incluyendo el header en códigos, tendremos acceso a ella, sino me equivoco que no estoy seguro pues siempre suelo usar #define.

Aunque no me acaba de convencer esto del extern, mejor considero usar variables globales, y diferenciar variables a definir para cada cabecera como puse anteriormente, porque eso de tener una variable, declararla en un lado inicializarla en otro, luego en otro que ya no sabes ni lo que vale etc XD, mejor variables globales XD.

Saludos.

Hola, no entiendo la seguridad de las claves publicas/privada.

Supongamos que genero una clave privada como hace facebook.com que va sobre SSL, entonces que tengo que hacer yo para generar una clave pública para facebook.com y poder descifrar los datos del otro extremo, ¿acaso facebook me da una clave pública o la genero yo?, y si es asi ¿como?.

La verdad quiero implementar una red p2p, y para poder hacer actualizaciones sobre la misma necesito una clave RSA y firmar los datos que mande en este caso comandos para que otro no pueda hacerlo sin la clave, ya tengo openssl, pero sigo sin entender como debería hacerlo.

Supongamos que los usuarios tienen clave pública, y yo tengo la privada, entonces yo les mando comandos a ellos, ellos con su clave pública descifran y ven el comando luego lo ejecutan, pero si hacen ingeniería inversa al usuario podrían crearme una clave privada que funcione con las claves públicas del bot no?.

¿Como debería de establecer esa conexión segura insuplantable a no ser que tuvieran mi clave?.

He estado leyendo y buscando pero no me queda claro como se genera la clave pública, quien la manda y como se acepta, pues si otro que no soy yo manda su clave publica y ya tiene su clave privada podría conectarse también.

Saludos, seguiré viendo poco a poco, gracias.

La estrategia de estados unidos es simple, entran en países pobres muy vulnerables, y comienzan a criticar a el que esta al mando a base de campañas que libran o bien dentro del mismo país o a través de internet (como hicieron con una cuenta de twitter que criticaba las políticas de Fidel Castro al que trataron de asesinar por activa y por pasiva).

Una vez comienzan a salir los primeros opositores al régimen que se han dejado llevar por esta propaganda vendida por estados unidos, inglaterra y occidente el menor medida, los países que han creado la campaña comienzan a armar a los grupos opositores, y se libran guerras civiles en el país, los medios occidentales comienzan a poner verde al antiguo mandatario del país e intesifican la campaña contra el, arrastrando cada vez a más gente al grupo rebelde.

Una vez dada inicio la guerra civil comienzan con la llamada "intervención", "acabar con los terroristas", "misiones de paz", etc. Tras esa mentira, los países que provocaron las primeras manifestaciones como el 100% de las veces es estados unidos, entran en la guerra directamente, y atacan directamente a los gobiernos al poder además de apoyar a los rebeldes.

Cuando acaba la guerra como siempre suele ganar estados unidos (esperemos que en Siria así no sea), entonces ponen a un mandando de presidente al servicio de los intereses económicos de estados unidos.

Edito: prefiero ahorrarme mi opinión personal acerca del tema.

Saludos.