domingo, 28 de junio de 2015

[RFID] Comprendiendo su funcionamiento







¿Qué es?

Por sus siglas Radio Frequency Identification, es un sistema que mediante tarjetas o tags con un circuito interno y un lector para estas, realiza una comunicación que, a menudo, se usa para realizar inventario de productos o (lo que nos interesa realmente) autenticación en sistemas, por ejemplo, de transporte público como el metro.
Todo esto se hace de manera inalámbrica, pero también existen varios tipos tags, están los pasivos y los activos, los activos tienen una fuente de poder propia y tienen mucho más alcance que el primero, por el contrario, los pasivos usan la energía del lector para realizar la comunicación, entre estos se encuentran las tarjetas de transporte público.


¿Cómo es una tarjeta?

En este caso hablamos de tarjetas del tipo Mifare Classic, de éstas hay dos tipos, las de 1K y las de 4K, con K nos referimos a kilobytes, osea que las de 1K almacenan 1024 bytes de datos.
En ambos casos las tarjetas se dividen por sectores, los sectores, a su vez, se componen de bloques, los bloques en ambos casos se componen de 16 bytes.

Las tarjetas de 1K contienen 16 sectores, y cada sector contiene 4 bloques.
Las tarjetas de 4K contienen 40 sectores, los primeros 32 sectores contienen 4 bloques, los otros 8 sectores se componen de 16 bloques.

El bloque 0 del sector 0 contiene información como el UID, BCC, e información del fabricante, de la siguiente manera.



El último bloque de cada sector es llamado trailer, contiene la Key A en los primeros 6 bytes, El Access Bits en los siguientes 4, y los últimos 6 contienen la Key B, con esto se da por entendido que cada sector tiene 2 claves, por lo mismo una sola tarjeta se puede usar en varios servicios, donde cada servicio usas sectores diferentes y sólo pueden modificar los sectores de los que conozcan las claves.



¿Cómo se comunican lector y tarjeta?

Las tarjetas usan cifrado en su comunicación, específicamente crypto-1, entonces para realizar la lectura de una de estas tarjetas debe haber un sistema de autenticación, ésta se produce en varias faces, en la primera face el lector le comunica a la tarjeta que desea leer el X sector, luego la tarjeta envía 32 bits que deberán ser cifrados con la clave privada anteriormente conocida, luego la tarjeta devuelve 64 bits, donde envía 32 bits de la respuesta cifrada, y los otros 32 bits para que la tarjeta los cifre, por último el lector envía la respuesta cifrada para que finalmente se genere la autenticación.

Fuentes:
http://www.nxp.com/documents/data_sheet/MF1S503x.pdf

lunes, 20 de abril de 2015

[HttpComponents-Client] Realizar peticiones http con Java

Es muy común que mientras estamos programando algún script nos encontremos con la necesidad de realizar una petición a alguna página web ó a una web api para obtener información de ella, en Java tenemos varias soluciones a este problema, las librerías nativas de Java nos ofrecen la librería java.net, pero en esta ocasión trataremos una librería externa creada por Apache llamada HttpComponents Client.

Como es común con los productos de Apache tienen muy buena documentación, pero en este post trataré de explicarlo de una manera más sencilla.

La librería puede obtenerse por descarga directa o por el repositorio de Maven.

Petición GET
Para comenzar creamos una clase llamada Peticiones para poner ahí los métodos que usaremos para crear las peticiones, inicialmente haremos una petición GET a example.com e imprimiremos el resultado en consola, para ello creamos un método de tipo String llamado httpGetSimple que llevará como argumento la url.
Para realizar una petición simple necesitamos una instancia de  HttpClient, que como su nombre lo indica es el cliente para realizar las peticiones al que podemos agregar una configuración, por ahora no lo haremos entonces instanciaremos con createDefault.
HttpClient httpClient = HttpClients.createDefault();
Luego instanciaremos un HttpGet que es el que contendrá nuestra petición en cuestión.
HttpGet httpGet = new HttpGet(url);
Ahora declararemos un HttpResponse  en que almacenaremos la respuesta de la petición, y con el método execute del cliente para obtenerla.
HttpResponse httpResponse = httpClient.execute(httpGet);
Finalmente el HTML de la respuesta la obtenemos con la ayuda de EntityUtils con su método toString.
String source = EntityUtils.toString(httpResponse.getEntity());
Quedando sí nuestro código.
public String httpGetSimple(String url){
    String source = null;

    HttpClient httpClient = HttpClients.createDefault();
    HttpGet httpGet = new HttpGet(url);
    try {
    HttpResponse httpResponse = httpClient.execute(httpGet);
        source = EntityUtils.toString(httpResponse.getEntity());
    } catch (IOException e) {
        e.printStackTrace();
    }
    return source;
}

Ahora creamos una instancia en nuestro main a la clase Peticiones y ejecutamos httpGetSimple para imprimirlo, así:
public static void main(String[] args) {
    Peticiones peticiones = new Peticiones();
    System.out.println(peticiones.httpGetSimple("http://www.example.com/"));
}

Y nos devuelve:


Petición POST
Aquí configuraremos el cliente de la misma forma y aunque en este caso podríamos usar la clase HttpPost, usaremos RequestBuilder. Primero crearemos un método llamado httpPostSimple que llevará como argumentos la url y otro con argumentos ilimitados para recibir los parámetros.
public String httpPostSimple(String url, NameValuePair...parametros){

}

NameValuePair es la clase usada por la librería para guardar parametros para las peticiones, su uso es de la siguiente manera:
NameValuePair valuePair = new BasicNameValuePair("nombre", "valor");

Creamos una instancia del RequestBuilder de la siguiente manera:
RequestBuilder requestBuilder = RequestBuilder.post().setUri(url);

Ahora pasamos los parámetros al builder y luego "buildeamos" en una HttpUriRequest
for(NameValuePair parametro:parametros)
    requestBuilder.addParameter(parametro);

HttpUriRequest uriRequest = requestBuilder.build();

Luego ejecutamos la petición de la misma manera que en la vez anterior:
try {
    HttpResponse httpResponse = httpClient.execute(uriRequest);
    source = EntityUtils.toString(httpResponse.getEntity());
} catch (IOException e) {
    e.printStackTrace();
}

Ahora probemos su funcionamiento en nuestra clase main, enviaremos la petición a un script en php que imprimirá los parametros que reciba.
public static void main(String[] args) {
    Peticiones peticiones = new Peticiones();
    NameValuePair parametro = new BasicNameValuePair("nombreParametro", "miValor");
    System.out.println(peticiones.httpPostSimple("http://localhost/Prueba01.php", parametro));
}

Y nos devuelve esto:


CookieStore

Si queremos añadir una cookie antes de una petición o almacenar u obtener las cookies luego de alguna petición podemos usar la cookie store que nos ofrece esta librería, su uso:
BasicCookieStore cookieStore = new BasicCookieStore();
HttpClient httpClient = HttpClients.custom().setDefaultCookieStore(cookieStore).build();
Añadir cookie:
Cookie cookie = new BasicClientCookie("nombre", "valor");
cookieStore.addCookie(cookie);
Obtener cookies:
List< Cookie> cookies = cookieStore.getCookies();
for(Cookie cookie: cookies)
    System.out.println(cookie.getName() + ":" + cookie.getValue());

Configuración
Estas peticiones también nos permiten configurar otras cosas como timeouts, proxys, máximas redirecciones, etc.
Su uso:
RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(8000).build();
requestBuilder.setConfig(requestConfig);

Aquí usamos setConnectTimeOut para establecer en milisegundos el tiempo máximo que esperara la petición para conectarse al servidor.
Podemos usar muchos otros métodos de configuración que puedes ver aquí. Esto es todo por este POST, saludos!

viernes, 17 de abril de 2015

[ForceBindIP] Forzar aplicación a usar una red específica

A veces pasa que tenemos acceso a diferentes redes, varias redes wifi, nuestra red ethernet, etc.
Y si tenemos varios adaptadores para usarlas podemos aprovechar la velocidad de todas ellas, una de las  maneras de hacerlo es usar es usar una por ejemplo para el navegador, y otra para un gestor de descargas, cada quien que le de su uso.

Para esto podemos usar ForceBindIP, un software que hace exactamente lo que acabo de describir, es de un uso muy simple, ejecutamos un comando que tendrá por argumentos la red que queremos usar y el programa que queremos iniciar con esta red configurada.

Para empezar necesitamos bajar el programa, lo puedes bajar de http://old.r1ch.net/stuff/forcebindip/
Puedes bajar el instalador o un archivo zip, luego de bajado e instalado el programa, procedemos a usarlo, a continuación un comando de ejemplo.

ForceBindIP 192.168.0.1 "C:\Program Files (x86)\Mozilla Firefox\Firefox.exe"

Donde 192.168.0.1 es mi IP local en la red y el segundo argumento es el programa que queremos ejecutar, si no sabes obtener tu ip local más adelante en el post lo explicaré.
En la página del programa sugieren que si al ejecutar comando, el programa crashea, agregues -i para solucionarlo, quedando así nuestro comando.

ForceBindIP -i 192.168.0.1 "C:\Program Files (x86)\Mozilla Firefox\Firefox.exe"

Para obtener la ip local en alguna de las redes a las que estás conectado debes abrir el cmd y ejecutar:
ipconfig

Te arrojará un resultado similar a este
Donde la dirección IPv4 es nuestra IP local y es la que usaremos para usar el ForceBindIP.
Eso es todo por este post. Saludos!

Presentación

Hola, soy TheMr, me gusta la programación y la seguridad informática, me gustan los lenguajes PHP y JAVA, y sé un poco de algunos otros. En este blog compartiré lo que sé y lo que vaya aprendiendo a lo largo de mis experiencias.