elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Introducción a la Factorización De Semiprimos (RSA)


  Mostrar Temas
Páginas: [1] 2 3 4 5 6 7 8 9 10
1  Comunicaciones / Android / Aplicaciones Android a 0.10 € durante 10 días en: 10 Diciembre 2011, 19:47 pm
No voy a enrollarme mucho con la descripción porque es sencillo, en el market de android durante 10 días se
ofertarán aplicaciones premium a 0.10€.

https://market.android.com/details?id=apps_timed_promotion

Yo me acabo de comprar Teclado SlideIT.


2  Programación / Programación General / Clasificación de los lenguajes de programación [Presentación] en: 17 Noviembre 2011, 20:27 pm
Una clasificación de los lenguajes de programación según varios criterios.

http://es.scribd.com/fullscreen/73045465?access_key=key-1pkxhsneo6mw1266rkz6

Se puede descargar desde scribd.

3  Programación / Programación General / Introducción a los modelos de ciclos de vida [Presentación] en: 17 Noviembre 2011, 20:25 pm
Presentación sobre los modelos de ciclos de vida. En realidad se habla sólo de modelo en cascada y sus variaciones
y el modelo en espiral.

http://es.scribd.com/fullscreen/73045251?access_key=key-1mwweoriatlz7h9768di

Se puede descargar desde scribd.

4  Programación / Java / JNode - Un sistema operativo creado en Java en: 14 Noviembre 2011, 21:16 pm



JNode, es un sistema operativo libre programado en lenguaje Java y con licencia GNU. Pero ésto no es del todo cierto, cómo bien sabemos,
para funcionar se necesita un kernel. Dicho kernel está programado en lenguaje Ensamblador (ASM), por tanto no es del todo Java.

De momento no hay ninguna versión estable o para usuarios finales, pero si se puede descargar y virtualizar alguna beta del sistema.

Empezó siendo un proyecto de investigación y para desarrolladores, pero la meta del proyecto es hacerlo amigable para el usuario. Aunque la descripción oficial lo explica todo
muy bien.


Already very early in the Java history, around JDK 1.0.2, Ewout Prangsma (the founder of JNode) dreamed of building a Java Virtual Machine in Java.

It should be a system that was not only a VM, but a complete runtime environment that does not need any other form of operating system. So is had to be a light weight and most important flexibel system.

Ewout made various attempts in achieving these goals, starting with JBS; the Java Bootable System. It became a somewhat functional system, but had far too much native code (C and assembler) in it.

So he started working on a new JBS system, called JBS2 and finally JNode. It had with a simple target, using NO C code and only a little bit of assembly code.[/font]

In may on 2003 Ewout came public with JNode and development proceeded ever faster from that point on.
Several versions have been released and there are now concrete plans for the first major version.





Se trata de un proyecto realmente interesante aunque dudo de que tenga mucha aceptación por parte de los usuarios.

Enlaces del proyectos:

JNode no es el primer sistema operativo que se intenta crear en Java, anteriormente existió JavaOS (descontinuado desde el 2006), aunque aún
podemos descargarnos la última versión e instalarla.

Otro proyecto interesante es Cosmos, otro sistema operativo creado en C#.

5  Foros Generales / Foro Libre / Colaboración de elhacker.NET en la revista PC Actual en: 23 Octubre 2011, 18:42 pm
Colaboración de elhacker.NET en la revista PC Actual





Parte del staff de elhacker.NET ha colaborado en la edición de un artículo para la revista PC Actual sobre Seguridad Informática.

Básicamente nos han hecho una lista de preguntas a las que hemos respondido entre todos.

Se trata de la revista número 245 de Noviembre de 2011. Las personas que han colaborado en la edición del artículo (cuyos nicks son ordenados alfebéticamente) son:

  • Aberroncho
  • Uxio
  • WHK
  • el-brujo
  • madpitbull_99
  • skapunky





Citar
Revista nº 245 (noviembre 2011)

A lo largo de nuestro Tema de Portada, aprenderás a identificar los puntos débiles de tu equipo, a asegurar el PC con las posibilidades que ofrece el sistema operativo o proteger tus datos cuando utilizas los servicios web

Nº 245 - 11/2011



La seguridad es la asignatura más importante que un usuario debe superar frente al PC, sin embargo, es una de las más olvidadas. Además, te ofrecemos cuatro comparativas: 6 Portátiles de gama alta al mínimo precio, 10 Discos duros externos con conexión USB 3.0, 8 Aplicaciones gratuitas de optimización y 9 Reproductores multimedia. Y, como siempre, trucos, informes, análisis independientes y artículos prácticos de todos los niveles para hacerte la informática más divertida.

Tema de portada: Todos los trucos para proteger tu PC


La seguridad es una asignatura rechazada por la complicación que a priori puede suponer si se carece de conocimientos técnicos. Acabar con este mito es el objetivo de este Tema de Portada en el que ofrecemos triquiñuelas fáciles de implementar para dotar a tu ordenador de la máxima fiabilidad. Entre otras cosas, aprenderás a establecer el protocolo adecuado en tus dispositivos móviles o a conocer y aplicar los trucos de elhacker.net.

  • Identifica tus puntos débiles
  • Un PC a prueba de bombas
  • Accede a la Red con seguridad
  • Seguridad en dispositivos móviles
  • Consejos de elhacker.NET

Fuente


La revista está disponible en todos los quiscos de España y cuesta 3 euros sin DVD. El número de éste mes les interesará todos a los que les apasione la
Seguridad Informática y los temas de Hardware.

Agradecemos a todos los que han colaborado en la edición de éste artículo y a los chicos de PC Actual, en especial a Juan Carlos López (Redactor Jefe Técnico) .


6  Programación / Ejercicios / Ejercicios en JAVA en: 18 Octubre 2011, 22:23 pm

Ejercicios y problemas en Java


Nota: Clic en las imágenes para ampliar.


1º parte



















2º parte















7  Programación / Java / Creación de una pila básica en Java en: 15 Octubre 2011, 12:18 pm
Al aprender a trabajar con arrays, siempre suelen mencionarse las pilas. Una pila no es más que una colección de valores de tipo LIFO (Last In First Out), o sea el último valor insertado en la

pila es el primero en salir o ejecutarse. La estructura básica de una pila es la siguiente:



Mediante un array conseguiremos construir nuestra pila de datos en Java. Para eso creamos la siguiente clase:

Código
  1.  
  2. public class Stack {
  3.  
  4.    private int stck[];
  5.    private int tos;
  6.  
  7.    //Constructor
  8.    Stack(int size){
  9.        //Crear la pila
  10.        stck = new int[size];
  11.        tos = -1;
  12.    }
  13.  
  14.    //Introduce valor en la pila
  15.    void push(int value) {
  16.        if (tos == stck.length - 1)
  17.            System.out.println("Stack Overflow!");
  18.            //Pila esta llena
  19.        else
  20.            stck[++tos] = value;
  21.            //Almacena valor en pila
  22.    }
  23.  
  24.    //Retira valor de la pila
  25.    int pop() {
  26.        if (tos < 0) {
  27.            //La pila esta vacia
  28.            System.out.println("Stack Underflow!");
  29.            return 0;
  30.        } else
  31.            return stck[tos--];
  32.  
  33.    }
  34. }
  35.  

El primer método de la clase es el constructor, al constructor tenemos que pasarle un parámetro que indique el tamaño de la pila. Dentro del constructor se crea una matriz con el tamaño especificado a través del constructor y se le asigna el valor -1 a la variable tos (eso indica que la pila está vacía).


El siguiente método push() introduce un valor al principio de la pila, primero se comprueba si la pila está llena, en caso contrario agrega el valor introducido en la pila. El último método pop() elimina de la pila el último valor insertado y lo devuelve (también se comprueba que la pila no esté vacía).

Ahora veamos cómo utilizar ésta clase:

Código
  1. public class Test {
  2.  
  3.    public static void main(String args[]) {
  4.  
  5.        //System.out.println("This is a test!");
  6.  
  7.        Stack pila = new Stack(10);
  8.        //Llenar la pila
  9.        for (int i = 0; i < 10; i++) pila.push(i);
  10.  
  11.        //Retirar 5 primeros elementos de la pila
  12.        System.out.println("Valores contenidos en la pila: ");
  13.        for (int i = 0; i < 5; i++) System.out.println("\t " + pila.pop());
  14.  
  15.    }
  16.  
  17. }
  18.  

Primero se crea instancia la clase Stack y mediante el constructor se inicializa una pila que puede contener hasta 10 valores. Luego mediante la sentencia for() se introducen elementos en la pila insertándolos usando el método push().

Acto seguid, eliminamos y mostramos los 5 primeros valores de la pila.

8  Programación / Java / [SRC] Menú básico usando switch en: 15 Octubre 2011, 10:13 am
Es un menú básico usando switch, puede que a alguien le venga bien.

Código
  1.  
  2. /**
  3.  *
  4.  * @author madpitbull
  5.  */
  6. import java.io.*;
  7.  
  8. public class Mine_Switch_Menu {
  9.  
  10.    public static void main (String args[]) throws IOException {
  11.  
  12.        //Variables
  13.        char op;
  14.        BufferedReader in = new BufferedReader (new InputStreamReader(System.in));
  15.  
  16.        System.out.print("Selecciona una opcion:\n"
  17.                        + "\t[a] Cuadrado.\n"
  18.                        + "\t[b] Circulo.\n\n");
  19.  
  20.        //Leer opción
  21.        op = (char) System.in.read();
  22.  
  23.  
  24.        //Limpiar buffer, caracter de retorno \n
  25.        System.in.read();
  26.        System.out.flush();
  27.  
  28.        //Buscar opcion
  29.        switch (op) {
  30.            case 'a':
  31.                //Cuadrado
  32.                System.out.print("Introduce el lado: ");
  33.                int l = Integer.parseInt(in.readLine());
  34.                System.out.println("El perimetro es: " + ( 4 * l));
  35.                break;
  36.            case 'b':
  37.                //Círculo
  38.                System.out.print("Introduce el radio: ");
  39.                int r = Integer.parseInt(in.readLine());
  40.                System.out.println("El perimetro es: " + ( (2 * Math.PI) * r));
  41.                break;
  42.            default:
  43.                //Opción por defecto
  44.                System.out.println("Opcion no valida");
  45.                //Cerrar programa
  46.                System.exit(-1);
  47.        }
  48.  
  49.  
  50.    }
  51.  
  52. }
  53.  

Ejecución:

Código:
Selecciona una opción:
        [a] Cuadrado.
        [b] Círculo.

a
Introduce el lado: 5
El perímetro es: 20

Si hay alguna cosa rara o alguna sugerencia no dudéis en decirlo.
9  Sistemas Operativos / GNU/Linux / Montar partición de forma automática al iniciar el sistema [Linux] en: 7 Octubre 2011, 18:26 pm
Para hacer más cómodo nuestro trabajo con Linux podemos montar algunas particiones de forma automática al iniciar el sistema operativo. En este caso he usado
Ubuntu 10.10, pero el proceso es el mismo para casi todas las distribuciones de GNU/Linux.

Primero tenemos que listar las particiones del sistema y elegir la que queremos que se monte de forma automática:

fdisk -l


Y mostrará la siguiente salida por pantalla:


madpitbull@desktop:~$ sudo fdisk -l
[sudo] password for madpitbull:

Disco /dev/sda: 750.2 GB, 750156374016 bytes
255 cabezas, 63 sectores/pista, 91201 cilindros
Unidades = cilindros de 16065 * 512 = 8225280 bytes
Tamaño de sector (lógico / físico): 512 bytes / 512 bytes
Tamaño E/S (mínimo/óptimo): 512 bytes / 512 bytes
Identificador del disco: 0x51513b8a

Dispositivo Inicio    Comienzo      Fin      Bloques  Id  Sistema
/dev/sda1   *           1       40794   327677773+   7  HPFS/NTFS
/dev/sda2           40795       44618    30716280   83  Linux
/dev/sda3           44619       44745     1020127+  82  Linux swap / Solaris
/dev/sda4           44746       91201   373157820    7  HPFS/NTFS



En mi caso quiero que se monte la partición de Datos, en mi caso es la última /dev/sda4.

El siguiente paso es crear la carpeta donde se montará la partición, lo más normal es crearla en el directorio /media.

sudo mkdir /media/Datos


El nombre queda a vuestra elección, yo he usado Datos. A continuación tendremos que editar el fichero /etc/fstab.

Al iniciarse el sistema operativo, mirará en dicho fichero y montará las particiones que nosotros le indiquemos.

 
sudo vim /etc/fstab


Al principio del fichero podemos encontrar algunas instrucciones básicas sobre cómo debería realizarse la configuración.

Al final del archivo agregamos la siguiente línea:

# Datos partition auto mount/dev/sda4 /media/Datos ntfs-3g defaults 0 0


Donde la sintaxis es la siguiente: <dispositivo para montar automáticamente> <carpeta donde se montará> <tipo de partición> <parámetros de configuración>.

Guardamos el fichero y ejecutamos el comando sudo mount -a, si todo ha ido bien, la partición elegida ya debería estar montada.

Al reiniciar el sistema la partición estará montada sin tener que ejecutar ningún comando más. En este ejemplo he intentado dar una explicación básico, si queréis profundizar más
en este tema os recomiendo que leáis sobre los distintos parámetros de configuración del fstab.




 

10  Seguridad Informática / Seguridad / Navegar de forma segura mediante túneles SSH en: 16 Septiembre 2011, 19:22 pm
 Mediante los túneles SSH podemos asegurar casi todo tipo de protocolos, al conectarnos a una red insegura, como puede ser la red WiFi de un hotel, restaurante o las típicas redes públicas que algunos ayuntamientos ofrecen de forma gratuita (que por cierto, no sé cuanto durará), estamos expuesto a diferentes ataques por parte de otros usuarios conectados a la misma red.

 El escenario por norma general es poner la tarjeta en modo “promiscuo” y estar mirando todos los paquetes que pasan por nuestra tarjeta de red, que puede tratarse de información sensible, desde usuarios y claves hasta números de cuentas bancarias.

 Para éste ejemplo he usado un servidor VPS de tipo “budget” (precios bajos - prestaciones bajas) para realizar el artículo. Lo primero será asegurarnos de que el servidor SSH, en mi caso OpenSSH, está correctamente configurado para soportar los túneles.

 Procedemos a mirar la configuración del servicio SSH en /etc/ssh/sshd_config y buscamos las siguientes directivas:

 
AllowTcpForwarding yes
GatewayPorts yes
TCPKeepAlive yes


Donde el primer parámetro activa el redireccionamiento y encapsulación de los diferentes protolocos basado en TCP y el segundo hace que la conexión se mantenga de forma continua, normalmente después de un tiempo, que suele ser aproximadamente unas dos horas, la conexión TCP se desconecta de forma automática.

 Una vez editado el fichero de configuración, procedemos a reiniciar el servicio:

 
/etc/init.d/ssh restart
En otros sistemas operativos como CentOS, los demonios se encuentran en rc.d.

 El siguiente paso es conectarnos y crear el túnel en el puerto que pasaremos como argumento al cliente ssh:

 
ssh -D 8080 mad@servidor-personal.com


Con el comando de arriba, estamos creando un túnel en el puerto 8080 de nuestro propio equipo hacia el servidor SSH. Si queremos aprovechar el puerto y navegar de forma segura, tendremos que configurar nuestro navegador para al conectarse a los servidores web, use como servidor SOCKS nuestro propio equipo local y el puerto 8080.

 En Firefox esto se hace en la Configuración de Red:

 

 Después de guardar los cambios, es recomendable reiniciar el navegador. El proceso es similar en la mayoría de los demás navegadores, para crear el túnel SSH, si estamos en Windows, en la parte final de artículo encontrarás otros artículos de apoyo para hacerlo desde Windows mediante el cliente SSH PuTTy.

 Podemos ver un claro ejemplo si empleamos un sniffer, en éste caso WireShark, las diferencias entre el envío de datos cifrados y en claro.

 

 En el ejemplo de arriba los datos están cifrados, mientras que en el de abajo no.

 

 El uso de túneles no se limita sólo al ámbito web, podemos tunelizar cualquier protocolo, si queremos acceder de forma segura a nuestro servidor de correo, también podemos tunelizar POP, SMTP, IMAP y demás.

 
ssh -f usuario@servidor-personal.com -L 2000:smtp.gmail.com:25 -N


En éste ejemplo, estamos haciendo un túnel desde el puerto 2000 del servidor-personal al puerto 25 del servidor SMTP de gmail.com. El uso es ilimitado, sólo depende de nuestra imaginación.

 

Recursos y Documentación:

 _SSH Port Forwarding [Symantec]

 _Port Forwarding [The SSH Definitive Guide]

 _How to tunnel Web Traffic with SSH Secure Shell [Using PuTTy]

 _Breaking Firewalls with OpenSSH and PuTTy

 

Nota:

No hace falta tener un VPS o un servidor dedicado, podemos usar nuestro propio equipo que tenemos en casa, claro está, que habrá que mantenerlo encendido continuamente.
Páginas: [1] 2 3 4 5 6 7 8 9 10
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines