Linfox

Después del script para descargar series de antena3.com y a petición de comentarios (ya que yo no veo nada que no sean las series) he aquí otro script chapucero, pero esta vez para descargar cualquier cosa, tanto las series, como los programas, como las noticias, como las TV Movies (también descarga la mayoría de los vídeos del programa 3D, que no está en el modo salón).

¿Cómo funciona?

Pues exactamente igual que el anterior. Llamas al script con la URL de antena3.com (del Modo Salón) de donde verías el vídeo a través del navegador. Ejemplo: si para ver la primera parte de la TV Movie de “Adolfo Suárez” navegas hasta: http://antena3.com/videos/tv-movies/adolfo-suarez/parte-1.html pues para descargar todas las partes de este vídeo llamas al script de la siguiente forma:

a3Downloader-2.sh http://www.antena3.com/videos/tv-movies/adolfo-suarez/parte-1.html

La nueva versión, la 3, intenta y consigue en muchos de los casos descargar cualquier vídeo alojado en antena3.com. La forma de utilizar el script con estos “no Modo Salón” vídeos es análoga a la anterior, se le pasa al script la URL de donde verías el vídeo en la web. Ejemplo para descargar el vídeo que está alojado aquí: http://www.antena3.com/programas/3d/noticias/luis-alfonso-presenta-familia_2010061600115.html

a3Downloader-2.sh http://www.antena3.com/programas/3d/noticias/luis-alfonso-presenta-familia_2010061600115.html

Evidentemente, al script tenéis que darle permisos de ejecución.

NOTAS IMPORTANTES:

- El script elimina todos los .html y .xml del directorio desde donde lo llames, por lo que se recomienda crear un directorio específico para ejecutar el script.

- El script puede fallar al captar los nombres de algunas noticias y TV Movies, pero las descarga sin problemas todas (comprobado a día 5 de Junio de 2010)

- El script es chapucero y no será mantenido regularmente. Si se detecta fallo (por cambio de estructura de vídeos en a3) avisadme si no sabéis modificar el script y en la medida de lo posible (tiempo libre) lo actualizaré.

- Recientemente se ha descubierto que al script es indispensable pasarle la URL con el ‘http://’ y las ‘www’, sino no funciona (ojo con esto por que si copias la url desde google-chrome tener en cuenta que este elimina las www)

- Este script reemplaza al anterior ya que también descarga las series sin problemas.

WINDOWS

No tengo pensado hacer una chapuza semejante para Windows, por lo que una solución para los que quieran utilizar esto en Windows es instalar Cygwin.

En este post se explica cómo: http://www.neverbyte.net/archivo/instalando-cygwin/

Además una vez instalado Cygwin necesitarás descargar este archivo: http://users.ugent.be/~bpuype/cgi-bin/fetch.pl?dl=wget/wget.exe y copiarlo a un directorio del PATH de Cygwin (por ejemplo si has mantenido la instalación por default, copiarlo a C:\cygwin\bin).

Y nada ya puedes descargar el script y merterlo también en el PATH (C:\cygwin\bin).

Si decidiste que se creara un Acceso Directo a Cygwin en el escritorio doble clik sobre el y se abrirá la terminal. Enhorabuena, ya puedes utilizar el script como si estuvieses en GNU/Linux, como se explica arriba.

NOTA: Para copiar en la terminal de Cygwin se utiliza el botón derecho del ratón, pero para ello tendríais que configurar Cygwin como indica en el enlace de instalación del mismo (chequear “Modalidad de edición rápida” en la pestaña “Opciones” de las Propiedades de Cygwin).

DESCARGA

Script a3Downloader-3.sh

Versiones antiguas aquí: http://linfox.es/docs/a3Downloader/

GNU/Linux, Software Libre, Trucos

OJO Actualización: http://linfox.es/2010/06/06/a3downloader-2sh-descargar-cualquier-video-la-nueva-antena3com/

Ayer comenzó la nueva temporada de “El internado” y como desgraciadamente estoy enganchado a esta serie y no me gusta verlas por tv (muchos anuncios y no puedo parar y reanudar a mi antojo) me dispuse a verla en antena3.com. Pero como siempre en la web de Antena 3 no funciona muy bien con GNU/Linux, y solo me quedaba descargarlo. Para ello estuve investigando un poco por le código de la web de Antena 3 y conseguí hacer un script chapucero, que de momento, descarga cualquier serie de la cadena (de su nuevo Modo Salón).

NOTA: Este script tal y como está solo descarga series (ni Programas, ni Noticias, ni TV Movies).

Lo único que tienes que hacer es descargar el script (darle permisos de ejecución) y ejecutarlo con el único parámetro de la URL del capitulo de la serie que quieres descargar (la URL final, en la cual verías el capitulo online).

No ejecutar el script desde un directorio donde contengas archivos .html o .xml por que los borrará.

Un ejemplo de ejecución sería (con URL del vídeo del cap. 1, de la temp. 7 de “El Internado”):

./a3Downloader.sh http://antena3.com/videos/el-internado/temporada-7/capitulo-1.html

El scrip se encarga de descargar lo necesario y las partes en las que está dividido el vídeo del servidor de Antena 3 (los vídeos se descargan en su formato origina, .mp4, y en el directorio desde donde llamas al script).

El script en cuestión es este (descargar del enlace, puede contener actualizaciones, no copiar el siguiente script):

#!/bin/sh
 
#########################################
#	a3Downloader.sh						#
#	aabilio@gmail.com					#
#	http://en.wikipedia.org/wiki/WTFPL 	#
#########################################
 
# No "valida" ningún dato, si hay error no devuelve info sobre el mismo.
# Valido mientras mantengan la mismas estructura de vídeos y URLs en el servidor.
 
clear
 
#Presentacion:
echo '==================================='
echo '| Descargar videos de Antena3.com |'
echo '==================================='
echo ''
 
#Borra antiguos .html, .xml y .mp4 (videos) que molesten:
echo '[+] Borrando archivos antiguos'
sleep 1.5
find . -name "*.html*" -exec rm {} \;
find . -name "*.xml*" -exec rm {} \;
#find . -name "*.mp4*" -exec rm {} \;
 
#Descarga la url pasada por parametro, la del cap.:
HTML=`echo $1`
echo '[+] Descargando '$HTML'...'
sleep 1.5
wget -nv $HTML
 
#No modificar, servidores de a3 para web y videos:
servidorDescarga="http://desprogresiva.antena3.com/"
servidorAntena3="http://www.antena3.com"
 
#Establecer nombre de archivos (mejorar esto ¿sed y awk?):
nombreHTML=`echo $HTML | cut -d. -f2-3 | cut -d\/ -f5`
XML=`cat $nombreHTML | grep "so.addVariable(\"xml\"" | cut -d'"' -f4`
nombreXML=`echo $XML | cut -d/ -f8`
 
#Establecer datos de la serie:
serie=`echo $HTML | cut -d/ -f5`
capitulo=`echo $nombreHTML | cut -d\- -f2 | cut -d. -f1`
temporada=`echo $HTML | cut -d\/ -f6 | cut -d\- -f2`
 
#Descargar xml:
echo '[+] Descargando ' $nombreXML'...'
sleep 1.5
wget -nv $servidorAntena3$XML
 
#Mostrar datos de la serie
echo ''
echo '\033[38;5;148m============================================\033[39m'
echo '\033[38;5;148mSerie : \033[39m"'$serie'"'
echo '\033[38;5;148mCap   : \033[39m"'$capitulo'"'
echo '\033[38;5;148mTemp  : \033[39m"'$temporada'"'
echo ''
echo '\033[38;5;148mSe descargarán las partes: \033[39m'
for i in `cat $nombreXML | grep .mp4 | cut -d[ -f3 | cut -d] -f1`
do
	nombreMp4=$serie'-'$temporada'x'$capitulo'_parte'`echo $i | cut -d. -f1 | cut -d/ -f6`'.mp4'
	echo $nombreMp4" ($i)"
done
echo '\033[38;5;148m============================================\033[39m'
echo ''
echo ''
sleep 4
 
#Sacar caps de .xml y descargar los caps.:
for i in `cat $nombreXML | grep .mp4 | cut -d[ -f3 | cut -d] -f1`
do
	nombreMp4=$serie'-'$temporada'x'$capitulo'_parte'`echo $i | cut -d. -f1 | cut -d/ -f6`'.mp4'
	echo "[+] \033[38;5;148mDescargando: "$nombreMp4"\033[39m ($i)"
	wget $servidorDescarga$i -O $nombreMp4
	echo ''
done
 
#Borra antiguos .html, .xml que molesten:
echo '[+] Borrando archivos temporales'
sleep 1.5
find . -name "*.html*" -exec rm {} \;
find . -name "*.xml*" -exec rm {} \;
 
echo '[FIN] \033[38;5;148mDescargas Finalizadas\033[39m'

ENLACE | Descarga a3Downloader.sh

GNU/Linux, Internet, Multimedia, Software Libre, Trucos

A estas alturas casi todos conocemos a Android, ese sistema operativo para dispositivos móviles que funciona con un corazón Linux que fue originalmente desarrollado por Android Inc. compañía que acabaría comprando Google.

Pero si aun no conoces este gran sistema operativo, siempre puedes pasarte por uno de los muchos blogs que tratan sobre el mismo. Uno de estos blogs es elandroidelibre.com, el cual va a sortear además entre los participantes en su concurso el móvil de Google, el Nexus One.

El blog en cuestión es un fantástico sitio para informarte sobre las últimas novedades, los móviles que van saliendo con Android, las aplicaciones más interesantes que puedes encontrar en el Market.

Por ejemplo, en  elandroidelibre.com puedes encontrar una guía para dar tus primeros pasos con el sistema operativo, un interesante directorio de aplicaciones para instalar en tu móvil,  las últimas noticias y novedades, tutoriales para modificar tu dispositivo con las últimas actualizaciones de Android, incluso podrás hacerte con una de sus divertidas camisetas.

La verdad que el blog llevado por Paolo AC, Daniel J. Narbona, Adrian Latorre, Roberto Martín, Iván Núñez, Luismix y Roobre está muy bien, y si aun por encima sortean un este Nexus One “pa que quieres más Tomás”.

Enlace Blog: elandroidelibre.com

Enlace concurso: Concurso Nexus One elandroidelibre.com

Android, Concursos, GNU/Linux, Google, HTC, Software Libre, hardware

No voy a hablar de lo que el Google ChromeOS ya que supongo que a estas alturas todo el mundo estará informado.
En la Web, existen imágenes preparadas para ejecutarse en VMWare o VirtualBox, incluso imágenes ISO, pero aquí se explicará como compilar el código fuente en tú máquina para crearte tu mismo esas imágenes del sistema.

1.- Instalar las Dependencias:

Google aconseja que se utilice:

• Ubuntu (Hardy 8.04 o siguientes, recomendada Karmic 9.10)
• Una cuenta con acceso a root  (necesaria para correr chroot y modificar la tabla de montaje)
• e instalar las dependencias, las cuales son:

• Python >= 2.4
• Perl >= 5.x
• gcc/g++ >= 4.2
  
• g++-multilib >=4.2
  
• bison >= 2.3
  
• flex >= 2.5.34
  
• gperf >= 3.0.4
  
• pkg-config >= 0.20
  
• libnss3-dev >= 3.12
  
• libasound2-dev
  
• libgconf2-dev
  
• libglib2.0-dev
  
• libgtk2.0-dev
  
• libnspr4-0d >= 4.7.1+1.9-0ubuntu0.8.04.5
  
• libnspr4-dev >= 4.7.1+1.9-0ubuntu0.8.04.5
  
• msttcorefonts (Fuentes Microsoft)
  
• freetype-dev
  
• libcairo2-dev
  
• libdbus-1-dev

Y opcionales (usadas para pruebas de diseño):

• wdiff
• lighttpd
• php5-cgi
  
• sun-java6-fonts (para Lucida)

Las cuales si estás usando Debian o Ubuntu las puedes instalar mediante:

$ sudo apt-get install subversion pkg-config python perl g++ g++-multilib \
bison flex gperf libnss3-dev libgtk2.0-dev libnspr4-0d libasound2-dev \
libnspr4-dev msttcorefonts libgconf2-dev libcairo2-dev libdbus-1-dev

Y las dependencias opcionales:

$ sudo apt-get install wdiff lighttpd php5-cgi sun-java6-fonts

Para otras distribuciones mirar el final de esta página.

Es importante saber que necesitas tener bastante espacio en disco, ya que el código y el sistema que crea ocupa bastante espacio, en google hablan de 10 GiB. Tambien se debe considerar que se necesitará una distribución de 64 Bits por las librerías que hacen falta, si bien puedes compilar en un sistema de 64 bits ChromeOS sin problemas para 32 bits, puede que tengas problemas de compilación o instalación por la ausencia de librerías de 32 Bits (muchas distribuciones ya no disponen de estas).

2.- Obtener el código fuente:

Existen dos maneras de obtener el código, descargándolo directamente desde la web (lo puedes descargar desde aquí) o puedes obtenerlo usando Git. No sé si es por que en el tarball que me baje de la web le faltaban algunos archivos, el caso es que me dio muchos errores de compilación. Por eso os aconsejo que utilicéis Git:

Primero hay que bajarse los “depot_tools”,  para ellos se utiliza svn (si no lo tienes: # aptitude install subversion):

$ svn co http://src.chromium.org/svn/trunk/tools/depot_tools depot_tools

Lo que te bajas son ejecutables que tienes que añadir al PATH:

$ export PATH=`pwd`/depot_tools:”$PATH”

Evidentemente la línea anterior está diseñada para que funcione tal cual acabas de hacer lo de línea anterior. Deberías incluso editar tu “.bashrc” para añadir al PATH ese directorio permanentemente. OJO: Si no sabes que estás haciendo, simplemente ejecuta las líneas tal cual, la próxima vez que reinicies el PATH será el de siempre, sin este nuevo directorio, pero podrás trabajar ahora, y no correrá peligro de que destroces nada.

Una vez obtenido los depot_tools, instalas Git (si no lo tenías instalado):

$ sudo apt-get install git-core

Creas una carpeta para guardar el código, entras en ella, y te bajas el mismo:

$ mkdir chromiunos

$ cd chromiunos

$ gclient config http://src.chromium.org/git/chromiumos.git

$ gclient sync

$ cd

Y si te quieres y a tomar un café, esto puede tardar bastante, aunque desde google digan que tardará entre unos 10-20 minutos.

3.- Compilar el código fuente:

• Lo primero y opcional es crear el siguiente enlace simbólico, si estás siguiendo los pasos tal cual, sin tener casi ni idea, mejor que lo hagas:

$ ln -s /usr/local/chromiumos/chromiumos.git ~/chromiumos

Evidentemente tienes que cambiar el /usr/local/chromiumos/ por el lugar donde tengas el chromiumos.git (donde hayas hecho el git), si has seguido el manual paso a paso (y la primera vez que abriste la terminal estabas en tu directorio HOME), haz:

$ ln -s ~/chromiumos/chromiumos.git ~/chromiumos

• Lo segundo es hacer un repositorio local (puedes utilizar un mirror en internet, pero si de esta manera tarda, más lo hará si usas un mirror). Así que nos vamos al directorio de scripts:

$ cd ~/chromiumos/src/scripts

$ ./make_local_repo.sh

Esto creará un repositorio local en ~/chromiumos/repo

Esto tarda una barbaridad, el que avisa no es traidor.

• Ahora tenemos que crear el entorno de compilación:

$ ./make_chroot.sh

Compilemos ChromiunOS:

Primero tenemos que crear el siguiente directorio:

$ mkdir -p ~/chromiumos/src/build/x86/local_assets

$ cd ~/chromiumos/src/build/x86/local_assets

Y descargar el siguiente ZIP (que NO tenemos que descomprimir):

$ wget “http://build.chromium.org/buildbot/archives/chromium-chromiumos-r32516/chrome-linux.zip”

$ cd ~/chromiumos/src/scripts

Antes hicimos una jaula con “make_chroot”, ahora tendremos que entrar en ella para compilar con:

$ ./enter_chroot.sh

Podemos crear una contraseña para usuarios compartido con:

$ ./set_shared_user_password.sh (preguntará la contraseña para introducir)

Y nada, solo queda poner a construir todo, pero antes vamos a corregir un error en uno de los archivos, concretamente vamos a:

$ cd ~/chromiumos/src/platform/chrome/

y editamos el fichero:  copy_chrome_zip.sh (con tu editor favorito):

$ nano copy_chrome_zip.sh

Buscamos la línea que dice:

BASE_FROM=”http://chrome-web/buildbot/snapshots/chromium-rel-linux-chromiumos”

y la cambiamos por:

BASE_FROM=”http://build.chromium.org/buildbot/snapshots/chromium-rel-linux-chromiumos/”

(aunque puede que en la versión que te descargaste ya esté arreglado el problema).

NOTA para aquellos que lleguen aquí por el error, si el error era del tipo:

Checking for latest build of Chrome
Downloading http://chrome-web/buildbot/snapshots/chromium-rel-linux-chromiumos/LATEST
–2009-11-20 08:10:42–  http://chrome-web/buildbot/snapshots/chromium-rel-linux-chromiumos/LATEST
Resolving chrome-web… failed: Name or service not known.
wget: unable to resolve host address `chrome-web’
make: *** [build-stamp] Error 1

dpkg-buildpackage: failure: debian/rules build gave error exit status 2

Si! se soluciona cambiando esa línea en ese fichero

Ale! todo preparado, a construir:

$ cd ~/chromiumos/src/scripts

$ ./build_platform_packages.sh

$ ./build_kernel.sh

Este es otro aviso de estos de que lo que estás haciendo ahora mismo, tarda bastante.

• Y por último, creamos la imagen (por fin):

$ ./build_image.sh

Una vez tenemos la imagen podemos hacer varias cosas con ella. Primeros salimos de la jaula escribiendo en la terminal “exit”.

1.- Copiar la imagen a una memoria USB:

$ ./image_to_usb.sh –from=~/chromiumos/src/build/images/SUBDIR –to=/dev/USBKEYDEV

- Donde SBUDIR es el directorio creado por ./build_image.sh

- y USBKEYDEV es el punto de montaje de la memoria (normalmente /dev/sdb - OJO! NO poner la partición: sdb1, sdb2, …, sdbn)

2.- Copiar la imagen al Disco Duro:

$ /usr/bin/chromeos-install

3.- Convertir la imagen para VMWare o VirtualBox:

Necesitas tener instalado qemu:

$ sudo aptitude install qemu

Para crear la imagen:

./image_to_vmware.sh –from=~/chromiumos/src/build/images/SUBDIR \
–to=~/chromiumos/src/build/images/SUBDIR/ide.vmdk

- SUBDIR es el directorio creado por ./build_image.sh

NOTA: La imagen de VMWare puede sufrir alguna limitación, según google no tendrás acceso a una terminal virtual, tendrás una lenta respuesta del teclado…

– — –

MÁS NOTAS para navegantes, si quieres deshacerte del chroot (del cual ya saliste hace unos pasos), no le hagas un “rm -rf” sobre el directorio “chroot” lo correcto es que ejecutes (desde el directorio de scripts):

$ ./make_chroot.sh –delete

4.- Abrir la imagen con VirtualBox:

Abrimos VirtualBox, creamos una nueva máquina, le damos a siguiente, le pones el nombre que quieres y en “Tipo de sistema operativo” eliges GNU/Linux. En “Versión” yo puse “Ubuntu 64 Bits” ya que ChromiumOS está basado en este. Siguiente.

Le dais el tamaño de memoria base que queráis (no necesita mucho), y siguiente.

En disco duro le dais a utilizar uno existente, y le dais a la carpeta que aparece a la derecha del cuadro de inserción. En las pestañas de arriba le dais “Añadir” y buscáis la imagen que acabáis de crear, llamada “ide.vmdk” que está en el directorio “~/chromiumos/src/build/images/SUBDIR” (SUBDIR es el directorio creado por ./build_image.sh).

Seleccionáis la imagen que acabáis de añadir y le dais a “Seleccionar” y Siguiente. Finalizar.

Y PUNTO! Todo preparado para arrancar la imagen y probar el nuevo (y aun muy simple Google ChromeOS).

Debian, GNU/Linux, Google, Internet, Software Libre, ubuntu

Cuelgo en el blog una modificación del pequeño programa “wlandecrypter” que genera un diccionario con las posibles claves de los diferentes routers de Timofónica.
Este comprueba por mac, como el original, si esta existe (está reconocida como una de las mac que utilizan los routers de la compañía) pero a diferencia del antiguo, es que si esta no existe también te da la posibilidad, previo aviso, de poder generar un diccionario con esos valores (más que nada por si se van añadiendo nuevas marcas o nuevas mac, y estas no han sido añadidas ya en la base del programa).
La forma de lanzarlo también cambia. Con la modificación en vez de tener que escribir todo el BSSID y todo el ESSID, solo se ingresarán las partes importantes, es decir, los primeros seis caracteres de la mac y los dos últimos del ESSID.
Ejemplo, si quieres generar un diccionario para la red con las siguientes características:
BSSID : 00:13:49:E8:29:7B
ESSID: WLAN_32
El programa se lanzará:

$ m0dWlandecrypter 001349 32 diccionario

NOTA: No comprobará si los 6 primeros caracteres pertenecientes al bssid son  hexadecimales (ya lo implemento uno de estos días).

Dejo el código en cuestión:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265

/*****************************************************************************
* Fichero:                      m0dWlandecrypter.c
* Fecha:                        22-09-2009
* Autor:                        aabilio (aabilio[at]gmail[dot]com)
* 
* Es una pequeña modificación del wlandecrypter de Nilp0inteR
* 
* Este programa es software libre; puedes redistribuirlo y/o modificarlo
* bajo los terminos de la Licencia Publica General GNU (GPL) publicada
* por la Free Software Foundation; en su version numero 2, o (bajo tu 
* criterio) la ultima version. Mira http://www.fsf.org/copyleft/gpl.txt.
* 
* Este programa se distribuye SIN GARANTIA de ningun tipo.
*****************************************************************************/
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
#define MAXROUTER 13
#define ULTIMO 12
 
/* Estructura Router */
typedef struct __Router {
    char bssid[7];
    char init;
    char info[20];
} _Router;
 
/* Variable global */
char hex[16]="0123456789ABCDEF";
 
/* Prototipos */
void datosRouters(_Router routers[MAXROUTER]);
void muestraAyuda();
int buscaBssid(_Router routers[MAXROUTER], char *bssid);
void imprimeClaves(FILE *fichero, _Router routers[MAXROUTER], 
                    int bssidId, char *keyEnd, char *);
void bucleImprimeClaves(FILE *fichero, char , int bssidId, char *keyEnd, char *);
 
/* MAIN */
int main(int argc, char *argv[]) {
 
        int i, bssidId, validHex=0;
        char opcion;
        char endKey[2];
        _Router routers[MAXROUTER];
        FILE *fichero;
 
        fprintf(stdout, "\n====================================\n");
        fprintf(stdout, "m0dWlandecrypter - aabilio@gmail.com\n");
        fprintf(stdout, "====================================\n");
 
        if(argc<3 || argc>4) {
            muestraAyuda();
            return 1;
        }
 
        if(strlen(argv[1]) != 6 ) {
            fprintf(stderr," [-] Longitud de BSSID invalida\n");
            muestraAyuda();
            return 1;
        }
        if(strlen(argv[2]) != 2 ) {
            fprintf(stderr," [-] Longitud de ESSID invalida\n");
            muestraAyuda();
            return 1;
        }
 
        datosRouters(routers);
        bssidId=buscaBssid(routers, argv[1]);
 
        fprintf(stderr, " [+] BSSID: %s\n" 
                        " [+] Modelo: %s\n", argv[1], routers[bssidId].info);
        if(bssidId==ULTIMO) {
            strcpy(routers[ULTIMO].bssid, argv[1]);
            routers[ULTIMO].init = 'Z';
            fprintf(stderr, "   |__>> [?] Puede que no genere un buen diccionario\n");
            do {
                fprintf(stderr, "          Continuar de todas formas?? (s/n) : ");
                opcion = getchar(); getchar();
                //scanf("%c", &opcion);
                opcion = toupper(opcion);
                if (opcion == 'N')
                    return 1;
                else if (opcion == 'S')
                    break;
            } while (1);
 
        }
 
        for(i=0;i<strlen(argv[2]);i++)
            argv[2][i]=toupper(argv[2][i]);
 
        if(strlen(argv[2]) != 2 ) {
            fprintf(stderr, " [-] ESSID: %s invalido!!\n", argv[2]);
            return 1;
        } else {
            for(i=0;i<strlen(hex);i++) {
                if(argv[2][0]==hex[i]) {
                    validHex++;
                    break;
                }
            }
            for(i=0;i<strlen(hex);i++) {
                if(argv[2][1]==hex[i]) {
                    validHex++;
                    break;
                }
            }
 
            if(validHex!=2) {
                fprintf(stderr, " [-] ESSID: %s invalido!!\n", argv[2]);
                return 1;
            }
            else {
                endKey[0]=argv[2][0];
                endKey[1]=argv[2][1];
 
                fprintf(stderr," [+] ESSID: %s\n", argv[2]);
 
                if(argc>3) {// Fichero
                    fprintf(stderr," [+] Fichero de claves: %s\n", argv[3]);
                    if ((fichero=fopen(argv[3], "a+")) == NULL) {
                       fprintf(stderr, " [-] Fallo al escribir en el fichero\n");
                       return 1;
                    }
 
                    imprimeClaves(fichero,routers,bssidId,endKey, argv[1]);
                    fclose(fichero);
                    fprintf(stderr, " [+] Fichero guardado\n");
                } else {
                    fprintf(stderr," [+] Seleccionada salida estandar\n");
                    imprimeClaves(stdout,routers,bssidId,endKey, argv[1]);
                }
            }
        }
        puts("");
        return 0;
}       
 
/* AYUDA */
void muestraAyuda() {
    fprintf(stderr, "\nuso: aawlandecrypter <bssid> <essid> [output file]\n"
                    "  |__<bssid> : Solo los 6 primeros caracteres del mismo sin contar ':'\n"
                    "  |__<essid> : Solo los XX de WLAN_XX\n"
                    "  |__[output file] : Archivo resultante\n\n"
                    "   Ejemplo: aawlandecrypter 001349 55 diccionario\n\n");
}
 
/* Imprime claves */
void imprimeClaves(FILE *fichero, _Router routers[MAXROUTER], 
                    int bssidId, char *keyEnd, char *bssid) {
    //int i,j,k,l;
 
    if(bssidId==ULTIMO){
        routers[bssidId].init = 'Z';
        bucleImprimeClaves(fichero,routers[bssidId].init,bssidId,keyEnd,bssid);
        routers[bssidId].init = 'X';
        bucleImprimeClaves(fichero,routers[bssidId].init,bssidId,keyEnd,bssid);
        routers[bssidId].init = 'C';
        bucleImprimeClaves(fichero,routers[bssidId].init,bssidId,keyEnd,bssid);
    } else {
        bucleImprimeClaves(fichero,routers[bssidId].init,bssidId,keyEnd,bssid);
    }
}
/* El bucle que imprime la clave */
void bucleImprimeClaves(FILE *fichero, char init, 
                        int bssidId, char *keyEnd, char *bssid) {
    int i,j,k,l;
 
    for(i=0;i<16;i++)
        for(j=0;j<16;j++)
            for(k=0;k<16;k++)
                for(l=0;l<16;l++) {
                    fprintf(fichero, "%c%s%c%c%c%c%c%c\n"
                            , init, bssid, hex[i],hex[j],hex[k],hex[l], 
                            keyEnd[0],keyEnd[1]);
                }
}
 
/* Datos de los routers: */
void datosRouters(_Router routers[MAXROUTER]) {
        int i =0;
        // Z-com
        strcpy(routers[i].bssid,"0060B3\0");
        routers[i].init = 'Z';
        strcpy(routers[i].info,"Z-com\0");
        i++;
        // Zyxel : Gracias a thefkboss de foro.elhacker.net por esta observacion
        strcpy(routers[i].bssid,"00A0C5\0"); 
        routers[i].init = 'Z';
        strcpy(routers[i].info,"Zyxel 650HW/660HW\0");
        i++;
        // P-660HW-D1
        strcpy(routers[i].bssid,"001349\0");
        routers[i].init = 'Z';
        strcpy(routers[i].info,"P-660HW-D1\0");
        i++;
        // Xavvy
        strcpy(routers[i].bssid,"000138\0");
        routers[i].init = 'X';
        strcpy(routers[i].info,"Xavi 7768r\0");
        i++;
        // Comtrend
        strcpy(routers[i].bssid,"0003C9\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 535\0");
        i++;
        // Comtrend NUEVO, gracias a dnreinad por el coche xD
        strcpy(routers[i].bssid,"001638\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 536+\0");
        i++;
        // Comtrend NUEVO
        strcpy(routers[i].bssid,"001915\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 536+\0");
        i++;
        // Comtrend NUEVO
        strcpy(routers[i].bssid,"0030DA\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 536+\0");
        i++;
        // Comtrend NUEVO
        strcpy(routers[i].bssid,"001A2B\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 536+\0");
        i++;
        // Comtrend NUEVO
        strcpy(routers[i].bssid,"001D20\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 536+\0");
        i++;
 
        // ZyGate
        strcpy(routers[i].bssid,"0002CF\0");
        routers[i].init = 'Z';
        strcpy(routers[i].info,"ZyGate\0");
        i++;
        // ZyGate
        strcpy(routers[i].bssid,"0019CB\0");
        routers[i].init = 'Z';
        strcpy(routers[i].info,"ZyGate\0");
        i++;
 
        strcpy(routers[ULTIMO].bssid,"000000\0");
        routers[ULTIMO].init = 'Z';
        strcpy(routers[ULTIMO].info,"Desconocido\0");
}
 
int buscaBssid(_Router routers[MAXROUTER], char *bssid) {
    int i;
 
    for(i=0;i<strlen(bssid);i++)
        bssid[i]=toupper(bssid[i]);
 
    for(i=0;i<MAXROUTER;i++) {
        if(strncmp ( routers[i].bssid, bssid, 6 ) == 0)
        return i;
    }
 
    return ULTIMO;
}

Para compilar en GNU/Linux:

$ gcc -o wlandecryter_mod m0dWlandecrypter.c

Enlace | m0dWlandecrypter.c para descargar

General, Internet, Software Libre, códigos, wifi, wireless

Si tienes Debian GNU/Linux testing y actualizas en estos días probablemente te encuentres que las ventanas maximizadas no muestran la decoración (los bordes de ventana).
Esto se debe a un problema con la nueva versión del paquete de metacity, el bug está reportado.

Para ir tirando, el problema lo puedes solucionar con un simple:

$ metacity --replace &

EDITADO (27/07/2009):
El bug ha sido corregido con el lanzamiento de la versión 2.26.0-3 en testing (ya había sido lanzada hace unos días en unstable)
Las ventanas no perdían la decoración, sino que ignoraban las barras del panel y se escondían detrás de estas.
Actualiza a la nueva versión para solucionar el problema.

Debian, GNU/Linux, Software Libre, gnome, tips

Hace unos días navegando por el blog de catrip me encontré con un pequeño scritp diseñado para manejar de forma fácil xwinwrap (programilla para colocar como fundo de escritorio imágenes animadas, vídeos o incluso tu propia webcam).

El script hace uso de Zenity para manejar de forma gráfica y mediante opciones la forma en la que se presentará el fondo de pantalla de tu ordenador.

Ese día no tenía mucho que hacer así que lo retoqué un poco y se lo envíe, a el le pareció correcto colgarlo en su web como una mejora y ahora yo lo cuelgo aquí por si alguno de los pocos visitantes de este blog les sirve para algo

EDITADO (01/02/2010): Ahora acepta seleccionar varios vídeos para para poner en cola al reproducir.

#!/bin/bash

#########################################################
#							                            #
#		VideoFondo.sh				                    #
#							                            #
# Realizado inicialmente por Catrip <alktrip@gmail.com>	#
# y retocado por aabilio <aabilio@gmail.com>		    #
# WTFPL <http://en.wikipedia.org/wiki/WTFPL> 		    #
#########################################################

### OPCIONES ###

PARAM="-fs -sp -ni -nf -st -s -b -o"

dato1="Colocar un o varios vídeos como Wallpaper"
dato2="Colocar Screen Saver como Wallpaper"
dato3="Finalizar la reproducción"
dato4="Colocar webcam como Wallpaper"
dato5="Finalizar el programa"

con_sonido="Colocar vídeo con sonido"
sin_sonido="Colocar vídeo sin sonido"
BACK="Volver"

### FUNCIONES ###

function fun_opacidad {
opacidad=$(zenity --list --width="60" --height="415" --text "Selecciona una opción" --title "Nivel de Opacidad" --column "Opacidad" `for (( c=1; c<=9; c++ )); do echo -n "0.$c "; done` 1)
}

function fun_check {
if pidof xwinwrap > /dev/null ; then
killall xwinwrap
fi
}

function fun_typeson {
typeson=$(zenity --list --width="315" --height="260" --text "Opciones del vídeo" --title "Opciones" --column "Opción" "$con_sonido" "$sin_sonido" "$BACK")
if [ "$typeson" = "$sin_sonido" ]; then
SON=" -nosound"
fi
if [ "$typeson" = "$con_sonido" ]; then
unset SON
fi
if [ "$typeson" = "$BACK" ]; then
main
fi
}

### MAIN ###

function main
{
type=$(zenity --list --width="415" --height="260" --text "Indique la operación a realizar" --title "ScreenSaver, Vídeo o WebCam como Wallpaper"  --column "Opción" "$dato1" "$dato2" "$dato4" "$dato3" "$dato5")

if [ "$type" = "$dato1" ]; then
fun_typeson

FILES=`zenity --file-selection \
--title="Selecciona el vídeo a colocar como Wallpaper" --multiple --separator=" "`

fun_opacidad
fun_check

exec xwinwrap $PARAM "$opacidad" -- mplayer -quiet -noconsolecontrols -loop 0$SON -wid WID $FILES
fi

if [ "$type" = "$dato2" ]; then
screen=$(ls /usr/lib/xscreensaver/ | zenity --list --width="60" --height="415" --text "Selecciona un ScreenSaver" --title "ScreenSavers" --column "ScreenSaver")
fun_opacidad
fun_check
exec xwinwrap -argb $PARAM "$opacidad" -- /usr/lib/xscreensaver/"$screen" -window-id WID
fi

if [ "$type" = "$dato3" ]; then
fun_check
fi

if [ "$type" = "$dato4" ]; then
fun_opacidad
fun_check
exec xwinwrap $PARAM "$opacidad"  -- mplayer -wid  WID -quiet -fps 30 tv:// -vf mirror
fi

if [ "$type" = "$dato5" ]; then
fun_check
exit;
fi

#Incluimos a main en un bucle infinito hasta que el USER cierre
main

}

#Llamamos a que se ejecute la function main:
main

Enlace | Descarga el script (VideoFondo.sh) junto con un xwinwrap compilado para amd64.

Enlace | Descargar un .deb con Xwinwrap para 32 bits.

Enlace | Para todo lo demás (requisitos del script, vídeo de funcionamiento, enlaces…) visitar la web de Catrip.

GNU/Linux, Software Libre, códigos, software

Galego | Español

La de Español ya viene incorporada en el proyecto, pero es un poco mala a mi gusto.

La de Gallego se incluirá en el próximo lanzamiento.

Web de BaShare

GNU/Linux, P2P, Software Libre, Traducciones, software

¿Ya has probado Mobling en tu netbook?

Puedes probar en modo live bajando la imagen desde aquí.

Lo puedes grabar en pen (al menos 1 GiB) de la siguiente manera con el comando dd:

# dd bs=4096 if=<image file> of=<usb drive>

o con el script de python image-writer que puedes encontrar aquí, y ejecutarlo de la siguiente manera:

# ./image-writer <image file>

Antes de nada le tendrías que haber dado permisos de ejecución al script de image-writer:

# chmod a+x ./image-writer

De momento el proyecto está en fase temprana y tiene barios bugs y muchas opciones no disponibles, pero se lanzan versiones a un ritmo bastante bueno.

Yo si lo he probado y puedo decir que pinta bastante bien y su interfaz de manejo es espectacular.

Enlace | Web de Mobling

GNU/Linux, Software Libre, software, wireless

Gtk-server es un software con el cual podemos crear interfaces gráficas (GTK 1.x o 2.x) en un un montón de shell scripts, desde bash a Perl, pasando por Ruby, Awk o Python (aquí lista completa).

Gtk-server se compila como un binario al que haremos referencias en nuestros shell scripts y que proporciona una especie de API a las librerías GTK, así podremos desde nuestro fichero en texto plano llamar a GTK para dibujar ventanas en el escritorio.

A pensar de lo que se pueda pensar a primera vista, gtk-server no supone una limitación por si misma para programar interfaces gráficas utilizando Gtk, se pueden hacer cosas muy interesantes mediante este software.

A continuación, vamos a ver el famoso Hola Mundo! con bash y gtk-server (una ventana con un botón que pone “Hola Mundo” y si le das se cierra la venta):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

#!/bin/bash
 
### ESTA PRIMERA PARTE ES PARA CREAR LAS FUNCIONES EMBEBIDAS DE GTK PARA BASH (.gtk4bash)
# no es necesario utilizar esto antes, pero te quita trabajo, y es más intuitivo.
###################################################################################################
#
# Create embedded GTK functions for BASH
#
# (c) Peter van Eerten 2006, GPL license
#
# Tested with:
# -BASH 3.0 on Slackware 10 and GTK-server 2.1.4
#
# October 11, 2006: Initial release
# October 12, 2006: Added check to see when created PIPE file is ready
# January 16, 2007: Solved problem of unique filename
# August 20, 2007: Improved for GTK-server 2.1.4
# October 13, 2007: Added mechanism for finding configfile
# May 14, 2008: Added define function, code is even shorter now
# Oct 9, 2008: Added default ‘gtk’ function to use after new definition of calls
#
# Put the first part of this file at the start of each of your BASH scripts and
# you can embed GTK as if you are using the original API.
#————————————————————————————————-
 
# Set the extending globbing option in BASH
shopt -s extglob
 
# Pipe filename must be unique for your application
PIPE=”/tmp/gtk.bash.\$$”
 
# Find GTK-server configfile first
if [[ -f gtk-server.cfg ]]; then
CFG=gtk-server.cfg
elif [[ -f /etc/gtk-server.cfg ]]; then
CFG=/etc/gtk-server.cfg
elif [[ -f /usr/local/etc/gtk-server.cfg ]]; then
CFG=/usr/local/etc/gtk-server.cfg
else
echo “No GTK-server configfile found! Please install GTK-server…”
exit 1
fi
 
# Now create global functionnames from GTK API
if [[ ! -f $HOME/.gtk4bash || $CFG -nt $HOME/.gtk4bash ]]; then
echo “#!/bin/bash” > $HOME/.gtk4bash
echo “gtk-server -fifo=$PIPE &” >> $HOME/.gtk4bash
echo “while [ ! -p $PIPE ]; do continue; done” >> $HOME/.gtk4bash
while read LINE
do
if [[ $LINE = FUNCTION_NAME* && $LINE = +(*gtk_*|*gdk_*|*g_*|*glade_*) ]]; then
LINE=${LINE#*= }
printf “\nfunction ${LINE%%,*}\n” >> $HOME/.gtk4bash
printf “{\n/bin/echo ${LINE%%,*} \$@ > $PIPE” >> $HOME/.gtk4bash
printf “\nread GTK < $PIPE\n}\n” >> $HOME/.gtk4bash
fi
done < $CFG
printf “\nfunction gtk()\n{\necho \$1 > $PIPE; read GTK < $PIPE;\n}\n” >> $HOME/.gtk4bash
fi
 
# Declare global variables
declare GTK NULL=”NULL”
unset CFG PIPE LINE
 
# Assignment function
function define() { $2 $3 $4 $5 $6 $7 $8 $9; eval $1=”$GTK”; }
 
# Wait for user
read -p “Press <enter> to start hola mundo…” VAR
 
#————————————————————————————————-
# Aquí empieza el Hola Mundo
#————————————————————————————————-
 
# Include the generated ‘.gtk4bash’-file in the shellscript to use embedded GTK functions
. $HOME/.gtk4bash
 
# Definir GUI
gtk_init “NULL NULL”
define WINDOW gtk_window_new 0
gtk_window_set_title $WINDOW “‘Hola Mundo!’”
gtk_window_set_position $WINDOW 1
gtk_window_set_default_size $WINDOW 230 150
define BUTTON gtk_button_new_with_label “‘Hola Mundo’”
gtk_widget_set_size_request $BUTTON 50 25
gtk_container_add $WINDOW $BUTTON
 
gtk_widget_show_all $WINDOW
 
# Inicializar variables
EVENT=0
 
# Mainloop
while [[ $EVENT != $BUTTON && $EVENT != $WINDOW ]]
do
define EVENT gtk_server_callback “wait”
done
 
# Exit GTK
gtk_server_exit

Este es un pequeño ejemplo de lo que se puede hacer con  gtk-server y bash (u otros lenguajes de script), aquí y aquí se pueden encontrar más ejemplos de lo que se puede hacer, y aquí encontrarás algunas aplicaciones creadas con gtk-server.

Gtk-server no es una aplicación para construir de manera fácil y rápida aplicaciones gráficas (como podría ser Zenity), tienes que conocer GTK, ya que lo único que hace es portar este a los lenguajes de script.

Para empezar a utilizarlo puedes descargarlo desde su web aquí.

Si descargas el source (wget http://downloads.sourceforge.net/gtk-server/gtk-server-2.3.1-sr.tar.gz) lo tienes que descomprimir:

1
2
3

$ tar xzvf gtk-server-2.3.1-sr
 
$ cd  gtk-server-2.3.1-sr

Y compilarlo e instalarlo:

1
2
3
4
5

$ ./configure
 
$ make
 
# make install

Y ya puedes empezar a crear tus scrip con interfaz gráfica. Para ello tienes que leer la documentación que puedes encontrar aquí.

Próximamente colgaré un pequeño manual de iniciación para utilizar Gtk-server y Bash.

Software Libre, shell, software