Mi lugar...

Ismsgratis.com y sus agujeros de seguridad!!!!

2010-11-01T18:23:00.001-07:00

Quien podría maginar que una página como esta contara con tantas fallas de seguridad, pues nada, el uso indiscriminado de Ajax hace que los programadores pasen por alto las tan importantes validaciones del lado del servidor y se centren más en cómo se verá el sitio, algo que es un error crucial en este tipo de aplicaciones teniendo en cuenta que queda abierto el camino para explotar vulnerabilidades que van desde enviar SMS gratuitos hasta saltarnos el Captcha de la página.

En ismsgratis.com hay dos modalidades que permiten el envió de SMS,

1- La primera nos permite enviar SMS gratis con un límite de 3 envíos diario.

2- La segunda es mediante el depósito de saldo, que tiene como ventajas precios muy competitivos.

Y ahora pa´la caliente:

La falla que le he encontrado a esta página permite enviar más de un SMS a una persona por el costo de uno. En la versión de pago queda más que claro su efecto y en la gratuita pues nada podemos enviarle un libro completo a un amigo y solo nos descontara uno de los 3 preciados mensajes del día.

1- Nos autenticamos en la página y pinchamos en la opción Enviar SMS.

2- Llenamos con el número al cual queremos enviar nuestro largo mensaje (ni se les ocurra llenar el campo del captcha eso está ahí sin motivos almenos yo creo eso!!!).

3- Quitamos la URL del navegador y en su lugar escribimos lo siguiente:

javascript: $('mensaje').value = "Aquí va nuestro interminable mensaje";

4- Presionamos enter y nuestro mensaje aparecerá en el cuadro destinado para esto.

5- Y por último sustituimos el anterior código javascript por este:

javascript: $('formularioEnvio').submit();

6- Presionamos enter y cachan enviamos un súper mensaje por el valor de uno solo!!

Solo espero que los chicos de ismsgratis.com solucionen pronto este tema.

Saludos y pues nada un Friki más.

ASP Net MVC 3 Beta ya está listo.

2010-10-23T19:01:00.000-07:00

El Frameowrk de Microsoft para desarrollo de aplicaciones WEB basado en el patrón MVC va bien impulsado, una muestra de esto es la primera beta de su versión número 3. Este está en la mira de todos los desarrolladores de aplicaciones WEB 2.0 que tiene como preferencia .Net. Su magnífica integración con el Framework de acceso a datos más suculento de la plataforma de .Net Entity Framework lo hace altamente cotizado. Las líneas de este Framework tienen como primicia el desarrollo ágil, el uso de estándares, la no repetición de código y la aplicación patrones en nuestras soluciones. Al parecer pretende convertirse en el estándar principal para el desarrollo web sobre la plataforma .Net. Entre las novedades que nos trae esta nueve versión aun en desarrollo se encuentran:

Inclusión de RAZOR como el nuevo motor para el procesamiento de las vistas.
Inclusión de Filtros Globales.
Se incluyen Nuevos tipos de ActionResult.
Mejoras en el JavaScript, AJAX, en las validaciones del modelo y en el manejo de las inyecciones de dependencia.
Se agregaron nuevos HTML helpers (Chart, Crypto, WebGrid, WebImage, WebMail).

En próximas entradas veremos los HTML helpers en acción.

Sitio oficial: http://www.asp.net/mvc/mvc3
Descargar desde: http://go.microsoft.com/fwlink/?LinkID=191795
Todo sobre esta versión aquí: http://www.asp.net/learn/whitepapers/mvc3-release-notes

Un servidor web con WCF.

2010-06-10T14:36:00.000-07:00

Pues les cuento, este es mi primer pos luego de ser ingeniero en ciencias informática, el jueves pasado presenté el trabajo de diploma el cual obtuvo una gran aceptación. Pues adentrándonos en el tema del pos, el cual trae como objetivo la realización de un servidor web con WCF. Este servidor es bien simple de implementar gracias a las bondades de WCF.Este servidor se resume en 3 clases fundamentales.

La interfaces o contrato que define el servicio que expondrá nuestro servidor para que sea consumido por los navegadores web.
La implementación de esta interfaz que sería el plato fuerte del servidor (incluso integración simple con php).
El código principal en el cual se define el server de WCF y todas las configuraciones para utilizarlo.

La interfaz:

using System.IO;using System.ServiceModel;
using System.ServiceModel.Web;

namespace WEBServer
{
    [ServiceContract]
    public interface IFileHost
    {
        [OperationContract, WebGet(UriTemplate = "/{*filename}")]
        Stream Files(string filename);
    }
}

La implementación:

Esta cuenta con un método principal Files, este retorna el Stream relacionada al fichero solicitado por el navegador web. Tiene en cuenta 3 variantes fundamentales, en el casa de solicitar una carpeta, revisa dentro de la carpeta un grupo de ficheros por defecto y los retorna, en esto caso son index.php, index.html y defaul.php. La próxima variante es en el caso de solicitar un archivo, aquí comprobamos si tiene como extención .php, de tenerlo se realiza una llamada al interprete de PHP para que genere el código html correspondiente a este fichero.

private Stream PhpFileToHtml(string filePath)
        {
            var p = new Process
                        {
                            StartInfo =
                                {
                                    FileName = "php\\php.exe",
                                    Arguments = filePath,
                                    RedirectStandardOutput = true,
                                    UseShellExecute = false
                                },
                        };

            p.Start();
            return p.StandardOutput.BaseStream;
        }

De no ser php el fichero lo retornamos directamente, que sería tan sencillo cómo:

return new FileStream(filePath, FileMode.Open, FileAccess.Read);

Para que el navegador entienda correctamente los Stream que se retornan es necesario incluir en la cabecera HTTP el mime type correspondiente a cada tipo de fichero, para esto hago uso de la función MimeType, esta dado una extención retorna el mime adecuado.

Aquí tiene el código completo de esta clase.

using System.Collections.Generic;
using System.IO;
using System.ServiceModel.Web;
using System.Net;
using System.Diagnostics;


namespace WEBServer
{
    public class Service : IFileHost
    {

        public Stream Files(string filename)
        {
            var filePath = "Hosting/" + filename;
            
            if (Directory.Exists(filePath))
            {
                filePath += filename.EndsWith("/") ? "" : "/";
                foreach (var file in DefaultFiles())
                {
                    var tempFile = filePath + "/" + file;
                    if (File.Exists(tempFile))
                    {
                        return FileToHtml(tempFile);
                    }
                }
            }
            else if (File.Exists(filePath))
            {
                return FileToHtml(filePath);
            }
            else
            {
                WebOperationContext.Current.OutgoingResponse.StatusCode = HttpStatusCode.InternalServerError;
                return new MemoryStream();
            }
            return null;
        }

        private Stream FileToHtml(string filePath)
        {
            int extIndex = filePath.LastIndexOf(".");
            string extension = filePath.Substring(extIndex, filePath.Length - extIndex);
            WebOperationContext.Current.OutgoingResponse.ContentType = MimeType(extension);

            switch (extension.ToLower())
            {
                case ".php":
                    return PhpFileToHtml(filePath);
                default:
                    return new FileStream(filePath, FileMode.Open, FileAccess.Read);
            }
        }

        private Stream PhpFileToHtml(string filePath)
        {
            var p = new Process
                        {
                            StartInfo =
                                {
                                    FileName = "php\\php.exe",
                                    Arguments = filePath,
                                    RedirectStandardOutput = true,
                                    UseShellExecute = false
                                },
                        };

            p.Start();
            return p.StandardOutput.BaseStream;
        }

        private string MimeType (string extension)
        {
            switch (extension)
            {
                case ".ai": return "application/postscript";
                case ".aif": return "audio/x";
                case ".aifc": return "audio/x";
                case ".aiff": return "audio/x";
                case ".asc": return "text/plain";
                case ".au": return "audio/basic";
                case ".avi": return "video/x";
                case ".bcpio": return "application/x";
                case ".bin": return "application/octet";
                case ".c": return "text/plain";
                case ".cc": return "text/plain";
                case ".ccad": return "application/clariscad";
                case ".cdf": return "application/x";
                case ".class": return "application/octet";
                case ".cpio": return "application/x";
                case ".cpt": return "application/mac";
                case ".csh": return "application/x";
                case ".css": return "text/css";
                case ".dcr": return "application/x";
                case ".dir": return "application/x";
                case ".dms": return "application/octet";
                case ".doc": return "application/msword";
                case ".drw": return "application/drafting";
                case ".dvi": return "application/x";
                case ".dwg": return "application/acad";
                case ".dxf": return "application/dxf";
                case ".dxr": return "application/x";
                case ".eps": return "application/postscript";
                case ".etx": return "text/x";
                case ".exe": return "application/octet";
                case ".ez": return "application/andrew";
                case ".f": return "text/plain";
                case ".f90": return "text/plain";
                case ".fli": return "video/x";
                case ".gif": return "image/gif";
                case ".gtar": return "application/x";
                case ".gz": return "application/x";
                case ".h": return "text/plain";
                case ".hdf": return "application/x";
                case ".hh": return "text/plain";
                case ".hqx": return "application/mac";
                case ".htm": return "text/html";
                case ".html": return "text/html";
                case ".php": return "text/html";
                case ".ice": return "x";
                case ".ief": return "image/ief";
                case ".iges": return "model/iges";
                case ".igs": return "model/iges";
                case ".ips": return "application/x";
                case ".ipx": return "application/x";
                case ".jpe": return "image/jpeg";
                case ".jpeg": return "image/jpeg";
                case ".jpg": return "image/jpeg";
                case ".js": return "application/x";
                case ".kar": return "audio/midi";
                case ".latex": return "application/x";
                case ".lha": return "application/octet";
                case ".lsp": return "application/x";
                case ".lzh": return "application/octet";
                case ".m": return "text/plain";
                case ".man": return "application/x";
                case ".me": return "application/x";
                case ".mesh": return "model/mesh";
                case ".mid": return "audio/midi";
                case ".midi": return "audio/midi";
                case ".mif": return "application/vnd.mif";
                case ".mime": return "www/mime";
                case ".mov": return "video/quicktime";
                case ".movie": return "video/x";
                case ".mp2": return "audio/mpeg";
                case ".mp3": return "audio/mpeg";
                case ".mpe": return "video/mpeg";
                case ".mpeg": return "video/mpeg";
                case ".mpg": return "video/mpeg";
                case ".mpga": return "audio/mpeg";
                case ".ms": return "application/x";
                case ".msh": return "model/mesh";
                case ".nc": return "application/x";
                case ".oda": return "application/oda";
                case ".pbm": return "image/x";
                case ".pdb": return "chemical/x";
                case ".pdf": return "application/pdf";
                case ".pgm": return "image/x";
                case ".pgn": return "application/x";
                case ".png": return "image/png";
                case ".pnm": return "image/x";
                case ".pot": return "application/mspowerpoint";
                case ".ppm": return "image/x";
                case ".pps": return "application/mspowerpoint";
                case ".ppt": return "application/mspowerpoint";
                case ".ppz": return "application/mspowerpoint";
                case ".pre": return "application/x";
                case ".prt": return "application/pro_eng";
                case ".ps": return "application/postscript";
                case ".qt": return "video/quicktime";
                case ".ra": return "audio/x";
                case ".ram": return "audio/x";
                case ".ras": return "image/cmu";
                case ".rgb": return "image/x";
                case ".rm": return "audio/x";
                case ".roff": return "application/x";
                case ".rpm": return "audio/x";
                case ".rtf": return "text/rtf";
                case ".rtx": return "text/richtext";
                case ".scm": return "application/x";
                case ".set": return "application/set";
                case ".sgm": return "text/sgml";
                case ".sgml": return "text/sgml";
                case ".sh": return "application/x";
                case ".shar": return "application/x";
                case ".silo": return "model/mesh";
                case ".sit": return "application/x";
                case ".skd": return "application/x";
                case ".skm": return "application/x";
                case ".skp": return "application/x";
                case ".skt": return "application/x";
                case ".smi": return "application/smil";
                case ".smil": return "application/smil";
                case ".snd": return "audio/basic";
                case ".sol": return "application/solids";
                case ".spl": return "application/x";
                case ".src": return "application/x";
                case ".step": return "application/STEP";
                case ".stl": return "application/SLA";
                case ".stp": return "application/STEP";
                case ".sv4cpio": return "application/x";
                case ".sv4crc": return "application/x";
                case ".swf": return "application/x";
                case ".t": return "application/x";
                case ".tar": return "application/x";
                case ".tcl": return "application/x";
                case ".tex": return "application/x";
                case ".texi": return "application/x";
                case ".texinfo": return "application/x";
                case ".tif": return "image/tiff";
                case ".tiff": return "image/tiff";
                case ".tr": return "application/x";
                case ".tsi": return "audio/TSP";
                case ".tsp": return "application/dsptype";
                case ".tsv": return "text/tab";
                case ".txt": return "text/plain";
                case ".unv": return "application/i";
                case ".ustar": return "application/x";
                case ".vcd": return "application/x";
                case ".vda": return "application/vda";
                case ".viv": return "video/vnd.vivo";
                case ".vivo": return "video/vnd.vivo";
                case ".vrml": return "model/vrml";
                case ".wav": return "audio/x";
                case ".wrl": return "model/vrml";
                case ".xbm": return "image/x";
                case ".xlc": return "application/vnd.ms";
                case ".xll": return "application/vnd.ms";
                case ".xlm": return "application/vnd.ms";
                case ".xls": return "application/vnd.ms";
                case ".xlw": return "application/vnd.ms";
                case ".xml": return "text/xml";
                case ".xpm": return "image/x";
                case ".xwd": return "image/x";
                case ".xyz": return "chemical/x";
                case ".zip": return "application/zip";
                default :
                    return "application/octet-stream";
            }
        }

        private List DefaultFiles()

        {

            return new List

                       {

                           "index.php",

                           "index.html",

                           "defaul.php",

                       };

        }

    }

}

Para culminar solo nos falta crear el servidor y hostiarlo, el codigo que permite hacer esto es el siguiente.

string baseAddress = "http://" + Environment.MachineName + ":80/";
var host = new ServiceHost(typeof(Service), new Uri(baseAddress));
host.AddServiceEndpoint(typeof(IFileHost), new WebHttpBinding(), "").Behaviors.Add(new WebHttpBehavior());
host.Open();
Console.WriteLine("Server is ready.");
Console.Write("Press ENTER to close the server");
Console.ReadLine();
host.Close();

Listo ya tenemos nuestro servidor http listo para ser usado y para ser modificado a su antojo agregándole todo lo que se les ocurra.

¿Donde se colocan los sitios para que sean hosteados?
Dentro de la carpeta que se encuentra en la raíz del programa que tiene por nombre Hosting.
¿Por qué no funcionan las paginas php?
Esto se debe a que debemos cambiar la dirección del interprete PHP para que pueda ser ejecutado.

StartInfo =
  {
    //Coloca aquí la dirección de donde se encuentre el PHP en la pc.
    FileName = "php\\php.exe",                                  
    Arguments = filePath,
    RedirectStandardOutput = true,
    UseShellExecute = false
   }

Descarga el proyecto completo desde aquí.

GScanner 0.1 un proyecto que comienza.

2010-04-16T09:24:00.001-07:00

GScanner no es más que un pequeño scanner orientado a detectar partidas creadas por conocidos juegos multi-jugador en al red. Este software actualmente no alcanza su primera versión, por problemas de tiempo y otras tareas no he podido dedicarle más esfuerzo a su desarrollo, pero ya se los dejo por aquí para que lo vallan probando y me dejen sus comentarios al respecto.

Juegos soportados:

Medal of Honor Allied Assault.
Medal of Honor Allied Assault, Breakthrough.
Halo, Combat Evolution.
Call of Duty, United Offensive. (Expansion Pack).

Espero que sea de su utilidad.

Download GScanner.

Pantallazo:

Recopilación de libros sobre C#

2010-03-14T22:16:00.000-07:00

Hola amigos, en esta entra quiero compartir con ustedes un recopilación de libros relacionados con el uso de las tecnologías asociadas al Framework 3.5 de .Net.

Aquí les dejo unos cuantos títulos, su enlace de descarga y la temática central del libro.

Download

Este ejemplar está entrado en WCF, su nombre lo deja bien claro.

Download

Visual C# 2008 es un libro orientado al aprendizaje del lenguaje C#.

Download

Todo sobre la fascinante tecnología para las interfaces visuales desarrollada por Microsot.

Download

Aquí tenemos un magnifico libro sobre el desarrollo de aplicaciones basados en Workflow.

Download

Y el ultimo y no por eso menos importante es un emprendedor libro que nos muestra todo sobre LINQ

Jugando con XMPP(jabber) en .Net

2010-03-07T20:53:00.000-08:00

El protocolo XMPP conocido anteriormente como Jabber, es un protocolo libre basado en XML, su objetivo es la mensajería instantánea. Existen disimiles clientes de mensajería que soportan este protocolo, ejemplos de esto son Gtalk, Pandion ,
Entre otro gran grupo del cual pueden encontrar una lista más completa en jabber.org.
Bueno entremos en el tema principal de este pos que es dar a conocer la librería agsXMPP la cual nos facilita el uso de este protocolo.
Configurado la conexión al servidor Jabber.


XmppClientConnection conection = new XmppClientConnection();
        conection.Port = 5222;
        conection.UseSSL = false; // or true
        conection.Server = "jabber.org";
        conection.Username = "my_user";
        conection.Password = "my_password";
        conection.Status = "hello";

Ahora implementaremos el evento para saber cuándo se establezca la conexión.


conection.OnLogin += new ObjectHandler(conection_OnLogin);

Definimos el método conection_OnLogin, en el cual mostrareos un mesnjae por consola: On line.


static void conection_OnLogin(object sender)
    {
        Console.WriteLine("On line.");
    }

Ahora implementamos el evento para mostrar los mensajes que recivimos.


conection.OnMessage += new agsXMPP.protocol.client.MessageHandler(conection_OnMessage);

static void conection_OnMessage(object sender, agsXMPP.protocol.client.Message msg)
    {
        if (msg.Type == MessageType.chat)
        {
            Console.WriteLine(msg.From.User + ": " + msg.Body);
        }
    }

Y por ultimo abrimos la conexión.


conection.Open();

Para enviar un mensjae al contacto que queramos solo hacemos lo siguiente.


Message newMsg = new Message(new Jid ("user@jabber.org"), "hello user");
        conection.Send(newMsg);

Aqui les va el ejemplo completo.


using System;
using agsXMPP;
using agsXMPP.protocol.client;

namespace JabberTest
{
class Program
{
    static XmppClientConnection conection;
    static void Main(string[] args)
    {
        conection = new XmppClientConnection();
        conection.Port = 5222;
        conection.UseSSL = false; // or true
        conection.Server = "jabber.org";
        conection.Username = "my_user";
        conection.Password = "my_password";
        conection.Status = "hello";

        conection.OnLogin += new ObjectHandler(conection_OnLogin);
        conection.OnMessage += new agsXMPP.protocol.client.MessageHandler(conection_OnMessage);       

        conection.Open();
    }

    static void conection_OnMessage(object sender, agsXMPP.protocol.client.Message msg)
    {
        if (msg.Type == MessageType.chat)
        {
            Console.WriteLine(msg.From.User + ": " + msg.Body);

            Message newMsg = new Message(msg.From, "hello user");
            conection.Send(newMsg);
        }
    }

    static void conection_OnLogin(object sender)
    {
        Console.WriteLine("On line.");
    }
}
}

Obteniendo dados de nuestra PC con c#

2010-02-26T07:09:00.000-08:00

Desde que me encuentro dedicado completamente a desarrollar sobre la plataforma .net he cumplido con algunas deudas que tenia conmigo mismo como programador. Una de estas está en un 40% saldada, se trata de este pequeño programa el cual he estado desarrollando para capturar la información de la pc. Si ya se, hay muchos que hacen eso, pero lo mejor de todo es que yo compartire con ustedes las facilidades que tiene c# para capturar toda esta información de nuestra PC.

Obteniendo el modelo, version y productor de nuestra MotherBoard.


       ManagementClass mc = new ManagementClass("Win32_BaseBoard");
       ManagementObjectCollection moc = mc.GetInstances();

       foreach (ManagementObject mo in moc)
       {
           manufacturer = mo["manufacturer"].ToString();
           model = mo["Product"].ToString();
           version = mo["Version"].ToString();

           mo.Dispose();
       }

Nuestro procesador.


       ManagementClass mc = new ManagementClass("Win32_Processor");
       ManagementObjectCollection moc = mc.GetInstances();

       foreach (ManagementObject mo in moc)
       {
           Console.WriteLine( mo["name"].ToString());
           Console.WriteLine(  mo["processorId"].ToString());
           Console.WriteLine(  mo["manufacturer"].ToString());
           string temp = mo["CurrentClockSpeed"].ToString();
           Console.WriteLine(  double.Parse(temp) / 1000d);
           mo.Dispose();
       }

Y para terminar la configuración referentes a nuestras tarjetas de red.


   ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
       ManagementObjectCollection moc = mc.GetInstances();

       foreach (ManagementObject mo in moc)
       {

           if ((bool)mo["IPEnabled"] == true)
           {
               Console.WriteLine(mo["MacAddress"].ToString());
               Console.WriteLine(mo["Description"].ToString());
               Console.WriteLine(mo["DNSHostName"].ToString());
               Console.WriteLine(mo["DNSDomain"].ToString());
           }

           mo.Dispose();
       }

Un nuevo camino

2010-02-25T18:52:00.000-08:00

Luego de tanto tiempo hago mi regreso, han cambiado muchas cosas, tecnologías, equipo de trabajo, Oracle compra a Sun, Microsoft debuta con WCF, WPF, WWF, Google cuenta con el Sistema Operativo para móviles mas seductor del momento, flash tiende a 0, Window 7 es todo un triunfo y el destino me ha llevada a un nueva campo dentro del desarrollo del software. En próximos entradas les estaré comentando sobre el proyecto en el cual me encuentro trabajando actualmete.

Nos vemos en el proximo post.

UUencode de binario a texto en Java

2009-07-03T06:47:00.000-07:00

UUencode de binario a texto
¿Se te ha presentado alguna vez la necesidad de enviar o guardar un fichero binario y no has podido porque solo puedes hacerlo con texto? Pues no pasa nada, con el algoritmo base64 UUEncode se le da una solución elegante a este problema, ya que nos permite convertir binarios a texto y el proceso inverso. Esto es muy usado en el envió de correo y en los sistemas de mensajería instantáneas basados en el protocolo xmpp o jabber.

Como ya es de costumbre, nuestro queridísimo Java nos trae una implementación de dicho algoritmo, la cual estaremos viendo a continuación con un ejemplo práctico.

 
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.logging.Level;
import java.util.logging.Logger;
import sun.misc.UUDecoder;
import sun.misc.UUEncoder;


public class TestUUe {

    private static void codifica(String inFichero, String outFichero) throws FileNotFoundException, IOException {
        try {
            UUEncoder uuec = new UUEncoder(inFichero);
            InputStream in = new FileInputStream(inFichero);
            BufferedInputStream bufin = new BufferedInputStream(in);
            OutputStream out = new FileOutputStream(outFichero);
            BufferedOutputStream bufou = new BufferedOutputStream(out);
            uuec.encodeBuffer(bufin, bufou);
            bufin.close();
            bufou.close();
            in.close();
            out.close();
        } catch (IOException e) {
            System.out.println(e.toString());
        }
    }

    private static void decodifica(String inFichero, String outFichero) {
        try {
            UUDecoder uudc = new UUDecoder();
            InputStream in = new FileInputStream(inFichero);
            BufferedInputStream bufin = new BufferedInputStream(in);
            OutputStream out = new FileOutputStream(outFichero);
            BufferedOutputStream bufou = new BufferedOutputStream(out);
            uudc.decodeBuffer(bufin, bufou);
            bufin.close();
            bufou.close();
            in.close();
            out.close();
        } catch (IOException e) {
            System.out.println(e.toString());
        }
    }

    public static void main(String[] args) {
        try {
            codifica("fichero a codificar", "fichero de salida");
        } catch (FileNotFoundException ex) {
            Logger.getLogger(TestUUe.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(TestUUe.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

Comprimiendo con Gzip

2009-03-04T18:22:00.000-08:00

El formato Gzip es una alternativa al famoso Zip de Windows, es bastante potente y muy usados en las comunicaciones http, para evitar el derroche del acho de banda, la gran mayoría de los navegadores (Creo que todos) soportan este formato, espero que les sea útil esta clase.


import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.*;


public class TratamientoGZipFiles 
{
 public void Comprimir(String inFile,String outFile)
 {
  try {
   GZIPOutputStream gzip = new GZIPOutputStream(new BufferedOutputStream(new FileOutputStream(outFile)));
   BufferedInputStream bis = new BufferedInputStream(new FileInputStream(inFile),1024);
   byte[] data = new byte[1024];
   int counter = 0;
   while((counter = bis.read(data,0,1024)) != -1)
    gzip.write(data,0,counter);
   bis.close();
   gzip.finish();
   gzip.close();
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  
 }
 
 public void Descomprimir(String inFile,String outFile)
 {
  try {
   File f = new File(outFile);
   f.mkdir();
   f = new File(inFile);
   outFile+= "/"+f.getName().substring(0,f.getName().indexOf("."));
   GZIPInputStream gzip = new GZIPInputStream(new BufferedInputStream(new FileInputStream(inFile)));
   BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(outFile));
   byte[] data = new byte[1024];
   int counter = 0;
   while((counter = gzip.read(data, 0, 1024)) != -1)
    bos.write(data, 0, counter);
   gzip.close();
   bos.flush();
   bos.close();
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }

}

El uso de los socket

2009-02-06T16:16:00.000-08:00

El objetivo de este artículo es introducirlo a la programación orientada a las redes con el uso de los socket, en especifico trataremos dicho tema orientado al lenguaje de programación de alto nivel JAVA, que consta de una muy cómoda implementación de la clase socket además de grandes facilidades para su manejo.

Las clases de java que implementan los socket son:
java.net.Socket
java.net.SocketServer

java.net.Socket nos permite establecer un socker en el cliente y establecer una conexión con un socket servidor.
java.net.SocketServer sirve para establecer un socket en un servidor y escuchar las peticiones de soket clientes.

Trabajar con un socket cliente requiere varios pasos:
1- Abrir el socket utilizando uno de sus constructores, estableciendo la ip y puerto de destino.
2- Abrir los stream de entrada y salida mediante los métodos getInputStream() y getOutputStream().
3- Enviar y recibir los datos que deseemos procesar en nuestra aplicación utilizando los métodos definidos por nosotros en dependencia de la problemática.
4- Y por ultimo cerrar los stream mediante el método close()
5- Y cerrar los socket mediante el método close()

Los atributos con los que cuenta la clase socket son:
getLocalPort(): Devuelve el puerto origen (local).
getInetAddress(): Devuelve la dirección destino (remota).
getPort(): Devuelve el puerto destino (remoto).
getLocalAddress(): Devuelve la dirección origen (local).

Ejemplo:


import java.io.*;
import java.net.*;
public class EchoClient
{
  public static void main(String[] args)
  {
    try
    {
      Socket clientSocket = new Socket("192.168.1.2",1234);
      PrintWriter out = new PrintWriter(clientSocket.getOutputStream(),true);
      BufferedReader in = new BufferedReader(new InputStreamReader
(clientSocket.getInputStream()));
      System.out.println("Enviando: ¡¡¡¡Ecooo!!!!");
      out.println("¡¡¡¡Ecooo!!!!");
      System.out.println("Recibiendo: " + in.readLine());
      out.close();
      in.close();
      clientSocket.close();
    }
    catch (UnknownHostException e) { }
    catch (IOException e) { }
  }
}

Trabajar con un socket servidor requiere varios pasos:
1-Abrir el socket: mediante uno de sus constructores, habitualmente dándole el puerto donde escuchar.
2- Enviar y recibir los datos que deseemos procesar en nuestra aplicación utilizando los métodos definidos por nosotros en dependencia de la problemática.
4- Cerrar los streams: mediante el método close().
5- Cerrar el socket: mediante el método close().

Ejemplo:


import java.io.*;
import java.net.*;
public class EchoServer
{
  public static void main(String[] args)
  {
    try
    {
      ServerSocket serverSocket = new ServerSocket(1234);
      Socket clientSocket = serverSocket.accept();
      PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
      BufferedReader in = new BufferedReader(new InputStreamReader
(clientSocket.getInputStream()));
      String inputLine = in.readLine();
      System.out.println("Recibiendo: " + inputLine);
      String outputLine = inputLine.toUpperCase();
      System.out.println("Enviando: " + outputLine);
      out.println(outputLine);
      out.close();
      in.close();
      clientSocket.close();
      serverSocket.close();
    }
    catch(IOException ex) { }
  }
}

Ejecutando desde Java

2009-02-01T17:20:00.000-08:00

En muchas ocasiones nuestra aplicaciones necesitan interactuar con software que residen en las PC de los usuarios, para realizar funciones tan comunes como lanzar una web en el navegador por defecto de nuestro sistema operativo o abrir una ventana para enviar un correo a una determina dirección. En un lenguaje como Java, donde el acceso a funciones nativas del sistema se puede volver una tarea algo engorrosa y tenemos que optar por variantes menos complejas y que nos faciliten una mayor rapidez en el desarrollo del software. Una solución podría ser beneficiarnos de otro programa escrito en algún lenguaje que nos facilites dichas funcionalidades.

Gracias al rico arsenal de funcionalidades que “Sun Microsystems” creo para nosotros estas tareas que nos planteamos solucionar no es gran problema, en el paquete AWT contamos con la clase Desktop (java.awt.Desktop) que nos facilitará parte de dicho problema.
1 - Podemos lanzar el navegador con la página que queramos sin preocuparnos por cual está instalado o donde está o cual es el preferido del usuario:
Desktop.getDesktop().browse(new URI("http://blackhat.org"));

2- Abrir una ventana lista para obtener una subscripción de BlackHat vía correo:


Desktop.getDesktop().mail(new URI("mailto:blackhat4all@gmail.com?subject=Suscripción"));

3- También es posible editar un determinado fichero con su software asignado por defecto en nuestro sistema:


Desktop.getDesktop().edit(new File("F:/articulo.docx"));

4- Nos permite también ejecutar un determinado archivo con su software asociado al igual que enviar a la impresora un documentó que queramos imprimir:


Desktop.getDesktop().open(new File("g:/disko.mp3"));
Desktop.getDesktop().print(new File("g:/listado.xls"));

Ya hemos visto las formas más simples de lanzar tareas cotidianas desde nuestro software, ahora veremos como obtener datos que nos pueden brindar otras aplicaciones o ejecutar funcionalidades las cuales no podemos realizar desde nuestra aplicación.

El responsable de esta tarea será “Runtime” quien nos facilitará la ejecución y comunicación con ejecutables externos, para ejecutar un .exe externo quedaría así:


Runtime.getRuntime().exec("wmplayer");

Pasándole argumentos:


Runtime.getRuntime().exec("wmplayer d:/películas/Hacker.mpg");

Pero esto no se queda solo aquí cuando ejecutamos el método exec() nos devuelve un objeto del tipo java.lang.Process que cuenta con los métodos:
destroy() –permite terminar el proceso que levantamos al ejecutar la aplicación
getErrorStream() –Permite obtener las excepciones o errores que lance el programa por la salida estándar
getInputStream() –Permite leer los datos que nos brinda dicho programa por la salida estándar
getOutputStream() –Permite crear un canal de comunicación con el software mediante la entrada estándar, siempre que dicho software tenga implementado esta funcionalidad

Bueno ahora veremos algunos ejemplos de las aplicaciones de lo comentado hasta ahora:


import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Apagando la maquina
* @author DJ_bryan
*/
public class Main
{
public static void main(String[] args)
{
try
{
Runtime.getRuntime().exec("shutdown -r -f");
}
catch (IOException ex)
{
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*  Nos permite obtener los procesos que están corriendo en nuestra pc
* @author DJ_bryan
*/
public class Main 
{
  public static void main(String[] args) 
  {
    try 
    {
      Process pro =  Runtime.getRuntime().exec("tasklist");
      BufferedReader leer =new BufferedReader( new InputStreamReader( pro.getInputStream()));
      String linea;
      while ((linea = leer.readLine())!= null)
      System.out.println(linea.split(" ")[0]);
    }
    catch (IOException ex) 
    {
      Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
    }
  }
}

Función resumen (hash) en Java

2009-02-01T09:40:00.000-08:00

Esta es una pequeña clase que escribí para calcular el hash a un fichero mediante la función md5 los objetivos que tenía en ese momento eran dos, comparar la integridad de un fichero enviado por la red y compara dos ficheros, sin dudad el uso de esta función me facilito mucho el trabajo, espero que ustedes también, aquí les deja la clase que implemente para darle solución a este problema en JAVA.


import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
*
* @author DJ_Bryan
*
*/
public class CodigoHash
{
public static String getCodigoHash(String path)
throws NoSuchAlgorithmException, FileNotFoundException, IOException
{
MessageDigest digest = MessageDigest.getInstance("MD5");
File f = new File(path);
InputStream is = new FileInputStream(f);
byte[] buffer = new byte[(int) f.length()];
int read = 0;
while ((read = is.read(buffer)) > 0)
{
digest.update(buffer, 0, read);
}
byte[] md5sum = digest.digest();
BigInteger bigInt = new BigInteger(1, md5sum);
String output = bigInt.toString(16);
is.close();
return output;
}
public static boolean Comparar(String file, String hashCode)
throws NoSuchAlgorithmException, FileNotFoundException, IOException
{
return hashCode.equals(getCodigoHash(file));
}
 public static boolean comparar(String file1, String file2) throws NoSuchAlgorithmException, FileNotFoundException, IOException 
 {
   return getCodigoHash(file1).equals(getCodigoHash(file2));
 }
}

Jugando con el wallpaper en Linux

2009-01-31T11:26:00.000-08:00

Esto es un pequeño script que escribí esta semana debido a que me encuentro estudiando python por estos días y además quería un poco de dinámica en el escritorio de mi Ubuntu 8.04, sin dudas python es un lenguaje que se los recomiendo ya que se disfruta aprendiendo a programar con el.

Adentrémonos en el script. El objetivo de este script es bien sencillo es ir cambiando el fondo de pantalla de nuestra PC cada cierto tiempo, para que nuestro script piche perfectamente necesitamos ponerlo en una carpeta en la cual tengamos nuestra wallpaper preferidos, yo lo hice para poner archivos con extensiones JPEG y JPG, pero ustedes lo pueden modificar para que pinche a su gusto.

Aquí va el codigo:

import os
import time
path = os.getcwd() + "/"
lista = os.listdir(os.getcwd())
while 1:
for img in lista:
image = path+img
if os.path.isfile(image):
if (image.split(".")[-1] == "jpg" or image.split(".")[-1] == "jpeg"):
os.popen("gconftool-2 -t str -s /desktop/gnome/background/picture_filename "+image)
print (image)
time.sleep(60*30)

Desglosando el código:
Importamos os (“import os”) para poder ejecutar comandos del sistema, y importamos time (“import time”) para lograr una pausa entre cambio y cambio, luego con (“os.getcwd() ”) obtenemos la ubicación del script en nuestro disco para a partir de ahí obtener una lista con todos los ficheros que estén dentro de ese directorio (“os.listdir(os.getcwd()”), luego declaramos un siclo infinito para mantenernos realizando esta acción mientras nuestro script este corriendo, ahora nos dedicamos a recorre nuestra lista armando cada una de las direcciones que contiene la carpeta donde nos encontramos (“image = path+img”) y luego verificamos que sea un fichero (“os.path.isfile(image)”) y si lo es, pasamos a comprobar que se del tipo que necesitamos (“if (image.split(".")[-1] == "jpg" or image.split(".")[-1] == "jpeg"):) y a partir de ahí ejecutamos un comando del sistema operativo con (“os.popen”) para ejecutar el cambio de wallpaper, una vez cambiado sacamos por consola la dirección de la imagen que se encuentra como wallpaper de nuestra PC a modo de información y ya no nos que da mas que hacer una pausa (“time.sleep(60*30)”) en este caso de media hora, estos valores pude ser perfectamente ajustado a su gusto.

La clase Robot en Java

2009-01-29T12:23:00.000-08:00

La clase Robot en java se encuentra en el paquete java.awt y tiene funcionalidades bastantes interesantes, para los que nos gusta improvisar con los códigos no viene de maravilla ya que sus funcionalidades se prestan para cosas bastante ocurrentes y útiles por su puesto.

1- Haciendo travesuras con el mouse:

Una de sus utilidades es simular la utilización del mouse por un usuario por ejemplo:


Robot robot = new Robot();

//Movemos el mouse a la posición de la pantalla que queramos

robot.mouseMove(x, y);

//presionamos el click derecho
robot.mousePress(InputEvent.BUTTON2_MASK);
robot.mouseRelease(InputEvent.BUTTON2_MASK);

2- El teclado esta loco:

Es posible simular las pulsaciones de teclas de un usuario utilizando alguna de las bondades que nos brinda Robot.


import java.awt.AWTException;
import java.awt.Robot;
import java.awt.event.KeyEvent;

public class test
{
/
public static void main(String[] args)
{
try
{
Robot robot = new Robot();
// abriendo el menu inicio
robot.keyPress(KeyEvent.VK_WINDOWS);
robot.keyRelease(KeyEvent.VK_WINDOWS);
// lanzando el explorerador
robot.keyPress(KeyEvent.VK_WINDOWS);
robot.keyPress(KeyEvent.VK_E);
robot.keyRelease(KeyEvent.VK_E);
robot.keyRelease(KeyEvent.VK_WINDOWS);
}
catch (AWTException e)
{
e.printStackTrace();
}
}
}

3- Espiando lo que pasa en la PC.

Nuestra mágica clase nos permite realizar capturas de nuestra pantalla con gran nitidez, hay que destacar que cuando realizamos esta función no se refleja el mouse en dicha imagen pero eso se puede resobre.


MouseInfo.getPointerInfo().getLocation().x;
MouseInfo.getPointerInfo().getLocation().y;

Resuelto el problema pasaremos al plato fuerte:


import java.awt.AWTException;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
public class test
{

public static void main(String[] args) throws IOException
{
try
{
Robot robot = new Robot();
BufferedImage pantalla = robot.createScreenCapture(new Rectangle (Toolkit.getDefaultToolkit().getScreenSize()));
File file = new File("C:\\captura.jpg");
ImageIO.write(pantalla, "jpg", file);
}
catch (AWTException e)
{
e.printStackTrace();
}
}
}

Dandole un buen uso a esta clase, obtendran sin dudas cosas muy interesantes.

Haciendo peticiones POST con java

2009-01-28T21:05:00.000-08:00

Este clase escrita en java, nos facilita la tares de hace una peticion mediante el método "POST" a una dirección web, esto tiene múltiples aplicaciones, automatizar el acceso a un determinado contenido web, saltarnos validaciones javascript que tenga una pagina, podemos intentar romper un pasword haciendo utilización de fuerza bruta o con unos buenos diccionarios, bueno eso se los dejo a ustedes. Solo espero que le encuentren una buena aplicación. Y que mejoren todo lo que puedan este código y lo compartan con la comunidad.


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;

public class PeticionPost {
private URL url;
String data;

public PeticionPost (String url) throws MalformedURLException{
this.url = new URL(url);
data="";
}

public void add (String propiedad, String valor) throws UnsupportedEncodingException{
//codificamos cada uno de los valores
if (data.length()>0)
data+= "&"+ URLEncoder.encode(propiedad, "UTF-8")+ "=" +URLEncoder.encode(valor, "UTF-8");
else
data+= URLEncoder.encode(propiedad, "UTF-8")+ "=" +URLEncoder.encode(valor, "UTF-8");
}

public String getRespueta() throws IOException {
String respuesta = "";
//abrimos la conexiÃ³n
URLConnection conn = url.openConnection();
//especificamos que vamos a escribir
conn.setDoOutput(true);
//obtenemos el flujo de escritura
OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream());
//escribimos
wr.write(data);
//cerramos la conexiÃ³n
  wr.close();

  //obtenemos el flujo de lectura
  BufferedReader rd = new BufferedReader(new InputStreamReader(conn.getInputStream()));
     String linea;
     //procesamos al salida
     while ((linea = rd.readLine()) != null) {
        respuesta+= linea;
     }
return respuesta;
}

}

Un ejemplo de como usar la clase:


import java.io.IOException;
import peticonesURL.PeticionPost;
public class Prueba {

public static void main(String[] args) throws IOException {
PeticionPost post = new PeticionPost ("http://10.7.23.174/post");
post.add("user", "DJ_bryan");
post.add("password", "*********");
String respuesta = post.getRespueta();
System.out.println(respuesta);
}

}

Bryan en la red

2009-01-28T19:43:00.000-08:00

Hace un tiempo atrás vengo cocinado la idea de crearme mi blog, para comentar sobre mis proyectos personales y las cosas que voy aprendiendo día a día en el largo y hermoso camino de la carrera de informática. Pues nada, aquí les dejaré plasmada cuantas cosas se me ocurran, solo espero que sean de su agrado y que ustedes también comportan conmigo y disfruten tanto de este espacio como lo disfrutare yo.