Archivo de la etiqueta: Java

Java [Twitter4J]: Creación de APP y consumo desde java (Actualización de estado)

Sin título-1-01

Para esta gúia rápida usaremos la api Twitter4J

Paso 1: Dirígete a https://apps.twitter.com/

01

Paso 2: Crea la aplicación y llena los datos solicitados *

02

03

Paso 3: Dirígete a “Keys and Access Tokens”

04

Paso 4: En la sección “Your Access Token” genera los tokens de acceso a la aplicación “Create my access token”. Lo que haces aquí es generar un acceso hacia tu cuenta desde la aplicación.

05

Paso 6: Revisa que tengas tanto como el Key y Secret que son los consumidores de la aplicación, asi como tus tokens de acceso, Access Token y Access Token Secret

06

Una vez hecho esto, utiliza tu ide de confianza, aplicando el siguiente código:

import twitter4j.TwitterException;
import twitter4j.TwitterFactory;
import twitter4j.auth.OAuthAuthorization;
import twitter4j.conf.ConfigurationBuilder;


/**
 * @version 1.0
 * Clase que inicia una sesión en Twitter a través de una app, y actualiza
 * el estado con un mensaje deseado
 * @author Julio Chinchilla
 */
public class UpdateStatus {
    private static final String CONSUMER_KEY = "xxx";
    private static final String CONSUMER_SECRET = "xxx";    
    private static final String ACCESS_TOKEN = "xxx";
    private static final String ACCESS_TOKEN_SECRET = "xxx";
	
    public static void main(String[] args) throws TwitterException {
    	ConfigurationBuilder builder = new ConfigurationBuilder();
        builder.setOAuthAccessToken(ACCESS_TOKEN);
        builder.setOAuthAccessTokenSecret(ACCESS_TOKEN_SECRET);
        builder.setOAuthConsumerKey(CONSUMER_KEY);
        builder.setOAuthConsumerSecret(CONSUMER_SECRET);
        OAuthAuthorization auth = new OAuthAuthorization(builder.build());
    	Twitter twitter = new TwitterFactory().getInstance(auth);
        twitter.updateStatus("Hola mundo desde java");
       
    }
}

Obviamente tendrás que llenar las variables: CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN, ACCESS_TOKEN_SECRET. Con los que generaste cuando configuraste la aplicación.

Y listo, la ejecución del código no deberá traerte ningún problema.

07

Java 8 para Windows XP (Proyecto comunitario)

jxp Recientemente me tocó el desarrollo de un proyecto, el cual había desarrollado bajo Java 8, oh sorpresa y dolor de cabeza cuando el cliente me comentó que tenía muchos equipos con Windows XP instalado y que lo necesitaba correr ahí. Investigando un poco me topé con que la incopatibilidad de Java 8 en Windows XP radica en su instalador y no en su núcleo. Asi que haciendo pruebas con Java 8 en Windows XP utilizando el JRE que viene comprimido y que se usa de forma manual, pues simplemente no tuve ningún problema con la aplicación que estaba utilizando. El problema siguiente fue que viendolo desde el punto de vista de usuario, la instalación manual de Java iba a ser un dolor de cabeza, teniendo en cuenta que esta no la iba a hacer yo, sino que tenía que ir dirigida a muchos usuarios. Por lo que me dí a la tarea de crear un instalador con el lenguaje de script NSIS, el cual es muy practico, y dicha instalación, no solo extrae los archivos del JRE y los coloca en una carpeta, sino que además de ello, escribe sobre el Registro de Windows, los valores correspondientes de la versión instalada. Todo esto se me hizo muy util el poder compartirlo, cree un proyecto en Sourceforge en el cual voy a ir subiendo y actualizando por un tiempo considerado. Además de ello dejo el código del instalador NSIS que desarrolle, para hacer esto un proyecto libre, de aprendizaje y que sirva a la comunidad Java. acá el link directo al proyecto en Sourceforge https://sourceforge.net/projects/java8forwindowsxp Dejo unas capturas de pantalla de como se instala y se ve en Windows XP Windows XP Professional-2015-02-26-10-29-23 Windows XP Professional-2015-02-26-10-29-40 Windows XP Professional-2015-02-26-10-29-48 Windows XP Professional-2015-02-26-10-29-56 Windows XP Professional-2015-02-26-10-31-24 Windows XP Professional-2015-02-26-10-31-50 Windows XP Professional-2015-02-26-10-32-18

Comprobación de ATR mediante Suma de Verificación XOR [Código Java]

FE26DS8GJ7MQAYF.MEDIUMCada vez que conectamos un SmartCard y hacemos la conexión correspondiente, obtenemos la cadena de respuesta del Chip conocida como ATR, pero ¿como verificar si el ATR recibido es correcto? para ello la norma ISO estable que el último byte recibido corresponde a uno de verificación desde el byte T0 hasta el Tj, donde T0 es el segundo byte del atr en mención y el byte Tj corresponde al penúltimo, por lo que el último es un byte de comprobación. Para ello se debe de usar una suma de verificación XOR.

ISO7816_23

Por ejemplo y para hacerlo de manera sencilla el ATR siguiente se comprobarían de la siguiente manera:

3B DB 96 00 80 B1 FE 45 1F 83 00 31 C0 64 C3 08 01 00 0F 90 00 9B

3B sería el byte incial, el cual se omite
DB 96 00 80 B1 FE 45 1F 83 00 31 C0 64 C3 08 01 00 0F 90 00 Sería la serie de bytes a comprobar (T0 – Tj)
9B sería la suma de verificación de los bytes T0 – Tj
por lo cual si la suma de verifciación xor desde T0 hasta Tj es distinta de 9B, este ATR estaría incorrecto o alterado.

 

A continuación un código de java que facilita la comprobación debida.

/*
 * Version 1.0 Revision 1
 *
 * 18/08/2014
 *
 * Copyright 2014 bit502
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 */



/**
 *
 * @author Julio Chinchilla
 */
public class ATRVerify {

    /**
     * Función que recibe un ATR en formato String con separador de espacio
     * entre cada byte, la función formatea la cadena de caracteres quitándole
     * los espacios en blanco, posteriormente separa los bytes T0 hasta TJ en
     * el String t0tj y separa el byte de comprobación final TCK, luego utiliza
     * la función getXORCheckSumValue para obtener la suma verificativa y lo
     * compara con el byte TCK, si los bytes coinciden la respuesta será true
     * de lo contrario será false, y el ATR a verificar estará incorrecto
     * @param atr ATR con espacios entre bytes
     * @return
     */
    public static boolean checkATRStrWS (String atr) {
        boolean resp = false;
        String t0tj = atr.replaceAll("\\s","");
        String tck = atr.substring(atr.length()-2, atr.length());
        t0tj = t0tj.substring(2, t0tj.length()-2);
        if (getXORCheckSumValue(t0tj).equals(tck))
            resp = true;
        return resp;
    }

    /**
     * Función que recibe un ATR en formato String con separador de espacio
     * entre cada byte, posteriormente separa los bytes T0 hasta TJ en
     * el String t0tj y separa el byte de comprobación final TCK, luego utiliza
     * la función getXORCheckSumValue para obtener la suma verificativa y lo
     * compara con el byte TCK, si los bytes coinciden la respuesta será true
     * de lo contrario será false, y el ATR a verificar estará incorrecto
     * @param atr ATR sin espacios entre bytes
     * @return
     */
    public static boolean checkATRStr (String atr) {
        boolean resp = false;
        String t0tj = atr.substring(2, atr.length()-2);;
        String tck = atr.substring(atr.length()-2, atr.length());
        if (getXORCheckSumValue(t0tj).equals(tck))
            resp = true;
        return resp;
    }

    /**
     * Función que realiza una suma de verificación a una cadena String en
     * formato Hexadecimal con el operador XOR
     * @param bytes Cadena String en formato hexadecimal a analizar
     * @see <a href="http://es.wikipedia.org/wiki/Suma_de_verificaci%C3%B3n">WikiES: Suma de verificación</a>
     * @return String de comprobación mediante Suma de Verificación HEX
     */
    private static String getXORCheckSumValue (String bytes) {
        int cc = 0;
        for (int i = 0; i < bytes.length(); i=(i+2)) {
            if (i==0){
                cc = Integer.parseInt(bytes.substring(i, i+2), 16) & (0x00FF);
            } else {
                cc^=(Integer.parseInt(bytes.substring(i, i+2),16)&(0x00FF));
                cc=cc&(0x00FF);
            }
        }
        return Integer.toString(cc, 16).toUpperCase();
    }

}

Su forma de uso es la siguiente:

/**
 *
 * @author Julio
 */
public class ATRVerify {

    public static final String GT01 = "3B DB 96 00 80 B1 FE 45 1F 83 00 31 C0 64 C3 08 01 00 0F 90 00 9B";
    public static final String GT02 = "3BDB960080B1FE451F830031C064C7FC10000F90007A";
    public static final String ATR1 = "3B DB 18 00 80 1F 03 00 31 C0 64 77 E3 03 00 82 90 00 4F";

    public static void main(String[] args) {
        System.out.println(checkATRStrWS(GT02));
        System.out.println(checkATRStr(GT02));
        System.out.println(checkATRStrWS(ATR1));
    }

}

ATR’s Utilizados por el RENAP en el DPI

Que es el ATR:
atr
Una Respuesta al reajuste (ATR) es una salida de mensaje por un contacto de tarjeta inteligente conforme a 7.816 normas ISO / IEC, tras el rearme eléctrico de el chip de la tarjeta por un lector de tarjetas. El ATR transmite información acerca de los parámetros de comunicación propuestas por la tarjeta, y la naturaleza de la tarjeta y el estado.

Por extensión, ATR a menudo se refiere a un mensaje obtenido de una tarjeta inteligente en un estadio temprano de la comunicación; o desde el lector de tarjetas utilizado para acceder a la tarjeta, que puede transformar el mensaje de la tarjeta en un formato de ATR-como (esto ocurre por ejemplo, para algunos lectores de tarjetas de PC / SC [1] [2] al acceder a un 14,443 tarjeta inteligente ISO / IEC) .

Los ATR utilizados por el RENAP son los siguientes:
3B DB 96 00 80 B1 FE 45 1F 83 00 31 C0 64 C3 08 01 00 0F 90 00 9B
3B DB 96 00 80 B1 FE 45 1F 83 00 31 C0 64 C7 FC 10 00 0F 90 00 7A

Aca dejo un código que hace la conexión SmartCard utilizando el primer ejemplo que desarrollamos aca en bit502 http://goo.gl/9MkNxt este código lee el ATR y comprueba si es un DPI emitido por el RENAP
imagen-oficial-DPI-2013-oficial

/*
 * 17/08/2014
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 */

package test;

import com.gd.smartcard.SCardConexion;
import javax.smartcardio.CardException;

/**
* @version 1.0 Agosto de 2014
* @author Julio Chinchilla
*/
public class DPIVerify {
    
    //ATR's utilizados por el RENAP en la generación del DPI 
    public static final String GT01 = "3B DB 96 00 80 B1 FE 45 1F 83 00 31 C0 64 C3 08 01 00 0F 90 00 9B";
    public static final String GT02 = "3B DB 96 00 80 B1 FE 45 1F 83 00 31 C0 64 C7 FC 10 00 0F 90 00 7A";

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws CardException {
        String atr = getATR();
        if (atr.equals(GT01) | atr.equals(GT02))
            System.out.println("El ATR es: "+ atr);
        else
            System.err.println("Este documento no es un DPI");
    }
    
    /**
     * Funcion que hace una conexión SmartCard utilizando la clase de conexión
     * SmartCard estandar desarrollada antriormente http://goo.gl/9MkNxt esta
     * conexión tiene conexión al dispositivo 0, utilizando el protocolo por 
     * default con el parámetro "*"
     * @return ATR de la tarjeta
     * @throws CardException 
     */
    private static String getATR() throws CardException {
        SCardConexion sc = new SCardConexion();
        String atr = byteToHex(sc.connect(0, "*").getBytes());
        sc.disconnect();
        return atr;
    }
    
    /**
     * Función que transforma una cadena de bytes a su valor Hexadecimal en un
     * tipo de dato String, con espacios entre cada byte
     * @param data Array de bytes
     * @return Valor del array de bytes en formato Hexadecimal con espacios
     * entre cada byte
     */
    private static String byteToHex(byte[] data)  {
        StringBuilder localStringBuilder = new StringBuilder();
        for (int i = 0; i < data.length; i++)  {
            String str;
            if ((str=Integer.toHexString(data[i]&0xFF).toUpperCase()).length()==1) {
                localStringBuilder.append(0);
            }
        localStringBuilder.append(str).append(" ");
        }
        return localStringBuilder.substring(0, localStringBuilder.length() - 1);
    }
    
}

Código JAVA: Tamaño de archivo en su debida nomenclatura Sistema Internacional Decimal

El siguiente código se ejecuta de la siguiente manera, y tiene como objetivo mostrar el tamaño de un fichero determinado devolviendo una cadena de texto con el tamaño de archivo en su debida

nomenclatura Decimal del Sistema Internacional:
“bytes, KB, MB, GB, TB, EB, PB, ZB, YB”.

File-512

El código es el siguiente

/*
 * 19/07/2014
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 */
package com.gd.utils;

import java.io.File;

/**
* @version 2.0 Julio de 2014
* @author Julio Chinchilla
*/
public class FileSize {

    private final static double fB = 1024.0;

    /**
     * Devuelve una cadena de texto con el tamaño de archivo en su debida
     * nomenclatura Decimal del Sistema Internacional:
     * "bytes, KB, MB, GB, TB, EB, PB, ZB, YB".
     * Donde bytes es la unidad mas pequeña equivalente a 8 bits.
     * @see <a href="http://es.wikipedia.org/wiki/Kilobyte">WikiES: KB = Kilobyte</a>
     * @see <a href="http://es.wikipedia.org/wiki/Megabyte">WikiES: MB = Megabyte</a>
     * @see <a href="http://es.wikipedia.org/wiki/Gigabyte">WikiES: GB = Gigabyte</a>
     * @see <a href="http://es.wikipedia.org/wiki/Terabyte">WikiES: TB = Terabyte</a>
     * @see <a href="http://es.wikipedia.org/wiki/Petabyte">WikiES: MB = Petabyte</a>
     * @see <a href="http://es.wikipedia.org/wiki/Exabyte">WikiES: EB = Exabyte</a>
     * @see <a href="http://es.wikipedia.org/wiki/Zettabyte">WikiES: ZB = Zettabyte</a>
     * @see <a href="http://es.wikipedia.org/wiki/Yottabyte">WikiES: YB = Zettabyte</a>
     * @param path Ruta de archivo que se desea verificar
     * @return tamaño en "bytes, KB, MB, GB, TB, EB, PB, ZB, YB"
     */
    public static String getFileSizeISDecimal (String path) {
        File file = new File(path);
        if (file.exists()) {
            double fL = file.length();
            if (fL <= fB) {
                return String.valueOf(fL).concat(" bytes");
            } else {
                double sizeKB = getFileSizeInKB(fL);
                if(getFileSizeInKB(fL) <= fB)
                    return String.valueOf(sizeKB).concat(" KB");
                else {
                    double sizeMB = getFileSizeInMB(fL);
                    if(sizeMB <= fB)
                        return String.valueOf(sizeMB).concat(" MB");
                    else {
                        double sizeGB = getFileSizeInGB(fL);
                        if(sizeGB <= fB)
                            return String.valueOf(sizeGB).concat(" GB");
                        else {
                            double sizeTB = getFileSizeInTB(fL);
                            if(sizeTB <= fB)
                                return String.valueOf(sizeTB).concat(" TB");
                            else {
                                double sizePB = getFileSizeInPB(fL);
                                if(sizePB <= 1024)
                                    return String.valueOf(sizePB).concat(" PB");
                                else {
                                    double sizeEB = getFileSizeInEB(fL);
                                    if (sizeEB <= 1024)
                                        return String.valueOf(sizePB).concat(" EB");
                                    else {
                                        double sizeZB = getFileSizeInZB(fL);
                                        if (sizeZB <= 1024) {
                                            return String.valueOf(sizeZB).concat(" ZB");
                                        } else
                                            return String.valueOf(getFileSizeInYB(fL)).concat(" YB");
                                    }
                                }
                            }
                        }
                    }
                }
            }
        } else {
            throw new java.util.EmptyStackException();
        }
    }

    /**
     * Recibe el tamaño de archivo y lo devuelve en Kilobytes
     * @param f para usos públicos el parámetro debe provenir de un objeto
     * double java.io.File.length();
     * @return Tamaño de archivo en Kilobytes
     */
    private static double getFileSizeInKB (double f) {
        f = (f/fB);
        int fs = (int) Math.pow(10,2);
        return Math.rint(f*fs)/fs;
    }

    /**
     * Recibe el tamaño de archivo y lo devuelve en Megabytes
     * @param f para usos públicos el parámetro debe provenir de un objeto
     * double java.io.File.length();
     * @return Tamaño de archivo en Megabytes
     */
    private static double getFileSizeInMB (double f) {
        f = f / Math.pow(fB,2);
        int fs = (int) Math.pow(10,2);
        return Math.rint(f*fs)/fs;
    }

    /**
     * Recibe el tamaño de archivo y lo devuelve en Gigabytes
     * @param f para usos públicos el parámetro debe provenir de un objeto
     * double java.io.File.length();
     * @return Tamaño de archivo en Gigabytes
     */
    private static double getFileSizeInGB (double f) {
        f = f / Math.pow(fB,3);
        int fs = (int) Math.pow(10,2);
        return Math.rint(f*fs)/fs;
    }

    /**
     * Recibe el tamaño de archivo y lo devuelve en Terabytes
     * @param f para usos públicos el parámetro debe provenir de un objeto
     * double java.io.File.length();
     * @return Tamaño de archivo en Kilobytes
     */
    private static double getFileSizeInTB (double f) {
        f = f / Math.pow(fB,4);
        int fs = (int) Math.pow(10,2);
        return Math.rint(f*fs)/fs;
    }

    /**
     * Recibe el tamaño de archivo y lo devuelve en Petabytes
     * @param f para usos públicos el parámetro debe provenir de un objeto
     * double java.io.File.length();
     * @return Tamaño de archivo en Petabytes
     */
    private static double getFileSizeInPB (double f) {
        f = f / Math.pow(fB,5);
        int fs = (int) Math.pow(10,2);
        return Math.rint(f*fs)/fs;
    }

    /**
     * Recibe el tamaño de archivo y lo devuelve en Exabytes
     * @param f para usos públicos el parámetro debe provenir de un objeto
     * double java.io.File.length();
     * @return Tamaño de archivo en Exabytes
     */
    private static double getFileSizeInEB (double f) {
        f = f / Math.pow(fB,5);
        int fs = (int) Math.pow(10,2);
        return Math.rint(f*fs)/fs;
    }

    /**
     * Recibe el tamaño de archivo y lo devuelve en Zettabytes
     * @param f para usos públicos el parámetro debe provenir de un objeto
     * double java.io.File.length();
     * @return Tamaño de archivo en Zettabytes
     */
    private static double getFileSizeInZB (double f) {
        f = f / Math.pow(fB,5);
        int fs = (int) Math.pow(10,2);
        return Math.rint(f*fs)/fs;
    }

    /**
     * Recibe el tamaño de archivo y lo devuelve en Yottabytes
     * @param f para usos públicos el parámetro debe provenir de un objeto
     * double java.io.File.length();
     * @return Tamaño de archivo en Yottabytes
     */
    private static double getFileSizeInYB (double f) {
        f = f / Math.pow(fB,6);
        int fs = (int) Math.pow(10,2);
        return Math.rint(f*fs)/fs;
    }

}

Ejemplo de Clase Main para ejecución del código

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package g4dh10.jpa_b01;

/**
 *
 * @author Julio
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        String path = "C:\\Windows\\notepad.exe";
        String fileSize = com.gd.utils.FileSize.getFileSizeISDecimal(path);
        System.out.println(fileSize);
    }

}

Resultado:
sdfsd

JAVA Encriptar y Desencriptar texto AES CBC 128 bits

Código JAVA Encriptar y Desencriptar Texto usando el algoritmo AES con Cifrado por bloques CBC de 128 bits, no voy a entrar en mucho detalle, pero esta clase tiene los enlaces en los comentarios los enlaces necesarios para profundizar en el tema y así poder entender la teoría del mismo.

Ojo descarguense la librería Apache Commons Codec

package encrypt;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import static org.apache.commons.codec.binary.Base64.decodeBase64;
import static org.apache.commons.codec.binary.Base64.encodeBase64;

/**
 * @version 1.0
 * Clase que contiene los métodos encrypt y descrypt, cuyos objetivos son
 * encriptar y desencriptar respectivamente, utilizando los algoritmos y codificación
 * definidas en las variables estáticas alg y cI.
 * Requiere la librería Apache Commons Codec
 * @see <a href="http://commons.apache.org/proper/commons-codec/">Apache Commons Codec</a>
 * @see <a href="http://docs.oracle.com/javase/8/docs/api/javax/crypto/Cipher.html">javax.crypto Class Cipher</a>
 * @see <a href="http://es.wikipedia.org/wiki/Advanced_Encryption_Standard">WikiES: Advanced Encryption Standard</a>
 * @see <a href="http://es.wikipedia.org/wiki/Criptograf%C3%ADa">WikiES: Criptografía</a>
 * @see <a href="http://es.wikipedia.org/wiki/Vector_de_inicializaci%C3%B3n">WikiES: Vector de inicialización</a>
 * @see <a href="http://es.wikipedia.org/wiki/Cifrado_por_bloques">WikiES: Cifrado por bloques</a>
 * @see <a href="http://www.linkedin.com/in/jchinchilla">Julio Chinchilla</a>
 * @author Julio Chinchilla
 */
public class StringEncrypt {

    // Definición del tipo de algoritmo a utilizar (AES, DES, RSA)
    private final static String alg = "AES";
    // Definición del modo de cifrado a utilizar
    private final static String cI = "AES/CBC/PKCS5Padding";

    /**
     * Función de tipo String que recibe una llave (key), un vector de inicialización (iv)
     * y el texto que se desea cifrar
     * @param key la llave en tipo String a utilizar
     * @param iv el vector de inicialización a utilizar
     * @param cleartext el texto sin cifrar a encriptar
     * @return el texto cifrado en modo String
     * @throws Exception puede devolver excepciones de los siguientes tipos: NoSuchAlgorithmException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException, NoSuchPaddingException
     */
    public static String encrypt(String key, String iv, String cleartext) throws Exception {
            Cipher cipher = Cipher.getInstance(cI);
            SecretKeySpec skeySpec = new SecretKeySpec(key.getBytes(), alg);
            IvParameterSpec ivParameterSpec = new IvParameterSpec(iv.getBytes());
            cipher.init(Cipher.ENCRYPT_MODE, skeySpec, ivParameterSpec);
            byte[] encrypted = cipher.doFinal(cleartext.getBytes());
            return new String(encodeBase64(encrypted));
    }

    /**
     * Función de tipo String que recibe una llave (key), un vector de inicialización (iv)
     * y el texto que se desea descifrar
     * @param key la llave en tipo String a utilizar
     * @param iv el vector de inicialización a utilizar
     * @param encrypted el texto cifrado en modo String
     * @return el texto desencriptado en modo String
     * @throws Exception puede devolver excepciones de los siguientes tipos: NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException
     */
    public static String decrypt(String key, String iv, String encrypted) throws Exception {
            Cipher cipher = Cipher.getInstance(cI);
            SecretKeySpec skeySpec = new SecretKeySpec(key.getBytes(), alg);
            IvParameterSpec ivParameterSpec = new IvParameterSpec(iv.getBytes());
            byte[] enc = decodeBase64(encrypted);
            cipher.init(Cipher.DECRYPT_MODE, skeySpec, ivParameterSpec);
            byte[] decrypted = cipher.doFinal(enc);
            return new String(decrypted);
    }

}

EJEMPLO DE CLASE CONSUMIDORA

package encrypt;

/**
 * Clase que consume los métodos de la clase StringEncrypt
 * @author Julio Chinchilla
 */
public class Main {

 public static void main(String[] args) throws Exception {
 String key = "92AE31A79FEEB2A3"; //llave
 String iv = "0123456789ABCDEF"; // vector de inicialización
 String cleartext = "hola";
 System.out.println("Texto encriptado: "+encrypt.StringEncrypt.encrypt(key, iv,cleartext));
 System.out.println("Texto desencriptado: "+encrypt.StringEncrypt.decrypt(key, iv,encrypt.StringEncrypt.encrypt(key, iv,cleartext)));
 }

}

El ejemplo anterior tiene como structura la siguiente: Sin título y su salida sería de la siguiente forma: enc

Crear un .EXE personalizable que ejecuta un .JAR en Windows verificando si Java está instalado [x32 y x64]

java-6 Voy a teorizar un poco ya que me veo en la necesidad de explicar un poco esto, he visto varios post diciendo campantemente “Convierte un JAR a EXE”, y vaya si no es una tremenda falta de conocimiento el decir semejante barbaridad. No te dejes engañar, como bien sabes, los archivos .JAR son un compilado de archivos .Class que son los Bytecode que utiliza Java para interactuar con su máquina virtual, en realidad esto es un código de Preensamblado. Si bien es cierto bajo el sistema operativo Windows estamos acostumbrados a utilizar .EXE como archivos finales de un programa, y dar doble click en él para iniciar el programa debido. Tambien está el problema de que muchas veces un .jar puede perder la asociación de archivos en el sistema, u otras veces necesitamos corroborar que todo ande bien en el sistema y que java se encuentre correctamente instalado, para ello dejo un código de la herramienta NSIS, este script, crea un ejecutable, que corrobora si java esta correctamente instalado en Windows.

!include "FileFunc.nsh"
!include "MUI.nsh"
!include "WinMessages.nsh"

!define COMPANY_NAME "bit502"
!define ANHO "2014"
!define MUI_ICON "ico.ico"
!define JAR "bit502.jar"
!define ID "11C7BF"

!insertmacro MUI_LANGUAGE "Spanish"

OutFile "bit502.exe"

Name "bit502"

SilentInstall Silent

  VIProductVersion "1.0.0.0"
  VIAddVersionKey /LANG=${LANG_SPANISH} "FileDescription" "bit502 Tool"
  VIAddVersionKey /LANG=${LANG_SPANISH} "LegalCopyright" "©${COMPANY_NAME} ${ANHO}"
  VIAddVersionKey /LANG=${LANG_SPANISH} "LegalTrademarks" "${COMPANY_NAME}"
  VIAddVersionKey /LANG=${LANG_SPANISH} "ProductName" "bit502 Tool"
  VIAddVersionKey /LANG=${LANG_SPANISH} "InternalName" "${COMPANY_NAME}"
  VIAddVersionKey /LANG=${LANG_SPANISH} "OriginalFilename" "${COMPANY_NAME}"
  VIAddVersionKey /LANG=${LANG_SPANISH} "CompanyName" "${COMPANY_NAME}"
  VIAddVersionKey /LANG=${LANG_SPANISH} "FileVersion" "1.0"
  VIAddVersionKey /LANG=${LANG_SPANISH} "ProductVersion" 1.0"

RequestExecutionLevel user

Function .onInit
System::Call 'kernel32::CreateMutexA(i 0, i 0, t "${ID}") i .r1 ?e'
 Pop $R0
 StrCmp $R0 0 +3
   MessageBox MB_OK|MB_USERICON "El programa ya esta en ejecución"
   Abort
FunctionEnd

Caption "bit502 Guatemala"

Section
        SetRegView 64
        Goto Lee
        Lee32:
                SetRegView 32
        Lee:
                ReadRegStr $1 HKLM "SOFTWARE\JavaSoft\Java Runtime Environment" "CurrentVersion"
                ReadRegStr $0 HKLM "SOFTWARE\JavaSoft\Java Runtime Environment\$1" "JavaHome"
                StrCmp $0 "" Lee32 0
        IfFileExists $0\bin\javaw.exe 0 NoJava
        IfFileExists ${JAR} 0 NoJAR
        ExecWait '$0\bin\javaw.exe -jar ${JAR}'
        Goto Fin
        NoJava:
                MessageBox MB_OK|MB_USERICON "No se encontró Java en este equipo"
       NoJAR:
                MessageBox MB_OK|MB_USERICON "No fue posible la ejecución de ${JAR}"
        Fin:
SectionEnd