Archive for programación
Seguridad Sistemas y Redes (8)
Posted by: | CommentsCadenas identificativas y otros recursos 4
Complementando a las herramientas administración y servicios de internet, existen otras técnicas que permiten detectar maquinas en una red. A este tipo de técnicas junto con las herramientas administrativas se les suele conocer con el nombre de fingerprinting, que viene a significar “huella identificativa”. Esta huella identificativa suele ser para un atacante toda la información de la implementación de pila TCP/IP, esta información permite descubrir de forma bastante fiable el sistema operativo que esta ejecutando la maquina, esto junto a otras informaciones permiten averiguar las versiones de los servicios que utiliza el servidor, con lo que se puede consultar si existen vulnerabilidades y herramientas para aprovecharse de las mismas.
La mayoría de las técnicas utilizadas para la obtención de huellas identificativas están basadas en la información de la pila del protocolo TCP/IP. El protocolo TCP es un protocolo de la capa de transporte que asegura que el envió de datos sea correcto, es decir que la información recibida se corresponda con la información enviada.
A la hora de realizar una búsqueda de sistemas, podemos distinguir quizás dos partes, la primera seria simplemente detectar si un dispositivo esta activo en una red y la segunda seria examinar las características de dicho dispositivo, como servicios en funcionamiento, puertos abiertos en el dispositivo y sistema operativo que utiliza el mismo. Para realizar estos tipos de análisis se pueden utilizar dos tipos de análisis:
- Análisis activo: Un análisis activo es aquel que envía información a la red para que los sistemas conectados a la misma, detecten dicha información y respondan en base a dicha información. Según la información obtenida de las respuestas de los diferentes sistemas el programa de análisis utilizado o nosotros mismos podemos realizar las deducciones pertinentes.
- Análisis pasivo: A diferencia del anterior tipo de análisis, en este tipo de análisis la maquina que quiere realizar el análisis no envía información a la red, sino que “escucha” la información que viaja por la misma y determina los resultados en base a la captura de dicha información. Lógicamente este tipo de análisis es mas difícil de detectar por parte de las maquinas analizadas.
Normalmente un intruso después de haber obtenido información de un sistema, intentara un intento de acceso utilizando técnicas de escaneo, estas acciones tendrán como finalidad conocer los servicios que tiene el sistema como ftp, web, telnet, mail, etc… Estos servicios se interpretan como puertos activos o abiertos en el sistema. La función de saber que puertos están disponibles por parte del intruso es la de conocer dichos puertos, ya que suelen ser las puertas de entrada al sistema. Si el intruso llegar a conocer el sistema operativo y las versiones de los servicios utilizados, es posible que pueda documentarse sobre alguna vulnerabilidad, herramienta o exploit que permita el acceso a la maquina atacada.
Los puertos disponibles van desde el 1 hasta el 65535 que se pueden clasificar de la siguiente forma:
Puertos estándar: su rango oscila entre el 1 y 1024.
Puertos registrados: su rango oscila entre el 1025 hasta el 49151
Puertos dinámicos: su rango oscila entre el 49152 y el valor 65535
La formas de analizar redes a través de paquetes tcp o udp, se suelen englobar dentro de los análisis activos. Ya que suelen enviar paquetes para determinar que puertos están activos o a la espera de recibir una conexión. Este hecho de cierta forma favorece al encargado de la seguridad del sistema, ya que se puede decir que este tipo de análisis “hacen mucho ruido”, y un sistema de detección de intrusos seria capaz de determinar el ataque y de donde proviene. Aun así ciertas herramientas utilizadas por intrusos son capaces de modificar el ataque para que su detección sea mas problemática por el ids (“sistema de detección de intrusos”), siendo estos distribuidos de la siguiente forma:
Análisis lentos: el análisis realizado de esta forma consiste en demorar o retardar el tiempo de envió entre paquetes aumentando los tiempos de espera, el análisis durara mucho mas tiempo, pero por otra parte el ids no tendrá claro si es un ataque o un acceso normal.
Análisis de puertos aleatorios: otra forma de realizar este tipo de ataque para que el ids no lo detecte es realizar el análisis de los puertos aleatoriamente y no siguiendo un orden secuencial, que podría “despertar” sospechas al ids, este tipo de ataque se suele combinar con el análisis lento, por parte del atacante su análisis durara mucho mas tiempo, pero no se notara tanto en la maquina atacada.
Análisis distribuidos: Este tipo de análisis consiste en realizar el análisis utilizando varias maquinas distintas, de esta forma y combinando el análisis con los dos anteriores, es prácticamente imposible que el ids detecte el análisis.
Análisis a través de proxy: este tipo de análisis lo realiza la maquina atacante utilizando un proxy, es decir una maquina intermedia que hace de proxy entre la maquina atacada y el atacante, así aun cuando se descubra el ataque se obtendrá información sobre el proxy y no sobre la maquina atacante.
Análisis fragmentación de paquetes: en análisis de la maquina atacada se realiza enviando paquetes lo suficientemente pequeños para así dividir la información de cabecera del paquete. Así el ids es posible que no sea capaz de reconstruir el paquete fragmentando y por tanto su identificación o detección se vuelve errónea, este tipo de análisis también puede afectar a los cortafuegos o “firewalls”. Como es lógico los paquetes son reconstruidos por la maquina atacada al llegar a la misma. La fragmentación se suele hacer generando trozos pequeños de 8 bytes, de esta forma los flag de cabecera TCP no van en el primer paquete o se envía un paquete fragmentado, que el segundo fragmento tiene desplazamiento negativo, con lo cual al unirlos en el destino se sobrescribe la información del mismo.
Análisis por cebos o señuelos: El envió de señuelos consiste en enviar paquetes a la maquina atacada con direcciones ip falsas y entre una de estas direcciones se envía la verdadera, con lo que el ids cree que no es un ataque y resulta muy difícil que lo detecte.
Ejercicios y practicas resueltas de c ( 6 )
Posted by: | CommentsOtro ejercicio de programación en c, para ir completando los ejercicios y practicas a resolver.
Enunciado del ejercicio:
Realizar un programa que solicite un numero entero por teclado y a continuación visualice por pantalla todos los números primos entre 1 y el numero introducido.
El ejercicio y practica resuelta a continuación:
#include <stdio.h>
#include <stdlib.h>
// Predefinición de funciones
int EsPrimo(int);
// Función principal
int main(int argc,char *argv[])
{
int numero;
int valores;
// Solicitar por pantalla el numero
printf(“Teclear No.: “);
scanf(“ %d”,&numero);
// Visualizar todos los números primos entre 1 y el numero
// se utilizara una función para saber si un numero es primo o no
for(valores=1;valores<=numero;valores++)
{
if(EsPrimo(valores)==0)
printf(“El valor %d es primo\n”);
}
return 0;
}
// Funciones desarrolladas
// la funcion devuelve 0 si el numero es primo en caso contrario 1
int EsPrimo(int Valor)
{
int primo=0;
int divisores=0;
// Calcular divisores del numero
for(divisores=2;divisores<Valor-1 && primo==0;divisores++)
{
// Comprobar si existe un divisor
if(Valor%divisores==0) primo=1;
}
return primo;
}
Ejercicios y practicas resueltas de c ( 5 )
Posted by: | CommentsNueva practica o ejercicio resuelto de programación en el lenguaje c, para que completes tu teleformacion con nuestros cursos online gratuitos.
Enunciado del ejercicio:
Realizar un programa en el lenguaje de programación c, que lea una matriz de un fichero, realiza la traspuesta de dicha matriz y la almacene en un fichero nuevo. Los nombres de los archivos se han de solicitar utilizando la línea de comandos como si de un comando ms-dos o Linux se tratara. Se ha de solicitar tanto el nombre del archivo origen como el nombre del archivo destino.
El ejercicio y practicas resuelta a continuación:
#include <stdio.h>
#include <stdlib.h>
// Predefinición de funciones
int Existe(char *);
// Función principal
int main(int argc,char *argv[])
{
// Comprobación del numero de parámetros recibido
if(argc!=3) {
printf("\n¡Faltan parámetros");
printf("\nFormato: comando fichero_origen fichero_destino");
exit(1);
}
// Comprobación de ficheros
if(Existe(argv[1])==1) {
printf("\nEl fichero de origen no se ha encontrado o no existe...");
exit(1);
}
// Declaración de variables necesarias
FILE *fichero;
int filas;
int columnas;
float **matriz1=NULL;
int contador;
int contador1;
// Abrir archivo en modo lectura
fichero=fopen(argv[1],"rt");
// Leer filas y columnas
fscanf(fichero,"%d %d",&filas,&columnas);
printf("%d %d",filas,columnas);
// Realizar la reserva de memoria para las matrices
matriz1=(float **)malloc(sizeof(float *)*filas);
for(contador=0;contador<filas;contador)
{
matriz1[contador]=(float *)malloc(sizeof(float)*columnas);
}
// Asignar datos de la matriz
for(contador=0;contador<filas;contador++)
{
for(contador1=0;contador1<columnas;contador1++)
{
fscanf(fichero,"%f",&matriz1[contador][contador1]);
}
}
fclose(fichero);
printf("\n");
for(contador=0;contador<filas;contador++)
{
for(contador1=0;contador1<columnas;contador1++)
{
printf("%.2f ",matriz1[contador][contador1]);
}
printf("\n");
}
// visualizar traspuesta
printf("\n%d %d\n",columnas,filas);
for(contador=0;contador<columnas;contador++)
{
for(contador1=0;contador1<filas;contador1++)
{
printf("%.2f ",matriz1[contador1][contador]);
}
printf("\n");
}
fichero=fopen(argv[2],"wt");
if(!fichero)
{
printf("\nERROR No se ha podido crear el archivo destino...");
exit(1);
}
// grabar traspuesta
fprintf(fichero,"%d %d\n",columnas,filas);
for(contador=0;contador<columnas;contador++)
{
for(contador1=0;contador1<filas;contador1++)
{
fprintf(fichero,"%.2f ",matriz1[contador1][contador]);
}
fprintf(fichero,"\n");
}
// cerrar archivo
fclose(fichero);
// liberar memoria
for(contador=0;contador<filas;contador++)
{
free(matriz1[contador]);
}
free(matriz1);
return 0;
}
// Funcion Existe
int Existe(char *nombre_fichero)
{
FILE *fichero;
int resultado=0; // 0 = existe 1 = no existe
fichero=fopen(nombre_fichero,"rt");
if(fichero!=NULL)
{
fclose(fichero);
}
else
{
resultado=1;
}
return resultado;
}
Ejercicios y practicas resueltas de C ( 4 )
Posted by: | CommentsOtro nuevo ejercicio de c para seguir el curso de teleformacion y así poder practicas con ejemplos uno de tus lenguajes de programación favorito.
Enunciado del ejercicio:
Realizar un programa que invierta un fichero de texto creando uno nuevo ( es decir el fichero de destino o final ha de tener el contenido del primero u origen pero al revés ), en vez de solicitar los nombres de archivos en el programa se utiliza la línea de parámetros como si de una orden de linux o ms-dos se tratara. Se utiliza para leer y grabar las funciones fread y fwrite, realizando una reserva de memoria dinámica con la función malloc, y la función free para liberar la memoria utilizada. El ejercicio se ha realizado utilizando el editor Code Blocks bajo Windows 7 y probado en la consola de comandos de Windows 7.
El ejercicio resuelto es el siguiente:
#include <stdio.h>
#include <stdlib.h>
// Predefinición de funciones
int Existe(char *);
long int Tamanyo(char *);
// Función principal
int main(int argc,char *argv[])
{
// Comprobación del numero de parámetros recibido
if(argc!=3) {
printf("\n¡Faltan parámetros");
printf("\nFormato: comando fichero_origen fichero_destino");
exit(1);
}
// Comprobación de ficheros
if(Existe(argv[1])==1) {
printf("\nEl fichero de origen no se ha encontrado o no existe...");
exit(1);
}
// Declaración de variables necesarias
FILE *fichero;
long int cuantos;
char *reserva=NULL;
int contador;
// Abrir archivo en modo lectura
fichero=fopen(argv[1],"rt");
// Averiguar el tamaño del archivo
cuantos=Tamanyo(argv[1]);
// Realizar la reserva de memoria correspondiente al tamanyo del fichero
reserva=(char *)malloc(sizeof(char)*cuantos);
// leer el archivo completo y almacenarlo en la variable reserva
fread(reserva,sizeof(char),cuantos,fichero);
// Cerrar fichero de origen
fclose(fichero);
// abrir archivo destino
fichero=fopen(argv[2],"wt");
// en caso de error devolver error y salir
if(!fichero) {
printf("\nNo se ha podido crear el archivo destino...");
exit(1);
}
// si no existe error recorrer el vector creado en orden inverso
// y almacenarlo en el archivo destino
printf("\nInvertir archivo");
for(contador=cuantos;contador>=0;contador--)
{
fwrite(&reserva[contador],sizeof(char),1,fichero);
printf(".");
}
// cerrar el archivo destino
fclose(fichero);
// finalizar programa
printf("Ok\n");
// Liberar memoria
free(reserva);
return 0;
}
// Función Existe
int Existe(char *nombre_fichero)
{
FILE *fichero;
int resultado=0; // 0 = existe 1 = no existe
fichero=fopen(nombre_fichero,"rt");
if(fichero!=NULL) {
fclose(fichero);
} else {
resultado=1;
}
return resultado;
}
// Función contador
long int Tamanyo(char *nombre_fichero)
{
FILE *fichero;
long int contador=0;
char caracter=0;
fichero=fopen(nombre_fichero,"rt");
fread(&caracter,1,sizeof(caracter),fichero);
while(!feof(fichero))
{
contador++;
fread(&caracter,1,sizeof(caracter),fichero);
}
fclose(fichero);
return contador;
}
Seguridad Sistemas y Redes ( 5 )
Posted by: | CommentsCadenas identificativas y otros recursos
Una de las formas más artesanales de obtener información sobre una organización, es obtenerla a través del código fuente de sus portales corporativos o páginas Web, es decir revisar manualmente el código xhtml, html, asp o php. De esta forma se puede conocer que aplicaciones corren los servicios web e incluso es posible determinar, de una manera bastante aproximada, que sistema operativo esta instalado en la maquina. También es normal buscar los comentarios en el código fuente, para ver si proporcionan alguna información que pueda ser de utilidad. Para realizar este proceso de descargar un portal entero a nuestra maquina para analizarlo existen numerosas herramientas, entre ellas destacamos las siguientes:
wget (Linux)
En distribuciones Linux, desde la línea de comandos, existe la herramienta wget, que permite descargar a un disco local todas las paginas web de un portal, bien por vía HTTP, o por vía FTP, es una aplicación para ejecutarla desde la consola, aunque existen entornos gráficos. la sintaxis del comando es la siguiente:
wget [opciones] [lista de urls]
Siendo las opciones disponibles para el comando las siguientes:
-h
–helpMuestra la ayuda del comando.
-V
Muestra la versión del programa.
-i nombrefichero
–input-file=nombreficheroLee la lista de urls del fichero especificado en nombrefichero.
-o ficherolog
–output-file=ficherologEscribe los ficheros de log en ficherolog, en vez de utilizar la pantalla.
-a ficherolog
–append-output=ficherologIgual que la opción anterior, pero si el fichero existe añade en el mismo la información, en caso de no existir el fichero lo crea.
-t numero
–tries=numeroEspecifica el numero de veces de intentos a realizar para la descarga, si se especifica el valor 0, indica un numero indefinido.
–follow-ftp
Sigue los enlaces ftp desde documentos HTML
-g on/off
–glob=on/offActiva o desactiva el uso de caracteres especiales como ‘*’ para indicar todos los ficheros.
-r
especifica el modo recursivo.
-U
especifica identificación de navegador. Ya que muchos sitios web deniegan la descarga si no se realiza a través de un navegador.
–wait=tiempo
Especifica un tiempo de parada o pausa entre descargas.
–limit-rate=valor
Especifica el valor o velocidad de descarga indicada en valor.
-no-parent
Indica que el comando no descargue por debajo del directorio especificado.
-k
Una vez terminada la descarga convierte los enlaces o links de los documentos a rutas relativas, para poder navegar en modo local con la descarga realizada.
-c
Continua con la descarga desde el punto en el que se haya quedado.
Vea los siguientes ejemplos:
// Descargar un archivo wget http://www.aprendoencasa.com/index.php // Descargar utilizando distintos métodos wget http://www.aprendoencasa.com/imagen1.jpg ftp://aprendoencasa.com/descargar/cursos.zip // Descargar utilizando archivo de entrada // se ha de crear un archivo el cual contendrá la uri de los archivos a descargar wget –i archivos.txt // Descargar después de una interrupción continuando por donde se haya quedado wget –i –c archivos.txt // Descargar y crear un informe wget –o informe.txt http://www.aprendoencasa.com/index.html // Descargar un archivo limitando el ancho de banda wget –o informe.txt –-limit-rate=50k ftp://ftp.aprendoencasa.com/ubuntu910.iso // Descargar especificando nombre de usuario y contraseña en caso de ser solicitado // por un sitio wget –http-user=admin –http-password=secreto http://www.aprendoencasa.com/archivo1.zip // Descargar aumentando el numero de intentos, útil en casos de sitios con saturacion // y descargar utilizando accesos infinitos wget –t 50 http://www.aprendoencasa.com/fedora10.iso wget –t inf http://www.aprendoencasa.com/suse11.iso // Descargar pagina web entera con los elementos que incluyen la misma como imágenes, // estilos, etc. wget –p http://www.aprendoencasa.com // Descargar pagina web entera especificando recursividad de hasta cinco niveles wget –r http://www.aprendoencasa.com // Descargar pagina web entera especificando nivel de recursividad wget –r -l10 http://www.aprendoencasa.com // Descargar pagina web convirtiendo los enlaces a relativas para navegar offline wget –r ––convert-links http://www.aprendoencasa.com // Existen mas opciones seria interesante consultar el comando para averiguarlas.
Ejercicios y practicas resueltas de c ( 3 )
Posted by: | CommentsUn ejercicio nuevo de c sobre ficheros, para complementar tu formacion en nuestro portal de cursos online y de teleformacion.
El planteamiento de ejercicio es que se soliciten utilizando la linea de comandos tres ficheros de formas que se lean los datos de los dos primeros archivos y se concatenen en el tercer archivo indicado.
// Inclusion de librerias
#include <stdio.h>
#include <stdlib.h>
// Predefinicion de funciones
// funcion para saber si existe o no un fichero
int Existe(char *);
// Funcion principal
int main(int argc,char *argv[])
{
// Control de los parametros obtenidos desde el sistema
// El planteamiento de ejecucion de la orden es el siguiente
// unir fichero1 fichero2 ficheronuevo
if(argc!=4)
{
printf("\n¡parametros incorrectos...\n");
printf("\nEl formato de la orden es orden fichero1 fichero2 ficherodestino\n");
exit(1);
}
// Comprobacion de si existen los ficheros que se van a leer
if(Existe(argv[1])==0)
{
printf("\nError: El primer archivo no existe o no se ha encontrado...\n");
exit(1);
}
if(Existe(argv[2])==0)
{
printf("\nError: El segundo archivo no existe o no se ha encontrado...\n");
exit(1);
}
if(Existe(argv[3])==0)
{
printf("\nEl archivo destino se creara automaticamente.\n");
}
else
{
printf("\nEl archivo destino ya existe y se sobreescribira automaticamente.\n");
}
// Apertura de los archivos
FILE *fichero1;
FILE *fichero2;
FILE *fichero3;
char caracter;
fichero1=fopen(argv[1],"rt");
if(fichero1==NULL)
{
printf("\nHa ocurrido un error en la apertura del archivo %s",argv[1]);
exit(1);
}
fichero2=fopen(argv[2],"rt");
if(fichero2==NULL)
{
printf("\nHa ocurrido un error en la apertura del archivo %s",argv[2]);
exit(1);
}
fichero3=fopen(argv[3],"wt");
printf("\nSe ha creado el archivo %s",argv[3]);
printf("\nConcatenando archivos");
// Lectura de los archivos y grabacion en el archivo destino
// se realiza una prelectura para evitar errores de archivos
// vacios.
fread(&caracter,sizeof(char),1,fichero1);
while(!feof(fichero1))
{
fwrite(&caracter,sizeof(char),1,fichero3);
fread(&caracter,sizeof(char),1,fichero1);
printf(".");
}
fread(&caracter,sizeof(char),1,fichero2);
while(!feof(fichero2))
{
fwrite(&caracter,sizeof(char),1,fichero3);
fread(&caracter,sizeof(char),1,fichero2);
printf(".");
}
// Cierre de archivos
fclose(fichero1);
fclose(fichero2);
fclose(fichero3);
printf("\nFichero concatenado Ok.\n");
return 0;
}
// Funcion Existe
int Existe(char *Nombre)
{
int resultado;
FILE *fichero;
if((fichero=fopen(Nombre,"r"))==NULL) resultado=0;
else {
resultado=1;
fclose(fichero);
}
return resultado;
}
