Actualizar certificados de Glassfish V2

Hace poco revisando información con respecto a los certificados que utiliza Glassfish para el tema de seguridad, me entero que los mecanismos de seguridad para la transmisión de mensajes requieren de los certificados con el estándar X.509 en su versión 3 y Glassfish trae por defecto dichos certificados pero en su versión 1, hago la aclaración que estoy trabajando con Glassfish V2. Entonces veremos una forma rápida y práctica de actualizar dichos certificados; para esto descargaremos este paquete que contiene dichos certificados y el script correspondiente para su actualización.

Entonces desempaquetamos el archivo y nos ubicamos dentro de ese directorio, en este caso tiene por nombre copyv3 y luego debemos tener en cuenta que si nosotros hemos cambiado la clave del keyStore anteriormente en algun momento configurando Glassfish, debemos modificar el archivo build.xml en la opción AS_KEYSTORE_PASSWORD y colocar dicha clave, si no en todo caso dejar todo por defecto (clave por defecto: changeit). Y luego hacemos lo siguiente tal como se muestra en la imagen:

Como pueden observar el primer comando que utilizo es export AS_HOME=/opt/glassfish esto por que el script busca esa variable de entorno seteada con la ruta de instalación de Glassfish, como pueden observar en mi caso yo lo tengo en /opt/glassfish. Luego el comando /opt/glassfish/lib/ant/bin/ant, esperamos unos segundos mientras se configura, luego lo que tenemos que hacer es iniciar el servicio y listo. Lo que ahora queda es verificar si se actualizo correctamente, para esto haremos lo siguiente:

Y listo eso seria todo. Espero les sea de utilidad, por el momento estoy trabajando esto como paso inicial para poder configurar webservices seguros.

Anuncios

Instalando Nessus en Fedora 12

Ya hace unos días que me estoy adentrando a este mundo de la seguridad de la información y como todo buen principiante siempre debe de empaparse de toda la información necesaria y sobre todo de las herramientas que nos puedan proporcionar dicha información. Nessus es una de estas herramientas, ya que nos provee mediante un escaneo a una red o redes  especificas un reporte de todos los puertos abiertos relacionados a servicios específicos, las posibles vulnerabilidades que estas puedan presentar, etc. Entonces debido a la gran importancia de este aplicativo decidí instalarlo para comenzar a realizar mis primeras pruebas. Manos a la obra

Lo primero que tenemos que hacer es descargar el paquete respectivo desde la pagina de Nessus, en este caso como estamos usando Fedora 12, lo descargamos desde aqui. Una vez descargado procedemos a instalarlo, bien haciendo doble click sobre el paquete o también rpm -Uvh Nessus-4.2.0-fc12.i386.rpm.

Terminada la instalación todo el aplicativo se ubicara dentro del directorio “/opt/nessus” y entonces procedemos a realizar la configuración. Lo primero que haremos sera crear un usuario con el que trabajaremos una vez configurado todo y para eso hacemos lo siguiente tal como se muestra en la imagen:

Como verán de esa manera agregamos en primera instancia un usuario que tendrá el rol de “admin”, solo es seguir las instrucciones. Una vez terminado este proceso, entonces tendremos que registrarnos y para esto nos dirigimos aquí y seleccionamos el tipo HomeFeed, ya que de esta forma podríamos registrarnos gratuitamente, aceptamos las condiciones y nos pedira una cuenta de correo al cual se enviara el código de registro, entonces una obtenido el código lo que haremos sera lo siguiente:

Y de esta manera ya tendremos nuestro Nessus registrado debidamente, esto nos permitirá tener lo plugins necesarios para los trabajos que haremos de aquí en adelante. Ahora solo nos queda iniciar el servicio para que los plugins se descarguen y podamos trabajar conectándonos mediante el cliente web. Para esto hacemos lo siguiente:

Y listo, se comenzara a descargar los plugins y el servicio se iniciara. Ahora como podrias comprobarlo, seria haciendo los siguiente:

Entonces de esta manera vemos que el puerto 8834 esta en escucha lo cual nos indica que ya podemos conectarnos a través del navegador, para esto solo escribimos https://127.0.0.1:8834 y nos mostrara la pantalla de logueo en donde colocaremos el usuario y password que habíamos registrado inicialmente tal como se muestra en la imagen:

Y eso seria todo. Mas adelante publicare un tutorial de como usarlo en base a experiencias propias y no propias, por el momento solo nos queda ir explorando. Espero les sea de utilidad.

Glassfish: Pool de conexiones con PostgreSQL desde NetBeans

Hace poco estuve trabajando con un pequeño sistema web con Java y JSP el cual tenia clases que accedían a la base de datos a través de una conexión directa, entonces el sistema creció y me vi en la necesidad de poder utilizar una pool de conexiones para poder mejorar el acceso en rendimiento y tiempo de respuesta a la base de datos. Como siempre he mencionado en en este blog no pretendo darles a conocer la parte teórica dado que eso lo podemos encontrar en la
Wiki o en otras paginas con un mayor detalle, así que iremos directamente al trabajo práctico.

Entonces lo primero que debemos tener es configurado un gestor de base de datos con la respectiva base de datos creada la cual usaremos para realizar la conexión, en este caso PostgreSQL con la base de datos llamada bd_pool.

Una vez creada y configurada nuestra base de datos, lo que haremos ahora sera abrir nuestro NetBeans y poder registrar nuestro driver de conexión JDBC para PostgreSQL y luego crear la conexión que nos servirá de referencia para mas adelante. Entonces para esto dentro de NetBeans nos ubicamos en la pestaña de “services” (o servicios) y desplegamos la opción de “Databases” segun como se muestra en la imagen:

Luego le damos click derecho a “Drivers” y seleccionamos la opción “New Driver” entonces nos aparecerá una ventana en donde seleccionaremos la opcion “Add” y ubicamos el driver de conexión, en mi caso yo tengo el “postgresql-8.2-505.jdbc3.jar” quedando algo como esto:

Entonces solo le damos OK y ya tendremos el driver JDBC registrado y listo para usarse., segun como se muestra en la imagen:

Ahora lo que nos tocaría hacer es crear la conexión que nos servirá de referencia para poder crear el pool de conexiones, entonces en la lista mostrada anteriormente, le damos click derecho a PostgreSQL y seleccionamos la opcion “Connect Ussing” y nos aparecera una ventana en la cual llenaremos todos los datos requeridos, quedando algo como esto:

Le damos OK y luego nos aparecerá una ventana en donde seleccionaremos el esquema, entonces debido a que nosotros estamos utilizando el esquema por defecto entonces desplegamos el combo y seleccionamos “public” y luego veríamos la referencia de conexión dentro de la lista como se muestra en la imagen:

Bueno ya tenemos la primera parte de este proceso terminado, ahora continuaremos creando una aplicación web a la que llamaremos WebAppPool, solo para temas didácticos; creo que ya sabemos como hacerlo, así que no entrare en detalle allí.

Entonces una vez creado el proyecto web, le damos click derecho y nos ubicamos en “New” y luego seleccionamos la opción “Other..” y luego dentro de la opciones  nos ubicamos en Glassfish, quedando de esta manera:

Entonces una vez aquí haremos dos procesos, el primero sera seleccionar la opción “JDBC Connection Pool”, luego click en “Next” y en la siguiente ventana colocaremos como nombre “PoolDemo” y en la relación de conexiones existentes, seleccionamos la conexión activa que habíamos registrando anteriormente tal como se muestra en la figura:

luego le damos click en “Next” y obtendremos una ventana con el detalle de la conexión, tal como la URL, el usuario y el password, pero necesitaremos agregar mas detalle; para esto haremos click en el botón “Add” e iremos agregando el “servername”, “database” y “portnumber” tal como se muestra en la figura:

y luego para terminar esta parte le damos click en “Next” y nos mostrara una ventana con varias opciones de configuración, para lo cual solo cambiaremos la opción de “Steady Pool Size” que no es mas que el numero de conexiones que tendrá nuestro pool, en este caso lo cambiare de 8 a 5; pero hago la aclaracion que esto dependera de cada usuario, puede tener hasta mas conexiones, y luego finalizamos.

Esto nos generara un archivo con extensión *.xml y que estará ubicado dentro del directorio “Server Resources” con el nombre “sun-resources.xml” el cual debería contener lo siguiente:

“sun-resources.xml”

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE resources PUBLIC "-//Sun Microsystems, Inc.//DTD Application Server 9.0 Resource Definitions //EN" "http://www.sun.com/software/appserver/dtds/sun-resources_1_3.dtd">
<resources>
  <jdbc-connection-pool allow-non-component-callers="false" associate-with-thread="false" connection-creation-retry-attempts="0" connection-creation-retry-interval-in-seconds="10" connection-leak-reclaim="false" connection-leak-timeout-in-seconds="0" connection-validation-method="auto-commit" datasource-classname="org.postgresql.ds.PGSimpleDataSource" fail-all-connections="false" idle-timeout-in-seconds="300" is-connection-validation-required="false" is-isolation-level-guaranteed="true" lazy-connection-association="false" lazy-connection-enlistment="false" match-connections="false" max-connection-usage-count="0" max-pool-size="32" max-wait-time-in-millis="60000" name="PoolDemo" non-transactional-connections="false" pool-resize-quantity="2" res-type="javax.sql.DataSource" statement-timeout-in-seconds="-1" steady-pool-size="8" validate-atmost-once-period-in-seconds="0" wrap-jdbc-objects="false">
    <property name="URL" value="jdbc:postgresql://localhost:5432/bd_pool"/>
    <property name="User" value="postgres"/>
    <property name="Password" value="mipassword"/>
    <property name="serverName" value="localhost"/>
    <property name="databaseName" value="bd_pool"/>
    <property name="portNumber" value="5432"/>
  </jdbc-connection-pool>
</resources>

luego nos quedaría agregar el recurso o referencia que utilizara el pool para ser llamado desde una clase que necesite la conexión, para esto le damos click derecho al proyecto, seleccionamos “New” y dentro de la ventana de opciones seleccionamos Glassfish y luego seleccionamos la opción “JDBC Resourcce” le damos click en “Next” y nos aparecera una ventana en donde seleccionaremos el pool creado anteriormente y en la opcion “JNDI Name” colocaremos como nombre “jdbc/pooldemo” quedando de la siguiente manera:

y luego finalizamos. Ahora en el archivo “sun-resources.xml” tendremos lo siguiente:

“sun-resources.xml”

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE resources PUBLIC "-//Sun Microsystems, Inc.//DTD Application Server 9.0 Resource Definitions //EN" "http://www.sun.com/software/appserver/dtds/sun-resources_1_3.dtd">
<resources>
  <jdbc-resource enabled="true" jndi-name="jdbc/pooldemo" object-type="user" pool-name="PoolDemo">
    <description/>
  </jdbc-resource>
  <jdbc-connection-pool allow-non-component-callers="false" associate-with-thread="false" connection-creation-retry-attempts="0" connection-creation-retry-interval-in-seconds="10" connection-leak-reclaim="false" connection-leak-timeout-in-seconds="0" connection-validation-method="auto-commit" datasource-classname="org.postgresql.ds.PGSimpleDataSource" fail-all-connections="false" idle-timeout-in-seconds="300" is-connection-validation-required="false" is-isolation-level-guaranteed="true" lazy-connection-association="false" lazy-connection-enlistment="false" match-connections="false" max-connection-usage-count="0" max-pool-size="32" max-wait-time-in-millis="60000" name="PoolDemo" non-transactional-connections="false" pool-resize-quantity="2" res-type="javax.sql.DataSource" statement-timeout-in-seconds="-1" steady-pool-size="8" validate-atmost-once-period-in-seconds="0" wrap-jdbc-objects="false">
    <property name="URL" value="jdbc:postgresql://localhost:5432/bd_pool"/>
    <property name="User" value="postgres"/>
    <property name="Password" value="mipassword"/>
    <property name="serverName" value="localhost"/>
    <property name="databaseName" value="bd_pool"/>
    <property name="portNumber" value="5432"/>
  </jdbc-connection-pool>
</resources>

Y ya con esto tenemos la configuración lista para ser desplegada en el servidor para luego poder ser usado desde una clase u otro aplicativo que necesite una conexión.

Entonce ahora le damos clic derecho a nuestra aplicación web y seleccionamos “deploy”, con esto estaremos generando el pool de conexiones y nombre de recurso asignado a ese pool en nuestro servidor de aplicaciones. Esto lo podemos verificar entrando a la consola de administración de Glassfish; una vez dentro nos ubicamos en la opción Recursos, luego en JDBC y luego para ver nuestro pool creado nos ubicamos en Conjunto de Conexiones, y luego dentro de la lista debería estar “PoolDemo”, lo seleccionamos y nos ubicamos en la parte derecha del detalle y hacemos clic en “Sondeo”, si todo marcha bien deberías tener lo siguiente:

y luego para verificar si nuestro recurso se creo nos ubicamos en “Recursos JDBC” y en la lista debemos tener “jdbc/pooldemo”, tal como se muestra en la figura:

Y listo prácticamente eso seria todo con referencia a este tutorial, lo único que faltaría es llamarlo desde una clase cualquiera, cosa que “posteare” mas adelante. Trate de ser lo mas didáctico posible, espero les sirva.

TripleDES con Java II (bouncyCastle)

Hace unos días escribí un post acerca de como poder cifrar y descifrar cadenas o textos completos utilizando el algoritmo TripleDES desde Java y bueno buscando formas de mejorar este proceso me tope con una API muy interesante que me permite realizar este tipo de cifrado utilizando TripleDES y ademas de otros (DES, AES, etc.). Esta API es desarrollada por un grupo de personas que se hacen llamar Legion of the Bouncy Castle y cuyo nombre es Bouncy Castle Crypto APIs”, lo cual consiste en un conjunto de librerías especificas para trabajos de criptografia, actualmente la tenemos en su versión 1.45 para Java compatibles desde el JDK 1.2 al JDK 1.6 y su versión 1.6.1 para trabajar desde C# .NET.

Bueno, aquí les propongo una forma de poder utilizar esta librería justamente con una clase para trabajar con TripleDES, para esto cree una clase a la que llame EncriptionSource y esta a su vez con los métodos Encrypt y Decrypt respectivamente:

Encriptionsource.java

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package appayudas;

/**
 *
 * @author nachxs
 */

import org.bouncycastle.crypto.*;
import org.bouncycastle.crypto.paddings.*;
import org.bouncycastle.crypto.engines.*;
import org.bouncycastle.crypto.modes.*;
import org.bouncycastle.crypto.params.*;

public class EncriptionSource {

    BlockCipher engine = new DESedeEngine();

    public byte[] Encrypt(byte[] key, String plainText) {
        byte[] ptBytes = plainText.getBytes();
        BufferedBlockCipher cipher = new PaddedBufferedBlockCipher(new CBCBlockCipher(engine));
        cipher.init(true, new KeyParameter(key));
        byte[] rv = new byte[cipher.getOutputSize(ptBytes.length)];
        int tam = cipher.processBytes(ptBytes, 0, ptBytes.length, rv, 0);
        try {
            cipher.doFinal(rv, tam);
        } catch (Exception ce) {
            ce.printStackTrace();
        }
        return rv;
    }

    public String Decrypt(byte[] key, byte[] cipherText) {
        BufferedBlockCipher cipher = new PaddedBufferedBlockCipher(new CBCBlockCipher(engine));
        cipher.init(false, new KeyParameter(key));
        byte[] rv = new byte[cipher.getOutputSize(cipherText.length)];
        int tam = cipher.processBytes(cipherText, 0, cipherText.length, rv, 0);
        try {
            cipher.doFinal(rv, tam);
        } catch (Exception ce) {
            ce.printStackTrace();
        }
        return new String(rv).trim();
    }
}

Y luego solo haríamos lo siguiente para llamarla desde una clase Main.java:

Main.java

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package appayudas;

/**
 *
 * @author nachxs
 */

public class Main {
    /**
     * @param args the command line arguments
     */

    public static void main(String[] args) throws Exception {
        EncriptionSource esource = new EncriptionSource();
        String key = "DC101AB52CF894CEE52F61731643B94F";
        String cad = "https://nachxs.wordpress.com";
        byte[] keyb = FunctionByte.hex2byte(key);
        System.out.println("Cadena Ingreso: " + cad);
        String enc = FunctionByte.toHEX1(esource.Encrypt(keyb, cad));
        System.out.println("Encripta: " + enc);
        String des = esource.Decrypt(keyb, FunctionByte.hex2byte(enc));
        System.out.println("Desencripta: " + des);
    }
}

Como podran observar estoy utilizando la clase Functionbyte la cual lo pueden descargar de aquí. Hago la aclaración que esta clase (FunctionByte) esta dentro de las clases que descargue para poder trabajar con DES tal como lo mencione en el post anterior, si no que esta con el nombre de Util.java. Espero les sirve y puedan mejorarlo y comentarlo.

12 tipos de bloggers

Revisando algunos blogs por la red me tope con este muy interesante se llama Chica SEO con un post algo peculiar, resulta que Milagros una de las administradoras de este blog, publico según su concepción una lista de los 12 tipos de bloggers que pudieran existir y que la verdad me parecio algo representativo y gracioso en algunos casos, sobre todo para los que se sientan identificados con alguno de estos tipos xD, los invito a leerlo y dar su opinión, por lo menos yo pienso que me identifico con el numero 7. Y uds. con cual se identifican?

Visto en : Chica SEO