El Mundo de Ubuntu

SSH (acrónimo del inglés Secure SHell, cuya traducción sería intérprete de comandos seguro) es un protocolo de comunicación para controlar un ordenador en remoto a través de una CLI (Command Line Interface -Interfaz de Línea de Comandos- también llamada: "shell".

Sirve para conectarnos con un ordenador ante el cual no estamos físicamente, bien porque está en una sala de servidores refrigerada, bien porque no tiene teclado ni pantalla, por ejemplo los que están apilados en un rack (un armario donde se guardan ordenadores como los servidores web, de correo electrónico, firewalls, etc...).

Es parecido a Telnet, con la gran diferencia de que en el caso de ssh, la información viaja codificada con lo cual es muchísimo más segura, en el caso de conectarnos a un ordenador que esté en nuestra LAN no es tan importante, pero si nos conectamos a través de Internet es fundamental, casi diría que imprescindible, usar un protocolo seguro como SSH. .

Conectarnos a un servidor ssh.
Para conectarnos con un servidor SSH remoto desde Ubuntu tenemos un cliente por defecto. En Windows no, hay que descargar un cliente (por ejemplo, el programa putty(Putty)). Usar el cliente es muy sencillo: basta con teclear desde una consola o terminal lo siguiente:

$ ssh host_remoto

Donde host_remoto es la IP del servidor SSH o el nombre de este. Eso hará que nos conectemos con nuestro nombre de usuario. Si queremos conectar como un usuario remoto teclearemos:

$ ssh usuario_remoto@host_remoto

Luego nos pide la contraseña del usuario. La primera vez que nos conectemos a un servidor tarda un poco más y nos pide confirmación tecleando "yes" con todas sus letras, las subsiguientes ya no. Sabemos que estamos conectados porque el prompt cambia y aparece en lugar del nombre de nuestro host el nombre del host remoto.

Los comandos, programas y scripts que lancemos tras conectarnos se ejecutarán en la máquina a las que nos hayamos conectado, utilizando los recursos del host remoto (CPU, memoria, disco, etc.).

Esta arquitectura puede utilizarse, por ejemplo, para tener un servidor más potente y varios clientes que ejecutan aplicaciones en dicha máquina.

Para ejecutar aplicaciones gráficas en la máquina a la que nos conectamos tenemos dos opciones. La primera consiste en definir la variable $DISPLAY apuntando a la máquina desde la que nos conectamos.

$ export DISPLAY=host_local:0.0

Este mecanismo no se recomienda por motivos de seguridad (el protocolo X11 no se encuentra cifrado) y, además, pueden encontrarse problemas porque cortafuegos intermedios bloqueen ese tráfico (puertos 600x TCP).

Una solución mejor es utilizar un túnel SSH para encapsular el protocolo X11, lo que transmite la información de manera segura y, además, no suele dar problemas con los cortafuegos intermedios.

Para poder ejecutar aplicaciones gráficas en el host remoto de forma segura, necesitamos dos cosas. La primera, que en la configuración del servidor SSH del host remoto (/etc/ssh/sshd_config) se encuentre activada la siguiente opción:

X11Forwarding yes

Para aprovechar esta característica, hemos de conectarnos usando el parámetro -X, lo que exportará la configuración de la variable $DISPLAY con lo que podremos ejecutar aplicaciones gráficas de forma remota:

$ ssh -X usuario_remoto@host_remoto

Ahora si ejecutas el programa xclock verás que la ventana sale en tu escritorio:

$ xclock

Tipo de ataque man-in-the-middle.

Imaginemos que la IP de nuestro servidor es 192.168.2.3. Nos conectamos via SSH desde otro equipo, la primera vez tarda un poco más porque tiene que escribir en el archivo /home/[nuestro_usuario]/.ssh/known_host una entrada para esa IP.

Las subsiguientes veces que nos conectemos compara la clave gpg de la IP con la que tiene guardada en el archivo known_host, en caso de variar supone que el ordenador es distinto -por ejemplo, porque el ordenador servidor ssh ha sido formateado o porque se ha apagado y sustituido por otro al que se le ha asignado la misma IP-. Ese es el error man-in-the-middle y significa: "el ordenador cuya IP es esa, no es el mismo que yo conocía. Puede ser que alguien se esté haciendo pasar por él" y no nos deja volvernos a conectar salvo que borremos la entrada de esa IP en el archivo known_host.

Evitar que nos pida el password cada vez.

Siempre que conectemos a un ordenador remoto con SSH nos va a pedir el password de acceso para asegurarse de que tenemos permisos. Hay una forma de evitar que nos pida el password siempre haciendo que el ordenador remoto confíe en nosotros. Para ello hemos de generar un par de claves DSA que se usarán en la relación de confianza:

$ ssh-keygen -t dsa

se generara esto:

Generating public/private dsa key pair.
Enter file in which to save the key (/home/usuario/.ssh/id_dsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/usuario/.ssh/id_dsa.
Your public key has been saved in /home/usuario/.ssh/id_dsa.pub.
The key fingerprint is:
81:a1:d3:96:fa:a2:73:4d:3a:76:c1:fd:3f:6a:6f:1e usuario@localhost

Una vez generada la copiamos al usuario del ordenador remoto con el que queremos mantener la relación de confianza usando el comando ssh-copy-id.

Este es un ejemplo del uso con la salida del programa: $ ssh-copy-id usuario_remoto@192.168.0.1

Now try logging into the machine, with "ssh 'usuario_remoto@192.168.0.1'", and check in:
.ssh/authorized_keys
to make sure we haven't added extra keys that you weren't expecting.

Si te da el error No identities found prueba a indicarle la ruta de la clave pública con -i
Para que funcione correctamente el comando ssh-copy-id el agente tiene que estar activo para la sesión. Si no lo has puesto que lo arranque al inicio como se explica un poco más abajo, tendrás que arrancarlo desde la consola ejecutando ssh-add.

Ahora solo hay que arrancar el agente SSH para que recuerde nuestra contraseña. Nos pregunta la contraseña y ahora ya podemos acceder al ordenador remoto sin tener que escribir el password cada vez.

$ ssh-add

El agente sólo dura mientras esté activa nuestra consola. O sea que si la cerramos y la volvemos a abrir ya no está activo el agente y nos volverá a pedir el password cada vez. Para evitar esto lo que podemos hacer es añadir el agente a la sesión para que se ejecute cada vez que se inicie GNOME. Al iniciar saldrá un diálogo que nos preguntará por la contraseña.

Copia de seguridad .

Si vas a migrar la configuración de tu usuario a otra máquina tienes que conservar el directorio $HOME/.ssh. Ahí es donde se guarda los ficheros de la clave pública y privada generadas en el punto anterior:

$ tar czf ssh.tgz $HOME/.ssh

SSHFS o montar directorio remoto con SSH
Algunas veces necesitamos trabajar durante bastante tiempo con un sistema remoto, copiando y editando ficheros. Existe la posibilidad de usar Nautilus que se puede conectar remotamente al servidor usando el protocolo 'sftp://, pero suele ser lento y muchas veces es más práctico usar la línea de comandos. La solución sería montar un recurso remoto al estilo de NFS y encima sin tener que se root. Pues si, se puede

Fuse es un módulo del kenel que permite montar distintos sistemas de ficheros con un usuario normal sin privilegios. SSHFS es un programa creado por el autor de fuse que permite montar un directorio remoto usando SSH.

Accederemos localmente como si estuviera en nuestra propia máquina. Hay que instalar el programa sshfs. El usuario que puede montar el sistema de ficheros tiene que pertenecer al grupo fuse.

$ sudo usermod -G fuse -a usuario_local

Tenemos que salir y volver a entrar en el sistema para que se haga efectivo el cambio de grupo. Antes de empezar a usar fuse tienes que cargar el módulo en memoria:

$ sudo modprobe fuse

Ahora vamos a hacer una prueba:

$ mkdir ~/directorio_remoto
$ sshfs usuario_remoto@servidor_remoto:/tmp ~/directorio_remoto

Este comando monta el directorio /tmp del servidor remoto en el directorio local ~/directorio_remoto. Ahora podemos trabajar en el directorio montado como si de un directorio local se tratase. Para desmontar el directorio:

$ fusermount -u ~/directorio_remoto

Si vamos a trabajar a diario con este directorio remoto, quizás es buena idea añadirlo al fichero /etc/fstab. De esta forma se montará automáticamente al iniciar nuestro ordenador o manualmente (si elegimos la opción noauto) sin necesidad de especificar la localización remota cada vez. Este es un ejemplo de configuración:

$ sshfs#usuario_remoto@remote_server:/tmp /home/usuario_local/directorio_remoto fuse defaults,auto 0 0

Si vamos a usar fuse y sshfs regularmente, tendrías que editar el fichero /etc/modules y añadir el módulo fuse. De otra forma tendrás que cargar el módulo manualmente cada vez que lo quieras usar:

$ sudo sh -c "echo fuse >> /etc/modules"

Ejecutar comandos en un host remoto.

Ahora que ya sabemos como entrar en un ordenador remoto sin el password, por qué no ejecutar comandos remotamente? Se abre un nuevo mundo de posibilidades muy útiles como tareas que se pueden ejecutar de forma automática.

$ ssh usuario_remoto@host_remoto "find /tmp -name *.txt"

Este comando buscará los ficheros de texto del directorio temporal que hay en el ordenador remoto. Si bien es un ejemplo poc útil, en la vida de un administrador de sistema hay muchos buenos ejemplos.
Y vamos a dar una nueva vuelta de rosca: si estamos administrando sistemas Unix/Linux es muy posible que necesitemos ejecutar el mismo programa en varios servidores a la vez. Este sencillo script e suna gran ayuda en esos casos:

#!/usr/bin/perl
@hosts=(
"usuario1\@maquina1.guay.es",
"usuario2\@maquina2.guay.es"
);
die "Uso: runonall \'command\'\n" unless $ARGV[0];
foreach(@hosts){
print "$_ -> $ARGV[0]:\n";
print `ssh $_ $ARGV[0]`;
}

Enviar u obtener archivos y carpetas con scp

En una consola o terminal tecleamos:

$ scp -r usuario@maquina:/home/carpeta .

luego ponemos la password del usuario y nos copiará la carpeta "/home/carpeta" remota en el directorio actual "." naturalmente siempre que usuario tenga permisos sobre la carpeta y su cuenta esté entre las de los que pueden hacer ssh. La opción "-r" significa recursivo, es decir, copia la carpeta y todo su contenido, incluidas las subcarpetas y el contenido de éstas. Si no lo ponemos la orden para copiar todos los archivos de una carpeta sería:

$ scp usuario@maquina:/home/carpeta/* .

Si lo que queremos es enviar una carpeta con su contenido, utilizaremos la orden:

$ scp /home/carpeta/* usuario@maquina:/carpeta/

Hacer todo esto en modo gráfico.

Silo que que queremos es conectarnos a un ordenador por ssh en modo grafico también lo podremos hacer. Es mas simple pero tambien tienes menos posibilidades, o para hacer ciertas cosas tardas mas incluso que haciendolo por consola pero para las operaciones faciles como administrar, editar un fichero tambien es posible hacerlo de esta manera.

Entraremos en Lugares -> Conectarse al servidor...

Elegiremos en el combbo de arriba en lugar de FTP publico, SSH y pondremos la IP o el nombre (en caso de anteriormente ya hallamos editado el fichero hosts) y asi despues de teclear la contraseña y aceptar estaremos ya dentro del mismo.

Instalación del servidor SSH.
El cliente ya viene instalado por defecto, de modo que para instalar el servidor de SSH en nuestro sistema lo único que necesitas es instalar el paquete openssh-server.

Restringir el acceso SSH
Para evitar que todos los usarios de la máquina estén accesibles por SSH tendremos que editar como root el fichero /etc/ssh/sshd_conf, y añadir la línea AllowUsers y a continuación los usuarios que deseamos que se puedan conectar remotamente via SSH:

$ sudo gedit /etc/ssh/sshd_conf

Y añadimos la línea:

AllowUsers usuario1 usuario2 usuario3

Para que los cambios surtan efectos habrá que reiniciar el servidor:

$ sudo /etc/init.d/ssh restart

* Restarting OpenBSD Secure Shell server...

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Servidores

PHP es un lenguaje de programación de uso general de código del lado del servidor originalmente diseñado para el desarrollo web de contenido dinámico.

Fue uno de los primeros lenguajes de programación del lado del servidor que se podían incorporar directamente en el documento HTML en lugar de llamar a un archivo externo que procese los datos.

El código es interpretado por un servidor web con un módulo de procesador de PHP que genera la página Web resultante. PHP ha evolucionado por lo que ahora incluye también una interfaz de línea de comandos que puede ser usada en aplicaciones gráficas independientes.

PHP puede ser usado en la mayoría de los servidores web al igual que en casi todos los sistemas operativos y plataformas sin ningún costo.

PHP fue creado originalmente por Rasmus Lerdorf en 1995. Actualmente el lenguaje sigue siendo desarrollado con nuevas funciones por el grupo PHP.2 Este lenguaje forma parte del software libre publicado bajo la licencia PHP que es incompatible con la Licencia Pública General de GNU debido a las restricciones del uso del término PHP.

fonte: Wikipedia

Ultima versión estable publicada:

PHP 5.4.19 and PHP 5.5.3 Released!

Calculadora básica.

PHP entre otras cosas nos permite realizar múltiples cálculos matemáticos. En este caso vamos a crear una calculadora elemental, tan elemental que solamente nos sumara tres valores, pero nos servirá para entender como opera con las variables PHP.

Es importante destacar que PHP contempla de manera diferente las variables tipo cadena (por ejemplo un nombre), y las de tipo numérico.

Una variable de cadena se define como $nombre = “Juan”;
Una variable numérica se define como $valor = 7;

Es decir, las variables numéricas no va el valor entre comillas. Con esto, los operadores son los ya conocidos en otros lenguajes:

+ para sumar
- para restar
* para multiplicar
/ para dividir

El código seria el siguiente:

<html> <head> <title>Formulario.</title> </head> <body> <form method="POST" action="sumar.php"> <p>Valor 1: <input type="text" name="T1" size="20"></p> <p>Valor 2: <input type="text" name="T2" size="20"></p> <p>Valor 3: <input type="text" name="T3" size="20"></p> <p><input type="submit" value="Sumar" name="B1"></p> </form> </body> </html> =============================== <html> <head> <title>Sumar.</title> </head> <body> <?php $valor1 = $_POST['T1']; $valor2 = $_POST['T2']; $valor3 = $_POST['T3']; $suma = $valor1 + $valor2 + $valor3; echo "$valor1 + $valor2 + $valor3 = $suma"; ?> </body> </html>

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

Bugtroid es una herramienta innovadora desarrollada por el equipo de Bugtraq-Team.

Las principales características de esta apk, es que cuenta con más de 200 herramientas de Android y Linux (PRO) para pentesting y forense a través de su Smarthphone o tableta.

Tiene un menú categorizado de acuerdo con la naturaleza de la herramienta puede encontrar:

Anonymity
Search People
Audit for frequencies 802.11 (Wireless and Bluetooth)
Mapping Networks
Remote
DDOS
Sniffers
Pentesting
Security
Examiner
Web Analysis
Cryptography
Brute Force
Antivirus
System

Desde el menú de la aplicación, puede:

Compruebe la información en la herramienta.
Instale la aplicación.
Desinstalar la aplicación.
Ejecutar la aplicación (PRO)
También la configuración de párrafo disponibles, que servirá para gestionar e instalar ciertos requisitos para el buen funcionamiento de las herramientas, así como otros fnciones:
Establecer fondo de pantalla .
nstalar los requisitos mínimos para ejecutar las herramientas.
Instale accesos directos en el escritorio (PRO)
Instale atajos Console (PRO).
Instalación de los intérpretes: Perl, Python, Ruby, PHP y MySQL (PRO).
Bugtraq equipo-Team no se hace responsable del uso que se le puede aplicar a estas herramientas, o el contenido de los mismos.
Bugtroid free
Bugtroid pro

Capturas de pantallas.

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Android

Editar.

Número máximo de niveles de deshacer
Use esta casilla de selección para especificar el número máximo de acciones que puede deshacer.
Mostrar el desplazamiento del cursor en la barra de estado como
Use esta lista desplegable para seleccionar el formato en el que se mostrará el desplazamiento del cursor. El formato puede ser decimal, hexadecimal o una cadena de estilo de impresión personalizado que sólo contenga los especificadores de formato x, o y s.
Mostrar columna de los desplazamientos
Seleccione esta opción para visualizar los desplazamientos del cursor en una columna situada a la izquierda de la vista hexadecimal de la ventana Editor Hexadecimal de GNOME.

Visualizar.

Tipografía: Use las cajas de selección de tipografía para editar la información existente sobre la tipografía o para escribir información nueva sobre ésta. Especifique un tipo, estilo y tamaño de tipografía para mostrar el contenido de los archivos en GHex.
Tipo de grupo predeterminado: Seleccione una de las siguientes opciones para especificar cómo GHex muestra el contenido hexadecimal de un archivo en la ventana de GHex:

Imprimir.

Pulse en el botón Fuente de los datos para especificar el tipo,estilo y tamaño de la tipografía que desea utilizar para imprimir los datos de un archivo.

Tipografía de las cabeceras: Pulse en el botón Tipografía de las cabeceras para especificar el tipo ,el estilo y el tamaño de la tipografía que desea utilizar para imprimir la información de cabecera de un archivo.
Sobreimprimir un recuadro sombreado: Use este cuadro de incremento para especificar el número de líneas que desea que el Editor hexadecimal de GNOME imprima dentro de un recuadro sombreado . Si el valor del cuadro de incremento es 10, el Editor hexadecimal de GNOME imprimirá las 10 primeras líneas del archivo sin el recuadro sombreado, y las 10 siguientes con el recuadro, y así sucesivamente. Si el valor del cuadro de incremento es 0, GHex no imprimirá ningun recuadro sombreado.

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Repositorios

Para editar un archivo, ejecute los siguientes pasos:

Pulse en la vista hexadecimal o ASCII del archivo. La vista en la que el cursor está activo muestra un cursor completo. La vista en la que el cursor no está activo muestra el contorno del cursor.
Use cualquiera de los siguientes métodos para mover el cursor por el archivo:
- Use la barra de desplazamiento de la ventana o las flechas del teclado para desplazarse a lo largo del archivo.
- Seleccione Editar ▸ Ir a byte, introduzca el desplazamiento del cursor como un valor decimal o hexadecimal y, luego, haga clic en Aceptar. El formato del valor hexadecimal debe ser 0x seguido del desplazamiento, por ejemplo, 0x3.
Edite el formato ASCII del mismo modo que edita un archivo de texto normal. Para editar el formato hexadecimal, use los valores del 0 a 9 y de la a a la f.

Para insertar datos sin sobrescribir los existentes, seleccione Editar ▸ Modo Insertar.

Para cortar, copiar, y pegar datos elija Editar ▸ Cortar, Editar ▸ Copiar, y Editar ▸ Pegar.
Para deshacer y editar elija Editar ▸ Deshacer. Para rehacer una acción elija Editar ▸ Rehacer. El número de ediciones previas que puede deshacer está determinado en la configuración de Número máximo de niveles de deshacer en la sección en pestañas Sección 4.1: Editar del cuadro de diálogoPreferences .
Guardar un archivo.
Para guardar un archivo, tiene dos opciones:

Para guardar cambios en el archivo actual, seleccione Archivo ▸ Guardar.
Para guardar el archivo actual bajo un nuevo nombre, seleccione Archivo ▸ Guardar como. Introduzca un nombre para el archivo en el cuadro de diálogo Seleccione el archivo donde quiere guardar el buffer actual y luego haga clic en Aceptar.

Revertir la última versión guardada de un archivo.
Para revertir a la última versión del archivo actual que haya guardado, y deshacer todas las ediciones que realizó en el archivo desde que lo guardó, elija Archivo ▸ Revertir, después pulse Sí en el cuadro de diálogo Pregunta.
Buscar datos en un archivo.
Para buscar una cadena hexadecimal o ASCII en un archivo, ejecute los siguientes pasos:

Seleccione Editar ▸ Buscar.
En el cuadro de diálogo Buscar los datos, seleccione una de las siguientes opciones:
- Buscar datos hexadecimales
- Buscar datos ASCII
Escriba la cadena que desea encontrar.
Pulse en Buscar siguiente para buscar la siguiente aparición de la cadena.
Pulse en Buscar anterior para buscar la aparición anterior de la cadena.
Pulse en Cancelar para cerrar el diálogo Buscar datos.

Realizar una búsqueda avanzada.
Para realizar una busqueda avanzada, ejecute los siguientes pasos:

Seleccione Editar ▸ Búsqueda avanzada.
En el cuadro de diálogo Buscar datos, seleccione el criterio de búsqueda requerido. Para obtener información acerca de cómo añadir nuevos criterios de búsqueda, consulte Sección 3.6: Añadir criterios de búsqueda.
Pulse en Buscar siguiente para buscar la siguiente aparición de la cadena.
Pulse en Buscar anterior para buscar la aparición anterior de la cadena.
Pulse en Cerrar para cerrar el diálogo Buscar datos.

Añadir criterios de búsqueda.
Para añadir criterios de búsqueda, realice los siguientes pasos:

Seleccione Editar ▸ Búsqueda avanzada.
Pulse en Añadir nuevo dentro del cuadro de diálogo Buscar datos.
En el cuadro de diálogo Añadir búsqueda, seleccione una de las siguientes opciones:
- Buscar datos hexadecimales
- Buscar datos ASCII
Escriba la cadena que desea encontrar.
Use la rueda de color o las casillas de selección para escoger un color para resaltar loscriterios de búsqueda.
Pulse en Añadir.
Pulse en Cancelar para cerrar el diálogo Buscar datos.

Eliminar criterios de búsqueda.
Para eliminar un criterio de búsqueda, siga los siguientes pasos:

Seleccione Editar ▸ Búsqueda avanzada.
En el cuadro de diálogo Buscar los datos, seleccione el criterio de búsqueda que desea eliminar.
Pulse en Eliminar seleccionados.
Pulse en Cancelar para cerrar el diálogo Buscar datos.

Buscar y reemplazar datos de un archivo.
Para buscar una cadena hexadecimal o ASCII en un archivo y luego reemplazarla, ejecute los siguientes pasos:

Seleccione Editar ▸ Reemplazar.
En la ventana de diálogo Buscar & reemplazar datos, seleccione una de las siguientes opciones:
- Reemplazar datos hexadecimales
- Reemplazar datos ASCII
En el primer cuadro de texto, escriba la cadena que desea encontrar.
En el segundo cuadro de texto, escriba la cadena con la que desea reemplazar la cadena que está buscando.
Pulse en Buscar el siguiente.
Pulse en Reemplazar para reemplazar la aparición actual de la cadena, o bien en Reemplazar todo para reemplazar todas las apariciones de la cadena.
Pulse en Cancelar para cerrar el diálogo Buscar y reemplazar datos

Añadir o quitar vistas adicionales de un archivo.
Para añdir otra vista del archivo actual a la ventana de Editor Hexadecimal de GNOME, seleccione Ver ▸ Añadir vista.
Para quitar una vista del archivo actual, seleccione Ver ▸ Eliminar vista. Al cerrar el ultimo archivo abierto, también se cerrará la aplicación.
Cambiar el tipo de grupo de datos.
Para modificar la forma en que GHex muestra el contenidohexadecimal de un archivo en la ventana de GHex, seleccioneVer ▸ Agrupar datos como, y seleccione una de las siguientes opciones:

Bytes: bytes únicos.
Palabras: grupos de dos bytes.
Palabras largas: grupos de cuatro bytes.

Exportar la visualización de Editor Hexadecimal de GNOME a HTML.
Para exportar los datos de la ventana de GHex a HTML, seleccione Archivo ▸ Guardar como HTML. Seleccione una carpeta y especifique un nombre para el archivo HTML y pulse Aceptar. GHex implementa las siguientes acciones:

Crea un archivo HTML independiente para cada página de datos que se muestra en la ventana Editor Hexadecimal de GNOME.
Usa el nombre de archivo HTML que usted especifique como base para el nombre del archivo.
Adjudica un número de página al nombre del archivo para diferenciar los documentos.

Por ejemplo, si especifica el nombre del archivo log.html, GHex crea una serie de archivos HTML denominados log00000000.html, log00000001.html, log00000002.html, y así sucesivamente.
Ver una tabla de caracteres.
Para ver una tabla que contenga las representaciones ASCII, hexadecimales, decimales, octales y binarias de los valores que van de 0 a 255, seleccione Herramientas ▸ Tabla de caracteres.
Ver conversiones de datos.
Para visualizar conversiones binarias, decimales, hexadecimales y ASCII hasta un máximo de cuatro bytes de datos, ejecute los siguientes pasos:

Seleccione Herramientas ▸ Convertidor base.
Seleccione una de las siguientes opciones:
- Escriba los datos que desea convertir en uno de los campos del cuadro de diálogo Convertidor base y pulse Intro.
- Si desea ver las conversiones de los datos de la posición del cursor en el archivo abierto, haga clic en el botón Recuperar valor del cursor.
Editor Hexadecimal de GNOME actualiza los valores de los demás campos para mostrar las conversiones de los datos.
Pulse en Cerrar para cerrar el diálogo Conversor de base.

Para mostrar u ocultar el cuadro de diálogo de conversión de tipo.
Para mostrar u ocultar el cuadro de diálogo de conversión de tipo, seleccioneVentanas ▸ Diálogo de conversión de tipo.
El cuadro de diálogo de conversión de tipos mustra el valor del carácter seleccionado en las siguientes representaciones:

8 bits con signo
8 bits sin signo
16 bits con signo
16 bits sin signo
32 bits con signo
32 bits sin signo
32 bits en coma flotante
64 bits en coma flotante
Hexadecimal
Octal
Binario
Longitud del flujo

El cuadro de diálogo de conversión de tipo también contiene las siguientes opciones:

Mostrar la decodificación en little endian
Seleccione esta opcion para mostrar la decodificación en little endian.
Mostrar como hexadecimal los números sin signo y en coma flotante
Seleccione esta opción para mostrar los números sin signo y en coma flotante como números hexadecimales.

Imprimir un archivo.
Para imprimir un archivo, seleccione Archivo ▸ Imprimir. Seleccione las opciones de impresión que necesita en el cuadro de diálogo Imprimir y, a continuación, pulse en Aceptar.
Para obtener una vista previa de una copia impresa del archivo, seleccione Archivo ▸ Vista previa de impresión.

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Repositorios

1.- Ubuntu 13.04 disponible para descarga (Información de pantalla, video, tutorial).

Canonical oficialmente ha publicado su version 13.04 nombre en codigo “Raring Ringtail”
Se están notando las ventajas de optimizar el sistema operativo para dispositivos móviles con pocos recursos.
El sistema consume menos Ram y se agiliza su utilización.
Los cambios más destacados, respecto al consumo son:

Se ha reducido el uso de memoria que hacían algunos paquetes, cargando datos e imágenes CSS de GTK3, sólo cuando se necesitan.
Se arreglaron problemas de memoria en los paquetes libdbusmenu, update-notifier, upower, whoopsie y otros más.
LightDM PPS cayó de un uso de 25.7M a 0.6M
Algunos procesos fueron modificados para que terminen si no se usan y se reinicien cuando se demandan, por

2.- Como ajustar el volumen de tus archivos de audio con QtGain.

QtGain es un frontend para MP3Gain, VorbisGain, AACGain y Metaflac.
Con el podrás ajustar automáticamente el volumen de tus archivos de audio. (MP3, MP4, Ogg-Vorbis y Flac)
Es sencillísimo de usar. Solo tienes que arrastrar los archivos de audio o carpetas a la ventana de QtGain para que inmediatamente se ponga a trabajar.
Si el archivo ya ha sido normalizado, solamente lo saltea y al finalizar te informa de la cantidad de archivos procesados, los que han sido normalizados, los que ha salteado y los que dieron error.
Ha sido actualizado a la versión 0.9.4 con esta lista de cambios:

3.- DJL es un instalador de juegos que proporciona una interfaz sencilla y muchas utilidades.

DJL es es un administrador de juegos escrito en Python, que nos permitirá instalar una gran cantidad de títulos (ver el detalle al final del post) en Linux.
Es un gestor de juegos, que nos sirve tanto para lanzar los juegos que hemos instalado con él, como para instalar juegos desde la red
He mirado los juegos disponibles en el repositorio y no me puedo quejar, están tanto los más famosos como los no tan conocidos.
Para usarlo debemos descargar la última versión, descomprimirla e instalarla.

4.- Diseño Gráfico en Linux: completo videotutorial de Gimp (28 vídeos).
GIMP (GNU Image Manipulation Program) es un programa de edición de imágenes digitales en forma de mapa de bits, tanto dibujos como fotografías. Es un programa libre y gratuito. Forma parte del proyecto GNU y está disponible bajo la Licencia pública general de GNU.
Es el programa de manipulación de gráficos disponible en más sistemas operativos (Unix, GNU/Linux, FreeBSD, Solaris, Microsoft Windows y Mac OS X, entre otros).

5.- Guía HTML: introducción y estructura interna de una página.

En una reciente limpieza a mi disco duro he encontrado esta guia que tenia guardada por ahi y creo que esta muy buena para empezar y conocer las nociones basicas del HTML.
Introducción.
HTML es el lenguaje que se emplea para el desarrollo de páginas de internet.
Este lenguaje está constituido de elementos que el navegador interpreta y las despliega en la pantalla de acuerdo a su objetivo. Veremos que hay elementos para disponer imágenes sobre una página, hipervínculos que nos permiten dirigirnos a otra página, listas, tablas para tabular datos, etc.

6.- Gscan2pdf útil herramienta para extraer el texto de archivos pdf que han sido escaneados como imagen.

Les presento una herramienta muy útil para Debian, se trata de gscan2pdf. Este sencillo programa permite extraer el texto de archivos pdf que han sido escaneados como imagen, de manera similar que algunos ORC's de Windows. Su instalación es muy sencilla, viene en los repositorios de los discos y se puede instalar desde Synaptic, o se puede descargar de la página principal gscan2pdf.sourceforge.net/ . Además se va a necesitar el respectivo paquete de idioma que en mi caso es tesseract-orc-spa.

7.- Instalar Angry Birds en Ubuntu 12.04 “Precise Pangolin”.

Angry Birds es un videojuego creado en 2009 por la empresa finlandesa Rovio Mobile. Desde entonces, el juego ha sido adaptado a dispositivos de pantalla táctil, como los basados en Maemo, iOS, Symbian, Java y Android.
Con más de un billón de descargas en 2012, esta aplicación quizá sea la más popular del año en la App Store de Apple. Además es también el juego más vendido de la historia en soportes móviles.

8.- Crack es el adivinador' de contraseñas más utilizado en entornos Unix

Crack, desarrollado por el experto en seguridad Alec Muffet, es el `adivinador' de contraseñas más utilizado en entornos Unix; actualmente se encuentra en su versión 522.5, que funciona correctamente en la mayoría de clones del sistema operativo (Linux, Solaris, OSF...).
Ejecutar periódicamente Crack sobre el fichero de contraseñas de sus sistemas es algo muy recomendable para cualquier administrador mínimamente preocupado por la seguridad, sin importar que se utilicen mecanismos para obligar a los usuarios a elegir passwords aceptables.

9.- Colección de iconos para Tux, el simpático pinguino de Linux.

10.- 4Pane navegador de archivos para Linux con cuatro paneles

4Pane es un explorador de carpetas con el que no perdernos entre la enorme cantidad de ficheros del directorio raíz.
Su interfaz se divide en cuatro partes, para facilitar la navegación y poder mover ficheros de una carpeta a otra rápidamente, recordando al mítico Midnight Commander pero en versión gráfica.
A sus funciones como gestor de archivos incorpora otras, como enlaces a Firefox, Openoffice y el editor de texto, montaje de discos, particiones e ISOs, extracción de archivos comprimidos e incluso una lista de las carpetas que más solemos abrir y acceso al terminal.

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Administradores de Archivos

La aplicación Editor hexadecimal de GNOME le permite ejecutar las siguientes acciones:

Visualizar un archivo en formato ASCII y hexadecimal de forma simultánea.
Editar un archivo en formato ASCII o hexadecimal.

Inicio de Editor Hexadecimal de GNOME.
Para iniciar Editor Hexadecimal de GNOME, siga los siguientes pasos:

Menú Aplicaciones: Seleccione Accesorios ▸ Editor hexadecimal.
Línea de comandos: Ejecute el siguiente comando: ghex

Al iniciar Editor Hexadecimal de GNOME
Al iniciar Editor Hexadecimal de GNOME, se muestra la siguiente ventana.

Ventana de Editor Hexadecimal de GNOME antes de abrir un archivo

Abrir un archivo.

Para abrir un archivo, seleccione Archivo ▸ Abrir. Seleccione el archivo que desea abrir y luego haga clic en Aceptar. Puede abrir múltiples archivos en Editor hexadecimal de GNOME. Editor Hexadecimal de GNOME muestra cada archivo en una nueva ventana.
Al abrir un archivo en Editor hexadecimal de GNOME, la aplicación muestra dicho archivo en la siguiente ventana.

Ventana de Editor Hexadecimal de GNOME con un archivo abierto

La ventana de Editor Hexadecimal de GNOME contiene los elementos siguientes:

Barra de menús: Los menús que aparecen en la barra de menú contienen todos los comandos necesarios para trabajar con archivos en Editor Hexadecimal de GNOME.
Una columna de desplazamientos del cursor: El desplazamiento del cursor es la distancia entre el comienzo del archivo y el primer byte de cada línea. De manera predeterminada, Editor Hexadecimal de GNOME muestra la columna de desplazamientos del cursor en la parte izquierda de la vista hexadecimal.
Panel de visualización en la parte izquierda: El panel de visualización ubicado en la parte izquierda del área de visualización muestra una vista hexadecimal del archivo.
Panel de visualización en la parte derecha: El panel de visualización ubicado en la parte derecha del área de visualización muestra una vista ASCII del archivo.
Diálogo de conversión de tipo: El cuadro de diálogo de conversión de tipo debajo del área de visualización muestra el valor del carácter seleccionado en distintos formatos numéricos.

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Administradores de Archivos

Conky es un software gratuito de monitor de sistema para el sistema X Window.

Conky es una aplicación de escritorio ideada con la finalidad de ofrecer información acerca del estado del sistema.
Por ejemplo:

El uso de la memoria.
Un historial del uso de la CPU.
Temperaturas.
Velocidades de ventiralores.
Hora-Fecha.
Estado del Disco Duro.

Está disponible para Linux, FreeBSD y OpenBSD.
Recuerden leer las instrucciones especificas de cada script, algunos necesitan ciertos plugins para poder mostrar el clima correctamente, y siempre es importante instalar las tipografías que usan, entre otros detalles.

Si te interesa profundizar el tema:

eOS

Conky-Vision
Minimal

Black 2.0 Conky
simple

Conky Flipclock
10 configuraciones para Conky bonitas y minimalistas

Flat-Weather for Conky
bonito

Dark Pixel Conky
conky

Elementary Conky
Minimal

Cloud Conky
simple

Dinnamo Clock Conky
10 configuraciones para Conky bonitas y minimalistas

Helix Conky
bonito

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Grafica

Les presento una herramienta muy útil para Debian, se trata de gscan2pdf.
Este sencillo programa permite extraer el texto de archivos pdf que han sido escaneados como imagen, de manera similar que algunos ORC's de Windows.
Su instalación es muy sencilla, viene en los repositorios de los discos y se puede instalar desde Synaptic, o se puede descargar de la página principal gscan2pdf.sourceforge.net/ . Además se va a necesitar el respectivo paquete de idioma que en mi caso es tesseract-orc-spa.

Como viene con interfaz gráfica es bastante intuitivo, pero de todas formas ahí va una pequeña intro de como sacarle el texto a un pdf formado de imagenes o una imagen.
1.- Abrimos la ventana principal.
2.- Despues vamos al menú Archivo y elegimos Importar, seleccionamos el archivo y abrir.
3.- Aparecerá una pequeña ventana indicandonos que páginas queremos analizar.

Esto es puede traer un poco de problemas porque algunos documentos e imagenes están formados por capas y cambia el orden de las páginas.
4.- Ahora se nos mostrará las imagenes de las páginas que elejimos antes.

5.- Por último, a lo que vine, buscamos la imagen que tenga texto, vamos al menú Herramientas, OCR y
se abre una ventana en la que elegimos el motor de busqueda y el idioma, seleccionamos Tessract.

6.- Automaticamente el texto en forma de imagen es extraido y está listo para copiarse.

En caso de querer sacarle texto a una imagen, en el paso 5, como motor elegimos GORC y se obtiene el texto aunque sin caracteres especiales ni tildes.
Espero que les sea útil y mas que todo les ahorre tiempo.
Capturas de pantallas.

Sistema

Python es un lenguaje de script desarrollado por Guido van Rossum.

Podemos codificar empleando programación lineal, estructurada y orientada a objetos (tengamos en cuenta que esta última es la que se ha impuesto en la actualidad).

Se cuenta con intérpretes de Python en múltiples plataformas: Windows, Linux, Mac etc. Se pueden desarrollar aplicaciones de escritorio como aplicaciones web. Empresas como Google, Yahoo, Nasa etc. utilizan este lenguaje para sus desarrollos (actualmente el creador de Python Guido van Rossum trabaja para Google.)

Se puede ejecutar instrucciones de Python desde la línea de comando o creando archivos con extensión *.py. Cuando uno comienza a aprender este lenguaje la línea de comandos nos provee una retroalimentación del resultado en forma inmediata.

El objetivo de este tutorial es presentar en forma progresiva los conceptos fundamentales de este lenguaje y poder analizar los problemas resueltos y codificar los problemas propuestos en este mismo sitio, sin tener que instalar en un principio el Python en su equipo (o luego de instalado poder avanzar con el tutorial en cualquier máquina conectada a internet).

Modificación de datos (App Engine).
Trabajaremos nuevamente con el problema de usuarios. Dispondremos un formulario que solicite la carga del nombre de un usuario y pasaremos a un segundo formulario donde mostraremos los datos actuales de dicho usuario. En una tercer página procedemos a modificar los datos ingresados.

import cgi
import wsgiref.handlers

from google.appengine.ext import webapp
from google.appengine.ext import db

class Formulario1(webapp.RequestHandler):
def get(self):
    self.response.out.write("""
<html>
<head></head>
<body>
<form action="formulario2" method="post">
Ingrese nombre de usuario a modificar:
<input type="text" name="nombre"><br>
<input type="submit" value="Buscar"><br>
</form>
</body>
</html>
""")

class TablaUsuarios(db.Model):
nombre=db.StringProperty()
clave=db.StringProperty()

class Formulario2(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    nom=cgi.escape(self.request.get('nombre'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nom)
    usu=usuario.fetch(1)
    if len(usu)>0:
      self.response.out.write("""
<html>
<head></head>
<body>
<form action="procformulario2" method="post">
Nombre actual:
""")
      self.response.out.write("<input type=\"text\" name=\"nombre\" value=\""+usu[0].nombre+"\"><br>")
      self.response.out.write("Clave actual:")
      self.response.out.write("<input type=\"text\" name=\"clave\" value=\""+usu[0].clave+"\"><br>")
      self.response.out.write("<input type=\"hidden\" name=\"nombreoculto\" value=\""+usu[0].nombre+"\">")
      self.response.out.write("""
<input type="submit" value="Modificar"><br>
</form>
</body>
</html>
""")
    else:
      self.response.out.write("No existe un usuario con dicho nombre<br>")
    self.response.out.write("</body></body>")


class ProcFormulario2(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    nomoculto=cgi.escape(self.request.get('nombreoculto'))
    nom=cgi.escape(self.request.get('nombre'))
    cla=cgi.escape(self.request.get('clave'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nomoculto)
    usu=usuario.fetch(1)
    if len(usu)>0:
      usu[0].nombre=nom
      usu[0].clave=cla
      usu[0].put()
    else:
      self.response.out.write("No existe un usuario con dicho nombre<br>")
    self.response.out.write("<a href=\"\\\">Principal</a>")
    self.response.out.write("</body></body>")

def main():
application = webapp.WSGIApplication([('/', Formulario1),
                                        ('/formulario2', Formulario2),
                                        ('/procformulario2', ProcFormulario2),
                                       ],
                                       debug=True)
wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
main()

El segundo formulario debemos inicializar los atributos value de los dos controles text para que aparezcan cargados inicialmente con los datos actuales.
Por otro lado también es necesario definir un campo oculto donde almacenar el nombre de usuario actual, ya que si lo modifica no sabremos cual buscar:

class Formulario2(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    nom=cgi.escape(self.request.get('nombre'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nom)
    usu=usuario.fetch(1)
    if len(usu)>0:
      self.response.out.write("""
<html>
<head></head>
<body>
<form action="procformulario2" method="post">
Nombre actual:
""")
      self.response.out.write("<input type=\"text\" name=\"nombre\" value=\""+usu[0].nombre+"\"><br>")
      self.response.out.write("Clave actual:")
      self.response.out.write("<input type=\"text\" name=\"clave\" value=\""+usu[0].clave+"\"><br>")
      self.response.out.write("<input type=\"hidden\" name=\"nombreoculto\" value=\""+usu[0].nombre+"\">")
      self.response.out.write("""
<input type="submit" value="Modificar"><br>
</form>
</body>
</html>
""")
    else:
      self.response.out.write("No existe un usuario con dicho nombre<br>")
    self.response.out.write("</body></body>")

La tercer página recupera el usuario que ingresó en el primer formulario, pero rescatado del campo oculto. Procedemos seguidamente a modificar los datos rescatados de la tabla y confirmamos los nuevos datos llamando al método put:

class ProcFormulario2(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    nomoculto=cgi.escape(self.request.get('nombreoculto'))
    nom=cgi.escape(self.request.get('nombre'))
    cla=cgi.escape(self.request.get('clave'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nomoculto)
    usu=usuario.fetch(1)
    if len(usu)>0:
      usu[0].nombre=nom
      usu[0].clave=cla
      usu[0].put()
    else:
      self.response.out.write("No existe un usuario con dicho nombre<br>")
    self.response.out.write("<a href=\"\\\">Principal</a>")
    self.response.out.write("</body></body>")

Listado, Alta, Baja y Modificación (App Engine).

Ahora plantearemos todos los conceptos vistos para el manejo de una tabla de datos utilizando el Google App Engine.
Mostraremos un listado con una tabla con todos los nombres de usuarios y claves, dos hipervínculos uno para poder borrar el usuario y otro para poder modificar el registro. Por último dispondremos un hipervínculo para llamar a un formulario de alta de usuario.

import cgi
import wsgiref.handlers

from google.appengine.ext import webapp
from google.appengine.ext import db

class TablaUsuarios(db.Model):
nombre=db.StringProperty()
clave=db.StringProperty()

class Listado(webapp.RequestHandler):
def get(self):
    self.response.out.write("<html><head></head><body>")
    self.response.out.write("<table border=\"1\">")
    self.response.out.write("<tr>")


self.response.out.write("<td>Usuario</td><td>Clave</td><td>Borrar</td><td>Modificar&l

t;/td>")
    self.response.out.write("</tr>")
    usuarios=db.GqlQuery("select * from TablaUsuarios")
    for usu in usuarios:
      self.response.out.write("<tr>")
      self.response.out.write("<td>" + usu.nombre +"</td>")
      self.response.out.write("<td>" + usu.clave +"</td>")
      self.response.out.write("<td><a href=\"baja?nombre="+usu.nombre+"\">Borra?</a>"+"</td>")
      self.response.out.write("<td><a

href=\"formulariomodificacion?nombre="+usu.nombre+"\">Modifica?</a>"+"</td>")
      self.response.out.write("</tr>")
    self.response.out.write("<tr>")
    self.response.out.write("<td colspan=\"4\"><a href=\"formularioalta\">Alta</a></td>")
    self.response.out.write("</tr>")
    self.response.out.write("</table>")
    self.response.out.write("</body></html>")

class FormularioAlta(webapp.RequestHandler):
def get(self):
    self.response.out.write("""
<html>
<head></head>
<body>
<form action="alta" method="post">
Ingrese su nombre:
<input type="text" name="nombre"><br>
Ingrese su clave:
<input type="password" name="clave"><br>
<input type="submit" value="Alta"><br>
</form>
</body>
</html>
""")

class Alta(webapp.RequestHandler):
def post(self):
    nom=cgi.escape(self.request.get('nombre'))
    cla=cgi.escape(self.request.get('clave'))
    usuario=TablaUsuarios()
    usuario.nombre=nom
    usuario.clave=cla
    usuario.put()
    self.redirect("/")

class Baja(webapp.RequestHandler):
def get(self):
    nom=cgi.escape(self.request.get('nombre'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nom)
    usu=usuario.fetch(1)
    if len(usu)>0:
      usu[0].delete()
    self.redirect("/")

class FormularioModificacion(webapp.RequestHandler):
def get(self):
    self.response.out.write("<html><head></head><body>")
    nom=cgi.escape(self.request.get('nombre'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nom)
    usu=usuario.fetch(1)
    if len(usu)>0:
      self.response.out.write("""
<html>
<head></head>
<body>
<form action="modificacion" method="post">
Nombre actual:
""")
      self.response.out.write("<input type=\"text\" name=\"nombre\" value=\""+usu[0].nombre+"\"><br>")
      self.response.out.write("Clave actual:")
      self.response.out.write("<input type=\"text\" name=\"clave\" value=\""+usu[0].clave+"\"><br>")
      self.response.out.write("<input type=\"hidden\" name=\"nombreoculto\" value=\""+usu[0].nombre+"\">")
      self.response.out.write("""
<input type="submit" value="Modificar"><br>
</form>
</body>
</html>
""")
    else:
      self.response.out.write("No existe un usuario con dicho nombre<br>")
    self.response.out.write("</body></body>")

class Modificacion(webapp.RequestHandler):
def post(self):
    nomoculto=cgi.escape(self.request.get('nombreoculto'))
    nom=cgi.escape(self.request.get('nombre'))
    cla=cgi.escape(self.request.get('clave'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nomoculto)
    usu=usuario.fetch(1)
    if len(usu)>0:
      usu[0].nombre=nom
      usu[0].clave=cla
      usu[0].put()
    self.redirect("/")


def main():
application = webapp.WSGIApplication([('/', Listado),
                                        ('/formularioalta',FormularioAlta ),
                                        ('/alta',Alta ),
                                        ('/baja', Baja),
                                        ('/formulariomodificacion', FormularioModificacion),
                                        ('/modificacion', Modificacion),
                                       ],
                                       debug=True)
wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
main()

En la función main() debemos inicializar la lista que vincula las URL de las páginas y las clases que se ejecutan:

def main():
application = webapp.WSGIApplication([('/', Listado),
                                        ('/formularioalta',FormularioAlta ),
                                        ('/alta',Alta ),
                                        ('/baja', Baja),
                                        ('/formulariomodificacion', FormularioModificacion),
                                        ('/modificacion', Modificacion),
                                       ],
                                       debug=True)
wsgiref.handlers.CGIHandler().run(application)

La clase Listado es la que muestra la raiz del sitio y tiene por objetivo crear una tabla HTML con todos los usuarios almacenados en la TablaUsuarios. Además de imprimir cada registro disponemos un hipervínculo pasando como parámetro el nombre de usuario a borrar o modificar:

class Listado(webapp.RequestHandler):
def get(self):
    self.response.out.write("<html><head></head><body>")
    self.response.out.write("<table border=\"1\">")
    self.response.out.write("<tr>")


self.response.out.write("<td>Usuario</td><td>Clave</td><td>Borrar</td><td>Modificar&l

t;/td>")
    self.response.out.write("</tr>")
    usuarios=db.GqlQuery("select * from TablaUsuarios")
    for usu in usuarios:
      self.response.out.write("<tr>")
      self.response.out.write("<td>" + usu.nombre +"</td>")
      self.response.out.write("<td>" + usu.clave +"</td>")
      self.response.out.write("<td><a href=\"baja?nombre="+usu.nombre+"\">Borra?</a>"+"</td>")
      self.response.out.write("<td><a

href=\"formulariomodificacion?nombre="+usu.nombre+"\">Modifica?</a>"+"</td>")
      self.response.out.write("</tr>")
    self.response.out.write("<tr>")
    self.response.out.write("<td colspan=\"4\"><a href=\"formularioalta\">Alta</a></td>")
    self.response.out.write("</tr>")
    self.response.out.write("</table>")
    self.response.out.write("</body></html>")

La clase FormularioAlta muestra los dos controles text y el botón submit, cuando se presiona dicho botón se procede a llamar a la URL alta:

class FormularioAlta(webapp.RequestHandler):
def get(self):
self.response.out.write("""
<html>
<head></head>
<body>
<form action="alta" method="post">
Ingrese su nombre:
<input type="text" name="nombre"><br>
Ingrese su clave:
<input type="password" name="clave"><br>
<input type="submit" value="Alta"><br>
</form>
</body>
</html>
""")

La clase Alta inicializa un objeto de la clase TablaUsuarios, procede a registrar los datos y mediante el método redirect redirige a la raiz del sitio (es decir la clase Listado):

class Alta(webapp.RequestHandler):
def post(self):
    nom=cgi.escape(self.request.get('nombre'))
    cla=cgi.escape(self.request.get('clave'))
    usuario=TablaUsuarios()
    usuario.nombre=nom
    usuario.clave=cla
    usuario.put()
    self.redirect("/")

Cuando se presiona el hipervínculo "Borra?" en el listado se ejecuta la clase Baja y recibe como parámetro en el hipervínculo el nombre de usuario a borrar. Recuperamos el registro, llamamos al método delete y redirigimos nuevamente a la página de listado:

class Baja(webapp.RequestHandler):
def get(self):
    nom=cgi.escape(self.request.get('nombre'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nom)
    usu=usuario.fetch(1)
    if len(usu)>0:
      usu[0].delete()
    self.redirect("/")

Cuando se presiona el hipervínculo "Modificación?" se ejecuta la clase FormularioModificacion, en este recuperamos el nombre de usuario e inicializamos los controles text y el campo oculto:

class FormularioModificacion(webapp.RequestHandler):
def get(self):
    self.response.out.write("<html><head></head><body>")
    nom=cgi.escape(self.request.get('nombre'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nom)
    usu=usuario.fetch(1)
    if len(usu)>0:
      self.response.out.write("""
<html>
<head></head>
<body>
<form action="modificacion" method="post">
Nombre actual:
""")
      self.response.out.write("<input type=\"text\" name=\"nombre\" value=\""+usu[0].nombre+"\"><br>")
      self.response.out.write("Clave actual:")
      self.response.out.write("<input type=\"text\" name=\"clave\" value=\""+usu[0].clave+"\"><br>")
      self.response.out.write("<input type=\"hidden\" name=\"nombreoculto\" value=\""+usu[0].nombre+"\">")
      self.response.out.write("""
<input type="submit" value="Modificar"><br>
</form>
</body>
</html>
""")
    else:
      self.response.out.write("No existe un usuario con dicho nombre<br>")
    self.response.out.write("</body></body>")

Cuando se presiona el botón modificación del formulario anterior se ejecuta la clase Modificacion donde se procede a modificar el nombre y clave del usuario. Por último se redirige a la raiz del sitio:

class Modificacion(webapp.RequestHandler):
def post(self):
    nomoculto=cgi.escape(self.request.get('nombreoculto'))
    nom=cgi.escape(self.request.get('nombre'))
    cla=cgi.escape(self.request.get('clave'))
    usuario=db.GqlQuery("select * from TablaUsuarios where nombre=:1",nomoculto)
    usu=usuario.fetch(1)
    if len(usu)>0:
      usu[0].nombre=nom
      usu[0].clave=cla
      usu[0].put()
    self.redirect("/")

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales