Códigos Fuente de C/Visual C

/*
----Lenguaje C-----
Texto en memoria.
********************
volcado_text_memo.c
**********************
Hilario Iglesias Martínez.
*******************************
En este ejemplo, se introduce un texto
sin espacios por teclado, para poder
identificarlo mejor en memoria,
de hasta 8 caracteres.
Ejemplo: MENSAJE
El programa realiza un volcado de memoria.
En este volcado se puede ver el texto en
exadecimal, y su ubicación en cada dirección
de memoria en formato TEXTO.
En el se puede estudiar muy bien el funcionamiento
de punteros y direcciones de memoria.

MENSAJE debería volcar en exadecimal:
4d,45,4e,53,41,4a,45

*********************************************
Realizado en plataforma LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI C.-C-11
Usado el IDE Sublime Text.
Compilación: gcc volcado_text_memo.c -o volcado_text_memo
EJECUCIÓN:$ ./volcado_text_memo
******************************************************
Durante la compilación pueden surgir algunos
errores tipo "warning", de asignación,
por incompativilidad de tipos, que no
influyen a la compilación del mismo.
*******************************************
Establecemos por defecto DimensionVolcado=180,
Y un direccionamiento de hasta 8 caracteres*****
for(i=0; i < 8; i++)
{ //Direccioamos hasta un mensaje de 8 caracteres
Se puede modificar parámetros y jugar con el mismo

**********************************************************
RESULTADO.
-------------------------------------
MENSAJE Cadena visible en el volcado pasando texto a exadecimal
------------------------------------------------------------
BYTES DE LA ESTRUCTURA LOCALIZADOS EN: 0x6f73bdc0
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
4d 45 4e 53 41 4a 45 00 c4 ff 00 00 00 00 00 00
c2 00 00 00 00 00 00 00 07 be 73 6f fe 7f 00 00
06 be 73 6f fe 7f 00 00 7d a3 4f 35 6b 55 00 00
e8 12 fb 5f e6 7f 00 00 30 a3 4f 35 6b 55 00 00
00 00 00 00 00 00 00 00 c0 a0 4f 35 6b 55 00 00
10 bf 73 6f fe 7f 00 00 00 d2 6c 7a cf 3b d0 66
00 00 00 00 00 00 00 00 83 40 de 5f e6 7f 00 00
20 36 00 60 e6 7f 00 00 18 bf 73 6f fe 7f 00 00
00 00 00 00 01 00 00 00 a9 a1 4f 35 6b 55 00 00
30 a3 4f 35 6b 55 00 00 a6 da ad c9 96 6b b7 d2
c0 a0 4f 35 6b 55 00 00 10 bf 73 6f fe 7f 00 00
*********************************************************
|En esta dirección | @ 0x6f73bdc0 |contenido TEXTO es:| M
||En esta dirección | @ 0x6f73bdc1 |contenido TEXTO es:| E
||En esta dirección | @ 0x6f73bdc2 |contenido TEXTO es:| N
||En esta dirección | @ 0x6f73bdc3 |contenido TEXTO es:| S
||En esta dirección | @ 0x6f73bdc4 |contenido TEXTO es:| A
||En esta dirección | @ 0x6f73bdc5 |contenido TEXTO es:| J
||En esta dirección | @ 0x6f73bdc6 |contenido TEXTO es:| E

*/

/*
----LENGUAJE C----
****************************
Volcado de memoria.
*********************
volcadoTime.c
******************************************
HILARIO IGLESIAS MARTÍNEZ
+++++++++++++++++++++++++++
Programa educativo
-----------------------
Realizado en plataforma LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI C.-C-11
Usado el IDE Sublime Text.
Compilación: gcc volcadoTime.c -o volcadoTime.c
EJECUCIÓN.
**********
$ ./volcadoTime
Al compilar, pueden surgir errores sin importancia de
compilación por disparidad con identificadores de impresión.
+++++++++++++++++++++++++++++++++++++++++++++
Esta estructura incluida en <time.h>, se toma
como ejemplo para realizar un volcado de memoria
llamando a alguna de sus características,
y comprobar su comportamiento en memoria.
Se debe tener en cuenta, que el alojamiento en memoria
es volcado en exadecimal, para localizar los valores
direccionados se deberá teber en cuenta su valor
decimal a exadecimal. Lo que podemos hacer con los
muchos conversores que podemos encontrar on line.
Para comprobar su alojamiento en memoria hemos
realizado una petición de la hora actual.
También se debe de tener en cuenta como se alojan
los valores en el ordenador, según sean
Big Endian o Little Endian. Ya explicado en
otro de mis programas.
Hemos volcado para comprobar 8 valores en memoria.
Tipo_int_puntero = (int *) tiempo_puntero;
for(i=0; i < 8; i++)
También hemos pedido un volcado de -int DimensionVolcado=176- Bytes
for(i=0; i < DimensionVolcado; i++) --int tamañovolcado=176
Cada uno puede modificar los parámetros como quiera.
**********************************************
La funciones ctime(), gmtime() y localtime() toman
todas un argumento de tipo time_t que
representa el tiempo de calendario.
Al ser interpretado como un valor de tiempo absoluto,
representa el número de segundos transcurridos desde
las 00:00:00 del 1 de Enero de 1970,
en Tiempo Universal Coordinado,
Coordinated Universal Time (UTC).
**********************************************

struct tm {
int tm_sec; segunados, rango 0 to 59
int tm_min; minutos, rango 0 to 59
int tm_hour; horas, rango 0 to 23
int tm_mday; dias del mes, rangeo 1 to 31
int tm_mon; meses, rango 0 to 11
int tm_year; El número de años hasta 1900
int tm_wday; dias de la semana rango 0 to 6
int tm_yday; dias del año rango 0 a 365
int tm_isdst; horario verano
};
**********************************************
*/

/*
---------------reverso.c-------------------------
Este programa es un pequeño ejemplo de como trata un ordenador
los datos a la hora de alojarlos en memoria.
Detecta, dependiendo del tipo de procesador, si es
Big Endian o Little Endian.
En este caso, lo hacemos aprendiendo como trata un puerto
de comunicación o una IP, dependiendo de las características
y el tipo de ordenador.
Al igual que existen lenguajes donde la lectura y escritura
puede ser izquierda-derecha o derecha-izquierda también
en el mundo de los ordenadores puede suceder algo parecido.
Encontrándonos distintas maneras en las que las máquinas
pueden almacenar los datos , que cobran especial
relevancia cuando se trata de trabajar con datos de más de
un byte.
A la hora de expresar estos datos tenemos que definir el
concepto debyte más representativo (MSB) y byte menos
representativo (LSB), que se denomina así al byte que
modificado altera el dato en mayor medida y al
que lo hace en menor medida.
+++++++--LENGUAJE C-- ++++++++
Big Endian o Little Endian.
********************************
Cuestiones o dudas a: [email protected]
Realizado en plataforma LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI C.-C-11
Usado el IDE Sublime Text.
************************************
Hilario Iglesias Martínez.
-------------------------------------

******ESNIFANDO RED********
EJECUTAR BAJO ROOT
*******************************************
-------------------------------------
snifo-paquetes.c
------------------------------------
snifo-paquetes.c
trabajo_dump.h
Deben estar bajo el mismo directorio linux.
-----------------------------------
Para el funcionamiento de este programa, deberán estar
instaladas las librerías pcap. Forma de instalarlas
bajo Linux-
sudo apt-get update
sudo apt-get install libpcap-dev
-----------------------------------------
Procedencia, y código modificado de:
https://www.tcpdump.org/
Código obtenido de la libreria hacking.h.
Se han modificado algunos parámetros
origen:
https://github.com/Partyschaum/haxe/blob/master/hacking.h
+++++++++++++++++++++++++++++++++++++++++++++++++++++++
Para saber las tarjetas presentes en el ordenador
bajo linux se puede utilizar el comando ifconfig.
Se puede snifar y probar con cualquier tarjeta,
incluida la ethernet, LOOPBACK. wifi...
Por defecto aqui se obtiene la tarjeta de rd wifi.
El comado habitual seŕia.
#sudo ./snifo-paquetes -tu tarjeta de red-
IMPORTANTE.
Nuestra librería trabajo_dump.h,
deberá estar colocada en el mismo directorio que
snifo-paquetes.c
************************************************
Realizado en plataforma LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI C.-C-11
Usado el IDE Sublime Text.
+++++++++++++++++++++++++++++++++++++++++
Compilacion, bajo linux.
:~$ gcc esnifo-paquetes.c -lpcap -o esnifo-paquetes
Los errores de compilación surgidos, no son importantes.
---------------------------------------------------
****************************************************
EJEMPLO DE ESNIFADO - (El dispositivo de red loopback).
$ sudo ./esnifo-paquetes lo
---------------------------------
Si se quiere guardar lo esnifado en un fichero de
texto, se puede utilizar este comando.
$ sudo ./esnifo-paquetes lo > mifichero.txt
Se deberá crear el fichero vacio mifichero.txt
++++++++++++++++++++++++++++++++++++++++++++++
SALIDA EJEMPLO POR CONSOLA LINUX
-----------------------------------------
Tarjeta de red wifi: wlp1s0
Dirección IP: 192.168.0.0
Mascara de Red: 255.255.255.0
***********************************************
*****ESPERA,ESTOY ESNIFANDO PAQUETES
****************************************************
****************************************************************
****ESNIFAMOS DE LA TARJETA: wlp1s0 -> EL PAQUETE N°:0 DE: 78 BYTES******
****************************************************************
45 00 00 4e 51 49 40 00 32 06 39 32 8c 52 71 19 | [email protected].
c0 a8 00 1b 01 bb bd 78 92 1a 73 e1 4f c5 1d 01 | .......x..s.O...
80 18 00 46 40 68 00 00 01 01 08 0a 7f 91 4d 56 | [email protected]
cb a9 16 b6 17 03 03 00 15 c1 51 f9 e2 7d ba 7a | ..........Q..}.z
7b b7 85 cf 31 d7 5d 1f 6f cc b0 1c c7 63 | {...1.].o....c
****************************************************************
****ESNIFAMOS DE LA TARJETA: wlp1s0 -> EL PAQUETE N°:1 DE: 52 BYTES******
****************************************************************
45 00 00 34 51 4a 40 00 32 06 39 4b 8c 52 71 19 | [email protected].
c0 a8 00 1b 01 bb bd 78 92 1a 73 fb 4f c5 1d 1f | .......x..s.O...
80 10 00 46 ec 07 00 00 01 01 08 0a 7f 91 4d c0 | ...F..........M.
cb aa 01 16 | ....
****************************************************************
****ESNIFAMOS DE LA TARJETA: wlp1s0 -> EL PAQUETE N°:2 DE: 52 BYTES******
****************************************************************
45 80 00 34 3c 5d 00 00 7b 06 47 a5 ad c2 4c bc | E..4<]..{.G...L.
c0 a8 00 1b 14 6c a8 10 e9 24 1b 82 0d 35 90 4d | .....l...$...5.M
80 10 01 09 2d 0c 00 00 01 01 08 0a 6b 3e d0 63 | ....-.......k>.c
82 d3 70 4a | ..pJ
****************************************************************
****ESNIFAMOS DE LA TARJETA: wlp1s0 -> EL PAQUETE N°:3 DE: 52 BYTES******
****************************************************************
45 00 00 34 51 4b 40 00 32 06 39 4a 8c 52 71 19 | [email protected].
c0 a8 00 1b 01 bb bd 78 92 1a 73 fb 4f c5 1d 1f | .......x..s.O...
80 10 00 46 3b 08 00 00 01 01 08 0a 7f 91 fe bf | ...F;...........
cb aa 01 16 | ....
****************************************************************
****ESNIFAMOS DE LA TARJETA: wlp1s0 -> EL PAQUETE N°:4 DE: 52 BYTES******
****************************************************************
45 80 00 34 42 22 00 00 7b 06 41 e0 ad c2 4c bc | E..4B"..{.A...L.
c0 a8 00 1b 14 6c a8 10 e9 24 1b 82 0d 35 90 4d | .....l...$...5.M
80 10 01 09 7d 0b 00 00 01 01 08 0a 6b 3f 80 63 | ....}.......k?.c
82 d3 70 4a | ..pJ
****************************************************************
****ESNIFAMOS DE LA TARJETA: wlp1s0 -> EL PAQUETE N°:5 DE: 78 BYTES******
****************************************************************
45 00 00 4e 51 4c 40 00 32 06 39 2f 8c 52 71 19 | [email protected]/.Rq.
c0 a8 00 1b 01 bb bd 78 92 1a 73 fb 4f c5 1d 1f | .......x..s.O...
80 18 00 46 ec ec 00 00 01 01 08 0a 7f 92 37 b5 | ...F..........7.
cb aa 01 16 17 03 03 00 15 43 ca 5a c9 96 a2 7a | .........C.Z...z
98 6e 12 6d 65 61 cf 01 c7 46 40 b4 c8 16 | .n.mea...F@...
****************************************************************
****ESNIFAMOS DE LA TARJETA: wlp1s0 -> EL PAQUETE N°:6 DE: 52 BYTES******
****************************************************************
45 00 00 34 51 4d 40 00 32 06 39 48 8c 52 71 19 | [email protected].
c0 a8 00 1b 01 bb bd 78 92 1a 74 15 4f c5 1d 3d | .......x..t.O..=
80 10 00 46 17 0e 00 00 01 01 08 0a 7f 92 38 1f | ...F..........8.
cb aa eb 77 | ...w
****************************************************************
****ESNIFAMOS DE LA TARJETA: wlp1s0 -> EL PAQUETE N°:7 DE: 52 BYTES******
****************************************************************
45 80 00 34 bb 96 00 00 7b 06 c8 6b ad c2 4c bc | E..4....{..k..L.
c0 a8 00 1b 14 6c a8 10 e9 24 1b 82 0d 35 90 4d | .....l...$...5.M
80 10 01 09 cd 0a 00 00 01 01 08 0a 6b 40 30 63 | ............k@0c
82 d3 70 4a | ..pJ
********************************************************************
Lo he programado para esnifar 8 paquetes.

Realizado en plataforma LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI C.-C-11
Usado el IDE Sublime Text.

/*
*****************************
PING EN ANSI C, BAJO LINUX.
****************************
otroping.c
*****************************************************
Hilario Iglesias Martinez
*****************************************************
El ejemplo lo forman, el ejecutable con main otroping.c
y otroping.h, los dos ficheros deberán estar bajo
el mismo directorio.

COMPILAR.
$ gcc otroping.c -o otroping
****************************************************
EJEMPLO DE EJECUCION
sudo ./otroping www.mipagina.com
***************************************

ICMP, el Protocolo de control de mensajes de Internet (Control Message Protocol ),
un protocolo de la capa de red, utilizado habitualmente para obtener información
informativa de un host determinado. Consiguiendo así en las señales de retorno,
basicamente la situación activa o inactiva del host.
A lo largo de su historia, utilizado también para floodear o inundar
de peticiones un host determinado. Es de recordar, por ejemplo,
aquellos incipientes programas de mensajería como el protocolo IRC,
sin ningún tipo de salvaguardia, con aquellas bromas de nukear
determinados usuarios de un canal.
Hoy día con aún utilizado para generación de mensajes
de error o control de flujo malicioso. En este caso el
objetivo es doble, degradar el servicio de red con la
inundación de peticiones y/o conseguir que los sistemas
receptores quede inutilizados por no poder procesar todas
las peticiones que les llegan, en
denegación de servicio. (Deny Of Service, DOS)
***************************************************************************
El programa ejemplo que expongo para uso educativo, es un extracto de
varias utilidades obtenidas en internet, modificadas por mi para
resultar mas esclarecedoras y educativas. El programa tiene un
flodeo intensido y continuo. El programa admite la modificación
de parámetros, para su nueva compilación o prueba.
******************************************************************
El progroma se ejecutará bajo consola Linux, y con privilegios de ROOT.
Fue adaptado y realizado en plataforma LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI C.-C-11
Usado el IDE Sublime Text.
Forma de compilación: gcc archivo.c -o archivo
Cuestiones o dudas a: [email protected]
Adaptado según.
Network Working Group
RFC: ICMP- 792
*****
Una salida típica por consola de linux debería ser:
************************************************
4 bytes from (null) (h: 192.168.0.27)(192.168.0.27) msg_seq=13375 ttl=64 rtt = 0.043117 ms.
64 bytes from (null) (h: 192.168.0.27)(192.168.0.27) msg_seq=13376 ttl=64 rtt = 0.038719 ms.
64 bytes from (null) (h: 192.168.0.27)(192.168.0.27) msg_seq=13377 ttl=64 rtt = 0.038763 ms.
64 bytes from (null) (h: 192.168.0.27)(192.168.0.27) msg_seq=13378 ttl=64 rtt = 0.038819 ms.
64 bytes from (null) (h: 192.168.0.27)(192.168.0.27) msg_seq=13379 ttl=64 rtt = 0.038608 ms.
64 bytes from (null) (h: 192.168.0.27)(192.168.0.27) msg_seq=13380 ttl=64 rtt = 0.038917 ms.
64 bytes from (null) (h: 192.168.0.27)(192.168.0.27) msg_seq=13381 ttl=64 rtt = 0.038339 ms.

*****************************************
otroping.h
*********************************
EJEMPLO DE UNA CABECERA ICMP DE RETORNO
-Destino Inaccesible-
****************************
Postel

RFC 792 Protocolo de Mensajes de Control Internet


Mensaje de Destino Inaccesible ("Destination Unreachable Message")

0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Tipo | Código | Suma de Control |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| sin usar |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Cabecera Internet + 64 bits de datos del datagrama original |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

Campos IP:

Dirección de Destino

La red y dirección del origen extraídos de los datos del datagrama
original.

Campos ICMP:

Tipo

3

Código

0 = red inaccesible;

1 = "host" inaccesible;

2 = protocolo inaccesible;

3 = puerto inaccesible;

4 = se necesitaba fragmentación pero DF estaba activado;

5 = fallo en la ruta de origen.

Suma de Control

El complemento a uno de 16 bits de la suma de los complementos a
uno del mensaje ICMP, comenzando por el Tipo ICMP. A la hora de
calcular la suma de control, el valor inicial de este campo es
cero. Esta suma de control puede ser sustituida en el futuro.

Cabecera internet + 64 bits de Datagrama de Datos

*/

Utilizamos la funcion de llamada fork,
bajo un bucle multiplicativo for.
La llamada al sistema de bifurcación se usa para
crear un nuevo proceso, que se llama proceso
secundario, que se ejecuta simultáneamente
con el proceso que realiza la llamada a la bifurcación ()
(proceso principal). Después de que se crea un nuevo
proceso secundario, ambos procesos ejecutarán la
siguiente instrucción después de la
llamada al sistema fork(). Un proceso hijo usa la
misma computadora (contador de programa),
los mismos registros de CPU, los mismos archivos
abiertos que usa el proceso padre.
ATENCION.
*********
Su ejecución continuada bajo consola de Linux
puede, en algunos casos..., ENLENTECER el
ordenador. Se ruega no ejecutar durante tiempo
excesivo. Para salir bajo consola linux
utilizar las teclas CONTROL C.
****************************************

/* DIRECCIÓNES DE MEMORIA
*************************
Ejemplo sencillo de aprendizaje
Correspondencia entre las direcciones de memoria
y cada letra de una frase cualquiera en un array.

Sencillo ejemplo,modificado del curso de Angel Salas
LENGUAJE "C",de Enero 1991, sobre cálculo de potencias
en ANSI-C. Se ha dividido el programa en dos partes
con el fin de mejorar el ejemplo.
Cuestiones o dudas a: [email protected]

DUDAS SOBRE PUNTEROS.
*********************
Resolviendo dudas sobre punteros
y direcciones de memoria. Sencillo
programa que apunta a elementos
numéricos individuales, con sus
respectivas direcciones de
memoria.