Sábado, 26 de mayo de 2007
ME MUDO A WORDPRESS!!!
Harto de tanta publicidad, un sistema tan inestable como bitácoras, con una edición de posts tan compleja y sufrida, y muchas otras más cosas, me mudo a wordpress. Trataré de poner todos los artículos aquí publicados en el nuevo blog.
A partir de ahora podréis leerme en la siguiente dirección:
InfoLinux en wordpress
Por: Miguel Araujo | General | Comentarios (0) | Referencias (0)
Miércoles, 24 de mayo de 2006
C++ Orientado a objetos II
Para continuar con el anterior artículo explicaremos:
Antes de continuar con la segunda parte de esta serie. Comentaré que perfectamente conozco manuales como el de C con clase, y lo recomiendo a todo el mundo que esté empezando en esto de la programación (yo ya lo leí). Estos trabajos simplemente son un apoyo a aspectos difíciles del lenguaje, un material de apoyo, y un intento de documentar temas superficialmente tocados en Internet.
1.- SOBRECARGA DE OPERADORES:
Se explicará a continuación la sobrecarga de los operadores más difíciles de encontrar en otros tutoriales o libros.
1- Operador new:
Antes de nada, comentar que estos prototipos son inamovibles, lo he comprobado. Su prototipo para memoria dinámica de tipos simples:
void* operator new(size_t tamano);
Para arrays:
void* operator new[](size_t tamano)
Como podemos sobrecargalo para que haga muchas cosas diferentes, veremos una manera que yo uso, no sé si es del todo correcta, es:
Ejemplo 1
void* operator new(size_t tamano)
{
void *puntero = NULL;
puntero = new "tipo";
return puntero;
}
Ejemplo2
void* operator new(size_t tamano)
{
void *puntero = NULL;
puntero = new("tipo"); //No entra en recursivo
return puntero;
}
Ejemplo3
void* operator new[](size_t tamano)
{
void *puntero = NULL;
puntero = new "tipo"[tamano];
return puntero;
}
- Explicación:
En el ejemplo1, creamos un puntero genérico del tipo void apuntado a NULL. Lo que me recuerda, un pequeño consejo sobre NULL extraido de Ceklog.
Después utilizamos memoria dinámica normal, y reservamos memoria para nuestro "tipo". El tipo puede ser el que nos interese en nuestro caso, puede ser un int, float, una clase...
Estaréis pensando que claro, eso no es nada dinámico, reservar siempre espacio para el mismo tipo, estoy de acuerdo. Pero lo cierto es que no he dado con otra forma de hacerlo. Teóricamente debería ser new(tamano) lo que hiciesemos, sin embargo esto a nuestro compilador no le va a gustar demasiado, podéis comprobarlo.
- LLamar a estos operadores:
Estos operadores se llaman en un posible main del siguiente modo:
objeto.operator new(parámetros);
Sobre este operador en Internet, siempre he encontrado información poco detallada, nunca un ejemplo clarificador. Incluso estoy seguro de que algunos que lo mencionan, realmente no sabrían usarlo.
El mejor ejemplo para C++ lo encontré en la web de Chuidiang , y aunque se explica para C++, no me convence del todo, porque dentro del operador utiliza malloc() y free() funciones propias de C para la gestión dinámica de memoria.
Pero esta sería una opción para lograr reservar memoria según el tamaño que queramos. Su código es:
Ejemplo4
void* operator new(size_t tamano)
{
void *puntero = NULL;
puntero = malloc(tamano);
return puntero;
}
Así que dejo aquí planteada la cuestión por si alguien quiere aclararla, de cómo sobrecargar new usando solamente memoria de C++, yo por mucho que he buscado no encontré nada al respecto.
2- Operador delete:
Su prototipo de nuevo inalterable es:
void operator delete(void *p);
Este resulta más sencillo y evidente en su uso. Un ejemplo sería:
void operator delete(void *puntero)
{
delete puntero;
return;
}
Le pasamos un puntero. En el operador liberamos la memoria. Se suele usar para tracear errores de memoria dinámica. Del siguiente modo, poniendo un contador de punteros creados y uno de punteros liberados, si no coinciden, ¡mal asunto!
Para arrays el prototipo es:
void operator delete[](void *p);
{
delete []puntero;
return;
}
3- Sobrecarga del operador []:
Este operador conocido como de subindexación de arrays, solo puede sobrecargarse como un método miembro (nunca friend, prestad atención a esto, nunca friend). Su prototipo:
tipo& nombre_clase::operator [](int indice )
Un ejemplo básico, aunque quizás demasiado enrevesado, de su uso es crear un array seguro. Veamos el código:
class Arrayseguro
{
public:
int array[5];
Arrayseguro();
int & operator [](int indice);
};
Arrayseguro::Arrayseguro()
{
for(int i=0;i<5;i++)
array[i]=i;
}
int & Arrayseguro::operator [](int indice)
{
if(i<0 || i > 4)
exit(1);
return array[i];
}
int main()
{
Arrayseguro objeto;
objeto.array[3] = 8; //FUNCIONA
//objeto.array[5] = 9; ABORTA
return 0;
}
- Explicación:
Creamos una clase que tiene por atributo un array y sobrecargamos el operador [] para que si se intenta acceder a posiciones que se encuentran fuera del array el programa aborte con código de error 1. Este ejemplo perfectamente se puede hacer con memoria dinámica, resultando mucho más útil.
Esta es una interesante medida de seguridad para nuestros programas.
2.- CLASES ABSTRACTAS:
El otro día me olvidé de comentar lo que son las clases abstractas, el segundo uso de la palabra reservada virtual.
Cuando en una clase definimos un método como virtual y lo igualamos a cero, se dice que es virtual puro. Una clase que contenga uno solo de estos métodos, se considera abstracta.
No se pueden generar objetos de las clases abstractas, ya que son una simple base para heredar. Lo vemos mejor con un ejemplo:
class Personalidad
{
protected:
int sociabilidad;
int gracioso;
public:
virtual void mostrar() = 0;
virtual int get_gracioso() = 0;
};
class Persona : public Personalidad
{
protected:
char *nombre;
int edad;
public:
void mostrar();
int get_gracioso();
bool mayor_de_edad();
};
void Persona::mostrar()
{
cout << "La persona es: " << nombre << endl;
return;
}
int Persona::get_gracioso()
{
return gracioso;
}
bool mayor_de_edad()
{
if (edad >= 18)
return true;
return false;
}
int main()
{
Persona Miguel;
return 0;
}
- Explicación:
Se observa que no tendría mucha lógica crear un objeto de tipo personalidad según la jerarquí de herencia. Por ello definimos la clase Personalidad como abstracta.
La segunda consideración a tener en cuenta, es que los métodos virtuales puros, siempre se deben redeclarar en las hijas, digamos que son un esquema o molde, y de este modo, si nos olvidamos el compilador nos dará error, evitando que el asunto vaya a más.
3.- CONCLUSIONES SOBRE LA POO:
Aquí termina esta segunda parte, los operadores tratados son bastante avanzados, igual que las clases abstractas. Deben utilizarse simplemente cuando se estime necesario. La programación orientada a objetos existe, no podemos negarlo, y por lo tanto es importante conocer sus ventajas e inconvenientes.
Son muchos sus detractores, habitualmente se argumenta que de ser una idea tan genial C habría dejado de usarse hace años, sin embargo no ha ocurrido. No existe todavía una técnica inmejorable.
Desde mi punto de vista, los objetos pueden brindarnos conjugados con la programación estructurada un buen arma de ataque.
Se debe sobrecargar solamente los operadores estrictamente necesarios, y tener una estructura hecha de las clases, antes de ponernos manos a la obra. Al principio pensar orientado a objetos es difícil, pero nos acostumbraremos.
En próximos fascículos, dentro ya de algún tiempo, quizás comente algo sobre programación explícitamente en Linux. Insisto que si os parece bien, dejéis algún que otro comentario.
Un saludo
Por: Miguel Araujo | Programación | Comentarios (6) | Referencias (0)
Martes, 23 de mayo de 2006
C++ Orientado a objetos
Se explicará:
Conocimientos previos de:
En este artículo explicaré la sobrecarga del operador de extracción >> (sí, este operador se denomina así, aunque pueda no parecerlo) y el operador insertor <<. Más tarde comentaré aspectos de la herencia, polimorfismo y otros asuntos que suelen resultar difíciles de comprender en un primer momento.
1.- OPERADORES:
- Operador insertor <<:
El prototipo de su sobrecarga es:
ostream &operator <<(ostream &flujo, nombre_de_la_clase objeto)
{
flujo << "Mostramos informacion del objeto: "
<< objeto.info << endl;
return flujo;
}
- Operador extractor >>:
El prototipo de este operador sobrecargado es:
istream &operator >>(istream &flujo, nombre_de_la_clase objeto)
{
cout << "Introduzca la informacion del objeto: ";
cin >> objeto.info;
cout << endl;
return flujo;
}
2.- SOBREESCRITURA DE MÉTODOS:
En C++ se pueden sobreescribir los métodos que queramos de tal forma que el compilador llamará al método del objeto correspondiente:
class Uno
{
protected:
int x;
public:
Uno(){x=2;}
mostrar(){cout << "CLASE UNO" << endl;}
};
class Dos : public Uno
{
private:
int y;
public:
Dos(){y=3;}
mostrar(){cout << "CLASE DOS" << endl;}
};
int main()
{
Uno objeto1;
objeto1.mostrar() // Mostrará "CLASE UNO"
Dos objeto2;
objeto2.mostrar() // Mostrará "CLASE DOS"
cin.get();
return 0;
}
En la herencia entre clases en ocasiones nos resultará útil que se ejecuten los métodos de la clase base o padre, y en otras los de la hija o la que hereda.
Como se acaba de ver esto se puede lograr mediante el objeto con el que llamemos al método, pero esto es lo que se conoce como ligadura estática, es decir se debe hacer antes de compilar el programa. Ahora veremos cómo lograrlo en tiempo de ejecución, mediante el polimorfismo (ligadura dinámica).
3.- POLIMORFISMO:
No os asustéis, el polimorfismo, al ir asociado a punteros, suele ser un quebradero de cabeza para los estudiantes de Programación. Lo cierto es que es un concepto sencillo que incorpora una potente flexibilidad al lenguaje C++.
Si en nuestro anterior ejemplo, nuestro main2 fuese:
int main()
{
Dos objeto2;
Uno *puntero = &objeto2;
puntero->mostrar(); // Mostrará "CLASE UNO"
}
Explicación:
Hemos creado un objeto de la clase hija, después un puntero del tipo Uno es decir de la clase base, que hemos apuntado a un objeto del tipo Dos (es decir de la hija). ¿Pero en punteros no se podía apuntar solamente al mismo tipo? Sí, vale, pero en la herencia, podemos usar un puntero a la clase padre y dirigirlo a la hijas.
Lo último es llamar al método mostrar(). Sin embargo no se llama al método de la clase hija, sino a la padre, a pesar de donde apunta el puntero.
¿Cómo lo solucionamos?
Si lo que nos interesa, y esto será así la mayoría de las veces, es llamar al método de la clase hija. definiremos la función mostrar en la clase padre como virtual. Quedaría así:
class Uno
{
protected:
int x;
public:
Uno(){x=2;}
virtual mostrar(){cout << "CLASE UNO" << endl;}
};
Ahora el mismo puntero, de antes, el mismo main de antes, ejecutará el método de la hija, es decir mostrará "CLASE DOS". Esto es en esencia el polimorfismo. Luego "virtual = métodos de la derivada".
4- HERENCIA VIRTUAL:
Pero vamos a complicarlo un poco más, y ya de paso explico la herencia virtual, también bastante desatendida en Internet.
Añadiremos una clase tres y una cuatro, con el siguiente código:
class Tres : public Uno
{
private:
int z;
public:
void mostrar(){cout << "CLASE TRES" << endl;}
};
class Cuatro : virtual public Dos, Tres
{
private:
int w;
public:
void mostrar(){cout << "CLASE CUATRO" << endl;}
};
La clase Tres, es similar a la Dos, hereda de Uno, digamos que Dos y Tres serían "hermanas". La clase Cuatro hereda de ambas, el tema es que de este modo contendría dos clases Uno, luego el compilador dará probablemente error de ambigüedad. ¿Solución?
Como vemos he añadido virtual al tipo de herencia. ¿Qué significa? El asunto es fácil, si hay una clase base repetida en las hijas, solamente se heredará una vez. fácil, ¿no?
- Virtual se hereda:
Ahora bien, volviendo a lo del polimorfismo, el main2, seguiría mostrando "CLASE DOS" si lo ejecutaramos ahora. Pero si hiciesemos:
int main()
{
Cuatro objeto4;
Uno *puntero = &objeto4;
puntero->mostrar(); // Mostrará "CLASE CUATRO"
}
Parece lógico, pero debemos observar que la clase Cuatro no hereda directamente de Uno en ningún momento, y sin embargo el método mostrar sigue siendo virtual. Esto es debido a que virtual se hereda, ¿a qué hora se ve todo más claro? Un último esfuerzo.
5.- LLAMADAS A MÉTODOS DE LA CLASE PADRE:
Me gustaría que recordásemos el primer ejemplo, teníamos dos clases Uno y Dos, y Dos heredaba de Uno, ni virtuales ni nada, simplemente el método estaba sobreescrito ¿ok? Vamos a hacerle unas modificaciones interesantes:
class Uno
{
protected:
int x;
public:
Uno(){x=2;}
mostrar(){cout << "CLASE UNO" << endl;}
};
class Dos : public Uno
{
private:
int y;
public:
Dos(){y=3;}
mostrar()
{
Uno :: mostrar();
cout << "CLASE DOS" << endl;
}
};
int main()
{
Uno objeto1;
objeto1.mostrar() // Mostrará "CLASE UNO"
Dos objeto2;
objeto2.mostrar()
// Mostrará "CLASE UNO"
"CLASE DOS"
cin.get();
return 0;
}
Vale este ejemplo es muy sencillito, lo sé. De este modo clasebase::metodo() podemos llamar a los métodos, a los que tengamos acceso, de la clase base. Igualmente a los operadores clasebase::operator =(parametro);. Así no tendremos que reescribir o copiar y pegar el codigo para añadir algo nuevo. El típico ejemplo de libro de programación:
class Persona
{
protected:
char nombre[30];
public:
void mostrar(){cout << "El nombre de la persona es: "
<< nombre << endl;}
};
class Estudiante : public Persona
{
private:
int curso;
public:
void mostrar()
{
cout << "El nombre de la persona es: " <<
nombre << endl;
cout << "Esta en el curso: " << curso << endl;
}
};
Como vemos si usasemos las llamadas a la padre el código sería:
class Estudiante : public Persona
{
private:
int curso;
public:
void mostrar()
{
Persona::mostrar();
cout << "Esta en el curso: "
<< curso << endl;
}
};
En este caso, la diferencia apreciable es mínima, pero en código extensos simplifica depuración y estructuración, y ahorra errores y tiempo de "reinventar la rueda".
Si interesa, otro día podría comentar el operador [] (Para construir arrays seguros), operadores como new y delete, clases abstractas, y algún que otro truquillo, espero comentarios..
Un saludo
Por: Miguel Araujo | Programación | Comentarios (3) | Referencias (0)
Sábado, 08 de abril de 2006
La canción del Administrador de Sistemas
Aunque hace ya un tiempo que vi este vídeo, no encontraba el momento para ponerlo aquí. Disfrutad de esta graciosa cancioncilla sobre el system administrator. Para ver el vídeo solamente tenéis que pinchar encima del reproductor.
Un saludo
Por: Miguel Araujo | General | Comentarios (0) | Referencias (0)
Martes, 28 de marzo de 2006
Temas interesantes: Licencias, enlaces...
Os dejo aquí algunas cosas que me han venido bien en los últimos días para que les saquéis partido
- Desde hace unos meses voy intentando recabar información sobre las distintas licencias disponibles aplicables al mundo de la informática, porque creo que es importante conocerlas, para salvaguardar la autoría de nuestros artículos a la vez que permitimos que otros puedan trabajar con ellos. Seguro que a muchos os suenan algunos de estas: GFDL, GPL...
Hoy me he encontrado en el siguiente blog, el Demonio negro un interesante vídeo que explica de forma comprensible la licencia Creative Commons. No tiene desperdicio. - He encontrado una traducción no oficial al español de la GPL. Vale la pena echarle un vistazo, para darnos cuenta de las posibilidades de las diferentes licencias¡
- Hoy me han hablado de un buscador que ordena por categorías los resultados, ¿que de qué va eso? Probadlo y descubriréis lo práctico que puede ser. Por lo visto el motor de búsqueda está implementado para recabar resultados de los buscadores más populares, ya sabéis cuáles son 8)
Estoy pensando en mover el blog a otro servicio, por problemas de velocidad en el servicio, la dificultad de maquetar decentemente el blog y debido a problemas con la visualización de CSSs en IE. Todo depende de si resuelven alguno de estos temas en los próximos días, y si yo logro resolver el tema de los CSSs.
Un saludo
Por: Miguel Araujo | General | Comentarios (0) | Referencias (0)
Viernes, 17 de febrero de 2006
Creando un dispositivo de Loopback
Versión PDF: 
Dificultad (Sobre 5): 
Veremos cómo crear un dispositivo de loopback paso a paso, con sus aplicaciones prácticas, aprovechando para explicar opciones especiales de montajes de particiones, aclarar conceptos...
REQUISITOS:
- Para exprimir al máximo el artículo: Conocer el montaje de particiones, y las principales opciones del parámetro mount -o
- Conocer el uso del comando dd y el operador aritmético básico $((expresion))
- ¿Qué es un dispositivo de Loopback?
- Usos prácticos
- Cuotas de disco duro
- Creando el dispositivo
- Últimos consejos
¿QUÉ ES UN DISPOSITIVO DE LOOPBACK?:
Este es un concepto algo difícil de entender, no os desaniméis en la definición, veréis que luego no es tan complicado (viéndolo en la práctica).
Consiste en un dispositivo especial de Linux que permite hacer referencias a un fichero o a un sistema de ficheros como si de otro dispositivo se tratase. Los datos se leen y se escriben en el fichero, en vez de en pistas del disco duro real.
Estos dispositivos se nombran /dev/loopX siendo X un dígito. Se usan para simular un dispositivo de bloques (una partición). Esta es la clave, simular una partición.
USOS PRÁCTICOS
- Establecer cuotas de espacio de disco duro. Se esplicará con más detalle a continuación
- Montar imágenes ISO antes de pasarlas a un CD para comprobar su funcionamiento
- Para montar una partición cifrada de forma transparente al usuario. Esto se conoce como cryptoloop, y en la actualidad ha caído en desuso, debido al nuevo sistema dm-crypt más eficaz y estable. Aun así es interesante conocerlo, para comprender mejor el segundo sistema
CUOTAS DE DISCO DURO:
Una cuota es un límite, en este caso, un límite de espacio que podremos ocupar en el disco duro. Algo así como los 2GB de Gmail.
Imaginemos que tenemos un servidor corriendo, un Apache, que sirve nuestra página web a todo Internet. Normalmente recibimos un buen promedio de visitas, pero aún así el syslog da a basto, igual que logrotate, así que los logs ocupan un espacio pero no todo. Un día, un enemigo de la empresa, un competidor, un empleado descontento... nos ataca por medio de un DoS (Denial of Service, ni siquiera Distributed). Sin embargo nuestra capacidad de logs se satura y el sistema se cae, porque no hicimos una partición a parte para estos logs. De este modo, solo la partición se hubiese saturado, y no el sistema completo.
Este suele ser uno de las situaciones típicas con las que se explica el loopback, nosotros lo veremos de una forma más casera, más asequible al usuario medio.
El entorno: Tenemos un ordenador para varias personas, cada una con su usuario y su propio home en /home/login, y como administradores de sistemas, queremos dar una situación de igualdad a todos los usuarios, en torno a cuanto espacio pueden ocupar, es decir, imponer un límite de espacio, por ejemplo 100mb, y queremos que no se pueda superar.
CREANDO EL DISPOSITIVO
Antes de nada, os podéis descargar un fichero txt que contiene mi sesión de consola para crear este dispositivo, puede que ayude a resolver dudas, o para tener el código recopilado.
En todos los casos, el dispositivo se creará del mismo modo. Primero vamos a crear un fichero de 100 mb, en /dev/loop/.
cd /dev/loop/Le damos formato, en este caso un reiserfs:
sudo dd if=/dev/zero of=carlosloop bs=1k count=$((1024*100))
sudo mkfs.reiserfs -f carlosloopNos preguntará, si queremos continuar, le damos a <
Continue (y/n):y
Initializing journal - 0%....20%....40%....60%....80%....100%
ReiserFS is successfully created on carlosloop.
El journal es un registro que guarda a nivel de bit lo que se debe guardar en el disco duro, y va volcando esos bufferes, si el sistema se cuelga, al reiniciar comprobará ese registro y terminará de grabar los bits que le faltasen. En cambio si usamos ext2, y sufrimos un corte de luz, nos tendremos que despedir de los datos que no se volcaron del buffer. El volvado se pude forzar manualmente con el comando sync.
El journal ocupa exactamente 33 mb, que no podremos usar para otras cosas, por lo que en realidad, 100 mb efectivos sería un dispositivo de 133mb.
Los formatos más conocidos que usan esta técnica son: ext3, reiserfs y XFS. Es por esto, que siempre al no iniciado en Linux, se le suele recomendar ext3.
Comentar también, que toda partición reserva un espacio exclusivo para el usuario root, así si hemos llenado con un usuario normal todo nuestro home, el root podrá seguir guardando ahí ficheros, ¿increíble no?
Creamos una carpeta temporal, con:
mkdir /tmp/pruebaMontamos el dispositivo como de loopback:
sudo mount -o loop,rw /dev/loop/carlosloop /tmp/prueba/Si se monta una partición encima de otra, la que está por debajo, no es borrada, simplemente no será visible, esto es importante tenerlo en cuenta si la montamos sobre algún directorio ya existente no vacío, por ejemplo sobre /tmp. De aquí se deduce, que un posible método de ocultación de datos es montar una partición encima de lo que queremos esconder, aunque esto solo nos funcionará con usuarios inexpertos, tenedlo en cuenta.
Le damos los permisos que queramos a nuestra partición, yo usaré:
chmod 775 /tmp/prueba/Con el comando df -h (diskfree -h humareadble) para ver el dispositivo de loop:
df -hEl archivo /etc/mtab contiene infomación al vuelo de las particiones montadas, si hacemos un cat nos dará:
/dev/loop/carlosloop 100M 33M 68M 33% /tmp/prueba
/dev/loop/carlosloop /tmp reiserfs rw,loop=/dev/loop0 0 0Vemos que el journalising ocupa 33Megabytes, como ya he dicho, sin embargo de esos una mega es usable por el usuario, por lo que tenemos 68megas eficaces disponibles para el usuario.
Intentaré ahora desbordar el loopback para probar su efectividad, creando para ello un archivo de una mega más de tamaño al disponible (69). Primero me dirijo cd /tmp/prueba/
sudo dd if=/dev/zero of=desbordamiento bs=1k count=$((1024*69))Vemos que escribe un archivo de 68 megabytes, 68 y ni uno más, el dispositivo está lleno, y ya no se podrán grabar nuevos datos.
dd: escribiendo «desbordamiento»: No queda espacio en el dispositivo
69481+0 registros leídos
69480+0 registros escritos
71147520 bytes transferred in 1,292817 seconds (55032935 bytes/sec)
Si queremos que una partición se conserve si reiniciamos la máquina, tendremos que añadirla a /etc/fstab, añadir en concreto la siguiente línea:
/dev/loop/carlosloop /tmp/prueba reiserfs loop,rw 0 0Ahora desmontaremos todo el tinglado:
sudo umount /dev/loop/carlosloopComo no he salido del dispositivo de loopback, no puede desmontarlo, y me salta el error dispositivo ocupado. Esto es un error muy común, así que tened cuidado de no tener ningún archivo de la partición abierto, y no estar dentro de ella, antes de desmontarla. En casos extremos se podría forcar con el modificador -f.
umount: /tmp/prueba: dispositivo ocupado
Lo vuelvo a hacer:
ÚLTIMOS CONSEJOS:
sudo umount /dev/loop/carlosloop
Hemos montado la partición en un directorio de prueba, pero en nuestro entorno tenemos dos opciones, montarla sobre el directorio home que queremos restringir (teniendo en cuenta que no haya nada debajo, recordad), o en otra parte del ordenador, y hacer un enlace simbólico a la partición de loopback.
Por ejemplo, podríamos montar los homes en /tmp/ (lo que significa, que una vez apagado el sistema, los archivos de borrarán y no se podrán recuperar) y hacer:
Ya está todo, explicado un poco por encima, porque el tema daría para mucho que hablar y contar, si no tienes conocimientos previos de montaje o creación de particiones, encontrarás muy buen material sobre el asunto en Internet y diferentes libros. Yo te recomiendo que leas con atención los enlaces:
ln -s /dev/loop/carlosloop /home/carlos/
- El blog La Coctelera suidae, que publicó un artículo, que resume las opciones más interesantes de mount -o.
- Un pequeño pero práctico manual de referencia para usuarios medios de Linux del equipo Zonasiete. Ideal para principiantes, y para llenar las lagunas que podamos tener sobre diferentes temas del Linux:
Manual Linux ZonaSiete
Digo esto, porque la ventaja fundamental del particionado del disco, es que las opciones de mount se aplican a las particiones como unidades mínimas, pudiendo poner particiones como no ejecutables, sin bits suid... es decir definir unas políticas de sistema, como todo buen administrador de sistemas debería. Podremos también hacer RAID y LVM sobre ellas.
Espero que con este artículo, te pique el gusanillo, y avances otros temas por tu cuenta. Si os interesa el tema, y queréis que desarrolle algo con mayor profundidad, dejadme un comentario.
Un saludo
Por: Miguel Araujo | Linux | Comentarios (6) | Referencias (0)
Lunes, 13 de febrero de 2006
SECURIZANDO IMAGENIO
Versión PDF:
Dificultad (Sobre 5): 
Veremos cómo configurar nuestro router de Telefónica, tanto en Linux como en Windows, para evitar que los vecinos u otros atacantes, nos roben ancho de banda, puedan ver Imagenio por la cara, o peor aún, naveguen en Internet con nuestra identidad.
ÍNDICE:
- Motivaciones del atacante
- Barreras preliminares
- Habilitando WPA-PSK
- Configurando nuestro adaptador inalámbrico (En Windows y Linux) para WPA. En concreto una IPW2200 b/g
MOTIVACIONES DEL ATACANTE:
Recientemente instalaron en mi casa Imagenio de Telefónica, como muchos ya sabréis, viene con WEP por defecto (de hecho la clave se encuentra escrita en la parte de abajo del router, y solamente varía en unos dígitos intermedios con otros routers de Telefónica).
Lo cual hace demasiado fácil que un atacante con unos conocimientos mínimos, pueda:
- Robarnos ancho de banda
- Acceder a la configuración del router
- Ver Imagenio en el ordenador.
- Navegar en Internet con nuestra identidad
Como estoy estudiando fuera de mi ciudad natal, Burgos, tuve que esperar a este fin de semana, para poder enfretarme al asunto de dar seguridad a mi red inalámbrica familiar. Voy a explicar los pasos que he dado, los manuales que referencio, están realizados en Windows, pero del mismo modo se pueden usar para Linux, simplemente con otro browser diferente.
BARRERAS PRELIMINARES:
- Como barreras preliminares contra un atacante dispuse las siguientes:
- 1.- Cambiar el ESSID por defecto y deshabilitar el broadcasting:
Las redes Imagenio tienen un nombre de red, que comienza siempre por WLAN_ y ofrecen algo más que simple ancho de banda. Esto aumenta el interés del atacante. Así que lo primero es cambiar el nombre de red o ESSID. Si deshabilitamos el broadcasting nuestro nombre de red no será visible en un escaneo con Windows (lo que significa que no será visible para un atacante, siempre y cuando este use Windows, ya que Linux es capaz de detectar este tipo de redes escondidas). En este caso será necesario configurar el ESSID manualmente. - 2.- Cambiar la contraseña del router por defecto:
Esta es aún más importante. El router de Telefónica, tiene como nombre de usuario:1234 y contraseña:1234 por defecto. Yo mismo he comprobado en redes cercanas, la facilidad de acceder al router, con todo lo que esto conlleva. Por favor, un poco de ética, y nunca tocar nada, sino sabéis de qué se trata. - 3.- Desactivar DHCP:
Esta es una barrera más, para desanimar al atacante. Consiste en no proporcionale en una dirección por defecto. Normalmente se le añade el poner la IP del gateway en una dirección no estándar, como puede ser 192.168.1.1 , por lo que en este caso no nos servirá de mucho, ya que no podremos cambiar la IP, ya que el router se encuentra en red con el deco, y la configuración es demasiado compleja. Por lo que este paso, resulta opcional, y puede interesar no llevarlo a cabo, por comodidad. - 4.- Filtrado de direcciones MAC:
Como ya sabemos, las medidas 3 y 4, no son impedimentos reales en un ataque.
Todos estos pasos vienen recogidos en un manual ilustrado que encontré de ADSLAyuda, y que seguro viene genial a los indecisos, principiantes e inseguros.
HABILITANDO WPA-PSK:
Estas son simples obstáculos, salvables por un atacante. Ahora pasemos a la acción, vamos a habilitar la más sencilla de las configuraciones más seguras que WEP, WPA-PSK. Sobre qué es WPA-PSK, hay mucho escrito en la red, documentación técnica y detallada, así que no entraré en materia.
¿Por qué digo que es la más fácil? Porque las demás necesitan un servidor RADIUS, esto a mí particularmente no me parece muy difícil de configurar, digo esto porque en varios sitios en Internet se pueden leer posts que dicen que estos sistemas sólo se encuentran en empresas,pymes...
- 1.- Habilitando WPA-PSK:
Esto también lo he encontrado totalmente detallado en otro manual de ADSLAyuda. Cabe decir que WPA-PSK, es un protocolo también inseguro, pero no tanto como WEP, y limitaremos el rango posible de atacantes a usuarios avanzados, que normalmente usan sus conocimientos de forma ética.
CONFIGURAR EL ADAPTADOR INALÁMBRICO:
Lo que no viene bien explicado, es cómo configurar nuestros adaptadores inalámbricos, para que accedan a la red.
- 1.- En Windows:
Para ello usaré el propio configurador de redes inalámbricas de Windows XP. Debemos ir a Panel de Control >> Conexiones de red >> Botón derecho sobre Redes inalámbricas >> Propiedades >> Ir a la pestaña redes inalámbricas >> Seleccionar nuestra red >> Dar al botón inferior Propiedades.
Nos saldrá la siguiente ventana, que debemos configurar como se describe en la imagen.
- 2.- En Linux:
En muchos foros de seguridad inalámbrica o Linux sin cables, se explica cómo debemos asociarnos a nuestra red si tiene WEP. Pero en muy pocos sitios se hace referencia a cómo lograrlo con WPA. Ahora veremos el método para conseguirlo detallado paso a paso.
La instalación está hecha en una Ubuntu Breezy 5.10 con una tarjeta inalámbrica IPW2200 B/G.
Necesitaremos el paquete wpasupplicant. Antes de nada, conviene comprobar que nuestra tarjeta o driver es compatible con este demonio. Este es un programa, que en el momento en que escribo estas líneas, está en fase beta, aunque funcione de manera bastante estable.
Lo instalaré con el gestor de paquetes apt. Para ello, abrimos una consola:
sudo apt-get install wpasupplicant
En otras distribuciones, podremos usar diferentes gestores de paquetes: emerge, yum... o también bajarnos los binarios y compilarlos en nuestra máquina, esto es a gusto del lector.
1.- Después necesitaremos generar nuestro psk válido:
wpa_passphrase "SSID o nombre de red" "nuestra clave"
Nos devolverá algo similar a lo siguiente:
network={
Es esta sarta de números y letras la que nos interesa. Copiamos el psk.
ssid="El nombre de red que pusiste"
#psk="La clave que pusiste"
psk=15671de34216d794948baa03b0
f3d9a0564763f698fbb716c75ccfcb5f6197aa
}
2.- Ahora editaremos el archivo wpa_supplicant.conf. Debería encontrarse en /etc/wpa_supplicant.conf , de no hacerlo, siempre podremos usar el comando find o locate para encontrar la ruta del fichero.
Lo editamos con nuestro editor preferido, en mi caso VI, aunque para principiantes resulta mucho más sencillo gedit, como root, por supuesto.
sudo gedit /etc/wpa_supplicant.conf
Ahora debemos colocar lo siguiente en nuestro fichero:
ap_scan=2
Es en psk donde pondremos lo que acabamos de copiar, el resto del fichero se deja tal cual viene por defecto.
network={
ssid="Tu nombre de red"
key_mgmt=WPA-PSK
proto=WPA
pairwise=TKIP
group=TKIP
psk=15671de34216d794948baa03b0f3
d9a0564763f698fbb716c75ccfcb5f6
}
Si tenemos el SSID oculto, tendremos que cambiar el valor Scan_ssid=1.
3.- Ahora ya está todo listo, así que vamos a asociarnos y autenticarnos frente a la red. Para ello escribiremos:
sudo wpa_supplicant -i ath0 -c /etc/wpa_supplicant.conf -d -D madwifi -w
En mi caso que uso una ipw2200 b/g, el comando quedaría así:
sudo wpa_supplicant -i eth1 -c /etc/wpa_supplicant.conf -d -D ipw -w
Después de este comando, el paquete wpasupplicant nos informará de los pasos que esté llevando a cabo. Si no consigue conectar, nos informará de los motivos, es recomendable, comprobar que:
- Es necesario tener una versión reciente del driver, que tenga la posibilidad de WPA incorporada. Si nuestro driver no soporta WPA probablemente obtengamos algo una línea que diga:
ioctl[IPW_IOCTL_WPA_SUPPLICANT]: Invalid argument
- Comprobar todos los pasos anteriores, tener especial cuidado en no confundirse en los datos al generar el psk.
dhclient eth1
Y si lo tenemos puesto en modo manual, como root:
ifconfig eth1 inet 192.168.1.5 # La IP estática en la red
ifconfig eth1 up
route add default gw 192.168.1.1 #La IP del router - Es necesario tener una versión reciente del driver, que tenga la posibilidad de WPA incorporada. Si nuestro driver no soporta WPA probablemente obtengamos algo una línea que diga:
O bien, actualizar la lista de redes, clickar en la nuestra (siempre y cuando no escondiéramos el SSID) y en contraseña escribir nuestro psk.
Dificultad especial (Sobre 5):
Podéis encontrar más material interesante sobre el router Zyxel 660 HW de Telefónica, en
Espero, que este manual, os sirva para securizar vuestra red, y evitar posibles gorrones. Si tenéis alguna duda, posteadla como comentario, y espero poder ayudaros.
Si os interesan manuales como este, o información relativa a algo sobre Linux sin cables, dejad un comentario al respecto.
Hasta la próxima
- El sitio especializado en seguridad Shell Security, publicaba el 16 de febrero de 2006, una noticia sobre este manual (con más de 4000 visitas).
- Error500, publicaba en su recopilatorio de blogs semanal XXXIII, un enlace recomendando este blog.
PUBLICADO EN:
Por: Miguel Araujo | Wireless | Comentarios (5) | Referencias (3)
Viernes, 10 de febrero de 2006
Poniendo skins a mplayer
Dificultad (Sobre 5):
Veremos cómo poner skins al programa de reproducción de vídeo Mplayer, que es el que utilizo yo y recomiendo, debido a su facilidad de uso, escaso consumo de CPU...
La configuración, que a continuación se describe, se ha probado en una distribución Ubuntu 5.10, con el mplayer instalado mediante apt, aunque no debería ser muy diferente en otras distribuciones.
SKIN DE MPLAYER:
Lo primero que necesitamos es encontrar una web de skins para el Mplayer , con varias opciones, para encontrar algo acorde con nuestro escritorio y preferencias.
En esta web, encontramos diferentes diseños, a mí particularmente me llama la atención el basado en la película Terminator3. Descargamos el archivo comprimido, a nuestro ordenador. Después descomprimimos la carpeta, yo uso ark, y la ponemos en una carpeta donde tengamos permisos de escritura.
Abrimos una shell de usuario, y movemos la carpeta, en mi caso:
sudo mv ./Terminator3/ /usr/share/mplayer/Skin/Ejecutamos el mplayer y pinchamos en la S pequeña señalada con una X en la imagen:
Después, nos saldrá un menú, con los skins que el programa encuentra en su directorio, en teoría deberíamos tener dos en estos momentos: default y terminator3. Marcamos Terminator3 y damos a ok.
Ahora es tu turno, busca el skin que más te guste, y sigue los pasos de este manual. Recuerda que el directorio donde este la carpeta Skin puede variar, según lo instalaste: compilando, a partir de un .deb, .rpm ...
Espero vuestros comentarios, y peticiones sobre qué os gustaría saber maquear en vuestro escritorio.
Un saludo
Por: Miguel Araujo | Tunea tu escritorio | Comentarios (0) | Referencias (0)
Viernes, 10 de febrero de 2006
BIENVENIDO A INFOLINUX
Saludos a todos y bienvenidos a mi weblog, InfoLinux. Me llamo Miguel Araujo Pérez, y soy estudiante de Ingeniería Informática. Infolinux no es mi primer proyecto en la red de redes, pero si pretende ser el más atractivo hasta la fecha.
Este blog busca ser un punto de encuentro para aquellos que sienten curiosidad por el Sistema Operativo GNU/Linux. Aquí podrás encontrar manuales, curiosidades, anécdotas, noticas, scripts caseros que te ayuden a sacar partido a tu ordenador, preguntar dudas y muchas otras cosas más. Quédate con nosotros y siéntete libre de dar tu opinión en cualquier artículo.
Gracias
Por: Miguel Araujo | General | Comentarios (0) | Referencias (0)
Búsqueda
Acerca de InfoLinux
Tu punto de encuentro GNU/Linux: Manuales, anécdotas, curiosidades, consejos y trucos, ¡sácale partido a tu ordenador!
Blogs que leo
-
Bítacora de Webmaster
Ceklog
Webs que visito
Todo-LinuxSindicación
Créditos
Diseñado por Studio.st
Online gracias a Bitacoras.com