Mensajes

El Updates es un contenedor que me indica cuantos items existen en la lista, y la lista el del tipo Update sin la S...

Código (c) [Seleccionar] Expandir


typedef struct {
int length;
Update **list;
}Updates;


typedef struct {
int update_id;
int type;
Message *message;
}Update;


El destino 0x0 no es escribible

No olvides NO conectarte a internet, ni usar memorias desconocidas.

Garantizado que no te infectaras de nada.

Ese memset no va a evitar que la variable con la cual llamaste a telegram_free_updates (en la cual no podes escribir ya que no la pasaste como doble puntero o referencia, updates es una variable local pasada por valor) continue apuntando al mismo bloque de memoria que liberas con free.

Código (c) [Seleccionar] Expandir

Updates *u = (Updates*)malloc(sizeof(Updates));
telegram_free_updates(u);
//u continua apuntando a la direccion de memoria que le haya retornado malloc

Tienes razon es lo que me quede pensando cuando respondi hace rato voy a cambiat el tipo de funcion y retornar NULL.
Y quedaria asi:

Código (c) [Seleccionar] Expandir


u= telegram_free_updates(u).

Gracias por el aporte

no le sacas partido a calloc ya que no veo para que te sirve que inicialize a 0 cuando luego lo sobrescribieras.

No seas vago. Es importante que el area en la que vas a escribir no tenga basura Me a pasado muchas veces que reservo exactamente la memoria que voy a usar + un byte. y algunas veces tu esperas que ese byte sea 0 y te quedas con esa idea y luego el programa empieza a hacer cosas raras y despues de pasara un rato depurando con GDB te das cuenta que la memoria tenia basura. cambias la instruccion a calloc o le agregas un memset despues del malloc y ahora todo funciona al 100.

Es todo correcto excepto lo de la condicion, la memoria asignada al puntero no la podes comparar de esa manera, de esa manera estas comparando la direccion a la que apunta el puntero con NULL y sera NULL con malloc o calloc en caso de fallo al reservar.

entiendo el punto, el codigo mostrado va cuando yo voy a liberar la memoria despues de usarla, si es que se usado,

Por ejemplo las funciones que ofresco para liberar la memoria

Código (c) [Seleccionar] Expandir


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


Como indica la documentacion de stdlib.

malloc y calloc reservan memoria. sin embargo no hay  garantia que la memoria reservada por malloc este limpia. A veces si a veces no.

calloc por otra parte es como malloc + memset(ptr,0,length). reserva memoria y la limpia. es importante tener la memoria limpia por que a veces haces condicidiones como:

Código [Seleccionar] Expandir

if(ptr!=NULL)
{
free(ptr);
}

basta que exista un byte de basura en la memoria para que la condicion se cumpla y el programa se cuelgue por tratar de liberar memoria inexistente o en su defecto escribir en un area no reservada.

https://www.freebsd.org/cgi/man.cgi?query=calloc&sektion=3&apropos=0&manpath=redhat

calloc()    allocates memory for an array of nmemb   elements of size bytes
      each and   returns   a pointer to the allocated memory.  The   memory is  set
      to zero.

      malloc()    allocates  size  bytes   and returns a pointer to the allocated
      memory.   The memory is not cleared.

Buen dia pues hice un pequeño programa para tu algoritmo.

La idea que tenia no a funcionado.

El enfoque era estadístico, lo que hice fue generar N arreglos de Enteros donde N es igual al numero de caracteres del mensaje.

El primer arreglo[0] es de longitud 1
El segundo arrega[1] es de longitud 2
y asi sucesivamente.

Guarde las sumas de los valores ascii de cada caracter en los arreglos. Ademas de contar cuantas veces se sumaba en cada caracter en cada casilla.

Saque los promedios y las desviaciones estandar ademas. saque el promedio de cada arreglo y las desviaciones estandar de las desviaciones estandar valga la redundancia...

Mi idea era ver como cambiaban las desviaciones estandar y me imaginaba que en los puntos de inflexion estaría la pista.

Curiosamente en algunos ejemplos el primer punto de inflexion coincidencia con la longitud de la contraseña, pero en otros no lo hacia.

Codigo:

Código (c) [Seleccionar] Expandir


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



Buen dia compañeros.

Quiero compartirles el proyecto en el que estoy trabajando.

Una interfaz en C para que programen su bot para telegram.

El codigo esta disponible en github, aun lo sigo mejorando y optimizando lo mas que pueda.
Casi todo el programa es memoria dimanica la cual  administra muy bien la aplicacion.

Ejemplo de uso.

Código (c) [Seleccionar] Expandir


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




Para trabajar con este ejemplo tenemos que te generar un token de autorización para nuestro bot y editar la linea de codigo:

Código (c) [Seleccionar] Expandir

telegram_init("123456789:zwxecrvtbynuyvbnmutyguhjdkeosdgjhfdouhn");

en este ejemplo procesamos las peticiciones:

getMe
getUpdates
sendDocument

Tambien que tenemos que sustituir el chat_id por el nuestro
El codigo depende de que tengamos instalado libcurl

Codigo en gihub

https://github.com/albertobsd/libtelegrambot

Saludos!

Como tu lo comentas un ataque por estadistica podria arrojar algo de luz sobre la distribución / frecuencia de los datos.

Código (c) [Seleccionar] Expandir


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


Hice este codigo para testear tu algoritmo, deja checo la salida y la analizo.

Cambie los length por strlen y cambie los bool por int para podrelo compilar sin errores, no se que compilador estes usando, en fin con los cambios que le hice funciona bien.

Esta fue la salida:

gF7Oe{%0HM%G4G2'I?L0)2G<'>$L&83X 8/%`&=3H5&y<MI'3i 3/%ME(2S >0$c&c2G`"_"*!f1By!-h-Xamr\T`V Y]i-aSoV"W*4Hbf\c1&f3G{%l"G `j

Saludos!

Practico el ejemplo, para fines de aprendizaje sobre sistemas de cifrados es buen trabajo, aun que realmente seguro no es.

Lo de agregar texto random suena bien, sin embargo la seguridad atravez de la oscuridad no estan segura.

Aun asi buen ejemplo para fines practicos.