Queria compartir estas páginas que tienen colección de proyectos, plugins, etc. que puede ser de mucha ayuda.


Saludos

Buenas a todos, hacia tiempo que andaba medio perdido. Así que vengo con un tema para debatir

Cuál framework consideran el mejor ya sea por facilidad de aprender, sintaxis, popularidad, documentación etc para desarrollo frontend?
Algunos de los mas conocidos hoy en dia son: Vue, Angular y React

Pequeño pdf con una introduccion sobre diseño de lan.
En donde se explica el modelo de redes jerarquicas y sus beneficios. Consideraciones para los switches de redes jerarquicas, caracteristicas de cada uno de ellos dependiendo de la capa y algunas otras cosas mas.



Descarga: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Buenas a todos!!!

El siguiente post detallará los pasos a seguir para poder configurar lo necesario y así poder mandar mail protegidos por PGP.
Para una introducción sobre PGP los invito a pasar primeramente por este No tienes permitido ver los links. Registrarse o Entrar a mi cuenta de Cl0udswX.

Para comenzar necesitaremos instalar los siguiente paquetes: thunderbird o icedove y enigmail.

Configurando Icedove

Al ejecutar Icedove por primera vez podremos configurar la dirección de correo, ya sea crear un nueva o utilizar una ya existente. En caso de no querer hacerlo ahora lo podremos hacer más adelante.
En mi caso presionamos "Omitir esta etapa y utilizar mi dirección existente".


Colocamos los datos de nuestra cuenta y por último presionamos "Finalizado"


En este punto ya vamos a poder utilizar nuestro correo para mandar y leer mails comunes.


Configurando Enigmail

Vamos al menú Enigmail > Asistente de Configuración.
Dejamos seleccionado "Si, deseo que me ayude el asistente" y presiono "Siguiente"


Elegimos el modo en que queremos que se cifren los mensajes (automático, siempre por defecto, nunca por defecto) según el gusto de cada uno.


Definimos si queremos que los mail se firmen por defecto o no.


En este paso nos dará la posibilidad de crear las claves para PGP o utilizar unas existentes en el caso de tenerlas.


Antes de finalizar nos mostrará las acciones que se van a realizar dependiendo de lo que hayamos elegido.
Presionamos "Siguiente".


En la generación de la clave nos va a pedir una contraseña y luego nos avisa que el proceso puede tardar algunos minutos y que para acelerarlo nos recomienda navegar por internet o que hagamos un uso intensivo del disco.


Al finalizar la generación de la clave se nos da la posibilidad de crear un certificado de renovación. Dicho certificado puede usarse para invalidad nuestra clave.


Ya tenemos configurado Enigmail.


Mandando mails cifrado y firmados

Para utilizar las opciones empezamos a escribir un mail y podemos elegir firmar y/o cifrar desde el menú "Enigmail" o desde los botones


Un mail cifrado se ve así.


Para decifrarlo debemos utilizar nuestra clave privada que elegimos en la creación de la clave pública.

Saludos

Nagios es una herramienta de código libre orientada a la supervisión automática y continua de Infraestructura IT.

Algunas de las características que tiene son:

• Monitoreo de Servicios de Red
• Monitoreo de Host y sus recursos como CPU, Memoria, Discos, etc
• Desarrollo de Plugins para el chequeo de una infinidad de plataformas y servicios
• Capacidad de Services Checks en paralelo
• Capacidad de Definir Host/Servicios padres o hijos, lo que permite detectar el origen del problema en caso de no ser de la propia máquina
• Definición de Contactos para el envío de notificaciones
• Capacidad de definir manejadores de eventos para el manejo de eventos de manera proactiva
• Log de eventos
• Interface Web para la visualización de estados de servicio, históricos, Archivo de Log, etc
• Integración con herramientas que la comunidad ha desarrollado
• Multiplataforma, aunque fue desarrollado originalmente para correr sobre Linux

La página oficial es No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.
Para probar dicha herramienta podemos descargarla desde la página, que nos provee el source o también máquinas virtuales ya preparadas.

Probando Nagios

Descargamos unas de las maquinas virtuales y utilizamos VMware o Virtual Box según conveniencia o gusto.


Podemos  loguearnos como root con la password 'nagiosxi'.
Para acceder a nagios, usamos un navegador e introducimos la ip que se nos detalla.


Entramos y vamos a necesitar ingresar algunos datos para la instalación.


Luego nos logueamos y por única vez tenemos que leer y aceptar los términos de la licencia.
Y ya podemos visualizar los diferentes menús y utilizarlos.


Saludos

STORED PROCEDURES

Descarga: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Saludos

Buenas a todos!!!! Como andan?
Después de tanto tiempo, a mi me pareció una eternidad, vengo a hacer una pequeña contribución.

Primero que nada definamos lo que es un túnel:

Wikipedia:

CitarSe conoce como túnel o tunneling a la técnica que consiste en encapsular un protocolo de red sobre otro (protocolo de red encapsulador) creando un túnel de información dentro de una red de computadoras. La técnica de tunelizar se suele utilizar para trasportar un protocolo determinado a través de una red que, en condiciones normales, no lo aceptaría. Otro uso de la tunelización de protocolos es la creación de diversos tipos de redes privadas virtuales.

En el siguiente aporte se va a detallar como hacer para crear un Túnel de IPv6 sobre IPv4, mediante la web No tienes permitido ver los links. Registrarse o Entrar a mi cuenta que nos provee Hurricane Electric.


Hurricane Electric además ofrece una certificación de IPv6 como lo menciona Cl0udswX No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Vayamos a lo nuestro.

Creación de una cuenta

El requerimiento para poder crear el túnel es estar registrado en la web. Por lo tanto el primer paso es registrarse. Nos va a pedir datos personales como el usuario, nuestro nombre, un mail, el lugar donde vivimos y un teléfono.
Si no ha habido ningún problema nos mostrará el siguiente mensaje:

CitarYou have successfully registered for Hurricane Electric's free IPv6 tunnelbroker service.
Your account information should be arriving in your email ([email protected]) shortly.

If you have not received your account information within the next few hours, please contact us at No tienes permitido ver los links. Registrarse o Entrar a mi cuenta and include your username in the email.

Y recibiremos en un mail la contraseña.

Creando el túnel

Ya con nuestro usuario y contraseña nos logueamos.
En la parte centrar habrá un panel con las últimas noticias sobre actualizaciones y mantenimiento que se vayan produciendo en los túneles que ofrecen.
Del lado derecho podrán encontrar un conjunto de links sobre temas importantes
Y del lado izquierdo aparecerá un menú sobre la cuenta, que nos permitirá modificar los datos personales anteriormente ingresados y desloguearnos. Y abajo un menú de funciones de usuario, con las opciones Crear túnel regular, Crear túnel BGP y Escáner de puertos para IPv6. En nuestro caso vamos a centrarnos en "Crear túnel regular".


Para la creación del túnel nos pide los siguientes datos:

• IPv4, colocamos nuestra IP pública, que es la que nos especifica en el punto de abajo. En caso de colocar alguna IP errónea nos lanza una advertencia con la descripción del problema.
• Servidor de túnel, tenemos la posibilidad de elegir de una lista amplia de servidores disponibles en diferentes lugares de Asia, Europa y América del Norte.

Cada uno elige según le convenga o le guste.
Y por último presionamos Crear Túnel.

Nuevamente si todo fue correcto se nos dirigirá a un nueva pantalla en donde en un primer plano vemos los datos del túnel creado.


Configuración del túnel

Por el momento solo hemos creado el túnel, ahora es necesario configurarlo en nuestra computadora.
La misma página, si ponemos en la solapa "Ejemplo de configuración" nos da la posibilidad de elegir nuestro sistema operativo y proveernos los comandos o pasos necesarios.


Por ejemplo para el caso de Windows no da una serie de comando para poner en consola. Para Ubuntu/Debian te da una serie de linear para agregar al archivo /etc/network/interface.

Testeando el túnel

Para testear nuestra conectividad vamos  a usar la página  No tienes permitido ver los links. Registrarse o Entrar a mi cuenta


Saludos

Objetos Recursivos. Categorías anidadas en Europe Engine.

Descarga: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Saludos

Buenas a todos!!!

Alguno que tenga conocimientos de Jsp, sabe si existe alguna forma de poder hacer una interacción entre algo desarrollado en jsp y alguna aplicación de escritorio en java en ambas direcciones.

Saludos

Preparando resumenes para dar finales me tope con este libro que tenia guardado y se los comparto.

Descarga: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Saludos

Web: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Vector: <img src=x onerror=prompt(1)>
Reportado: SI

Saludos

Despues de tanto tiempo sin postear nada xD Voy volviendo a las andadas.



Shana Tova - Edicion Especial
50 tips, tricks y hacks en php y howto para europio engine

Descarga: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Fuente: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Saludos

Comparto este post porque me parecio bastante buena la ayuda que puede ser tener los digramas de Venn para entender los joins


Hace ya algún tiempo, mientras aprendía a hacer consultas avanzadas a SQL a marchas forzadas, empecé a buscar información que me explicara mejor cómo funcionaban los JOINs de SQL. ¡Hay tantos! La verdad es que al principio, cuesta entenderlos bastante.

Pero entonces me topé con un artículo que el bueno de Jeff Atwood (creador de Stackoverflow) escribió allá por el 2007. Jeff, utiliza diagramas de Venn para explicar de manera muy concisa cada JOIN. Soy consciente de que mucha gente no busca en inglés por lo que me dije, ¿por qué no lo traducimos?

Si has intentado comprender cómo funcionan los JOINs y no acabas de entenderlos y, lo que es peor, dudas sobre qué JOIN usar, tan solo debes tener una imagen en mente. Con estos sencillos ejemplos, pretendo solo que te hagas a la idea de lo que un JOIN en concreto te devolverá.

Tengamos estas dos tablas como ejemplos:

id nombre     id  nombre
-- ------     --  ------
1  Homer      1   Marge
2  Bart       2   Homer
3  Marge      3   Spidercerdo
4  Maggie     4   Moe

Vamos a unir las tablas por el campo del nombre de distintas formas y vamos a ver cómo resultan.

Inner join

SELECT * FROM TablaA 
INNER JOIN TablaB
ON TablaA.nombre = TablaB.nombre

id  nombre     id   nombre
--  ------     --   ------
1   Homer      2    Homer
3   Marge      1    Marge

Un inner join produce únicamente el conjunto de registros que están tanto en la Tabla A como en la Tabla B.

Full outer join

SELECT * FROM TablaA
FULL OUTER JOIN TablaB
ON TablaA.nombre = TablaB.nombre

id    nombre     id    nombre
--    ------     --    ------
1     Homer      2     Homer
2     Bart       null  null
3     Marge      1     Marge
4     Maggie     null  null
null  null       3     Spidercerdo       
null  null       4     Moe

Full outer join produce el conjunto de todos los recursos de la Tabla A y de la Tabla B, haciendo coincidir los registros de ambos lados si están disponibles. Si no hay coincidencias, el lado que falte, contendrá null.

Left outer join

SELECT * FROM TablaA
LEFT OUTER JOIN TablaB
ON TablaA.nombre = TablaB.nombre

id  nombre     id    nombre
--  ------     --    ------
1   Homer      2     Homer
2   Bart       null  null
3   Marge      1     Marge
4   Maggie     null  null

Left outer join reproduce todos los registros de la Tabla A, con los registros completos (donde se pueda), de la Tabla B. Si no hay coincidencias en el registro, el lado derecho contendrá null.

Estas son las operaciones básicas que podemos hacer con JOIN. No obstante, vamos a ver algunos trucos para obtener otras partes de las tablas que nos puedan interesar.

SELECT * FROM TableA
LEFT OUTER JOIN TableB
ON TableA.name = TableB.name
WHERE TablaB.id IS null

id  nombre     id     nombre
--  ------     --     ------
2   Bart       null   null
4   Maggie     null   null

Para obtener los registros que solo estén en la Tabla A, pero no en la Tabla B, realizaremos el mismo left outer join, y excluimos los registros de la derecha que no queremos, con where.

SELECT * FROM TablaA
FULL OUTER JOIN TablaB
ON TableA.nombre = TablaB.nombre
WHERE TablaA.id IS null 
OR TablaB.id IS null

id    nombre     id    nombre
--    ------     --    ------
2     Bart       null  null
4     Maggie     null  null
null  null       3     Spidercerdo
null  null       4     Moe

En este caso, obtendremos los registros únicos de la Tabla A y de la Tabla B. Para lograrlo, ejecutamos el mismo full outer join, y luego excluimos los resultados indeseados de ambos lados con where.

Ten en cuenta que, aunque no están aquí incluidos por parecerme redundante, podemos cambiar LEFT por RIGHT si queremos darle la vuelta al gráfico, operando así con la tabla derecha como principal, en vez de la izquierda

Fuente: funcion13
Autor: Antonio Laguna

Saludos

Buenas les dejo un pequeño desafío, bastante fácil sobre excepciones.


Objetivos:

Decir cuál sería la salida al siguiente código y por qué es esa salida, o por qué no es otra.

La idea del desafío es dar una primera respuesta sin tener que recurrir a ejecutar el código.

Usuarios que contestaron bien al desafio:

- fermino
- LKI

Saludos

Guia definitiva para montar un servidor GNU/Linux Profesional.

Guia ilustrada paso a paso para novatos y expertos.

Descarga: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Fuente: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Saludos

Sobreescritura y sobrecarga de métodos son 2 conceptos que pueden parecer confusos pero veremos que en sí representan algo muy simple.

Debemos saber que estas propiedades de la Programación Orientada a Objetos nos traen algunas ventajas como por ejemplo la facilidad, extensibilidad y flexibilidad en el código.

Pero que son?

La sobrecarga y sobreescritura no son mas que dos conceptos aplicados al trabajo con métodos, específicamente en el uso que le queremos dar. Estos conceptos dependen principalmente de nuestra lógica de programación y el enfoque o forma de trabajo, depende de lo que queremos hacer. ¿Como así?, veamos de forma mas clara cada concepto.

Sobrecarga de métodos (Overloading)

En java sabemos que si ya declaramos una variable o un método con un nombre en especifico, no podemos declarar otra variable o método que se llame igual, sin embargo esta regla no aplica cuando usamos la Sobrecarga de métodos, ya que esta permite usar el mismo nombre del método pero solo si se tiene diferente firma, ¿firma?, cuando hablamos de la firma de un método, nos referimos a sus parámetros.

En resumen la sobrecarga permite declarar métodos que se llamen igual pero que reciban parámetros diferentes (no pueden haber 2 métodos con el mismo nombre y los mismos parámetros), por esta razón lo que define a que método se ingresa, son los argumentos que se envían como parámetros.

Anteriormente mencioné algo sobre la forma de trabajo o lógica de programación, esto es porque supongamos que yo quiero hacer sumas, pero mi programa debe sumar por aparte 2 números enteros o 2 números doubles, para esto tengo 2 opciones.

1. crear 2 métodos, uno llamado sumaEnteros(int a, int b) y otro sumaDoubles(double a, double b)

2. Aplicar el concepto de sobrecarga, donde aunque también vamos a crear 2 metodos, los vamos a llamar con el mismo nombre pero con diferentes parametros, sumar(int a, int b) y sumar(double a, double b) quedando algo como esto:

public void sumar(int a, int b) {
        int suma=a+b;
        System.out.println("la suma es: "+suma);
}
     
public void sumar(double a, double b) {   
        double suma=a+b;
        System.out.println("la suma es: "+suma);
}

Podemos ver que los 2 métodos se llaman igual pero poseen parámetros diferentes, así cuando sean llamados, dependiendo del parámetro enviado se accede al método.

Y no es igual? para que sobrecargar si en ultimas se crea el mismo numero de métodos? 

La pregunta anterior es muy valida y tiene mucha lógica, pero como en otros casos la respuesta también gira en torno a la facilidad, las buenas practicas y la búsqueda de aplicaciones optimizadas. El ejemplo es muy simple y poco complejo, pero imaginemos una aplicación donde se tenga la misma acción pero con procesos diferentes?

Por ejemplo encender un motor y si tenemos diferentes tipos de encendido como el eléctrico, encendido térmico, encendido de combustión etc etc. donde los procesos son muy diferentes pero en ultimas el objetivo es el mismo, pero cada uno necesita ciertas características únicas para encender, aquí podríamos aplicar la sobrecarga para no preocuparnos por llamar los métodos por su nombre sino tan solo llamando al mismo pero enviando los parámetros (características) propios de cada tipo de motor y listo, dependiendo de lo que mandemos java sabrá que motor queremos iniciar.

Sobreescritura de métodos (Overriding)

La Sobreescritura es la forma por la cual una clase que hereda puede re-definir los métodos de su clase Padre, de esta manera puede crear nuevos métodos con el mismo nombre de su superClase.

Es decir, si tengo una clase padre con el método ingresar() yo puedo crear en la clase hija un método que también se llame ingresar() pero implementándolo según lo que necesite (siguiendo obviamente unas reglas que veremos mas adelante) a esto se le llama sobreescritura.

Y para que? si cuando se hereda se pueden usar los métodos de la superClase sin tener que declararlos otra vez, entonces porque sobreescribirlos?

Esta pregunta es muy común, la respuesta es que también depende de lo que queremos hacer, si lo que queremos es extender una funcionalidad por medio de la herencia y si bien, en la clase padre existe el método ingresar(), el método y la lógica que tenga es propia de esa clase, si yo quiero vincularle algo mas a ese método pero que sea especifico para la clase hija, no podría, ya que tendría que modificarlo en la clase padre y de esta manera ya se perdería el enfoque como tal, pues dicha funcionalidad sería común para todas las clases hijas que hereden de la superClase.

Por la razón anterior, la sobreescritura nos permite extender la funcionalidad de un método heredado para hacerlo especifico a lo que necesitemos, pudiendo implementar la lógica que queramos en nuestras clases hijas para el mismo método.

Y cuales son las reglas?

Así como en la sobrecarga nos fijamos en los parámetros, en la sobreescritura nos debemos fijar en que la estructura del método sea igual a la de su superClase, no solo el mismo nombre sino el mismo numero de argumentos y tipo de retorno (o al menos un subtipo de este), así como no tener un nivel de acceso mas restrictivo que el original (que en la clase padre sea protected y en la hija sea private por ejemplo) tampoco se pueden sobreescribir métodos static ni final. (ya que static representa métodos globales y final constantes.)

Algo que también debemos mencionar es que podemos identificar un método sobreescrito cuando tiene la anotación @override, esto es muy común encontrarlo cuando trabajamos con clases abstractas o interfaces, donde se obliga a implementar los métodos de estas si son heredadas o implementadas respectivamente, sin embargo no es obligatorio ponerlo pero si  es recomendable, pues de esta manera el compilador reconoce que se están sobreescribiendo los métodos ayudando a que si nos equivocamos al crear un método distinto, el compilador nos avisaría. Adicionalmente si tenemos la anotación inmediatamente podremos saber que se está aplicando el concepto, algo muy útil cuando trabajamos con código de otras personas.

Veamos un ejemplo donde se sobreescribe el método tocar()

Public class Instrumento{
        public String tipo;
 
        public abstract void tocar() {
                System.out.println("Tocar un Instrumento");
        }
}
 
 
class Guitarra extends Instrumento {
        @Override        
        public void tocar() {
                System.out.println("Tocar La Guitarra");
        }
}

Como vemos la clase Guitarra hereda de la clase Instrumento, esta ultima tiene el método tocar() con una implementación diferente a la del método en la clase Guitarra (el mensaje es distinto), al tener la anotación @Override nos damos cuenta que se está sobreescribiendo dicho método y se le puede dar la lógica que queramos especifica para la clase Guitarra.

Ingresar a uno u otro método depende de la lógica del llamado, también es algo muy ligado al polimorfismo donde por medio de este se puede acceder a uno u otro método, por ejemplo si queremos acceder al método tocar() de la clase guitarra aplicando la sobreescritura y el polimorfismo tendríamos que hacer una instancia de la clase padre con un objeto de la clase hija así:

Instrumento miGuitarra=new Guitarra();
miGuitarra.tocar();

con esto accederíamos al método tocar de la clase guitarra.

Conclusiones!!!

Como pudimos ver los 2 conceptos son muy similares pero con enfoques totalmente diferentes, en sí el concepto como tal no es confuso y a medida que se va conociendo de a pocos su aplicación tampoco lo será.

Y Listo!!!!! con esto vimos a nivel general lo que representan la sobrecarga y sobreescritura de métodos, recuerden que la forma de dominarles es la práctica y ver su comportamiento con diferentes ejercicios.

Fuente: codejavu

Saludos

Saludos

Buenas a todos!!!

Para entender un poco este concepto veamos un ejemplo:

"Una fábrica de juegos de PC desea modelar un sistema de selección aleatoria de Jugadores (RandomSelector). Dado que la selección aleatoria se usa en muchos y variados juegos (p.e: selección aleatoria de números, de cartas, de colores, de fichas, etc.) se detallo que el RandomSelector debería ser diseñado de tal forma que se pueda usar con cualquier tipo de objetos.
El funcionamiento debería ser el siguiente: Una vez creado el RandomSelector con el tipo de Objeto que va a seleccionar este permanece así. Al RandomSelector se le pueden agregar N objetos a seleccionar. Cuando se le dice selectNext() retorna un objeto seleccionado de manera aleatoria."

En java, cuando se define una nueva clase, se debe conocer el tipo de datos con el que se trabajará. Pero en este caso necesitamos que sea independiente al tipo de datos, y así poder reutilizar la clase sin necesidad de hacer alteraciones al código.
Es aquí donde entra el concepto de tipos genéricos.

La utilización seria:

public class RandomSelector<T> {

}

T es un tipo genérico que será sustituido por el tipo real cuando se instancie la clase.
Al RandomSelector se le podía agregar N objetos, vamos a necesitar hacer uso de alguna colección para ir guardando los objetos.

import java.util.ArrayList;
import java.util.Random;

public class RandomSelector<T> {

	private ArrayList<T> elementos;
	private Random rn;
	
	public RandomSelector() {
		this.elementos = new ArrayList<T>();
		this.rn = new Random();
	}

}

Verán como a la colección se le da como tipo de datos a T, el tipo genérico.
rn es de tipo Random, y nos va servir más adelante para la aleatoriedad.
Agregamos el método agregarElemento que recibe como parámetro un objeto de tipo T y lo agrega a la colección.

public void agregarElemento(T elemento) {
	this.elementos.add(elemento);
}

Por otro lado, el método selectNext retorna un elemento de tipo T, y que es el que se ubica en la posición 'x' de la colección elementos. Dichas posición 'x' se obtiene con un numero aleatorio que va desde 0 al tamaño de la colección - 1

public T selectNext() {
	return this.elementos.get(rn.nextInt(this.elementos.size()));
}

Probemos como funcionaría:

public static void main(String[] args) {
	RandomSelector<String> rS1 = new RandomSelector<String>();
	rS1.agregarElemento("Piedra");
	rS1.agregarElemento("Papel");
	rS1.agregarElemento("Tijera");
	System.out.println(rS1.selectNext());
		
	RandomSelector<Integer> rS2 = new RandomSelector<Integer>();
	rS2.agregarElemento(1);
	rS2.agregarElemento(2);
	rS2.agregarElemento(3);
	System.out.println(rS2.selectNext());
}

Usamos un primer objeto RandomSelector con T = String y uno segundo con T = Integer. Y funcionó de igual manera sin importar el tipo

Por último existen una serie de convenciones para nombrar a los genéricos:

• E – Element (usado bastante por Java Collections)
• N – Number (para números)
• K – Key (Llave, usado en mapas)
• T – Type (Representa un tipo, es decir, una clase)
• V – Value (representa el valor, también se usa en mapas)

Saludos

Lo que me motivó a escribir esta guía de colecciones en java es el inmenso tamaño del framework de colecciones que puede echar para a atrás a cualquier programador que se ponga a investigar las APIs sin ordenar un poco las ideas. Hay tantas interfaces e implementaciones que es fácil perderse y no saber que usar en cada momento.

Esta pequeña guía de colecciones en Java pretende explicar, de manera sencilla, que las colecciones en Java y que implementación sería mejor que usases para cada caso.

Este va a ser un post extenso, así que voy a ser tan amable de proporcionaros una pequeña tabla de contenidos.

1- Tipos de colecciones en java

• Listas
• Sets
• Maps
• Colas

2- Listas

• ArrayList
• LinkedList
• Vector
• CopyOnWriteArrayList

3- Sets

• HashSet
• LinkedHashSet
• TreeSet
• EnumSet
• CopyOnWriteArraySet
• ConcurrentSkipListSet

4- Maps

• HashMap
• LinkedHashMap
• TreeMap
• EnumMap
• WeakHashMap
• HashTable
• ConcurrentHashMap

5- Colas

• ArrayDeque
• LinkedBlockingDeque
• LinkedList
• PriorityQueue
• PriorityBlockingQueue

6- Diagramas de clases

• Diagrama de clases: Listas
• Diagrama de clases: Sets
• Diagrama de clases: Maps
• Diagrama de clases: Colas

7- Notas finales

Tipos de colecciones en Java

Los tipos de colecciones vienen representados por interfaces. Una serie de interfaces clasifica las colecciones de Java en los siguientes tipos:

- Listas: Una lista ordenada, o secuencia. Normalmente permiten duplicados y tienen acceso aleatorio (es decir, puedes obtener elementos alojados en cualquier índice como si de un array se tratase).
- Sets: Colecciones que no admiten dos elementos iguales. Es decir, colecciones que no admiten que un nuevo elemento B pueda añadirse a una colección que tenga un elemento A cuando A.equals(B).
- Maps: Colecciones que asocian un valor a una clave. Parecido a la estructura de "array asociativo" que se encuentra en otros lenguajes. Un Map no puede tener dos claves iguales.
- Colas: Colecciones que permiten crear colas LIFO o FIFO. No permiten acceso aleatorio, solo pueden tomarse objetos de su principio, final o ambos, dependiendo de la implementación.

Listas

La colección más básica de Java. También, es la más usada por los programadores que no han investigado el framework de colecciones a fondo por hacernos pensar que se trata de una especie de array hipervitaminado ya que hace su trabajo y es fácil de entender.

Sin embargo, por grande que sea la tentación de usar una lista (como un ArrayList) para todo, ¡has de resistir!

Sabiendo los requisitos de tu aplicación, seguramente encontrarás otra colección que haga el trabajo de una lista mejor. Procura asegurarte de que cuando vas a usar una lista es porque realmente te hace falta, no porque no conoces el resto. La diferencia de rendimiento puede ser enorme. Y cuando digo enorme, me refiero a superior a un 600% en según que operaciones.

¿Qué beneficios tienen las listas?

- Acceso aleatorio.
- Están ordenadas (Podemos usar Colections.sort() para ordenar los elementos siguiendo el criterio que queramos).
- Podemos añadir / eliminar elementos sin ninguna restricción.
- Tienen un iterador especial ListIterator que permite modificar la lista en cualquier dirección.
- Siguen la notación de los arrays, por lo que son fáciles de comprender.

¿Qué problemas tienen las listas?

- Bajo rendimiento en operaciones especialziadas respecto a otras colecciones.

A continuación voy a enumerar todas las listas de Java con sus características, además, daré una pequeña explicación de cuando deberíais usar esa lista.

Tipos de Lista

• ArrayList: Muy rápida accediendo a elementos, relativamente rápida agregando elementos si su capacidad inicial y de crecimiento están bien configuradas. Es la lista que deberías usar casi siempre.
• LinkedList: Una lista que también es una cola (hablaré de esto más tarde). Más rápida que ArrayList añadiendo elementos en su principio y eliminando elementos en general. Utilízala en lugar de ArrayList si realizas más operaciones de inserción (en posición 0) o de eliminación que de lectura. La diferencia de rendimiento es enorme.
• Vector: Terreno peligroso. Vector es una colección deprecated (obsoleta), así que usadla únicamente si necesitáis un ArrayList concurrente. El rendimiento de Vector es superior al de Collections.syncronizedList(new ArrayList()).
• CopyOnWriteArrayList: Colección concurrente que es muy poco eficiente en operaciones de escritura, pero muy rápida en operaciones de lectura. Usala sobre Vector (o synced ArrayList) cuando el número de lecturas concurrentes sea mucho mayor al número de escrituras.

Sets

Los sets, o conjuntos, son colecciones que por norma general no admiten elementos iguales en su interior. Como mencionaba antes, dos elementos A y B son iguales si A.equals(B).

Podemos añadir y eliminar elementos de un set, así como saber si determinado elemento está en un set, pero no tenemos acceso aleatorio, por lo que hay que tener muy claro cuando queremos usarlos.

Una colección normal, en apariencia, nos da todo lo anterior -excepto el hecho de eliminar duplicados-, así que, ¿por qué usar un Set y no una Lista?, el motivo es simple: eficiencia.

Supongamos este código:

List b = new ArrayList();
     
if (!b.contains(1))
    b.add(1);

La funcionalidad es la misma que la de set.add, pero el rendimiento es muchísimo peor, hasta el punto de que podemos tener problemas muy serios cuando añadamos muchos elementos y no queremos eso, ¿verdad?.

¿Qué beneficios tienen los sets?

- No permiten elementos duplicados.
- Implementación muy eficiente de .add para asegurarnos de que no hay duplicados.

¿Qué desventajas tienen?

- No tienen acceso aleatorio.
- Solo algunos tipos de set pueden ordenarse y lo hacen de forma poco eficiente.

¿Cuando deberíamos usar un set sobre una lista?, y ¿qué tipo de set?, veámoslo...

Tipos de Set

• HashSet: La implementación más equilibrada de la interfaz Set. Es rápida y no permite duplicados, pero no tiene ningún tipo de ordenación. Utilízala si necesitas un control de duplicados pero no ningún tipo de ordenación o acceso aleatorio.
• LinkedHashSet: Un HashSet que incluye ordenación de elementos por orden de entrada, una velocidad de iteración mucho mayor y un rendimiento mucho peor a la hora de añadir elementos. Utilizala si necesitas un Set ordenado por orden de inserción o si vas a usar un Set que vaya a realizar solamente operaciones de iteración.
• TreeSet: Un set que incluye una implementación de un árbol rojo-negro. Este Set puede ser ordenado, pero su rendimiento es mucho peor en cualquier operación (menos iteración) respecto aun HashSet. Utilizalo solo si necesitas un Set con un criterio de ordenación específico y ten cuidado con las inserciones.
• EnumSet: La mejor implementación de Set para tipos enumerados (Enum). Utilizala si quieres crear un Set de Enums.
• CopyOnWriteArraySet: Set concurrente que tiene un gran rendimiento de lectura, pero pésimo de escritura, eliminado y contains. Úsalo solo en Sets concurrentes que apenas tengan estas operaciones.
• ConcurrentSkipListSet: Set concurrente y ordenable. Utilizalo solo cuando requieras un Set ordenable (como TreeSet) en entornos de concurrencia. En Sets de tamaños muy grandes su rendimiento empeora notablemente.

Maps

Los maps son colecciones que asocian un valor con una clave. Tanto la clave como el valor pueden ser cualquier tipo de datos de Java: Objetos, primitivos, otras colecciones, etc.

Las implementaciones son muy parecidas a los Sets debido a que, internamente, utilizan un Set (la implementación varía según el tipo de Map) para garantizar que no hay elementos duplicados en las claves.

¿Que ventajas tienen los map?

- Asociación clave -> valor.
- Gracias a que utilizan internamente un Set, garantizan que no habrá dos claves iguales.
- Es fácil reconocer cuando necesitamos usar un Map.

¿Qué desventajas tienen los map?

- Rendimiento no muy elevado comparado con otras colecciones.

Tipos de Map

• HashMap: La implementación más genérica de Map. Un array clave->valor que no garantiza el orden de las claves (de la misma forma que un HashSet). Si necesitas un Map no-concurrente que no requiera ordenación de claves, este es el tuyo. Si os fijais en el código de HashSet, veréis que curiosamente utiliza un HashMap internamente.
• LinkedHashMap: Implementación de map que garantiza orden de claves por su tiempo de inserción; es decir, las claves que primero se creen serán las primeras. También puede configurarse para que la orden de claves sea por tiempo de acceso (las claves que sean accedidas precederán a las que no son usadas). Itera más rápido que un HashMap, pero inserta y elimina mucho peor. Utilizalo cuando necesites un HashMap ordenado por orden de inserción de clave.
• TreeMap: Un Map que permite que sus claves puedan ser ordenadas, de la misma forma que TreeSet. Usalo en lugar de un HashMap solo si necesitas esta ordenación, ya que su rendimiento es mucho peor que el de HashMap en casi todas las operaciones (excepto iteración).
• EnumMap: Un Map de alto rendimiento cuyas claves son Enumeraciones (Enum). Muy similar a EnumSet. Usadlo si vais a usar Enums como claves.
• WeakHashMap: Un Map que solo guarda referencias blandas de sus claves y valores. Las referencias blandas hacen que cualquier clave o valor sea eligible por el recolector de basura si no hay ninguna otra referencia al mismo desde fuera del WeakHashMap. Usa este Map si quieres usar esta característica, ya que el resto de operaciones tienen un rendimiento pésimo. Comúnmente usado para crear registros que vayan borrando propiedades a medida que el sistema no las vaya necesitando y vaya borrando sus referencias.
• HashTable: Map deprecated y concurrente. Básicamente, es un HashMap concurrente que no debes usar nunca. En su lugar, utiliza ConcurrentHashMap.
• ConcurrentHashMap: Un Map concurrente que no permite valores nulos. Sustitución básica de HashTable. Usala si necesitas un HashMap concurrente.

Colas

Las colas son estructuras que ofrecen un gran rendimiento al obtener elementos de su principio o de su final, representando colas LIFO / FIFO, aunque también veremos colas ordenadas en función de otros criterios.

Deberás usar una cola cuando vayas a recuperar siempre el primer o último elemento de una serie. Se usan para implementar las mencionadas colas LIFO / FIFO, así como colas de prioridades (como puede ser un sistema de tareas o de procesos).

Cabe destacar que hay dos tipos de colas, Queues y Deques. Las primeras solo proporcionan métodos para acceder al último elemento de la cola, mientras que las Deques permiten acceder a cualquiera de los dos extremos.

¿Qué ventajas tienen las colas?

- Ofrecen un gran rendimiento al recuperar el primer o último objeto de la cola.
- Permiten crear estructuras LIFO / FIFO o colas de prioridades con muy buen rendimiento.

¿Qué desventajas tienen las colas?

- La iteración por las colas suele ser muy lenta.
- El acceso aleatorio, de la misma manera, es muy lento.

Tipos de colas

• ArrayDeque: Una implementación de Deque de rendimiento excepcional. Implementa tanto cola LIFO como FIFO al ser una Deque y es la Cola que deberías usar si quieres implementar una de estas dos estructuras.
• LinkedBlockingDeque: Una Deque concurrente que has de usar cuando quieras usar un ArrayDeque en entornos multihilo.
• LinkedList: LinkedList, anteriormente mencionada en la sección de listas, también es una Deque, sin embargo, su rendimiento es muy inferior al de ArrayDeque. No deberías usar LinkedList cuando quieras usar una cola.
• PriorityQueue: Una cola que se ordena mediante un Comparator, permitiendo crear una Cola donde el primer elemento no dependerá de su tiempo de inserción, sino de cualquier otro factor (tamaño, prioridad, etc). Deberemos usarlo cuando necesitemos este comparator, ya que ArrayDeque no lo permite.
• PriorityBlockingQueue: La versión concurrente de PriorityQueue.

Diagramas de clases

Para entender mejor el framework de colecciones, nada como un diagrama de clases de todas los tipos de colección. He aquí dicho diagrama, por cortesía de No tienes permitido ver los links. Registrarse o Entrar a mi cuenta:

Diagrama de clases – List


Diagrama de clases – Set


Diagrama de clases – Maps


Diagrama de clases – Colas


Notas finales

A la hora de usar colecciones en Java, lo más importante es elegir el tipo de colección. Cuando trabajemos con colecciones, siempre declararemos las instancias con el nombre de su interfaz, aprovechando el enlace dinamico.

De esta forma, aunque la implementación cambie en el futuro, podemos tener claro que la aplicación no va a dar fallos (ya que estamos usando las interfaces y estas tienen los métodos que usan sus implementaciones).

A la hora de escoger la implementación de cada tipo de colección, debéis fijaros en dos cosas:

- Si estamos trabajando en un entorno concurrente o no.
- En el rendimiento de las operaciones que vamos a necesitar en las distintas implementaciones válidas para nuestro entornos (concurrentes o no).

Sabiendo eso ya podréis empezar a explotar a fondo el Framework de colecciones en Java y no limitaros a usar las colecciones Vanilla, mal de muchos programadores que empiezan en este lenguaje.

Confío en que la lectura haya sido interesante y fructífera, para mi lo ha sido, por lo menos.

Fuente: luaces-novo

Saludos

Escrito por: Macario Polo y Daniel Villafranca

Contenido:

Introducción a la tecnología WEB con J2EE
Introducción a JSP
EJBs
Algunos ejemplos
Ejercicios prácticos

Descarga: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Saludos

Voy a crear una aplicación WEB con Java desde cero usando Eclipse

Es necesario tener un servidor web o de aplicaciones a la mano para poder ejecutarlo, puede ser tan simple como un Tomcat, o si gustan un JBoss, Glassfish, o en mi caso como trabajo diariamente con el Oracle WebLogic.

La idea de esto es que puedan ver paso a paso como se crea la aplicación WEB, como se crea un Servlet(Una aplicación puede tener infinidad de estos), como sobreescribir los métodos de acción doGet y doPost y como llamar la ejecución de estos.

Paso 1. crear el proyecto


Paso 2. Definir el nombre del proyecto y el servidor en el cual este se deploya


Paso 3: Si se requiere algún otro directorio con archivos .class este seria el momento ideal para hacerlo, se puede hacer después , no hay ningún problema


Paso 4: Pongamole un contexto a nuestra aplicación, en mi caso el contexto será /MiAplicacionWeb


Bueno con esto nuestro proyecto WEB ya esta listo ahora vamos a probarlo.
No pongo como crear un paquete pero metí un paquete llamado servlets en mi carpeta de src.
Ahora vamos a crear el Servlet.

Paso 1: Busco en el menú desplegable la creación de mi servlet.


Paso 2: Indico el nombre de la clase que ejecutará el Servlet


Paso 3: El Mapéo del Servlet, osea como lo voy a llamar desde mi explorador


Paso 4: ¿Qué métodos ejecutará mi Servlet? Bueno lo normal es un doGet y un doPost. Solo por cultura general de las aplicaciones web, el protocolo HTTP soporta 7 métodos GET, POST, TRACE, PUT, OPTIONS, DELETE, HEAD, de los cuales tienen muchas funcionalidades pero sigamos con los nuestros GET y POST


Perfecto ya con esto esta listo nuestro mapeo de Servlet ademas de que tenemos nuestra clase con los métodos sobreescritos de doGet y doPost el doGet es para cuando entremos desde el navegador ( En mi caso No tienes permitido ver los links. Registrarse o Entrar a mi cuenta ). Además de esto ya implemente una impresión con un OutputStream de mi servlet para que pueda imprimir "Hola mundo, Servlet"

package servlets;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class MiServlet
 */
public class MiServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;

    public MiServlet() {
        super();
    }

	protected void doGet(HttpServletRequest request,
                   HttpServletResponse response)
                   throws ServletException, IOException {
              	ServletOutputStream out=response.getOutputStream();
		out.println("Hola mundo, Servlet!");
		out.flush();
		out.close();
	}

	protected void doPost(HttpServletRequest request,
                   HttpServletResponse response)
                   throws ServletException, IOException {

	}

}

Una vez llamado el servlet desde mi navegador se verá lo siguiente:


¿Sencillo verdad? Si necesitan que les explique algo mas en especifico no duden en publicar su pregunta, será respondida en cuanto la vea

Ahora unos ejemplos de uso para el método doGet y doPost:

En el caso de doGet es cuando se llama la aplicación desde la URL, este llamado puede contener parámetros la sintaxis es la siguiente

http://servidor:puerto/contextoAplicacion/Servlet?parametro1=texto1&parametro2=texto2

el símbolo ? es para iniciar los parámetros y el & es para separarlos.

En el ejemplo anterior le enviaré el siguiente parámetro:

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta Perez

Con una pequeña adaptación al método anterior:

protected void doGet(HttpServletRequest request,
			HttpServletResponse response)
					throws ServletException, IOException {

        //getParameter() es para obtener los parametros ingresados desde
        //Una URL o por POST, no confundir con getAttribute(String,Object)
        //este método es para obtener datos previamente guardados

	String usuario=(String)request.getParameter("usuario");
	ServletOutputStream out=response.getOutputStream();
	out.println("Hola " + usuario);
	out.flush();
	out.close();
}

Llamando la URL tal cual como la tengo arriba tengo el siguiente resultado:


Ahora un ejemplo con el método doPost, para esto necesitamos a fuerzas crear un formulario que sea capaz de enviar por método POST
para su comodidad ya tengo un HTML hecho, solo descarguenlo No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Ahora, acabo de adaptar el servlet de la siguiente manera:

protected void doPost(HttpServletRequest request,
			HttpServletResponse response)
					throws ServletException, IOException {
	String usuario = (String) request.getParameter("usuario");
	String password= (String) request.getParameter("password");
	ServletOutputStream out = response.getOutputStream();

	if (password.equals("12345678")){
		out.println("Bienvenido: " + usuario);
	}else{
    		 out.println("El password es invalido intentelo de nuevo");
	}
	out.flush();
	out.close();
}

Cuando ingreso el usuario "Carlos" y un password diferente a 12345678 tengo el siguiente resultado:


Cuando ingreso el usuario "Carlos" y el password "12345678″


Señoras y señores todo por el momento, estaré escribiendo pronto, espero les sea de utilidad este artículo.

Fuente: desarrolloinnovador

Saludos

Indice:

Guia para ser un buen estudiante de sistemas: Las 12 reglas del aprendiz de hacker
Sobre el reporte del bug #56883 en apache 2 .4 y otros conflictos sobre Ubuntu 14.04
Novedades sobre JackTheStripper y EuropioCode
Tui: Text User Interfaces en GNU/Bash y Python
Python web sin frameworks: sobre las sesiones y el acceso restringido

Descarga: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Fuente: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Saludos

JRuby es una implementación 100% Java del lenguaje de programación Ruby. Básicamente es un intérprete de Ruby escrito en Java y que se ejecuta sobre la máquina virtual. Es una de las tantas implementaciones, de las más completas.


Actualmente Ruby se encuentra en su versión 1.9.2, y la implementación oficial (la más usada – Matz's Ruby Interpreter o MRI) se toma como referencia para la especificación del lenguaje. Esta versión de Ruby corre sobre una máquina virtual específica de Ruby, y está escrita en C. JRuby soporta completamente Ruby 1.8, y se está trabajando en la compatibilidad con 1.9.2. Además de estas dos implementaciones existen también MacRuby (Ruby en Mac OS X), Rubinius, y otras.

La madurez de una implementación es medida (segun Wikipedia) por su habilidad de ejecutar Ruby On Rails. Este punto se denomina la singularidad Rails. Para tener una referencia de la madurez de JRuby, en mayo de 2010 solamente la MRI y JRuby eran capaces de ejecutar Rails sin modificaciones en un ambiente de producción.

¿Porqué JRuby?

No recuerdo cuándo leí por primera vez sobre JRuby, pero esta fue la primer pregunta que vino a mi cabeza. No me terminé de convencer de su utilidad hasta que fui a RubyConf Uruguay.

El tema es que JRuby es solo Ruby, pero no es solo Ruby. Se ejecuta sobre la JVM, que tiene bastante trabajados y aceitados varios aspectos de una máquina virtual como el Garbage Collector. Además, tenemos a disposición las miles de herramientas y bibliotecas ya maduras en el ambiente Java, y la integración con todos los demás lenguajes que corren sobre la JVM. Agregarle a eso la cantidad de plataformas en las que puede correr (y la concurrencia).

En resumen, podemos programar en Ruby dentro del ambiente Java, con todas las ventajas que esto nos aporta.

Usando JRuby

Instalarlo es trivial, en mi caso simplemente usé yaourt para descargar e instalar el paquete, pero pueden visitar el sitio web para descargarlo y ver instrucciones de instalación: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Una vez hecho esto, podemos ejecutar código Ruby con JRuby, o escribir un híbrido Ruby Java. Un ejemplo que Charles Nutter – uno de los lead developers y gran evangelista de JRuby – dió en la RubyConf fue levantar un JFrame con JRuby. Es un código bien sencillo, pero en mi caso fue como el golpe que me hizo dar cuenta que se "programa Ruby con Java" (no sé si me explico, en fin, dejo a libre interpretación):

#Usar Java
require "java"
 
#Importar las clases Java requeridas:
include_class javax.swing.JFrame
include_class javax.swing.JLabel
 
#Crear Frame y agregar etiqueta:
f = JFrame.new 'Ventana - JRuby'
f.setSize 400,400
l = JLabel.new 'Hola mundo desde JRuby'
f.add l
f.show

No hay que olvidar además que podemos hacer uso de Ruby On Rails y desplegarlo junto a otras aplicaciones web en un servidor Java como Tomcat.

JRuby 1.6

Esta entrada fue motivada por el lanzamiento de JRuby 1.6.0 RC1. Se trata de uno de los hitos más importantes para JRuby debido a varias razones. Llevó 9 meses de trabajo y algunas de las características destacadas son la compatibilidad con Ruby 1.9, mejoras en el rendimiento y soporte para Windows.

Respecto a la compatibilidad con el lenguaje y la API de Ruby 1.9.2, está casi terminada. Faltan algunas pocas cosas por implementar antes de la versión final. El rendimiento de las llamadas a métodos Ruby ha sido mejorado, reduciendo sustancialmente los tiempos, además de muchas optimizaciones en respuesta a reportes de los usuarios.

Otras mejoras a destacar:

• Profiler Gráfico incorporado
• Cambios en RubyGems – Actualización a RubyGems 1.4.2 y otros cambios
• Soporte experimental para API de extensión de C
• Preview de soporte RubyGems para Maven
• Compatibilidad y experiencia de usuario mejorada en Windows

Además de todo esto, se hicieron más de 2000 commits y se resolvieron 265 problemas. El desarrollo de esta versión contó con la mayor cantidad arreglos, revisiones y contribuciones de usuarios hasta el momento.

Con todo esto podemos suponer que JRuby está creciendo, y seguirá así por un buen tiempo. Ya presenta una alternativa interesante a Ruby en un contexto de desarrollo específico de Java.

Viniendo de desarrollar en Java y queriendo desarrollar en Ruby, mirar JRuby es como un puente entre ambas. Todavía tengo fijada la idea de aprender Ruby, pero JRuby presenta una oportunidad para ir pensando en mechar Ruby con el trabajo diario en Java.

Autor: Fernando Briano
Fuente: picandocodigo

Saludos

Nos llega este interesante proyecto de la mano de No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, un framework basado en OpenGL escrito en python que nos permite hacer aplicaciones desktop, IOS, Windows y tambien Android.

Hace poco vimos cómo compilar con el SDK de Android desde otro lenguaje que no sea Java, por ejemplo desde No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.
Ahora con  No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, que es a la vez un framework y un toolkit como PythonQT o como el GTK+ toolkit de Gnome, podemos crear botones, animaciones, elementos visuales desde Python.

Mathieu Virbel, leader programmer de Kivy nos publica hace pocos días este script en Python que permite compilar desde python con el toolchain de Android y de esta forma  obtener un APK para Android.

Introducción: Instalación del Framework Kivy

En nuestro caso no es necesario instalar a kivy, el script de No tienes permitido ver los links. Registrarse o Entrar a mi cuenta nos descaraga directemente el framework de Kivy.

Solo instalamos Kivy para tener los ejemplo Demo a Compilar, no es necesario tenerlo instalado se puede saltar al siguiente paso.

En Mac os, es simple uno se puede bajar el archivo No tienes permitido ver los links. Registrarse o Entrar a mi cuenta para snow Leopard y lo instala como de costumbre, esto instalará todas las dependencias de Python OpenGL

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

[update] En Ubuntu, para instalarlo desde apt-get:

sudo apt-add-repository ppa:kivy-team/kivy
sudo apt-get install python-kivy

Para Compilar kivy desde easy_install:

Si estas en ubuntu o con Debian, se puede compilar el framework Kivy desde easy_install.

Al instalar desde easy_install, para instalarse, se requiere muchas dependencias como No tienes permitido ver los links. Registrarse o Entrar a mi cuenta que pueden ser descargadas desde pip o easy_install.

sudo apt-get install python-setuptools python-pygame python-opengl python-gst0.10 python-enchant gstreamer0.10-plugins-good cython python-dev build-essential mesa-common-dev libgl1-mesa-dev libgles2-mesa-dev

sudo pip install Cython==0.17.1

sudo easy_install pyrex

sudo easy_install kivy

Aqui inicia el paso para Python-For-Android ...

Instalación del NDK y del SDK de Android

Descargar los ejemplos demos:

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Descargar y descomprimir el SDK y el NDK de Android en una carpeta opt.

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Luego hay que bien configurar los Paths del SDK y del NDK. Con un Export de ANDROIDSDK y ANDROIDNDK.

vi ~/.bashrc

export ANDROIDSDK="/opt/android-sdk-linux_86″
export ANDROIDNDK="/opt/android-ndk-r8″
export ANDROIDNDKVER=r8
export ANDROIDAPI=14

Debes estar seguro que tenes el PATH del SDK y del NDK en tu PATH, podes comprobar esto con un simple echo $PATH, sino agregalos a tu archivo .bashrc
cuando ya terminaste con las variables env, para tomar las variables en tu shell, ejecutas:

source ~/.bashrc

Si no tenés instalado en Ubuntu el git core build essentials Tambien hay que hacerlo:

sudo apt-get install build-essential patch git-core ccache

y vas a necesitar también No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, que es a la vez un lenguaje y una extension para usar librerias en C desde Python:

sudo pip install Cython==0.17.1

Instalación del script python-for-android

Con un simple Clone del proyecto desde github:

git clone git://github.com/kivy/python-for-android.git

Ahora creamos una distribución de la toolchain de Android incluyendo al modulo de Kivy.

./distribute.sh -m "kivy"

Y ya tenemos nuestra toolchain lista para compilar un script en Python que va a generar un APK. Buscamos la carpeta dist y buscamos un ejemplo a compilar.

Podemos mirar el codigo del ejemplo del touchtracer que está en los ejemplos demo de Kivy.

$ vi kivydemo-for-android/touchtracer/main.py

import kivy
kivy.require('1.0.6')
 
from kivy.app import App
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.label import Label
from kivy.graphics import Color, Rectangle, Point, GraphicException
from random import random
from math import sqrt
 
 
def calculate_points(x1, y1, x2, y2, steps=5):
    dx = x2 - x1
    dy = y2 - y1
    dist = sqrt(dx * dx + dy * dy)
    if dist < steps:
        return None
    o = []
    m = dist / steps
    for i in xrange(1, int(m)):
        mi = i / m
        lastx = x1 + dx * mi
        lasty = y1 + dy * mi
        o.extend([lastx, lasty])
    return o
 
 
class Touchtracer(FloatLayout):
 
    def on_touch_down(self, touch):
        win = self.get_parent_window()
        ud = touch.ud
        ud['group'] = g = str(touch.uid)
        with self.canvas:
            ud['color'] = Color(random(), 1, 1, mode='hsv', group=g)
            ud['lines'] = (
                Rectangle(pos=(touch.x, 0), size=(1, win.height), group=g),
                Rectangle(pos=(0, touch.y), size=(win.width, 1), group=g),
                Point(points=(touch.x, touch.y), source='particle.png',
                      pointsize=5, group=g))
 
        ud['label'] = Label(size_hint=(None, None))
        self.update_touch_label(ud['label'], touch)
        self.add_widget(ud['label'])
        touch.grab(self)
        return True
 
    def on_touch_move(self, touch):
        if touch.grab_current is not self:
            return
        ud = touch.ud
        ud['lines'][0].pos = touch.x, 0
        ud['lines'][1].pos = 0, touch.y
 
        points = ud['lines'][2].points
        oldx, oldy = points[-2], points[-1]
        points = calculate_points(oldx, oldy, touch.x, touch.y)
        if points:
            try:
                lp = ud['lines'][2].add_point
                for idx in xrange(0, len(points), 2):
                    lp(points[idx], points[idx+1])
            except GraphicException:
                pass
 
        ud['label'].pos = touch.pos
        import time
        t = int(time.time())
        if t not in ud:
            ud[t] = 1
        else:
            ud[t] += 1
        self.update_touch_label(ud['label'], touch)
 
    def on_touch_up(self, touch):
        if touch.grab_current is not self:
            return
        touch.ungrab(self)
        ud = touch.ud
        self.canvas.remove_group(ud['group'])
        self.remove_widget(ud['label'])
 
    def update_touch_label(self, label, touch):
        label.text = 'ID: %s\nPos: (%d, %d)\nClass: %s' % (
            touch.id, touch.x, touch.y, touch.__class__.__name__)
        label.texture_update()
        label.pos = touch.pos
        label.size = label.texture_size[0] + 20, label.texture_size[1] + 20
 
 
class TouchtracerApp(App):
    title = 'Touchtracer'
    icon = 'icon.png'
 
    def build(self):
        return Touchtracer()
 
    def on_pause(self):
        return True
 
if __name__ in ('__main__', '__android__'):
    TouchtracerApp().run()

Nos posicionamos en la carpeta de dónde se encuentra el build, resultado de nuestra compilación.

cd dist/default

Luego lanzamos la ejecución del build:

./build.py --package org.test.touchtracer --name touchtracer --version 1.0 --dir ~/code/kivydemo-for-android/touchtracer debug

y tenemos un BUILD SUCCESSFUL

Se encuentra el resultado en un apk compilado que esta en la carpeta bin/. Lo instalamos con un simple adb install.
Aqui esta el resultado del No tienes permitido ver los links. Registrarse o Entrar a mi cuenta en el Market de Android.

[update] el APK se ejecutará normalmente en dispositivos android que soportan GPU, OpenGPL 2.0 ES, y android Froyo minimo. Para ver si su dispositivo puede correr Kivy Python, prueban correr antes el No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Si queremos empezar con nuestro propio proyecto:
   

if __name__ in ('__main__', '__android__'):
    YourApp().run()

Y si queremos empezar ahora con un simple tutorial, les dejo este: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

La doc del No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Github del proyecto: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta para hacer el clone.

Fuente: androidda

Saludos

Es un gran libro sobre patrones de diseño. Esta en ingles pero es muy bueno.

Descarga: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Saludos

Los lenguajes de programación esotéricos son lenguajes minimalistas, creados como prueba de concepto y/o reto, tanto para programar el lenguaje como para escribir para él. Veamos un repaso de algunos de ellos:

Brainfuck

Es el más conocido y el más popular, su sintaxis es bastante simple:

++++++++++
 [          Bucle para iniciar las memorias (se repite 10 veces)
    >+++++++>++++++++++>+++++++++++>+++>+<<<<<-
       70        100       110      30  10
 ]
 >++.              'H'   (72) 1
 >>+.              'o'  (111) 3
 ---.              'l'  (108) 3
 <---.             'a'   (97) 2
 >>++.             espacio (32) 4
 <+.               'm'  (109) 3
 ++++++++.         'u'  (117) 3
 -------.          'n'  (110) 3
 <+++.             'd'  (100) 2
 >+.               'o'  (111) 3
 >+.               '!'   (33) 4
 >.                '\n' (10) 5

Para explicar su sintaxis lo mejor es recurrir a otros lenguajes de programación. Así, en No tienes permitido ver los links. Registrarse o Entrar a mi cuenta nos proveen de esta tabla de equivalencias, en las que ptr equivale a un unsigned char:


Ook !

Está basado en el anterior, pero utiliza en su lugar la combinación de palabras Ook?, Ook! y Ook. Es una parodia del bibliotecario de Mundodisco, que es transformado en orangután y solo puede pronunciar esas tres palabras. Veamos un cacho de código.

Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook. Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook. Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook? Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook? Ook. Ook? Ook. Ook. Ook! Ook. 

Supuestamente este "programa" lo que hace es escribir el típico "hola mundo".

Befunge

En mi opinión el más original de todos, su estructura de control de flujo se basa en flechas que le dicen al programa dónde ir. Además, facilita mucho la creación de código mutante (código que se modifica a sí mismo):

vv  <      <
    2
    ^  v<
 v13v4
    ^   ^
>  >?>  ?>5^
    v   v
 v97v6
    v  v<
    8
.  >  >   ^
^<

El código de arriba se trata de un generador de números aleatorios infinito, que generará un número entre el 1 y el 9. Bastante más legible que los anteriores.

Malbolge

Aquí tenemos a un lenguaje de programación creado para ser irritante e ilegible (no, no es C, y no, tampoco es Perl). Se trata de Malbolge, cuyo nombre proviene del 8º circulo del infierno de La Divina Comedia. Aquí tenemos un "hello world" (o eso me han contado que es):

(=<`:9876Z4321UT.-Q+*)M'&%$H"!~}|Bzy?=|{z]KwZY44Eq0/{mlk**
 hKs_dG5[m_BA{?-Y;;Vb'rR5431M}/.zHGwEDCBA@98\6543W10/.R,+O<

Lolcat

Una simple broma. Veamos su código:

HAI
CAN HAS STDIO?
I HAS A VAR
IM IN YR LOOP
   UP VAR!!1
   VISIBLE VAR
   IZ VAR BIGGER THAN 10? KTHX
IM OUTTA YR LOOP
KTHXBYE

Dado que es bastante más legible que los lenguajes de programación anteriores, dejaré que adivinéis que es lo que se supone que hace.

INTERCAL

Y por ultimo , pero no menos irritante tenemos a una parodia del lenguaje de programación FORTRAN . INTERCAL. Y aquí el hola mundo .

DO ,1 <- #13
PLEASE DO ,1 SUB #1 <- #238
DO ,1 SUB #2 <- #108
DO ,1 SUB #3 <- #112
DO ,1 SUB #4 <- #0
DO ,1 SUB #5 <- #64
DO ,1 SUB #6 <- #194
DO ,1 SUB #7 <- #48
PLEASE DO ,1 SUB #8 <- #22
DO ,1 SUB #9 <- #248
DO ,1 SUB #10 <- #168
DO ,1 SUB #11 <- #24
DO ,1 SUB #12 <- #16
DO ,1 SUB #13 <- #162
PLEASE READ OUT ,1
PLEASE GIVE UP

Bueno , y eso es todo .

He de decir que algunos de estos lenguajes de programación son muy útiles para aprender sobre algunos conceptos informáticos. Por ejemplo, Brainfuck es perfecto para aprender sobre los punteros.

Fuente: desdelinux

Saludos

Una DLL (Dynamic Library Link) o biblioteca de enlace dinámico, es un archivo que contiene bloques de código (funciones o métodos) que se ejecutan por solicitud de algún programa, es en ese momento cuando se carga en memoria.

Diferentes programas pueden utilizar simultáneamente una misma DLL, debido a su esquema modular. Por ello, la desinstalación de un programa podría afectar a otras aplicaciones que hicieran uso de bibliotecas compartidas.


El archivo DLL utilizado para este análisis, fue creado como prueba de concepto (PoC) con algunas acciones maliciosas que son comunes. A continuación, se muestra que el archivo "malicious.dll", efectivamente corresponde a una biblioteca de enlace dinámico con ayuda del comando "file" para Windows.


Con la herramienta "CFF Explorer" se puede obtener información importante como: el lenguaje de programación con el cual fue creado el archivo, su tamaño en bytes, sus firmas md5/sha1, el nombre original del archivo, entre otros.

Para el archivo "malicious.dll" se muestra la siguiente información:


Es recomendable que, así como a los archivos ejecutables sospechosos, a las DLLs maliciosas también se les realice un análisis de cadenas, con el fin obtener más información. En este caso, utilizando "BinText", se puede apreciar que manda a llamar la interfaz de línea de comandos de Windows con el argumento "C:\WINDOWS\system32\calc.exe", lo cual es un indicio de que la DLL contiene código que ejecutará el binario de la calculadora de Windows.


Al desensamblar la DLL con "IDA Pro", se puede corroborar que, una vez que se inyecta en un proceso, se ejecuta "calc.exe". La llamada al sistema "ShellExecuteA" lleva a cabo una operación en un archivo específico, en este caso, abrir la calculadora de Windows.


A diferencia de los programas ejecutables, no se puede hacer doble clic sobre los archivos DLL para correrlos, puesto que no son una entidad autónoma, por lo cual requieren de un proceso para operar. Los sistemas operativos Windows cuentan con una utilería llamada "rundll32.exe" (versión de 32 bits) para ejecutar archivos DLL. Sin embargo, las acciones maliciosas serán atribuidas al proceso "rundll32.exe", por lo que, si se utiliza "ProcessMonitor" para dar seguimiento a las acciones de la DLL maliciosa, el filtro por nombre del proceso deberá ser para "rundll32.exe".

A continuación se muestra el árbol de procesos:


También, puede presentarse un problema al correr una DLL con el comando "rundll32.exe", si es que la biblioteca de enlace dinámico valida el proceso en cual debe ser inyectada. Una solución podría ser renombrar la utilería "rundll32.exe" por el nombre del proceso objetivo, lo cual implicaría hacer una inspección más a fondo en su código ensamblador.

La inyección de DLLs, es la inserción de código de las bibliotecas de enlace dinámico en el espacio de direcciones de algún proceso, para que se pueda ejecutar. En nuestro laboratorio, utilizaremos la herramienta "DLL_Injector.exe" programada en Visual Basic y la herramienta "DLL_Shot.exe" programada en C#, ambas desarrollada por el equipo de análisis de malware.

·         DLL_Injector: herramienta de interfaz gráfica para inyectar una o varias DLLs en un proceso.


·         DLL_Shot: herramienta de interfaz gráfica para identificar las DLLs activas inyectadas tanto en el proceso del malware como en otros procesos objetivo. Lo anterior, es mediante la comparación de las bibliotecas de enlace dinámico activas en el sistema, antes y después de la ejecución de malware o inyección de DLLs.


Para analizar la DLL iniciamos las herramientas de monitoreo: "Process Explorer", "TCPView", "Regshot", "DLL_Injector" y "DLL_Shot".


1 ) Ejecutar el programa en el cual se inyectará la DLL maliciosa, por ejemplo en el "Bloc de notas"


2 ) Listar los procesos en el sistema, desde la herramienta "DLL_Injector", con el botón "List" y seleccionar el proceso objetivo


3 ) Buscar la DLL maliciosa con el botón "Browse ..."


4 ) Tomamos el primer shot, tanto con la herramienta "Regshot" como con la herramienta "DLL_Shot"


5 ) Inyectar la DLL en el proceso objetivo con el botón "Inject"


6 ) Observar la actividad de los procesos


7 ) Observar la actividad de red


8 ) Tomar el segundo shot de las herramientas del paso 4


9 ) Comparar resultados


10 ) Analizar resultados

- En el paso 6, la actividad de procesos muestra que a partir del proceso "notepad.exe" troyanizado se levanta el proceso "calc.exe".

- En el paso 7, el proceso troyanizado abre el "puerto local 50500" en modo escucha, lo cual es un indicio de "Backdoor" (puerta trasera).

- En el paso 9, la actividad en el sistema de archivos fue la creación de una carpeta y un archivo con extensión "txt". En cuanto a las DLLs, se aprecia que el archivo "malicious.dll" se inyectó correctamente en el proceso "notepad.exe" y también se muestra la DLL "netcfgx.dll" cargada por el proceso "svchost.exe", la cual tiene como descripción Network Configuration Objects (objetos de configuración de red), que involucra protocolos de red y es compartida por varias aplicaciones de Windows.

Finalmente, una forma de verificar si el puerto local 50500, que fue abierto en modo escucha, tiene un shell asociado, es utilizando desde otro equipo el comando "telnet". A continuación se muestra la obtención del "cmd" de Windows:


Se establece una conexión de red al puerto 50500 desde un equipo Linux y otra instancia del proceso troyanizado se queda en modo escucha:


Fuente: malware.unam

Saludos

Buenas a todos!!!!

Tengo una aplicación desarrollada en Django, que utiliza una bd para controlar usuarios y una conjunto de información sobre un tema determinado.
Que consideraciones "básicas" de hardware tendría que tener para la máquina en la que se aloje?
Puse "básicas" porque se que depende también de las visitas que vaya a tener y demás, pero me gustaría saber si tengo que tener alguna consideración especial al ser Django.

Saludos

PyMerc es una aplicación que busca equipos en la red utilizando la API de nmap (python-nmap) para Python realizando un barrido ping. Una vez encuentra equipos los almacena en una base de datos sqlite que permite su futura edición para asignar nombres a cada equipo encontrado en función de su MAC.
Con los datos almacenados estos pueden ser mostrados por la terminal o bien lanzar un servidor web con el framework Bottle para ver los resultados desde el navegador.

Capturas:


Descargar: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Fuente: 0verl0ad

Saludos

 A estas alturas todos sabemos que la plataforma Android es un auténtico caldo de cultivo para el malware por diversos motivos:

• Escasos controles en el momento de la publicación de aplicaciones en Google Play
• Ventanas de tiempo entre publicación de malware y su eliminación que permiten obtener un beneficio de estas actividades ilícitas
• Facilidad de distribución de aplicaciones a través de métodos alternativos a los canales oficiales
• Necesidad de una mayor granularidad en los permisos
• Un muy largo etcétera...

Pero de esta situación también podemos sacar algo positivo, donde reina el malware nosotros tenemos campo donde investigar, así que vamos a dedicar unas líneas a construir un entorno de análisis para jugar con el malware además de con todo tipo de aplicaciones Android.

Descripción del entorno

Con la idea de tener controlado el comportamiento de la aplicación a analizar vamos a crear un entorno repetible (a través de backups), en un dispositivo sobre el que tengamos pleno control (debe estar rooteado) y enrutando las comunicaciones que genere por una máquina que nos permita su análisis (utilizando iptables, wireshark y burp).

De forma gráfica el escenario que vamos a recrear es el siguiente:


Y para crear este entorno partiremos de los siguiente pre-requisitos:

• Tener un dispositivo rooteado donde hacer las pruebas (tenéis más documentación en los foros xda-developers en inglés y htcmania en español), y aunque estoy seguro de que esto sobra decirlo, si lo vais a utilizar para el análisis de malware no utilicéis vuestros dispositivo de uso diario.
• Instalación del Android SDK (tenéis más documentación en la Web oficial de Android ).
• Red Wifi a la que conectar el dispositivo.
• Disponer de una máquina con iptables, Wireshark y Burp instalados. En el ejemplo usaré una distribución Kali.

Empecemos con la configuración del entorno.

Preparando la distribución Kali

Como vamos a enrutar el tráfico del dispositivo a la máquina Kali, lo primero será configurarla:

• Iniciamos y configuramos Burp
• En Proxy > Options, editamos el Proxy que está escuchando para que atienda a todas las interfaces:

• Actúe de forma invisible:

• Genere un certificado de CA por host:

• Exportamos el certificado de la CA de Burp codificado en DER, para ello podemos configurar el cliente Web de Kali para que pase por el proxy y acceder a una página Web por HTTPS:

• Configuramos las reglas de pre-routing con iptables que nos permitirán analizar el tráfico HTTP/HTTPS en Burp:
• echo 1 > /proc/sys/net/ipv4/ip_forward
• iptables -F
• iptables -t nat -F
• iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8080
• iptables -t nat -A PREROUTING -p tcp --dport 443 -j REDIRECT --to-port 8080
• Iniciamos Wireshark y le ponemos a la escucha en la interfaz de red por la que entre el tráfico del dispositivo

En este momento ya tenemos preparado el entorno de la máquina Kali, continuemos con el dispositivo.

Preparando el dispositivo Android

Antes de realizar el backup, vamos a hacer algunos ajustes previos en el dispositivo Android:

• Instalamos la aplicación ProxyDroid para enrutar correctamente el tráfico HTTPS a nuestra máquina de análisis de comunicaciones y la configuramos del siguiente modo:

• Importamos el certificado de la CA que habíamos exportado desde Burp, para ello lo copiamos a la SD (o memoria interna del dispositivo) y accedemos a Ajustes > Seguridad > Almacenamiento de credenciales > Instalar desde la tarjeta SD (o alamcenamiento). Tener en cuenta que estas opciones de menú pueden variar según la versión instalada de Android.
• Configuramos la Wifi en el dispositivo y establecemos como puerta de enlace la dirección IP de la máquina Kali

Con esto ya tenemos el dispositivo listo para su castigo, así que vamos a realizar un backup que poder restaurar finalizados nuestros análisis. Tenemos las siguientes opciones:

• Nandroid, os dejo un No tienes permitido ver los links. Registrarse o Entrar a mi cuenta a un tutorial.
• Herramienta adb del Android SDK:
• Para hacer backup:   adb backup -apk -shared -all -system -f C:\estado0.ab
• Para hacer restore:    adb restore C:\estado0.ab

Ya tenemos preparada la máquina Kali para capturar el tráfico y el entorno sobre el que vamos a realizar las pruebas, de modo que sólo queda activar la aplicación ProxyDroid en el dispositivo:


Y empezaremos a capturar el tráfico del dispositivo en el Wireshark y Burp de la máquina Kali:


Algunas herramientas útiles

Encontraréis de gran utilidad para la realización del análisis las siguientes herramientas:

• adb (incluida en el Android SDK)
• dex2jar
• jd-gui
• apk toolkit

Virtualizando el laboratorario

Si no disponéis de un dispositivo físico donde probar esta será vuestra mejor opción, pero incluso teniéndolo merece la pena virtualizar el laboratorio ya que os permitirá una mayor agilidad en la restauración del sistema además de facilitaros obtener el root.

Recuerdo los pasos para crear la máquina virtual y os dejo algunas indicaciones adicionales:

• Instalación y configuración de VM Android 4.3 x86 en VirtualBox:

• Rooteo completo de la VM: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta.
• Instalar una herramienta para la gestión de la ejecución con privilegios de root, por ejemplo SuperSU
• Instalar y configurar ProxyDroid y el certificado de Burp como se describía anteriormente
• Instalar un servidor FTP en la máquina Kali de análisis, por ejemplo vsftpd
• Instalar un cliente FTP en el dispositivo virtual, por ejemplo AndFTP. Configurar un perfil con el servidor de la máquina de análisis
• Crearemos una carpeta para el contenido de nuestros análisis en la SD, para ello accedemos a la terminal presionando ALT+F1 y hacemos un mkdir /sdcard/analisis
• Apagar la VM del dispositivo Android y guardar una instantánea que poder restaurar finalizado el análisis.

Finalmente utilizaremos Kali como máquina de análisis de comunicaciones y de la aplicación en sí.

Os dejo algunos trucos interesantes para manejarnos con el entorno virtualizado:

• Para controlar correctamente el ratón dentro de la VM seleccionar la opción Máquina > Inhabilitar integración del ratón
• Podéis acceder a la terminal con ALT+F1. En este modo echaréis en falta más de un símbolo, aquí tenéis el juego que utiliza.
• Podéis volver a la interfaz gráfica con ALT+F7
• Si analizáis una aplicación que gire la pantalla y cuando volváis a acceder a la HOME no se recupera la vista en horizontal, presionar 2 veces seguidas F9

• Si se queda la pantalla en negro (se ha bloqueado el dispositivo), seleccionar la opción Máquina > Apagado ACPI y se desbloqueará:

Recogiendo información

El primer paso es arrancar en la máquina Kali las aplicaciones Wireshark y Burp para inspeccionar las comunicaciones. También activamos ProxyDroid en el dispositivo virtual.

Lo siguiente que vamos a hacer es crear en el dispositivo un fichero que nos sirva de hito histórico para detectar más adelante variaciones con el comando find, de modo que presionamos ALT+F1 y escribimos touch /sdcard/analisis/instante.

Para continuar con el artículo he escogido la aplicación SMS, whatsapp, LLAMADA - SPY a la cual sólo le falta auto-declararse troyano:


Instalamos e iniciamos la aplicación. Si seguimos el proceso que indica nos pedirá que habilitemos la instalación desde orígenes desconocidos. Vemos que la cosa se anima en cuanto nos refleja todos los permisos que pide el segundo APK que quiere descargar:


Como estamos dentro de la VM podemos aceptar sin miedo, y si continuamos con el proceso que propone llegaremos a un punto en el que nos pide la dirección de correo sobre la que queremos vincular la actividad espía..., proceso que indica siempre que no hay conexión a internet, aunque sí que la haya. Sospechoso, ¿verdad?.

Finalizado el proceso anterior reiniciamos el dispositivo (para que se agarre bien el troyano) y seguimos nuestra tarea de recogida de información lanzando algunos comandos desde la terminal, para ello presionamos ALT+F1 y obtenemos algunos datos:


En resumen:

• Obtenemos el APK y todos los datos de la aplicación para analizarlos
• Obtenemos todos los ficheros modificados a partir de la fecha de creación del fichero creado antes de iniciar el análisis
• Obtenemos los procesos y conexiones activas del dispositivo

De vuelta al entorno gráfico (ALT+F7) podemos utilizar AndFTP para enviar toda la información recogida en el directorio /sdcard/analisis a la máquina Kali donde podremos analizarla con más detalle.


Además desde Burp podremos ver que la aplicación ha generado dos peticiones al dominio No tienes permitido ver los links. Registrarse o Entrar a mi cuenta:


Y desde Wireshark con File > Export objects > HTTP podremos exportar el APK descargado para su posterior análisis:


Analizando la información recuperada

Al final de la entrega anterior recuperamos cierta información que nos puede ser útil durante el resto del análisis, por ejemplo si revisamos el listado de procesos que realizamos al reiniciar el sistema tras instalar la aplicación nos encontraremos con que una nueva aplicación se ha iniciado automáticamente:


Por otro lado y a través de los ficheros modificados podemos ver los APKs instalados y como se ha descargado en la SD un paquete light.apk:


Si generamos un resumen con MD5 a los paquetes de spy2mobile y light veremos que se tratan del mismo fichero:


Y como vimos en las trazas de las comunicaciones del artículo anterior podemos deducir el proceso que ha seguido el troyano: a través de la aplicación com.supportcaptcha se realizó la descarga en la SD del paquete light.apk, que posteriormente se instaló bajo el nombre com.spy2mobile.light y el cual se inicia con el arranque del dispositivo.

Pero continuemos obteniendo información con otras herramientas.

apktoolkit

Nos sirve para extraer los recursos de la aplicación. Para usarla es necesario copiar el APK que queremos analizar en el directorio /usr/share/apktoolkit/, en nuestro caso vamos a centrarnos en el troyano que se descargó vía Internet una vez instalada la aplicación:


El resultado de esta aplicación nos permitirá inspeccionar el código smali (código ensamblador para el formato dex) sobre el que podremos localizar comportamientos anómalos a través de comandos en el sistema:



Además utilizando el explorador del sistema de ficheros podremos revisar los recursos recuperados del APK donde encontraremos las imágenes, definición de pantallas, textos, ficheros incluidos en la aplicación


Dentro de los recursos que encontraremos cabe destacar el fichero AndroidManifest.xml. donde se definen versiones, permisos, servicios, actividades... información esencial para que Android tenga conocimiento de cuándo y cómo ejecutar los componentes de la aplicación.
En el caso de la aplicación que estamos analizando podemos ver como nos hacen un all-in de permisos:


En ese mismo fichero también se reflejarán los broadcast receivers:


Como podemos ver la aplicación se declara a la escucha de llamadas salientes y del arranque del dispositivo. Cualquiera de estas dos acciones desencadenará que la clase com.source.MainReceiver gestione el evento, dato que en términos del arranque ya habíamos identificar al listar los procesos al inicio del sistema.

Herramientas d2j

Esta herramienta se utiliza de forma habitual para convertir un fichero en formato dex (los APK) en un fichero en formato jar:


Una vez realizado el paso anterior es posible decompilar el contenido del jar con las herramientas jd-gui o jad.
Es interesante comentar también que este conjunto de herramientas dispone de otras utilidades que nos permitirán:

- Modificar el contenido de un APK a través de código Jasmin.
No profundizo en esta opción ya que se escapa del objetivo del artículo, aunque podéis imaginar el uso de esta herramienta para modificar aplicaciones y publicarlas en mercados alternativos.

- Des-ofuscar código bajo un criterio establecido de forma manual.
Vamos a ver esta opción más en detalle. Primero abrimos el fichero jar generado con jd-gui:


Si exploramos las clases encontraremos que el código que nos interesa se encuentra ofuscado:


El siguiente paso será extraer los nombres de paquetes, clases, métodos y atributos para editarlos:


Modificamos su contenido para hacerlo más legible (aunque con sólo extraerlos se generarán nombres aleatorios que serán algo más sencillos de identificar que los ofuscados):



A continuación insertaremos estos nombres dentro del fichero jar y volveremos a abrirlo desde jd-gui:


El resultado que veremos será el siguiente:


sqlitebrowser

Con esta herramienta podremos ver de forma gráfica las bases de datos de tipo SQLite, de modo que lo primero que haremos será instalar el paquete en la máquina de análisis con:

apt-get install sqlitebrowser

Una vez instalada la herramienta la encontraremos en Applications > Programming > SQLite Database Browser.
El siguiente paso es disponer de la base de datos que queremos analizar, de modo que continuando con el ejemplo que teníamos entre manos vamos a intentar localizar su base de datos.

En Android lo habitual es que para gestionar las bases de datos se cree una clase que herede de la clase SQLiteOpenHelper, de modo que vamos a intentar localizar esta cadena en el código:


Tenemos una clase ganadora: com.source.b.f. Esta misma búsqueda la podemos realizar desde jd-gui para ver el código de forma más clara:


Si curioseamos esa clase nos encontraremos el siguiente método:


De modo que todo apunta a que tendremos una base de datos con nombre No tienes permitido ver los links. Registrarse o Entrar a mi cuenta, la descargamos desde su directorio por defecto (/data/data/com.spy2mobile.light/databases/) y la abrimos con sqlitebrowser:


Y aunque ya sabíamos desde el principio que estábamos analizando una aplicación para espiar el uso del dispositivo, confirmamos a través de la base de datos las múltiples tablas preparadas para capturar la información del usuario.

Conclusiones

Como veis tenemos a nuestro alcance múltiples herramientas que nos permitirán transformar la aplicación para que la podamos analizar desde distintas perspectivas, haciendo que los resultados del proceso de análisis se reduzcan a una cuestión de habilidad, experiencia y el tiempo que le queramos/podamos dedicar.

Finalmente os dejo una captura de la pinta que tiene el panel de administración Web del software espía que al final he podido configurar desde un dispositivo físico:


Artículo cortesía de Miguel Ángel García
Fuente: securitybydefault

Saludos

DEFT es una distribución Live CD muy fácil de usar, con un grandísimo listado de herramientas forenses y con una excelente detección del hardware.
No se enfoca únicamente al típico análisis forense de discos duros, si no que ofrece la posibilidad también de realizar forenses de red e incluso de dispositivos móviles.

Dentro del menú principal de la distribución, nos encontramos las siguientes categorías de herramientas incluidas:

• Analysis - Herramientas de análisis de ficheros de diferentes tipos
• Antimalware - Búsqueda de rootkits, virus, malware, así como PDFs con código malicioso.
• Data recovery - Software para recuperación de ficheros
• Hashing - Scripts que permiten la realización de cálculo de hashes de determinados procesos (SHA1, SHA256, MD5...)
• Imaging - Aplicaciones que podemos utilizar para realizar los clonados y adquisición de imágenes de discos duros u otras fuentes.
• Mobile Forensics - Análisis de Blackberry, Android, iPhone, así como información sobre las típicas bases de datos de dispositivos móviles en SQLite utilizadas por las aplicaciones.
• Network Forensics - Herramientas para procesamiento de información almacenada en capturas de red
• OSINT - Aplicaciones que facilitan la obtención de información asociada a usuarios y su actividad.
• Password recovery - Recuperación de contraseñas de BIOS, ficheros comprimidos, ofimáticos, fuerza bruta, etc.
• Reporting tools - Por último, dentro de esta sección encontraremos herramientas que nos facilitarán las tareas de generación de informes y obtención de evidencias que nos servirán para documentar el análisis forense. Captura de pantalla, recopilación de notas, registro de actividad del escritorio, etc.

Web Oficial: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Descarga: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Saludos

Eres un trabajador más del ámbito de la seguridad informática. Acabas de despertarte un domingo por la mañana y has sido alertado de un incidente de seguridad. Te diriges a la oficina para averiguar lo que ha sucedido. Empezarás a mirar el incidente en los paneles de alrededor. El IPS/IDS y las alertas WAF muestran que ha habido una aplicación o malware no deseada en el sistema. La lista de conexiones del firewall te muestra que uno de los hosts tiene conexiones inusuales hacia fuera de la red. Y por último, el antivirus muestra información sobre este host infectado. Después de estas pequeñas comprobaciones iniciales y de suponer que efectivamente tienes un bicho, lo que queda por hacer es averiguar qué tipo de malware hay en el host en cuestión y cuán malicioso es su código. Por supuesto, hay que ordenar al equipo de red y antivirus que realicen una evaluación de los daños inmediatos de la red, mientras se escanea el host infectado en un entorno aislado. ¡No está mal para un domingo por la mañana! Volverás a casa pensando que el incidente está bajo control.


¿Qué podemos hacer para proteger nuestros activos de red, recursos de red, y lo más importante, nuestros datos? Como medidas preventivas, se puede empezar por actualizar el hash de IDS para detectar el siguiente ataque de software malintencionado similar y actualizar la base de firmas del antivirus para detectarlo a nivel de host. Aparte de estas medidas, todavía tenemos que obtener más información acerca de este software malicioso, o en otras palabras, es necesario llevar a cabo un análisis de malware para averiguar el comportamiento exacto de esta pequeña y desagradable pieza de software.

¿Qué es un malware?

En primer lugar, ¿qué es un malware? ¿Podemos considerar cualquier pieza de código que no está autorizado a estar en nuestra red como un software malicioso? De forma general, podemos decir que un malware es una pieza de software capaz de realizar cualquier acción que causa algún tipo de daño a un usuario u organización, un equipo, o una red. Esto incluye pero no se limita a los virus, troyanos, gusanos, rootkits, scareware y spyware.

Si se determina que la pieza de software encontrada es perjudicial, un análisis de malware es el arte de la disección del software malicioso para entender cómo funciona, cómo identificarlo y cómo derrotarlo o eliminarlo.

Uno de los propósitos y objetivos del análisis de malware suele ser el poder proporcionar la información necesaria para responder a una intrusión en la red. Este propósito incluye el determinar exactamente lo que sucedió, y qué alcance y grado de disperesión tuvo en la red.

Al analizar los supuestos elementos de software malicioso, en primer lugar se necesita explorar lo que el archivo binario sospechoso puede hacer, cómo detectarlo en su red, y cómo medir y contener el daño. En el post de hoy hablaremos de un caso práctico con un virus educativo, el RaDa, al cual someteremos a una serie de pruebas que revelarán parte de sus intenciones.

Análisis de Malware

Configuración del entorno de laboratorio

En primer lugar, si no se dispone de un entorno de laboratorio adecuado para llevar a cabo un análisis de malware, es posible que se deban volver a examinar las opciones que se tienen, para alinear lo mejor posible los recursos disponibles con la eficacia del análisis. Como ejemplo, se puede utilizar un entorno virtual para realizar el análisis o tener sistemas físicos separados. A diferencia de los entornos virtuales, los datos pueden tener fugas en el sistema base y esto puede eventualmente perjudicar a todo el sistema. Los malware más modernos son capaces de detectar los sistemas virtuales y cambiar sus comportamientos para permanecer sin ser detectados. De todas las opciones que hemos probado, tanto VMWare como VirtualBox ofrecen buenas soluciones para el análisis de malware. Usaremos VirtualBox para nuestro análisis.

Por otra parte, tener sistemas físicos dedicados puede tener varias desventajas, tales como tener que restaurar el sistema en cada ciclo de análisis. Para ello utilizamos software libre, como la herramienta udpcast disponible para estos fines. En  caso de que tengas suficiente presupuesto, Norton Ghost proporciona características más avanzadas para hacer restauraciones del sistema.

Una vez decidido el entorno en el que se va a trabajar, el siguiente paso sería definir el acceso a la red de esos sistemas. Los malwares avanzados son capaces de detectar cambios en la dirección IP y se esconden o no revelan la información sobre la ubicación real de otros nodos o puntos de control. Estas detecciones pueden desencadenar algunas otras funciones ocultas, tales como ataque DOS al servidor interno. Por lo tanto, recomendamos entornos de red aislados con servidores virtuales que incluyen DNS propios, y servidores HTTP y de correo. En el caso de prueba adicional con conexión a internet, la red aislada puede aplicarse a través de un cortafuegos con reglas estrictas establecidas para supervisar las posibles conexiones abiertas y cerradas.

El conjunto de herramientas

Después de haber decidido y configurado el entorno de laboratorio, el siguiente paso es seleccionar un conjunto de herramientas que faciliten el proceso de análisis. Recomendamos las siguientes herramientas que pueden ser útiles en distintas etapas del ciclo de análisis, aunque hay muchas otras disponibles. Principalmente usaremos herramientas libres o gratuitas, incluidas las versiones demo de algunas herramientas comerciales.

En la siguiente sección se ofrece una breve descripción de cada herramienta que utilizamos para llevar a cabo el análisis.

OllyDbg

OllyDbg es un depurador a nivel de aplicación. La interfaz OllyDbg muestra el código ensamblador, volcado hexadecimal, la pila y registros de la CPU. OllyDbg también soporta rastreo, puntos de interrupción condicionales, visión de cabecera PE, edición hexadecimal, y plug-in de soporte.

En la primera puesta en marcha, OllyDbg pide configurar el directorio de datos del usuario (UDD) y el directorio de plug-ins. UDD se utiliza para guardar información específica de la aplicación como puntos de interrupción. Ofrece amplias opciones de depuración como la configuración de breakpoints en la carga de nuevos módulos, la creación de threads, la forma de procesar las excepciones, etc. OllyDbg soporta el establecimiento de puntos de interrupción de hardware, puntos de interrupción de software, puntos de interrupción de memoria e incluso puntos de interrupción condicionales.

IDA Pro

Al igual que OllyDbg, IDA Pro es un depurador / desensamblador a nivel de aplicación que nos ayudará enormemente en seguir la pista de la ejecución del programa. Cuenta con una versión de demo y una versión freeware más antigua, que es gratuita solo para uso no comercial.

UPX

UPX es un compresor/descompresor de código ejecutable, que logra una excelente relación de compresión y ofrece descompresión muy rápida cuidando el consumo de memoria. Una medida más que utilizan los ejecutables para ocultarse es el almacenar su código comprimido, por lo que necesitaremos una herramienta capaz de extraer el código ejecutable en claro, como UPX.

Autoruns

Esta herramienta, que cuenta con la lista más amplia de ubicaciones de inicio automático, muestra qué programas están configurados para ejecutarse durante el arranque del sistema o de inicio de sesión, y muestra las entradas en el orden en que Windows las procesa. Estos programas incluyen los de su carpeta de inicio, Run, RunOnce, y otras claves del registro. Puede configurar Autoruns para mostrar otras ubicaciones, incluidas las extensiones de shell del Explorador, barras de herramientas, objetos de ayuda del navegador, las notificaciones de Winlogon, servicios de inicio automático, y mucho más. Autoruns extiende por mucho la utilidad MSConfig incluida en Windows Me y XP.

ProcessExplore

ProcessExplore es, como su nombre indica, un explorador de procesos. Su interfaz gráfica se compone de dos subventanas; la superior siempre muestra una lista de los procesos activos, incluidos los nombres de las cuentas que poseen, mientras que la información mostrada en la inferior depende del modo en que Process Explorer esté configurado. En el modo de DLL, mostrará los archivos DLL y archivos asignados en memoria que el proceso ha cargado. Process Explorer también tiene una herramienta de búsqueda muy potente que mostrará rápidamente qué procesos tienen handlers abiertos o sus DLL cargados.

Las capacidades de Process Explorer lo hacen especialmente útil para localizar problemas de DLL – versión o pérdidas de identificadores, y para dar una idea de la forma de funcionar de Windows y otras aplicaciones.

Process Monitor

Process Monitor es una herramienta de monitorización avanzada para Windows que muestra en tiempo real actividad en el sistema de archivos, el registro, y los procesos en ejecución. Combina las características de las herramientas Filemon y Regmon, y añade una amplia lista de mejoras que incluyen el filtrado avanzado y no destructivo, las propiedades de eventos integrales tales como identificadores de sesión y nombres de usuario, pilas de threads completas con soporte para símbolos integrados de cada operación, registro simultáneo en un archivo, y mucho más. Las características de Process Monitor hacen de ella una utilidad fundamental en la solución de problemas del sistema y en el conjunto de instrumentos de caza de malware.

Active Registry Monitor

El Active Registry Monitor (ARM) es una utilidad diseñada para analizar los cambios hechos al registro de Windows – tomando snapshots de su estado y guardándolos en una base de datos. Posteriormente, pueden compararse dos de estas fotografías y obtener un listado de claves/datos nuevos, eliminados o, simplemente, cambiados.

TCPview

TCPView es un programa de Windows que muestra la lista detallada de todos los puntos finales TCP y UDP en el sistema, incluyendo las direcciones y el estado de las conexiones TCP locales y remotas. En Windows Server 2008, Windows Vista y XP, TCPView también informa del nombre del proceso que posee el punto final. TCPView proporciona un subconjunto más informativo y bien presentado del programa Netstat que se incluye con Windows.

WinVi

WinVi es un editor gratuito para MS Windows para la edición y la detección automática de archivos Unicode en codificaciones UTF- 8, UTF-16 Little Endian y UTF-16 Big Endian. WinVi funciona como un editor Vi para Windows. En el análisis de malware se utiliza esta herramienta como un editor hexadecimal que puede soportar archivos de hasta 2 GB.

Técnicas de análisis de malware

Muy a menudo, cuando se realiza el análisis de malware, la única cosa que se tiene es el propio ejecutable malicioso, que no dará demasiada información, ya que está destinado a no ser comprendido por seres humanos. Con la intención de encontrarle sentido, vamos a usar una variedad de herramientas y trucos, cada uno revelando una pequeña cantidad de información.

Habrá que hacer uso de una gran variedad de herramientas con el fin de obtener una comprensión amplia del malware en cuestión. Existen dos enfoques fundamentales para el análisis de malware: los análisis estáticos y los análisis dinámicos. El análisis estático consiste en examinar el malware sin ejecutarlo, mientras que el análisis dinámico implica la ejecución del malware en entornos controlados.

Análisis estático básico

El análisis estático básico consiste en examinar el archivo ejecutable sin ver las instrucciones reales. El análisis estático puede confirmar si un archivo es malicioso, proporciona información sobre su funcionamiento, y a veces ofrece información que permitirá realizar un network footprinting simple. El análisis estático básico es sencillo y puede ser rápido, pero es en gran medida ineficaz contra el malware sofisticado, y se pueden pasar por alto funciones importantes.

Análisis Dinámico Básico

Las técnicas de análisis dinámicas básicas implican ejecutar el malware y la observación de su comportamiento en el sistema con el fin de averiguar algunos aspectos de su comportamiento, poder eliminar la infección, y producir firmas eficaces. Sin embargo, antes de poder ejecutar el malware de forma segura, se debe configurar un entorno que permita estudiar el malware ejecutándose sin riesgo de daño al sistema o la red. Al igual que las técnicas básicas de análisis estático, las técnicas básicas de análisis dinámico pueden ser utilizadas por la mayoría de las personas sin grandes conocimientos de programación, pero no serán eficaces con todo el malware y también se puede pasar por alto funcionalidad importante.

En la Práctica

Mostraremos un ejemplo práctico de cómo realizar un análisis de una pieza de malware para identificar su funcionalidad.

Disclaimer: No se recomienda la realización de este ejercicio en un entorno sin acondicionar debidamente, por el riesgo que puede suponer para todos los equipos de la red.

El virus que vamos a analizar, el virus RaDa, es un virus real creado en el marco del Proyecto Honeynet para aumentar la concienciación sobre la seguridad en torno a ejemplares de malware y para señalar la necesidad de contramedidas defensivas adicionales con el fin de luchar contra las actuales amenazas de malware.

Una vez localizado (o descargado) el ejecutable del malware, y aislado en nuestro entorno de laboratorio, procedemos al análisis del mismo, pasando por cada una de las etapas y usando varios de los software mencionados.

Análisis estático

En el análisis estático de este virus vamos a intentar recabar tanta información como sea posible, que nos ayudará a comprenderlo mejor y a orientar de forma eficiente nuestros esfuerzos en el posterior análsis dinámico.

Como primer paso, se lleva a cabo una recolección de información previa observando los detalles del virus y realizando una visualización en un editor hexadecimal. Esto revela algunas cadenas en el código del virus, además de ayudarnos a verificar que se trata de un ejecutable.


El siguiente paso comienza con cargar el ejecutable (el virus RaDa) en OllyDbg para llevar a cabo un análisis de código con el fin de descubrir sus capacidades funcionales. En primer lugar, abrimos el archivo ejecutable en el OllyDbg para ver los detalles básicos. La siguiente figura muestra cierta información de los registros, la CPU y el estado de la memoria del programa, incluyendo un mensaje de advertencia que indica que el código está comprimido, cifrado o codificado para ocultar su verdadera naturaleza.


Para salvar este paso y poder extraer el ejecutable real y ver sus instrucciones, o al menos obtener información sobre el tipo de compresión, codificación o cifrado lleva (y, en definitiva, averiguar más cosas sobre la naturaleza del virus), se utiliza la utilidad de descompresión de ejecutables UPX:


Tal y como se puede observar en la imagen superior, el virus se resiste a desempaquetarse a través del método común con UPX. Por lo tanto, podemos probar a forzar el proceso usando el comando upx -9 --brute, que puede tardar un buen rato.

Después de un rato no ha habido suerte en el desempaquetamiento, por lo que vamos a moldear un poco el análisis, redireccionando nuestros esfuerzos en cierto modo hacia un análisis de comportamiento del malware, más que un análisis estático, debido a que el virus está preparado para evitar este tipo de análisis. Para este propósito, es necesario realizar una ejecución controlada del virus, analizar sus puntos de inicio, y encontrar un breakpoint del virus.

Para poder localizar dichos puntos, vamos a empezar por analizar el mapa de memoria  del malware, cosa que podemos hacer con el OllyDbg:


El mapa de memoria indica que hay tres secciones en el binario de RaDa: JDR0, JDR1 y .rsrc. El entry point de RaDa.exe (0x0040FD20) está ubicado en la sección JDR1. Podemos echar un vistazo también a la sección JDR0 haciendo doble click sobre la etiqueta de la sección, aunque nos encontraremos en este caso que la sección está vacía:


Podemos obtener algo más de información sobre la sección JDR0 (0x004018A4) usando el IDA Pro:


La siguiente captura de pantalla muestra que el código en JDR1 desempaqueta el código ofuscado que contiene en la sección JDR0. El registro ESI apunta a la dirección del bloque cifrado/ofuscado de código, mientras que el registro EDI apunta a la dirección de memoria a la que será copiada el código una vez se haya desempaquetado. Al terminar la sección JDR1, el control del programa salta a la dirección en que se ha desempaquetado el código (jmp loc_40FD42).


Observando además la información presente en la vista General Register, en el registro EIP, podemos consolidar que la dirección de memoria  JDR1:0040FD20 es el punto de inicio del programa. Dicho esto, aún es necesario extraer un buen String dump del código empaquetado.

Con el OllyDbg podemos obtener cierta información de los (posibles) módulos de los que puede hacer uso el virus, que nos pueden ayudar a comprender la naturaleza del virus más a fondo:


También podemos observar los handles del virus, para un propósito similar:


Recapitulando hasta ahora:

• La información recabada en el análisis estático será de gran ayuda para, a la hora de hacer el análisis dinámico, saber dónde deben ir dirigidos nuestros esfuerzos.
• Los handles del virus nos ayudarán a saber de qué recursos del sistema el ejecutable pretende hacer uso. Todo ejecutable hace uso de algún recursos del sistema; la cuestión aquí está en filtrar qué recursos son potencialmente peligrosos como para que los use un fragmento de software desconocido, y cuáles son más y menos habituales.
• El mapa de memoria del ejecutable nos ha ayudado a determinar breakpoints del virus, que nos puede servir para controlar eficientemente la ejecución del virus en el análisis dinámico.
• La lista de módulos ejecutables del malware nos da una pista (a veces, falsa) de los módulos que puede utilizar el virus.

Reunidas todas estas pistas, hemos preparado el terreno para dirigir nuestro análisis dinámico de la forma más eficiente posible.

El análisis dinámico

Ejecutaremos el virus en un ambiente controlado para ver su capacidad de abrir conexiones con el mundo exterior (calling home), las alteraciones del registro, modificaciones del sistema de archivos y los procesos en ejecución. Para controlar este tipo de actividades se utilizarán los programas TCPView, Active Registry Monitor, Process Explorer, Process Monitor y la aplicación Autoruns.

Al haber localizado en el análisis estático el punto de inicio del programa, podemos controlar su ejecución:



Una vez tenemos el entorno de laboratorio bien preparado y con el virus listo para ser ejecutado, el primer paso es averiguar cómo intenta comunicarse con el exterior: ¿cuáles son los puertos y las conexiones que el virus puede abrir hacia el mundo exterior? El TCPView muestra los detalles de conexiones salientes del malware:


El monitor de procesos y el ARM muestran las claves del registro recién alteradas del sistema local:


Como una observación, podremos ver que el virus se está ejecutando detrás de la aplicación Internet Explorer para ocultarse. La única indicación que podemos ver es que el proceso "IEXPLORE.EXE" está abierto por el virus para conectarse al destino remoto 10.10.10.10 en el puerto 80. También observamos que el proceso parece consumir más y más memoria.


El ProcessExplorer de Sysinternals nos da información relevante del virus en ejecución, pudiendo comprobar los DLL's que carga, y compararlos con lo encontrado en el análisis estático:



Echando un ojo al Advanced Registry Editor, podemos ver los cambios que hace el virus en el registro de Windows:


También observamos los cambios que ha hecho en el sistema de ficheros:
Cambios en el sistema de ficheros introducidos por RaDa


Por último, también podemos ver en el Process Monitor información sobre el proceso RaDa.exe y el IEXPLORE.EXE, en especial, que RaDa ha sido capaz de lanzar el IEXPLORER como NTAUTHORITY\SYSTEM, siendo RaDa ejecutado por un usuario con privilegios reducidos:



Hasta aquí...:

Después de realizado los análisis estático y dinámico, se han podido comprobar varias cosas:

El virus intenta ocultar su código ejecutable empaquetándolo, así como su punto de inicio. Hay virus más sofisticados que lo ponen mucho más complicado, con decenas de secciones de código distintas.

El programa Active Registry Monitor nos indica que se ha creado la siguiente clave del registro HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\RaDa:C:\RaDa\bin\RaDa.exe. Esto permite que RaDa persista tras el reinicio del sistema.

El TCPView muestra que hubo intentos de conexión desde iexplore.exe, Internet Explorer, a 10.10.10.10:80. Parece que RaDa utiliza Internet Explorer como herramienta para conectarse con el sistema externo, y que además, es capaz de lanzarlo como el usuario NTAUTHORITY\SYSTEM.

A través del Process Monitor se ha podido comprobar que se crearon los directorios C:\RaDa, C:\RaDa\tmp y C:\RaDa\bin. El ejecutable RaDa.exe se ha copiado en el directorio C:\RaDa\bin\.

El panel de Process Explorer muestra el proceso RaDa.exe en su lista activa, (no oculto bajo otro ejecutable), mostrando el crecimiento de la memoria usada.

Este breve análisis supone solo una introducción al análisis de malware, sin entrar mucho en detalle en los aspectos más técnicos. Seguiremos publicando artículos que poco a poco irán entrando más a fondo, desmenuzando a todos los niveles las técnicas del análisis de malware más comunes, con ejemplos prácticos para poder experimentar con conocimiento y aprender cosas interesantes de este área de la seguridad informática.

Fuente: hard2bit

Saludos

1.- Evitar la creación innecesaria de objetos, Lazy Initialitation

La creación de objetos en Java es una de las operaciones mas costosas en términos de uso de memoria e impacto en el performance.  Esto es evitable creando o inicializando objetos solo en el momento en que serán requeridos en el código.

public class Paises {

    private List paises;

    public List getPaises() {
        //se inicializa solo cuando es requerido
        if(null == paises) {
            paises = new ArrayList();
        }
        return paises;
    }
}

2.- Nunca hacer variables de instancia públicas

Hacer una clase publica se puede ocasionar problemas en un programa.  Por ejemplo si tienes una clase MiCalendario. Esta clase contiene un arreglo de cadenas diasDeLaSemana.  Pero es una arreglo público y este puede ser accedido por cualquiera.  Tu asumes que este arreglo contiene siempre los 7 nombres de los días de la semana.  Alguien por error puede cambiar el valor e insertar un error!

public class MiCalendario {
   
    public String[] diasDeLaSemana =
        {"Domingo", "Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado"};
   
    //mas código
   
}

La mejor práctica es como mucho de ustedes saben, es siempre definir estas variables como privadas y crear los métodos accesores, "setters" y "getters"

private String[] diasDeLaSemana =
    {"Domingo", "Lunes", "Martes", "Miercoles", "Jueves", "Sabado", "Domingo"};

public String[] getDiasDeLaSemana() {
    return diasDeLaSemana;
}

Pero escribir los métodos accesores no resuelve el problema del todo.  El arreglo sigue siendo accesible.  La mejor forma de hacerlo inmodificable es devolviendo un arreglo clonado en lugar del arreglo mismo.  Esto se logra modificando el método get de la siguiente forma.

public String[] getDiasDeLaSemana() {
    return diasDeLaSemana.clone();
}

3.- Tratar siempre de minimizar la Mutabilidad de las clases

Hacer una clase inmutable es hacerla inmodificable.   La información de la clase se preservara durante el tiempo de vida de la clase.  Las clases inmutables son simples y fáciles de manejar.  Son "thread safe".  Normalmente son los bloques para formar otros objetos mas grandes.

No obstante, crear objetos inmutables pueden golpear significativamente el rendimiento de una aplicación.  Así que elije cuidadosamente si quieres que una clase sea o no inmutable.  Trata siempre de tener clases pequeñas con el menor número de clases inmutables.

Para hacer una clase inmutable puedes definir sus constructor de forma privada y luego crear un método estático para inicializar al objeto y devolverlo.

public class Empleado {

    private String primerNombre;
    private String segundoNombre;
   
    // constructor private default
    private Empleado (String primerNombre, String segundoNombre) {
        this. primerNombre = primerNombre;
        this. segundoNombre = segundoNombre;
    }
   
    public static Empleado valueOf (String primerNombre, String segundoNombre) {
        return new Empleado (primerNombre, segundoNombre);
    }
}

4.- Trata de usar mas las Interfaces sobre las Clases Abstractas

No es posible la herencia múltiple en Java, pero definitivamente puedes implementar múltiples interfaces.  Esto hace que cambiar la implementación de una clase existente sea fácil y que puedas implementar una o mas interfaces en lugar de cambiar la jerarquía completa de clases.

Pero si tu estás cien por ciento seguro de que métodos de una interface tendrás, entonces solo implementa esa interfaz.   Es bastante difícil agregar un nuevo método en una interfaz existente sin alterar todo el código que se está implementando.  Por el contrario un nuevo método puede ser fácilmente agregado en una clase abstracta sin alterar la funcionalidad existente.

5.- Limita siempre el alcance de una variable local

Las variables locales son grandiosas.  Pero algunas veces pueden insertar mas bugs durante el copiado y pegado de código viejo. Minimizar el alcance de una variable local hace que el código sea mas legible, menos propenso a errores  y mas mantenible.

Por lo tanto, debemos declarar variables justo antes de ser usadas.

Procura inicializar una variable desde su declaración.  Si eso no es posible asígnale el valor nulo.

6- Trata de usar librerías estándar en lugar de hacer las tuyas desde cero.

Escribir código es divertido.  Pero no reinventes la rueda.  Es bastante recomendable usar librerías estándar que ya han sido probadas, debugeadas y usadas por otros.    Esto no solo mejora la eficiencia de un programador sino que redice las posibilidades de tener errores en el código.  Además, usar una librería estándar  hace al código mas legible y mantenible.

Por ejemplo Google tiene liberada la nueva librería Google Collections que puede ser usada para agregar mas funcionalidad a tu código.

7.- Siempre que sea posible trata de usar tipos primitivos en lugar de las clases Wrapper

Las clases Wrapper son buenas, pero también son lentas.  Los tipos primitivos son como clases, sin embargo las clases wrapper almacenan la información completa acerca de una clase.

Algunas veces un programador puede agregar un error en el código usando una wrapper por un descuido.  Por ejemplo:

int x = 10;
int y = 10;

Integer x1 = new Integer(10);
Integer y1 = new Integer(10);

System.out.println(x == y);
System.out.println(x1 == y1);

El primer System.out.println imprimirá true mientras que el segundo imprimirá false.  El problema cuando comparas dos clases wrapper es que no se puede usar el operador ==, por que en realidad se están comparando referencias y no sus valores actuales.

Además si estás usando una clase wrapper no debes olvidar inicializarla.  Porque el valor por default de las variables wrapper es null.

Boolean bandera = null;
     
        //mas código

if(flag == true) {
    System.out.println("Se establece el valor de bandera ");
} else {
    System.out.println("No se establece el valor de bandera");
}

El código lanzará un NullPointerException cuando se trate de comparar con true y el valor sea nulo si en el código intermedio no fue inicializada.

8.- Usa los Strings con mucho cuidado.

Usa siempre las cadenas con mucho cuidado en tu código.  Una simple concatenación de cadenas puede reducir el rendimiento de tu programa.  Por ejemplo si queremos concatenar cadenas usando el operador "+" en un ciclo for entonces todo el tiempo se estará creando un objeto String.  Esto afecta tanto a la memoria como al rendimiento.

Además en lugar de que instancies una objeto String no uses su constructor, sino que debes instanciarlo directamente. Por ejemplo:

//instanciación lenta
String lenta = new String("solo otro objeto string");

//instanciación rápida
String rapida = "solo otro objeto string";

9.- Siempre regresa colecciones vacías en lugar de nulas

No importa que tu método regrese una colección o un arreglo, siempre asegúrate de que cuando sea necesario se regrese vacío y no nulo, en aquellos casos en los que no contendrá elementos porque la lógica de tu programa lo requiera.  Esto te ahorrará un montón de tiempo cuando hagas pruebas para valores nulos.

10.- El copiado defensivo es salvador

El copiado defensivo hace que los objetos creados estén libres de la mutación.  Por ejemplo en el código siguiente tenemos definida la clase Estudiante la cual a su vez tiene una variable con la fecha de nacimiento que es inicializada cuando el objeto es construido.

public class Estudiante {
    private Date fechaNacimiento;
   
    public Estudiante(fechaNacimiento) {
        this. fechaNacimiento = fechaNacimiento;
    }
   
    public Date getFechaNacimiento () {
        return this.fechaNacimiento;
    }
}

Ahora podríamos tener el siguiente código que use al objeto Estudiante.

public static void main(String []arg) {
    Date fechaNacimiento = new Date();    
    Estudiante estudiante = new Student(fechaNacimiento);
    fechaNacimiento.setYear(2019);
    System.out.println(estudiante.getFechaNacimiento ());
}

En el código siguiente creamos tan solo al objeto Estudiante con algunas fechas de nacimiento por default.  Pero entonces cambiamos el valor de el año de nacimiento.  Después imprimimos el año de nacimiento, este año fue cambiado por 2019!

Para evitar estos casos, se puede utilizar el mecanismo defensivo copias. Cambie el constructor de la clase del estudiante a lo siguiente.

public Estudiante(fechaNacimiento) {
    this.fechaNacimiento = new Date(fechaNacimiento);
}

Esto para asegurarnos de tener otra copia de la fecha de nacimiento que usamos en clase Estudiante.

11.-  Nunca dejes salir una excepción de un bloque finally

12.- Nunca lances "Exception" directamente.

Fuente: decodigo

Saludos

Indice:

Php y el manejo de objetos en memoria
Php: Hacking, Debugging o simplemente diversión
Software libre y la diferencia con el software privativo desde una óptica intrínsecamente profesional y no política
La orientación a objetos y sus enfoques como estilo y paradigma

Descarga: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Fuente: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Saludos

Dentro de los lenguajes utilizados para programar códigos maliciosos encontramos AutoIt, veamos como podemos llegar a analizar este tipo de amenazas ya que en los últimos meses hemos detectado varias muestras de malware desarrolladas en este lenguaje alojadas en servidores vulnerados de Latinoamérica.

La muestra sobre la cual vamos a realizar el análisis corresponde a una campaña de propagación que buscaba afectar usuarios brasileños, a través de un correo electrónico que simulaba ser un comprobante de depósito en formato PDF.


Lo que realmente descarga este correo electrónico es un archivo ejecutable que si un usuario desprevenido lo descarga y ejecutra en su computadora, a pesar que durante unos segundos no ocurrirá nada sobre la máquina, después empezamos a ver que se genera tráfico de red.


Vemos que la muestra establece una comunicación con un servidor, intercambiando paquetes TCP. Además al principio de la comunicación luego de la ejecución la muestra envía cierta información del sistema.

Además del análisis dinámico podemos tratar de entender como fue construido este código malicioso. Para ello podemos analizar las propiedades del archivo ejecutable descargado que dice ser un complemento de Java.


Cuando tratamos de hacer análisis estático sobre muestras de malware se suele recurrir a herramientas de debugging. Para el caso de las muestras que han sido compilados desde AutoIt podemos utilizar un desensamblador para llegar hasta el script y lograr que el análisis sea más sencillo. Para lograrlo utilizamos Exe2Aut una herramienta que nos sirve como decompilador.


Después de hacer la decompilación nos encontramos con un código ofuscado. Lo único entendible a simple vista son las 7 pausas pausas de 3000 milisegundos al principio del código, lo cual explica la demora en la ejecución de esta muestra. El resto del código se convierte en un dolor de cabeza al momento de analizarlo.

Sin embargo, si miramos por un momento el código podemos darnos cuenta que hay una función que se repite en todo el script y que como argumento tiene cadenas de caracteres ilegibles.


Si vamos a buscar esta función dentro del script, nos encontramos con una función que realiza una serie de operaciones sobre su argumento.


Lo que se puede entender de esta función es que va recorriendo la cadena de caracteres que se ingresa y hace unas transformaciones de forma iterativa para obtener la cadena de caracteres con la información que podemos entender.


Si vamos siguiendo la ejecución del script, nos podemos dar cuenta de los valores reales que toman las variables definidas dentro del código una vez que han sido desofuscadas.


Podríamos separar solamente esta función para desofuscar las diferentes cadenas de caracteres y lograr entender lo que está modificando este código malicioso en nuestro sistema.


Una vez que logramos desofuscar muchas de las cadenas podemos a llegar entender cuales son los archivos que modifica e incluso las variables con la información del sistema que envía.


Una de las cuestiones importantes para analizar las muestras desarrolladas en AutoIt es que desde el Laboratorio de ESET Latinoamérica hemos encontrado variantes de la familia Win32/Injector.Autoit en servidores de sitios latinoaméricanos, haciéndose pasar por actualizaciones de Adobe Flash, herramientas para pagar impuestos entre otras técnicas de ingeniería social. La recomendación es para que nuestros usuarios tengan instalada una solución de seguridad en sus dispositivos y eviten ser infectados con códigos maliciosos que roben información del sistema.

Autor: Camilo Gutiérrez Amaya, ESET

Saludos

Lista de reproducción sobre arduino

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Fuente: codigofacilito

Saludos

¿Qué es una aplicación multihilo?

Java es un lenguaje de programación multihilo. Un programa de multiproceso contiene dos o más partes que se pueden ejecutar al mismo tiempo y cada parte puede manejar diferentes tareas al mismo tiempo, haciendo un uso óptimo de los recursos disponibles, especialmente cuando el equipo tiene varias CPU.

Por definición la multitarea es cuando varios procesos comparten recursos comunes de procesamiento, tales como CPU. Multithreading extiende la idea de la multitarea en aplicaciones donde se puede subdividir operaciones específicas dentro de una sola aplicación en hilos individuales.

Cada uno de los hilos se pueden ejecutar en paralelo. El sistema operativo divide el tiempo de procesamiento, no sólo entre las diferentes aplicaciones, sino también entre cada hilo dentro de una aplicación.

¿Cómo creamos una aplicación multihilo en Java? – Modo 1

Si la clase está destinado a ser ejecutado como un hilo, entonces pedemos lograr esto mediante la implementación de interface Runnable. Para crear un hilo debemos seguir los siguientes pasos:

Primer paso

Como primer paso, es necesario implementar el método run() proporcionado por la interface Runnable. Este método proporciona una puerta de entrada para el hilo y en el cual pondremos la lógica de negocio.

public void run( )

Segundo paso

El segundo paso tendremos que instanciar Thread usando el siguiente constructor:

Thread(Runnable threadObj, String threadName);

Observemos que threadObj es una instancia de la interface Runnable y threadName es el nombre que recibe el nuevo hilo.

Tercer paso

Una vez creado el objeto Thread, lo podemos iniciar llamando al método start(), que ejecuta una llamada al método run(). Veamos como:

void start( );

Veamos un ejemplo:

class Multihilo implements Runnable {
   private Thread hilo;
   private String nombreHilo;
  
   Multihilo(String nombre){
       nombreHilo = nombre;
       System.out.println("Creando " +  nombreHilo);
   }
 
   public void run() {
      System.out.println("Ejecutando " +  nombreHilo );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Hilo: " + nombreHilo + ", " + i);
            // vamos a dormir el hilo unos 50s
            Thread.sleep(50);
         }
     } catch (InterruptedException e) {
         System.out.println("Hilo " +  nombreHilo + " interrumpido.");
     }
     System.out.println("Hilo " +  nombreHilo + " termino.");
   }
  
   public void start ()
   {
      System.out.println("Iniciando " +  nombreHilo );
      if (hilo == null)
      {
         hilo = new Thread (this, nombreHilo);
         hilo.start ();
      }
   }
 
}
 
public class PruebaHilo {
   public static void main(String args[]) {
  
      Multihilo hilo1 = new Multihilo( "Hilo-1");
      hilo1.start();
      
      Multihilo hilo2 = new Multihilo( "Hilo-2");
      hilo2.start();
   }  
}

Observemos que en el ejemplo anterior implementamos la interfaz Runnable. Ademas, creamos dos hilos y los iniciamos.

Si ejecutamos el código anterior deberíamos obtener lo siguiente:

Creando Hilo-1
Iniciando Hilo-1
Creando Hilo-2
Iniciando Hilo-2
Ejecutando Hilo-1
Thread: Thread-1, 4
Ejecutando Hilo-2
Hilo: Hilo-2, 4
Hilo: Hilo-1, 3
Hilo: Hilo-2, 3
Hilo: Hilo-1, 2
Hilo: Hilo-2, 2
Hilo: Hilo-1, 1
Hilo: Hilo-2, 1
Hilo Hilo-1 termino.
Hilo Hilo-2 termino.

¿Cómo creamos una aplicación multihilo en Java? – Modo 2

La segunda forma de crear un hilo es crear una nueva clase que extiende la clase Thread utilizando los siguientes dos sencillos pasos. Este enfoque proporciona una mayor flexibilidad en el manejo de múltiples subprocesos creados usando los métodos disponibles en la clase Thread.

Primer paso

Tendremos que reemplazar el método run() que está disponible en la clase Thread. Este método proporciona una puerta de entrada para el hilo y en el cual pondremos la lógica de negocio.

public void run( )

Segundo paso

Una vez creado el objeto Thread, lo podemos iniciar llamando al método start(), el cual ejecuta una llamada al método run().

void start( );

Veamos un ejemplo:

class Multihilo extends Thread {
   private Thread hilo;
   private String nombreHilo;
  
   Multihilo(String nombre){
       nombreHilo = nombre;
       System.out.println("Creando " +  nombreHilo);
   }
 
   public void run() {
      System.out.println("Ejecutando " +  nombreHilo );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Hilo: " + nombreHilo + ", " + i);
            // vamos a dormir el hilo unos 50s
            Thread.sleep(50);
         }
     } catch (InterruptedException e) {
         System.out.println("Hilo " +  nombreHilo + " interrumpido.");
     }
     System.out.println("Hilo " +  nombreHilo + " termino.");
   }
  
   public void start ()
   {
      System.out.println("Iniciando " +  nombreHilo );
      if (hilo == null)
      {
         hilo = new Thread (this, nombreHilo);
         hilo.start ();
      }
   }
 
}
 
public class PruebaHilo {
   public static void main(String args[]) {
  
      Multihilo hilo1 = new Multihilo( "Hilo-1");
      hilo1.start();
      
      Multihilo hilo2 = new Multihilo( "Hilo-2");
      hilo2.start();
   }  
}

Observemos que en el ejemplo anterior extendemos de la clase Thread. Ademas, creamos dos hilos y los iniciamos.

Si ejecutamos el código anterior deberíamos obtener lo siguiente:

Creando Hilo-1
Iniciando Hilo-1
Creando Hilo-2
Iniciando Hilo-2
Ejecutando Hilo-1
Thread: Thread-1, 4
Ejecutando Hilo-2
Hilo: Hilo-2, 4
Hilo: Hilo-1, 3
Hilo: Hilo-2, 3
Hilo: Hilo-1, 2
Hilo: Hilo-2, 2
Hilo: Hilo-1, 1
Hilo: Hilo-2, 1
Hilo Hilo-1 termino.
Hilo Hilo-2 termino.

Fuente: codehero

Saludos

De Karthikeyan A K.

Contenido:

• Installing Ruby
• Online Resources
• Getting Started
• Comparison and Logic
• Loops
• Arrays
• Hashes and Symbols
• Ranges
• Functions
• Variable Scope
• Classes & Objects
• Struct and OpenStruct
• Rdoc
• Modules and Mixins
• Shebang
• Date and Time
• Files
• Proc, Lambdas and Blocks
• Multi Threading
• Exception Handling
• Regular Expressions
• Gems
• Meta Programming
• Final Word
• Underscore
• An important Math Discovery

Descarga: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Saludos

Comparto un canal de youtube con una serie de videos para quienes estan interesado en aprender Django desde cero.

No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

Saludos