void telegram_free_updates(Updates *updates)	{
	int i = 0;
	if(updates)	{
		while(i < updates->length)	{
			if(updates->list[i])
				telegram_free_update(updates->list[i]);
			i++;
		}
		memset(updates,0,sizeof(Updates));
		free(updates);
	}
}
 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<sys/stat.h>
 
off_t fsize(const char *filename);
unsigned char max(unsigned char item,unsigned char mx);
unsigned char min(unsigned char item,unsigned char mn);
 
int main()	{
	int **sums;
	int **counts;
	float **diff;
	float **promedios;
	float **desviacion;
	float *sumdesviaciones;
	float *promedioDesviaciones;
	float *diffdesviaciones;
	float *desviacion2;
	FILE *file;
	char *buffer;
	float temp;
	int l,i,j,k;
	file = fopen("salida.txt","r");
	if(file)	{
		l = fsize("salida.txt");
		buffer = calloc(l+1,sizeof(char));
		fread(buffer,sizeof(char),l,file);
		fclose(file);
		sums = calloc(l,sizeof(int*));
		counts = calloc(l,sizeof(int*));
		diff = calloc(l,sizeof(float*));
		promedios = calloc(l,sizeof(float*));
		desviacion = calloc(l,sizeof(float*));
		sumdesviaciones = calloc(l,sizeof(float));
		promedioDesviaciones = calloc(l,sizeof(float));
		diffdesviaciones = calloc(l,sizeof(float));
		desviacion2 = calloc(l,sizeof(float));
		i = 0;
 
		while(i < l)	{
			sums[i] = calloc(i+1,sizeof(int));
			counts[i] = calloc(i+1,sizeof(int));
			diff[i] = calloc(i+1,sizeof(float));
			promedios[i] = calloc(i+1,sizeof(float));
			desviacion[i] = calloc(l,sizeof(float));
			i++;
		}
 
		//rellenar array de sumas
		j = 0;
		while(j < l)	{
			k =0;
			while(k < l)	{
				//printf("Procesando sums[%i][%i]\n",j,(k % (j+1)));
				sums[j][k % (j+1)] += buffer[k];
				counts[j][k % (j+1)] +=1;
				k++;
			}
			j++;
		}
		//mostramos las sumas y los contadores
		i=1;
		j=0;
		while(j < l)	{
			k =0;
			while(k < i)	{
				//printf("sums[%i][%i] = %i\n",j,k,sums[j][k]);
				//printf("counts[%i][%i] = %i\n",k,i,counts[j][k]);
				k++;
			}
			i++;
			j++;
		}
		//calcular promedios
		i=1;
		j=0;
 
		while(j < l)	{
			k =0;
			while(k < i)	{
				promedios[j][k] = ((float)sums[j][k])/((float)counts[j][k]);				
				//printf("promedios[%i][%i] = %f\n",j,k,promedios[j][k]);
				k++;
			}
			i++;
			j++;
		}
		//calcular Diferencias
		j = 0;
		while(j < l)	{
			k =0;
			while(k < l)	{
				temp = promedios[j][k % (j+1)] - buffer[k];
				if(temp < 0.0)	{
					temp = -1.0 *temp;
				}
				diff[j][k % (j+1)] += temp;
				k++;
			}
			j++;
		}
		//calcular desviacion
		i=1;
		j=0;
		while(j < l)	{
			k =0;
			while(k < i)	{
				desviacion[j][k] = diff[j][k]/counts[j][k];				
				//printf("desviacion[%i][%i] = %f\n",j,k,desviacion[j][k]);
				k++;
			}
			i++;
			j++;
		}
 
		//calcular suma desviaciones
		i=1;
		j=0;
		while(j < l)	{
			k =0;
			while(k < i)	{
				sumdesviaciones[j]+= desviacion[j][k];
				k++;
			}
			promedioDesviaciones[j] =  sumdesviaciones[j]/i;
			printf("promedio desviacion[%i] = %f\n",j,promedioDesviaciones[j]);
			i++;
			j++;
		}
		//calcular differencia de desviaciones
		i=1;
		j=0;
		while(j < l)	{
			k =0;
			while(k < i)	{
				diffdesviaciones[j]+= promedioDesviaciones[j] - desviacion[j][k];
				k++;
			}
			desviacion2[j] = diffdesviaciones[j]/(float)k;
			printf("desviacion2[%i] = %f\n",j,desviacion2[j]);
			i++;
			j++;
		}
 
		printf("l : %i\n",l);
	}
	return 0;
}
 
unsigned char max(unsigned char item,unsigned char mx)	{
	return (item >= mx)? item:mx;
}
 
unsigned char min(unsigned char item,unsigned char mn)	{
	return (item <= mn)? item:mn;
}
 
off_t fsize(const char *filename) {
	struct stat st;
	if (stat(filename, &st) == 0)
		return st.st_size;
	fprintf(stderr, "Cannot determine size of %s: %s\n",filename, strerror(errno));
	return -1;
}
 
 

/*
 * Luis Alberto 
 * Twitter @albertobsd
 */
 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<curl/curl.h>
#include<sys/stat.h>
#include<errno.h>
#include"telegram.h"
#include"jsmn.h"
 
int main()	{
	Updates *updates;
	User *user;
	Message *message;
	File *file;
	char **variables;
	char **valores;
	int i = 0;
	char *filename;
	telegram_init("123456789:zwxecrvtbynuyvbnmutyguhjdkeosdgjhfdouhn");
	user = telegram_getMe();
	if(!telegram_is_error())	{
		printf("User: id: %i\nusername: %s\n",user->id,user->username);
		telegram_free_user(user);
	}
	else	{
		printf("%s\n",telegram_get_error());
	}
	updates = telegram_getUpdates();
	if(!telegram_is_error()){
		printf("updates: %i\n",updates->length);
		while(i < updates->length)	{
			if(updates->list[i]->item.message->document)	{
				printf("Document exits file_id : %s\n",updates->list[i]->item.message->document->file_id);
				file = telegram_getFile(updates->list[i]->item.message->document->file_id);
				if(!telegram_is_error())	{
					filename = telegram_downloadFile(file,updates->list[i]->item.message->document->file_name);
					printf("file name : %s\n",filename);
				}
				else	{
					printf("%s\n",telegram_get_error());
				}
			}
			i++;
		}
		telegram_free_updates(updates);
	}
	else	{
		printf("%s\n",telegram_get_error());
	}
	variables = calloc(5,sizeof(char*));
	valores = calloc(5,sizeof(char*));
	variables[0] = "chat_id";
	variables[1] = "text";
	valores[0] = "9219883";
	valores[1] ="Texto de prueba";
	message = telegram_sendMessage(telegram_build_post(variables,valores));
	if(!telegram_is_error())	{
		printf("OK %s\n",message->text);
		telegram_free_message(message);
	}
	else	{
		printf("%s\n",telegram_get_error());
	}
	variables[1] = "caption";
	valores[1] = "Envio archivo";
	message = telegram_sendDocument("test_telegram",variables,valores);
	if(!telegram_is_error())	{
		printf("OK %s\n",message->text);
		telegram_free_message(message);
	}
	else	{
		printf("%s\n",telegram_get_error());
	}
	return 0;
}
 
 

	telegram_init("123456789:zwxecrvtbynuyvbnmutyguhjdkeosdgjhfdouhn");

#include<stdio.h>
#include<string.h>
 
int main()	{
	char *pass = "HolaMundo";
	char *text = "QWERT456Y76U76I7OP6A756S7D567F6G7H56J7K67L6Ñ7Z56X7C567V65B7N65M7q56w2e3r2t41213yuiopasdfghjklzxcugjh877yvbty7t6645r311nm";
	int x = 1;
	char *name = "salida.txt";
	crypt(pass,text,x,name);
	return 0;
}
 

/*
	Twitter @albertobsd
	cc -o RSA_2048 RSA_2048.c `libgcrypt-config --cflags --libs`
	Prueba de generacion de claves RSA 2048 y 4096 bits.
*/
 
#include<stdio.h>
#include<gcrypt.h>
 
int main()	{
	FILE *f = NULL;
	gcry_sexp_t rsa_parms = NULL;
	gcry_sexp_t rsa_keypair = NULL;
	gcry_error_t err = 0;
	char *buffer;
	size_t length = 4;
	size_t offset = 0;
	err = gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
	err |= gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
	err |= gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
	err |= gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
	if(err) {
		fprintf(stderr,"gcrypt: failed initialization");
		exit(0);
	}
	err = gcry_sexp_build(&rsa_parms, NULL, "(genkey (rsa (nbits 4:4096)(rsa-use-e 1:1)))");
	if (err) {
		fprintf(stderr,"gcrypt: failed initialization");
		exit(0);
	}
	length = gcry_sexp_sprint(rsa_parms,GCRYSEXP_FMT_CANON,NULL,0);
	buffer = calloc(length,sizeof( char));
	offset = gcry_sexp_sprint(rsa_parms,GCRYSEXP_FMT_CANON,buffer,length);
	printf("Buffer size %i\n",length);
	printf("Buffer offset %i\n",offset);
	printf("%s\n",buffer);
	memset(buffer,0,length);
	err = gcry_pk_genkey(&rsa_keypair, rsa_parms);
	if (err) {
		fprintf(stderr,"gcrypt: failed initialization");
		exit(0);
	}
	length = gcry_sexp_sprint(rsa_keypair,GCRYSEXP_FMT_CANON,NULL,0);
	buffer = realloc(buffer,length*sizeof(char));
	offset = gcry_sexp_sprint(rsa_keypair,GCRYSEXP_FMT_CANON,buffer,length);
 
	printf("Buffer size %i\n",length);
	printf("Buffer offset %i\n",offset);
	printf("%s\n",buffer);
	f = fopen("clave.txt","w");
	if(f)	{
		fwrite(buffer,sizeof(char),offset,f);
		fclose(f);
	}
	memset(buffer,0,length);
	free(buffer);
	gcry_sexp_release(rsa_keypair);
	gcry_sexp_release(rsa_parms);
}
 

gcry_sexp_build(&rsa_parms, NULL, "(genkey (rsa (nbits 4:4096)(rsa-use-e 1:1)))");

"(genkey (rsa (nbits 4:4096)(rsa-use-e 1:1)))"

Buffer size 49
Buffer offset 48
(6:genkey(3:rsa(5:nbits4:4096)(9:rsa-use-e1:1)))
Buffer size 2441
Buffer offset 2440
(8:key-data(10:public-key(3:rsa(1:n513:

gcry_pk_genkey(&rsa_keypair, rsa_parms);

offset = gcry_sexp_sprint(rsa_keypair,GCRYSEXP_FMT_CANON,buffer,length);

printf("%s\n",buffer);

fwrite(buffer,sizeof(char),offset,f);

• Buscar un tipo de UUID en la maquina y usar su sha256 de password
• Generar un archivo random y usar su sha256 de password
• hardcodear el password en la aplicacion (mala idea) pero es una opcion