Número áureo (cálculo alternativo)

Holas, hace unas semanas publiqué una entrada en la que explicaba lo que era el número áureo y como se calculaba a partir de la secuencia de Fibonacci.

En esta entrada os mostraré una manera alternativa de calcular el número áureo, lo cierto es que esta manera de calcularlo me parece super curiosa, mas que nada por las operaciones que se realizan...

El cálculo en cuestión es el siguiente:


1+(1/1+(1/1+(1/1+(1/1+(1/1+(1/1))))))


La operación a simple vista puede parecer un poco engorrosa, pero realmente es una operación muy sencilla, lo único que estamos haciendo es sumar uno mas uno, y después dividir el segundo operando de la suma (el segundo uno) entre uno mas uno, y así seguido, la operación se puede repetir hasta el infinito, de manera que cuantos mas bucles realicemos mas preciso será el número áureo que obtengamos.

Y al igual que con el otro método, en esta ocasión también he diseñado un código para calcular el número áureo usando este método, os lo dejo a continuación:

#include <stdio.h>

int main(int argc, char *argv[])
{

 if(argc<2)
 {
  printf("\nSe necesita un argumento\n\n");
 
  return -1;
 }

 if(!(atoi(argv[1]) > 0 && atoi(argv[1]) <=37))
 {
  printf("\nEl argumento debe estar entre 0 y 37\n\n");

  return -1; 
 }

 int max, i=0;

 double inc = 1;

 max = atoi(argv[1]);

 for(i=0; i < max; i++)
 {
  inc=(double)1/((double)1+inc);

 }

printf("\nNumero Aureo: %.50lf\n\n", (double)1+inc);


}

Para usar el programa solo hay que indicarle como argumento el número de bucles que realizará el programa para calcular el número áureo.

y esto es todo por ahora.

Saludos =)

Visor hexadecimal

Buenas, en esta entrada os traigo algo que tenía ganas de hacer hace tiempo, un programa para ver los datos de un archivo en formato hexadecimal.

Este tipo de programas es algo que suelo usar bastante, así que ademas de servirme como práctica de programación también es algo a lo que le voy a dar bastante uso.

La verdad es que me gusta la simplicidad con la que he diseñado el programa. De momento el programa solo visualiza los datos, pero probablemente modifique el programa para que también permita editarlos.

Cuando ejecutéis el programa os saldrán dos columnas, a la izquierda os aparecerán los datos en hexadecimal y a la derecha los caracteres ASCII imprimibles.

En la columna de la derecha, donde se visualizan los caracteres imprimibles, he decidido poner solo los caracteres básicos, del ASCII 33 al 126, y no los extendidos, ya que varían según la codificación que se use.

Os dejo el código a continuación:

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

int main (int argc, char *argv[])
{
 FILE *arc;

 int i=0, k=0, h=0, j=0, m=0, x=0;
 int **car = NULL;


 if(argc<2)
 {
  printf("\nFaltan un argumento\n\nModo de uso: %s \n\n", argv[0]);
 
  exit(-1);
 }


 if((arc = fopen(argv[1], "r")) == NULL)
 {
  printf("\nError al abrir el archivo\n\n");
 
  exit(-1);
 }


 while(!ferror(arc) && !feof(arc))
 {

  if ((car = (int **)realloc(car, (i+1) * sizeof(int *))) == NULL)
  {
   printf("\nError al asignar memoria\n\n");
   exit(-1);
  }


  if((car[i] = (int *)malloc(16 * sizeof(int))) == NULL)
  {
   printf("\nError al asignar memoria\n\n");

   exit(-1);
  }


  for(k=0; k<16; k++)
  {
  
   car[i][k] = fgetc(arc);

  }

  i++;

 }

 if(ferror(arc))
 {
  perror("\nSe ha producido un error durante la lectura\n\n");
 }


 printf("\n\n");


 for(h=0; h<i; h++)
 {
  for(j=0; j<16; j++)
  {
  
   if(car[h][j]==-1)
   {
    for(x=0; x < (16-j); x++)
     printf("   ");

    break;
   }
   else
   {
    if(car[h][j]<16)
    {
     printf("0%X ",car[h][j]);
    }
    else
    {
   
     printf("%X ", car[h][j]);
    }
   
   
   }

  }

  printf("\t");

  for(j=0; j<16; j++)
  {
 
   if(car[h][j]==-1)
   {
    break;
   }
   else
   {
   
    if((car[h][j] > 32) && (car[h][j] < 127))
    {
    
     printf("%c",car[h][j]);
   
    }
    else
    {
    
     printf(".");

    }
   }
  }


 printf("\n");
 
 }

 printf("\n\n");


 for(m=0; m<i; m++)
  free(car[m]);


 free(car);

 fclose(arc);


 return 0;

}
 

lo compilamos con:


cc hexa.c -o hexa


Para ejecutarlo solo tenemos que indicar como argumento el nombre de archivo que queremos visualizar:


./hexa <nombre_archivo>


Si el archivo a visualizar es demasiado grande probablemente el shell os trunque el principio de los datos, en esos casos os recomiendo redireccionar la salida del programa a un archivo tal que así:


./hexa archivo.jpg > prueba


y a continuación visualizar el archivo resultante desde un editor de texto.

espero que os haya gustado

Saludos =)

La proporción áurea y la secuencia de Fibonacci

La proporción áurea es una proporción que se encuentra en la naturaleza y que tiene una característica especial, todos los objetos que tienen una proporción áurea nos resultan mas agradables a la vista.



El rectángulo anterior tiene una proporción áurea, ya que si dividimos su largo por su alto nos da 1,6 que es aproximadamente la proporción áurea.

Dada esta característica, la proporción áurea es habitualmente usada en el mundo del arte y en muchos objetos cotidianos, para que nos parezcan "mas bonitos".

Una de las maneras de calcular el número áureo es usando la secuencia de Fibonacci, que es una secuencia de números que también se encuentra en la naturaleza.

Para calcular la secuencia de Fibonacci solo tenemos que realizar la suma de un número de la secuencia mas el número anterior a ese en la secuencia, siendo los dos primeros números de la secuencia el 0 y el 1, de manera que los primeros números de la secuencia son:


0 1 1 2 3 5 8 13...


y para calcular el número áureo solo tenemos que dividir un número de la secuencia entre el número anterior a ese en la secuencia, teniendo en cuenta que el número áureo sera mas preciso cuanto mas avanzada esté la secuencia de Fibonacci, de manera que obtendremos un número áureo mas preciso si dividimos por ejemplo 13/8 que si dividimos 8/5.

Aprovechando la ocasión he creado un programa que calcula la secuencia de Fibonacci y opcionalmente muestra el número áureo calculado con los dos últimos números de la secuencia.

Os dejo el código a continuación:

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

int fibonacci(unsigned long **, long);

int main(int argc, char *argv[])
{
unsigned long *num, i=0, max;
double aur;

if(argc==1)
{
printf("\nFalta tamaño de la secuencia\n\n");
printf("Modo de uso: %s <tamaño secuencia> [a]\n\n",argv[0]);
exit(-1);
}

max = atoi(argv[1]);

if(max>=95)
{
 printf("\nEl tamaño maximo es 94\n\n");

 exit(-1);
}


printf("\n");

fibonacci(&num, max);

i=0;

for(i=0;i<max;i++)
 printf("%lu\n\n",num[i]);


if(argc==3 && argv[2][0]=='a')
{
aur = (double)num[i-1]/(double)num[i-2];

printf("\nNumero aureo: %.50lf\n\n", aur);
}

free(num);

}


int fibonacci(unsigned long **num, long max)
{
  int i=0;
  
  *num = (unsigned long *)malloc(max * sizeof(long));

 for(i=0; i<max; i++)
 {
  if(i==0)
  {
   (*num)[i]=0;
  }
  else if(i==1)
  {
   (*num)[i]=1;
  }
  else
  {
  (*num)[i] = ((*num)[i-1]+(*num)[i-2]);

  }
 }
}

El programa lo compilamos usando:


gcc fibonacci.c -o fibonacci


Para ejecutar el programa tenemos que indicar un parámetro, que es la cantidad de números que queremos que tenga la secuencia, por ejemplo


./fibonacci 7


El ejemplo anterior nos mostrara los 7 primeros números de la secuencia de Fibonacci

Opcionalmente podemos indicar un segundo parámetro para que el programa calcule el número aureo usando los dos últimos números de la secuencia, para ello solo tenemos que indicar la letra 'a' como segundo parámetro, por ejemplo:


./fibonacci 7 a


Espero que os haya gustado

Saludos =)

Cifrado del César

La criptografía es algo que me llama bastante la atención, es una de esas cosas en las que me gustaría profundizar en un futuro (preferiblemente un futuro cercano jeje).

Así que en base a esto se me ocurrió hacer un programa que usase un cifrado simple para cifrar cadenas de caracteres, y que mejor para un novato que usar una de las técnicas criptograficas mas simples que existen, el cifrado del César.

Para los que no lo conozcáis, el cifrado del Cesar es un algoritmo criptografico que consiste simplemente en coger una cadena de caracteres y desplazar cada uno de sus caracteres una cantidad fija de posiciones en el alfabeto, probablemente sea el algoritmo criptografico mas simple que existe.

Poniendo un ejemplo, si cogiésemos la cadena "hola" y desplazásemos todos sus caracteres 5 posiciones hacia adelante en el alfabeto nos quedaría la cadena "mtqf", en el caso de que quisiésemos descifrar la cadena para obtener de nuevo la cadena original pues tendríamos que hacer el proceso inverso y desplazar todos los caracteres 5 posiciones hacia atrás.

Antes de ni siquiera empezar a pensar en el código del programa pensé que me llevaría bastantes lineas de código realizarlo, pero para mi sorpresa cuando me puse a programarlo me di cuenta de que el programa se podía realizar con una pequeña cantidad de lineas de codigo, es curioso como a veces algo que piensas que puede ser complicado al final resulta sencillo.

Os dejo el código del programa a continuación:

#include <stdio.h>

int main(int argc, char *argv[])
{
char c;

if(argc==1)
{
 printf("\nModo de uso: %s \n\n",argv[0]);

 return 0;
}

while((c=getchar()) != EOF)
{
if(c=='\n')
{
 printf("\n");
}
else if(c==' ')
{
 printf(" ");
}
else
{
 printf("%c",c+atoi(argv[1]));

}
}
return 0;
}

Para compilar el programa simplemente lo guardáis en un archivo "cesar.c" y ejecutáis el compilador tal que así:


gcc cesar.c -o cesar


Para usar el programa tendréis que ejecutarlo con un parámetro, este parámetro es el numero de cifrado que queréis usar (lo que equivaldría al desplazamiento de las letras en el alfabeto)

Imaginaros que queremos realizar el ejemplo que os ponía antes, pues lo haríamos de la siguiente manera, primero ejecutamos el programa tal que así:


./cesar 5


Después de ejecutarlo, el programa se queda a la espera de que introduzcamos una cadena de caracteres, así que introducimos "hola" y pulsamos enter y el programa a continuación nos muestra el resultado encriptado:



Si lo deseamos podemos seguir introduciendo cadenas de caracteres y el programa las ira traduciendo una a una, cuando queramos finalizar la ejecución del programa podemos hacerlo con control+c o control+d.

Para desencriptar este mensaje seguiríamos el mismo proceso, pero esta vez en vez de poner 5 como parámetro pondríamos -5, así desharíamos la encriptacion:



El numero de cifrado puede oscilar entre 0 y 255, en este aspecto podríamos decir que es una mejora del cifrado del César ya que no solo usa los caracteres del alfabeto sino que uso todos los caracteres ASCII.

También podéis usar el programa para cifrar archivos (archivos de texto plano), podéis hacerlo usando una doble redirección en el shell tal que así:


./cesar 24 < prueba > prueba_cifrado


Donde prueba es el archivo que queremos cifrar y prueba_cifrado es el archivo resultante ya cifrado.

Para descifrar el archivo lo haríamos así:


./cesar -24 < prueba_cifrado > prueba_descifrado


Donde prueba_cifrado es el archivo que ciframos anteriormente y prueba_descifrado el archivo ya descifrado, osea el archivo original.

Espero que os haya gustado, Saludos =D

Como detectar y evitar un ARP Spoofing

Holas, hoy os traigo otra de esas entradas que está relacionada con otra entrada.

En este caso está relacionada con el manual de ARP Spoofing que subí hace un tiempo, así que en esta ocasión os contare como detectar y evitar un ARP Spoofing.


¿CÓMO DETECTAR UN ARP SPOOFING?

Esta es quizá la parte mas complicada, ya que es muy difícil detectarlo, de hecho una persona que sepa hacerlo muy bien puede hacer un ARP Spoofing prácticamente indetectable.

El primer método para detectar un ARP Spoofing es mirar la tabla ARP y comprobar que todas las direcciones MAC son distintas, si hay alguna repetida quiere decir que estamos siendo víctimas de un ARP Spoofing, ya que las direcciones MAC son únicas para cada dispositivo, además es muy probable que la dirección mac duplicada sea la que hace referencia a vuestra puerta de enlace (gateway), ya que casi siempre se intenta redirigir el tráfico que se envía hacia internet.

para mirar la tabla ARP podéis hacerlo con este comando (se necesitan permisos de root para ejecutar el comando arp):


arp -v




como se puede ver en la imagen aparecen dos direcciones IP con la misma dirección MAC. La dirección MAC que aparece es la del ordenador al que estamos siendo redirigidos (por lo general suele ser el pc del atacante).

La segunda manera de detectar un ARP Spoofing es ejecutando un sniffer (como wireshark) en nuestro ordenador, de manera que tenemos que fijarnos en los paquetes ARP reply que recibimos (podemos poner un filtro en el wireshark para facilitar la visualización), si vemos que recibimos varios paquetes indicando una dirección IP y distintas direcciones MAC, quiere decir que estamos siendo victimas de un ARP Spoofing.



Como se puede ver en la imagen, se están recibiendo varios paquetes ARP reply indicando la dirección 192.168.120.30, pero las direcciones MAC con la que vienen asociados son distintas, lo cual es una incongruencia, ya que una tarjeta de red no puede tener más de una dirección MAC, lo cual indica que hay un atacante enviándonos paquetes ARP reply falsos y por otra parte está el dispositivo verdadero que también nos esta enviando sus paquetes ARP reply.

Por lo general en estos casos los paquetes ARP mas abundantes serán los falsos y los menos abundantes serán los verdaderos.


¿CÓMO BLOQUEAR O EVITAR UN ARP SPOOFING?

Bien, lo que veremos a continuación es como evitar ser víctimas de un ARP Spoofing, el procedimiento a seguir es bastante fácil.

Lo único que tenemos que hacer para evitar un ARP Spoofing es poner las entradas de la tabla ARP, estáticas (en vez de dinámicas que es como se crean por defecto).

Para introducir entradas estáticas en la tabla ARP lo haremos de la siguiente manera:


arp -s <direccion IP> <direccion MAC>


donde <direccion IP> es la dirección IP del ordenador que queramos introducir en la tabla ARP y <direccion MAC> es la dirección MAC que tenga dicho ordenador.

Ahora viene la pregunta ¿qué ordenadores tengo que meter en la tabla ARP?, realmente el más importante de todos es la puerta de enlace (gateway) ya que el ARP Spoofing casi siempre se hace con el objetivo de conseguir interceptar el tráfico que va dirigido hacia internet, pero si te sueles conectar a ordenadores de tu red (y no solo a internet) también es recomendable poner estos ordenadores en la tabla.

Nota: para saber la dirección MAC de los ordenadores que vas a introducir en la tabla puedes fiarte de las direcciones que ya están en la tabla (como dinámicas) siempre y cuando estés 100% seguro de que nadie te esta realizando un ARP Spoofing en ese momento, de todas maneras lo mas seguro es que las mires directamente en los ordenadores que quieras meter en la tabla (usando el comando ifconfig en cada uno de ellos por ejemplo), en el caso del router puedes mirar la dirección MAC en la página de configuración del mismo.

En este caso yo solo voy a poner la entrada para mi puerta de enlace (gateway), de manera que lo haría así:


arp -s 192.168.120.30 d0:ae:ec:ec:0a:44




Como podemos ver ahora en el campo "Flags" aparece una "M" indicando que la entrada ha sido introducida de manera manual en la tabla.

Nota: la entrada manual se borrará al reiniciar el sistema, así que, si queremos, podemos crear un script que se inicie en el arranque del sistema para que se introduzca la entrada manual automáticamente.

Tal y como está la tabla ARP ahora mismo sería imposible que se modificase la entrada del router enviando paquetes ARP reply, de manera que es imposible que nos hagan un ARP Spoofing para suplantar a nuestro router (puerta de enlace / gateway).


Espero os haya gustado =)

Cualquier duda dejádmela en comentarios

Saludos =D

[Manual] SSH Tunneling

holap, aquí os traigo otro de mis manuales, este en concreto creo que fue uno de los últimos (sino el último) que escribí.

Este manual trata sobre como crear un túnel a través de un protocolo seguro como lo es ssh, la verdad es que me parece algo realmente interesante, ya que te permite convertir una transmisión de datos insegura en segura, ya que ssh cifra los datos que envía.

Por otra parte esta técnica también puede emplearse para hacer una redirección de puertos lo cual puede ser bastante útil en ciertas ocasiones.

El manual en si es bastante escueto, pero creo que el contenido merece la pena.

Os dejo el manual a continuación: SSH Tunneling

Saludos =)

¿Cómo saber quien está en mi red? PARTE 2

Buenassssss.... esta entrada es una continuación de una que publiqué hace unas semanas, os la dejo AQUI.

Bien, como mencioné en la otra entrada, a veces los paquetes ICMP pueden ser bloqueados, de manera que no podemos confirmar realmente si hay o no un dispositivo en una dirección concreta, ya que si bloquea lo paquetes ICMP no recibimos ninguna respuesta a pesar de que SI hay alguien en la dirección ip a la cual enviamos la solicitud ICMP.

Ok, aquí es donde entra en juego el protocolo ARP. Resumiendo mucho el tema: en una red de área local los ordenadores se comunican con direcciones físicas (MAC), y el protocolo ARP se encarga de hacer una asociación entre las direcciones IP y las direcciones MAC. Resumiendo del todo, si un ordenador quiere estar conectado a una red tendrá que responder a las solicitudes ARP que se le manden, así que nosotros usaremos esto para descubrir que dispositivos están conectados realmente a nuestra red.

Nota: si un ordenador bloquease los paquetes ARP no se podría conectar a la red, ya que no podría ni enviar ni recibir paquetes al no poder recibir información del protocolo ARP, lo cual nos asegura que al realizar solicitudes ARP nos responderán todos los dispositivos que están realmente en nuestra red.

perfecto, ahora ya sabemos el truco definitivo para saber quien están en nuestra red, pero.... ¿cómo lo ponemos en práctica? pues bien, podemos hacerlo de varias maneras:

La primera manera de hacerlo es haciendo un ping con nmap tal y como hacíamos en la parte 1 y a continuación mirar la tabla ARP de nuestro equipo, para mirar la tabla ARP se necesitan privilegios de root, asi que la secuencia de comandos sería así:

Nota: yo uso la red 192.168.120.0 porque es la dirección de mi red, pero cada uno deberá de usar la dirección de su propia red, si tienes configurado el router por defecto probablemente la dirección de tu red sea 192.168.1.0


nmap -sP 192.168.120.0-255




su

arp -v




Como podemos ver se muestran un montonazo de entradas en la tabla ARP, pero casi todas nos marcan que están incompletas, las que nos interesan son las que están completas, osea, las que se nos muestran con una dirección MAC, si queremos podemos ejecutar el comando de la siguiente manera para que se nos muestren solo las entradas completas:


arp -v | grep C




estas entradas son los ordenadores que están conectados a nuestra red, en mi caso se muestran dos entradas, que corresponden a la dirección 192.168.120.30 (mi router) y 192.168.120.29 (otro ordenador de mi red), como podéis observar cuando se realiza el sondeo ICMP no se muestra esta ultima dirección (192.168.120.29) ya que en este ordenador hay un firewall que bloquea los paquetes ICMP, pero en cambio cuando consultamos la tabla arp vemos que esta ahí porque SI que responde a la solicitud ARP que hace el sistema.

Nota: en el sondeo icmp sale la dirección 192.168.120.21 que es la dirección de mi propio ordenador, por eso no sale después en la tabla ARP.

La segunda manera es la mas factible, ya que solo usamos nmap, de hecho usamos nmap exactamente de la misma manera que antes, lo único que cambia es que lo haremos con permisos de root:


su

nmap -sP 192.168.120.0-255




Como podemos ver en esta ocasión también se nos muestra la dirección 192.168.120.29 que antes no se mostraba.

El tema es que nmap siempre hace un sondeo ARP, lo que pasa es que, por decirlo de alguna manera, nmap necesita permisos de root para poder acceder a la información del protocolo ARP, así que cuando lo ejecutamos sin permisos de root solo nos muestra el resultado del sondeo ICMP, pero cuando lo ejecutamos con permisos de root nos muestra también el sondeo ARP (que es mas fiable).

De todas maneras también podemos indicarle a nmap que haga un sondeo exclusivamente ARP de la siguiente manera:


nmap -PR 192.168.120.0-255


Esta opción ademas del sondeo ARP también hará un escaner de los puertos mas habituales, si queremos evadir un poco el escaner de puertos, podemos ejecutar el programa de la siguiente manera:


nmap -p 0 -PR 192.168.120.0-255


Conclusión final:

Para saber quien esta en tu red lo único que tienes que hacer es ponerte como root en un shell (usando el comando su) y después simplemente usar nmap con la opción -sP y el rango de direcciones de tu red.

Cualquier duda que tengáis dejádmela en los comentarios

Saludos =)