UUencode de binario a texto en Java

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

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

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

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);
    }
  }
}

La clase Robot en Java

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

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);
}

}