int **calificaciones;

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

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

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

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

#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++;
	}
}
 

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 

• Petya

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);
}
 

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

• 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

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

/*
	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;
}
 
 
 

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