Tiempo de Tux: shell

Mostrando las entradas con la etiqueta shell. Mostrar todas las entradas

viernes, 17 de octubre de 2014

[Shell] Reloj binario en C

Esta ocasión crearemos un reloj binario en C,en el entorno de escritorio KDE,contamos con un reloj binario como applet,me imagine como programar uno y mas adelante colocare el código.

En primer lugar debemos saber como leerlo,en esta ocasión el reloj se basa en cuatro bits,representados por 1 y 0 como realmente se hace,para el bit activo usamos 1 y para el bit apagado usamos 0,el reloj esta representado en formato de 24 horas y cada hora es un Byte de 4 bits un nibble.

Veamos la notación,por ejemplo las 5 de la tarde es 17 en formato de 24 horas,ahora vamos a dividir los números de uno en uno y nos queda 1 y 7,representados en binario son:

1 = 0001
7 = 0111

Bien la lectura binaria la podemos traducir asi de la forma mas fácil,imaginemos que los numero de arriba corresponden a una potencia de 2,comensando por el 1 y luego el 2 mismo,en nuestro caso cuatro bits:

8 4 2 1

Ahora abajo de esos numero colocamos el 0 o 1 que estén activados para que la suma de el numero en notación decimal,por ejemplo 1 y 7:

bits : 8 4 2 1

1 = 0 0 0 1
7 = 0 1 1 1

Bien ahora sumamos los bits que están activos:

1 = 0+0+0+1 = 1 en decimal

7 = 0+4+2+1 = 7 en decimal

Bien eso es todo ahora si el código,el código cuenta con 6 numero en notación binaria,2 para la hora 2 para los minutos y dos para los segundos:

El código se basa en programación funcional y llamamos las funciones una a una en el main.

#include <stdio.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>

/*
 * Archivo : relojbinario.c
 * Compila : gcc -o relojbinario relojbinario.c
 */


#define BUF_TIME 60
#define BITS 4

typedef enum {
    ZERO = 0x30,
    UNO,
    DOS,
    TRES,
    CUATRO,
    CINCO,
    SEIS,
    SIETE,
    OCHO,
    NUEVE
} Hora;

typedef struct _f_hora {
    int hora_decena[BITS];
    int hora_unidad[BITS];
    int minuto_decena[BITS];
    int minuto_unidad[BITS];
    int segundo_decena[BITS];
    int segundo_unidad[BITS];
} f_hora;

char formato[] = "%k%M%S";
char fecha[BUF_TIME];
void create_clock();
void create_num(char num,f_hora *hora,int i);
void destroy_Binary(f_hora *hora);
void create_binary(f_hora *hora);
void show_clock(f_hora hora);

int main()
{
    f_hora hora;
    create_clock();
    create_binary(&hora);
    show_clock(hora);
    return 0;
}

void create_clock()
{
    struct tm *tiempo;
    time_t ahora = time(0);
    tiempo = localtime(&ahora);
    strftime(fecha,BUF_TIME,formato,tiempo);
}

void create_binary(f_hora *hora)
{
    int len = strlen(fecha),i;
    if (len == 0)
        exit(1);
    for (i = 0;i< len;i++)
        create_num(fecha[i],hora,i);
}

void create_num(char num,f_hora *hora,int iter)
{
    int aux[BITS],i;
    switch((int)num)
    {
        case ZERO:
            aux[0] = 0;
            aux[1] = 0;
            aux[2] = 0;
            aux[3] = 0;
            break;
        case UNO:
            aux[0] = 0;
            aux[1] = 0;
            aux[2] = 0;
            aux[3] = 1;
            break;
        case DOS:
            aux[0] = 0;
            aux[1] = 0;
            aux[2] = 1;
            aux[3] = 0;
            break;
        case TRES:
            aux[0] = 0;
            aux[1] = 0;
            aux[2] = 1;
            aux[3] = 1;
            break;
        case CUATRO:
            aux[0] = 0;
            aux[1] = 1;
            aux[2] = 0;
            aux[3] = 0;
            break;
        case CINCO:
            aux[0] = 0;
            aux[1] = 1;
            aux[2] = 0;
            aux[3] = 1;
            break;
        case SEIS:
            aux[0] = 0;
            aux[1] = 1;
            aux[2] = 1;
            aux[3] = 0;
            break;
        case SIETE:
            aux[0] = 0;
            aux[1] = 1;
            aux[2] = 1;
            aux[3] = 1;
            break;
        case OCHO:
            aux[0] = 1;
            aux[1] = 0;
            aux[2] = 0;
            aux[3] = 0;
            break;
        case NUEVE:
            aux[0] = 1;
            aux[1] = 0;
            aux[2] = 0;
            aux[3] = 1;
            break;
        default:
            break;
    }
    for (i=0;i<BITS;i++)
    {
        if (iter == 0)
        {
            hora->hora_decena[i] = aux[i];
        }
        else if (iter == 1)
        {
            hora->hora_unidad[i] = aux[i];
        }
        else if (iter == 2)
        {
            hora->minuto_decena[i] = aux[i];
        }
        else if (iter == 3)
        {
            hora->minuto_unidad[i] = aux[i];
        }
        else if (iter == 4)
        {
            hora->segundo_decena[i] = aux[i];
        }
        else
        {
            hora->segundo_unidad[i] = aux[i];
        }
    }
}

void show_clock(f_hora hora)
{
    int i;
    for (i=0;i<BITS;i++)
    {
        printf("\t%d\t",hora.hora_decena[i]);
        printf("\t%d\t",hora.hora_unidad[i]);
        printf("\t%d\t",hora.minuto_decena[i]);
        printf("\t%d\t",hora.minuto_unidad[i]);
        printf("\t%d\t",hora.segundo_decena[i]);
        printf("\t%d\t",hora.segundo_unidad[i]);
        puts("");
    }
}

Para compilar usamos:

gcc -o relojbinario relojbinario.c

Y si lo ejecutamos en linux podemos llamarlo así,para ver como se ejecuta cada segundo:

while [ 1 ];do sleep 1; clear; ./relojbinario; done

-->

sábado, 8 de febrero de 2014

[Shell] Guardar mas comandos en history Linux

Muchas veces vemos en el historial comandos que hemos tecleado,muchas veces ni los recordamos y es por eso que los tecleamos,por ejemplo que hayamos usando un estándar de unix,un pipe o un comando que es difícil volver a escribir o simplemente no recordamos como era.

En Ubuntu por defecto el historial de history es de 2000 comandos,yo lo tengo en 20000,ya que uso mucho,pero mucho la terminal,así que si la usan igual o quieren registrar lo que escriben (puede que 1000,2000 quede corto) aquí veremos como:

Tutorial

Bien esto es bien sencillo,lo único que tenemos que hacer es cambiar dos variables de entorno,o una si así lo deseamos,las cuales son:

HISTSIZE # Numero de lineas que se muestran cuando tecleamos history

HISTFILESIZE # Numero de lineas que se guardan en el archivo

HISTFILE # Archivo donde esta el historial

Bien las que nos interesan son las dos primeras,mas especifico la segunda,ya que la primera es cuando tecleamos history,vean yo lo tengo en 20:

Para cambiar estas variables lo podemos hacer de varias formas,pero primero hay que localizar nuestro .bashrc :

Esta en nuestro home,a menos que hayamos cambiado esto:

Lo editamos:

nano ~/.bashrc

Lo buscamos :

Si no existen las variables las crean,si existen las actualizan, salimos:

Ctrl+x

Y reiniciamos la shell;

reset

Si queremos hacerlo con un editor de flujo y ahorrarnos el trabajo de entrar podemos usar sed:

sed -i -e 's/HISTSIZE.*/HISTSIZE=200/' ~/.bashrc

sed -i -e 's/HISTFILESIZE.*/HISTFILESIZE=20000/' ~/.bashrc

Si ven esto un poco peligroso,porque tecleamos cosas que no queremos que vea cualquiera,solo añaden un espacio al principio y no se guarda el comando.

Eso es todo.

miércoles, 5 de febrero de 2014

Como listar archivos con filtrado en Perl

En esta ocasion vamos a aprender como listar los archivos de un directorio con filtrado de extension,por ejemplo listar los .txt,los .png,etc.

En perl las cosas se pueden hacer de muchas maneras,así que vamos a ver algunas(no todas),pero las que me gustan o conozco:

En todos los ejemplos,el array @archivos contendrá los archivos filtrados,este sera el que pueden usar para lo que necesiten.

use feature 'switch'; # Usamos switch

my $dir = "."; # . hace referencia al directorio actual

my @archivos;

 opendir(my $recorrer, $dir) || die "Error :( $! \n";  # recorrer es el filehandle
    while(readdir $recorrer){  # Leemos el directorio
        if (-f $dir . "/" . $_) { # Vemos si es un fichero
            given ($_) { 
                when (/.*jpg/) { # Elegimos la extension
                     push (@archivos, $_); # Añadimos al array el archivo
                }
                when (/.*jpeg/) { # Elegimos otra(si queremos)
                    push (@archivos, $_);
                }
            }
        } 
    }
    closedir $recorrer;  # Cerramos el directorio

Bien ese es que yo uso mas,es un poco a lo Java,pero me gusta que se vea mucho codigo,aunque luego me dicen que mientra menos mejor,y en perl eso es muy simple.

Bien ahora una forma mas sencilla,usando glob al estilo python,glob es similar a los pipes de Unix:

my @arr = glob("*.jpg");

Así de sencillo,aquí el problema es para añadir mas,podemos hacer esto si quisieramos tambien los .jpeg.

foreach (glob("*.jpeg")) 
{
   push (@archivos, $_);
}

Bien,ahora una manera aun mas sencilla:

my @arr = <*.jpg>;

De igual manera si queremos añadir mas:

foreach (<*.jpeg>)) 
{
   push (@archivos, $_);
}

Si queremos usar un directorio en especifico lo especificamos antes:

my @archivos = ;

Ahora por ejemplo para mostrar en pantalla:

use feature 'say';

my @archivos = <*.pl>;

foreach (@archivos) {    
    say $_;
}

Eso es todo.

lunes, 3 de febrero de 2014

[Shell] Spam comentarios wordpress

Seguimos hablando de pentest y aquí otra cosa que se ve mucho y que molesta,el spam,el spam son esos comentarios que no dejan nada y que son masivos.

A mi no me ha tocado mucho spam en blogger como dicen que sucede en wordpress,me han llovido anuncios,mentadas de madre,y otras ridiculeces pero bueno,es lo que pasa en la web hay todo tipo de gente hay muchas personas que comentan aportan y hay otras que,que bueno...

Pero bueno lo que sea de cada quien no se que sistema usen pero hace un tiempo pasaron mi capcha y comentaron 40 veces seguidas al mismo tiempo :O,hay que reconocer que saben lo que hacen.

En esta ocasión vamos a aprender a crear un spamer para los comentarios de wordpress.

Esto no es para que anden spameando ya que es una tontería mas si el webmaster del sitio tiene las ip's(o simplemente wordpress nos manda la ip del comentario),es para que vean como se podría spamear y como defenderse,si quieren spamear haganlo bajo su propio riesgo yo solo les aviso de la hulla de Internet.

Bien vamos a usar Perl para este ejercicio,primero que nada instalamos lo necesario:

Abrimos una shell:

sudo cpan WWW::Mechanize

sudo cpan WWW::Mechanize::GZip

sudo cpan Data::Dumper

Bien ahora debemos por ejemplo:

Ver los imput del sitio en donde queremos "comentar",para esto podriamos usar regex y pipes Unix,pero vamos a hacerlo desde perl:

Aqui un sencillo script que ubica todos los input:

use strict;
use WWW::Mechanize;
use HTML::Form;
use LWP::UserAgent;
use Data::Dumper;

my $url = "http://url";

my $mech = WWW::Mechanize->new(autocheck => 1);

$mech->get( $url ) or die("No es posible conectarse a $url");

my $ua = LWP::UserAgent->new;

my $response = $ua->($url);

my @forms = HTML::Form->parse($response);

foreach (@forms) {
    print Dumper($_);
}

Ejecutamos y vemos todos los input,en wordpress es una tontería esto ya que están a fuego:

Ahora tenemos los fields:

comment
email
author
url

Bien vamos a crear un script para un comentario simple:

#!/usr/bin/env perl

use warnings;
use strict;
use WWW::Mechanize::GZip;

my $url = "http://url";

my $mech = WWW::Mechanize::GZip->new();

$mech->agent_alias("Linux Mozilla");

$mech->get($url) || die $!;

my $respuesta = $mech->submit_form(
       fields => {
       comment => "Este es un spam",
       email => 'email@gmail.com',
       author => "unknow",
       url => "direccion.com",
    }
);
print "Listo";
}

Con eso podemos comentar de manera común,ahora que convierte un comentario en spam:

El numero de envíos,así que vamos a enviar mas comentarios con un bucle:

Pero primer problema,wordpress verifica los comentarios en su base de datos,si son iguales redirigue la pagina y ya podríamos comentar.

Solución añadir un contador al comentario,con añadir un numero al principio o al final basta,esto en el mail o en el comentario.

'email@gmail.com'.$i

Otro problema,wordpress checa el tiempo en el que enviamos los mensajes,esto se solucion esperando un tiempo por ejemplo:

sleep 10;

Esperar 10 segundos en cada envió,si somos un poco ingeniosos incluso podemos usar una ip diferente para cada comentario,pero eso se los dejo de tarea.

#!/usr/bin/env perl

use warnings;
use strict;
use WWW::Mechanize::GZip;

my $url = "http://url";

my $mech = WWW::Mechanize::GZip->new();

$mech->agent_alias("Linux Mozilla");

$mech->get($url) || die $!;

for (1..10) {
my $respuesta = $mech->submit_form(
       fields => {
       comment => "Este es un spam".$_,
       email => 'mail'.$_.'@gmail.com',
       author => "unknow".$_,
       url => "direccion.com",
    }
);
print $respuesta->content(); # Nos muestra la respuesta del sitio.
sleep 10;
}

De esa manera podríamos spamear un sitio con comentarios,de igual forma lo podemos hacer en formularios de contacto,pero bueno.

Ahora como defenderse de esto:

1. Wordpress automáticamente no publica estos comentarios,pero de por si ya tenerlos en la bandeja es molesto así que si los publica automáticamente deben cambiar a moderar.

2. Si tienen los registros del servidor se podría hacer un filtrado de ip basado en tiempo esto lo hace wordpress automáticamente,pero no esta de mas usarlo a nivel de servidor,solo que si se usa una ip diferente podría evadirse este sistema.

3. Dejárselo a los profesionales hay filtros contra el spam(si tenemos wordpress en nuestro host),hay plugins para evitar esto,los instalamos y listo.

Pero cuidado ya que aqui esta la trampa:

Metemos un plugin pensando que nos soluciona esto,pero ese es el anzuelo de los spamers,por ejemplo Akismet,en una version(no se si ahora),mostraba nuestro full path disclosure(lo veremos en su momento) que seria un problema mas grande y que se abria logrado gracias al spam.

Bien eso es todo :D.

Un comunicado de este sitio:

Ya no voy a dejar comentar a personas anonimas,solo a las de google y personas registradas,son los que dejan mejores comentarios y si me mientan la madre(como lo han hecho últimamente) por lo menos den la cara y cuerpo,o mejor dicho el nick y el avatar :P.

Es enserio ya tengo bastante con la delincuencia de este país, uno no se siente seguro en la calle como para que en el sitio donde me distraigo un rato también fomenten la violencia,así que si quieren comentar háganlo con su cuenta,también serán moderados los comentarios.

jueves, 23 de enero de 2014

[ Shell ] Como ver los exif de una imagen

Exchangeable image file format o Exif gracias a esto podemos ver los metadatos de las imágenes,tales como tamaño,fecha hasta la localización.

De esto ya hemos hablado en alguna ocasión,de los metadatos pero los de los mp3,id3tags, en esta ocasión hablamos de Exif para las imágenes:

Mas informacion

Bien se o pienso que existen muchas herramientas para hacer esto desde la shell de linux,pero yo cree un script para hacer esto:

Veamos:

Primero instalamos las dependencias:

sudo cpan Data::Dumper

sudo cpan Image::EXIF

Ahora bajamos el script:

Creamos un archivo y pegamos el script en perl,por ejemplo:

vim exif_data.pl

Ahora vamos a moverlo a ejecutarlo así:

perl exif_data.pl

o así:

chmod +x exif_data.pl

./exif_data.pl

Como ven es una shell,asi que solo escriben help:

Vemos las opciones y por ejemplo usamos:

ls

use imagen

imagen

Eso es todo,después añado mas funciones :D

lunes, 13 de enero de 2014

Tutorial SQlite3 Ejemplos

En la entrada pasada de estos tutoriales vimos cuales son los tipos de datos y cuales son los comandos DML y DDL,en esta ocasión vamos a ver como usar el DML y DDL para poder crear una base de datos con una tabla de datos.

Imaginemos que queremos administrar unos usuarios para nuestros pc's en el cual debemos introducir el id del usuario,el nombre el nucleo del sistema operativo y el nombre del sistema operativo.

Para eso vamos a crear una base de datos llamada Usuarios:

sqlite3 Usuarios.db

Como vemos esta vacía si mostramos las tablas:

.tables

Primero que nada vamos a crear una tabla con lo mencionado:

Para eso se usa el comando CREATE TABLE seguido del nombre de la tabla y luego entre paréntesis el contenido con esta sintaxis:

( nombre TIPO,nombre TIPO,etc)

Para lo mencionado arriba así seria:

CREATE TABLE Usuarios (id INTEGER,nombre TEXT,nucleo TEXT,sistema TEXT);

Ahora ya tenemos una tabla.para comenzar a insertar valores usamos el comando INSERT INTO la sintaxis es :

INSERT INTO Tabla VALUES (valor1,valor2);

Por ejemplo que me añadiera yo:

INSERT INTO Usuarios VALUES (1,'atheyus','linux','ubuntu');

Esa es una inserción muy básica ya que por lo menos hubiéramos usado PRIMARY KEY pero veremos en su momento el uso mas avanzado.

Vamos a añadir mas:

INSERT INTO Usuarios VALUES (2,'usuario2','linux','arch');

INSERT INTO Usuarios VALUES (3,'usuario3','linux','gentoo');

INSERT INTO Usuarios VALUES (4,'usuario4','darwin','MacOSX');

Para ver los valores podemos usar la sentencia SELECT, la sintaxis es:

SELECT dato FROM Tabla;

Por ejemplo si queremos mostrar todos los usuarios:

SELECT nombre FROM Usuarios;

Podemos mostrar toda la información usando un asterisco (*) al estilo Unix:

SELECT * FROM Usuarios;

También podemos mejorar la interfaz,esto no es muy necesario ya que lo que importan son los datos y comandos DML y DDL ya que estos son mas de la shell de sqlite3,pero podemos usar por ejemplo:

.mode column

Junto con:

.headers on

Para que se vea muy legible, también podemos usar la que me gusta mas:

.mode line

O en menor escala podemos definir el separador por defecto(|):

.separator -

Bien eso como dije no es muy importante hablando de datos,pero es muy util para sentirse mas cómodo usando solo la shell de sqlite3.

Ya que tenemos datos en nuestra tabla,vamos a filtrar los resultados usando la clausula WHERE,que es como si fuera un if en Lenguaje de Programación(tambien existe IF en sql),sintaxis:

... WHERE condicion;

La clausula WHERE se puede usar de manera muy avanzada incluso vinculando otras tablas,usando condicionales etc WHERE y las clausulas mas importantes tendran su propio tutorial pero de momento estamos viendo ejemplos sencillos,vamos a ver como mostrar todos los datos de los usuarios que usen el núcleo linux:

SELECT * FROM Usuarios WHERE nucleo='linux';

De ese modo mostrara todo.

Si quisiéramos mostrar solo los nombres usamos:

SELECT nombre FROM Usuarios WHERE nucleo='linux';

De igual modo con los demás datos.

Ahora que sabemos como filtrar datos de esta manera podemos borrar parte de ellos usando el comando DELETE,por ejemplo borrar un usuario de la tabla(una columna),para ello vamos a borrar el de nombre usuario2:

DELETE FROM Usuarios WHERE nombre='usuario2'; -- No olvidar usar comillas simples

Si queremos modificar la tabla lo podemos hacer en cualquier momento usando ALTER TABLE,junto con la instrucción:

Ejemplo 1,añadir una columna a la tabla,por ejemplo que queremos añadir la version del sistema:

Nota: Para que no haya problemas con números vamos a usar una cadena de texto.

ALTER TABLE Usuarios ADD COLUMN version TEXT;

Ahora ya tenemos una nueva columna donde guardar los datos de la version,pero en todos los usuarios esta vacia,vamos a añadir datos haciendo un update con el comando UPDATE,sintaxis:

UPDATE Table SET column=valor WHERE condicion;

Por ejemplo voy a añadir que yo uso la version 13.10 y que el usuario de mac usa la version lion:

Añadir version de ubuntu a atheyus por nombre:

UPDATE Usuarios SET version='13.10' WHERE nombre='atheyus';

Añadir versión de Mac a usuario4 por id:

UPDATE Usuarios SET version='Lion' WHERE id=4;

El comando UPDATE no se usa solo si no hay contenido en una tabla también se usa para modificar existente,por ejemplo cuando salga Ubuntu 14.04 yo modifico mi versión:

UPDATE Usuarios SET version='14.04' WHERE nombre='atheyus'

Ejemplo 2,renombrar tabla.

Si quisieramos renombrar la tabla podemos hacerlo,vamos a ver como se hace.

Nuestra tabla se llama Usuarios,la sintaxis de SQL siempre es en MAYUSCULAS,no es necesario pero es recomendable para no confundir si no quisiéramos cambiar Usuarios por usuarios no seria necesario ya que SQL lo identifica pero si quisiéramos cambiar Usuarios por Users,haríamos esto:

ALTER TABLE Usuarios RENAME TO Users;

Ya casi hemos visto todos los comandos DML Y DDL,solo nos falta como borrar una tabla,para ello borrariamos todo lo visto en este tutorial,ahora nuestra tabla se llama Users,para borrarla solo usamos DROP TABLE antes del nombre de la tabla:

DROP TABLE Users;

Con eso nos quedamos sin tabla para el ejemplo y termina este tutorial :(

Nos falto CREATE INDEX.

Referencia : sqlite.org/

viernes, 20 de diciembre de 2013

Tutorial SQlite3 Tipos DML DDL

Este es el primer tutorial para usar Sqlite en su versión 3 que es la versión que uso,yo tengo instalada la versión 3.7.17 , no la instale directamente pero se debe haber instalado como dependencia con algún conjunto de herramientas que instale en sistema,por lo que lo mas seguro es que no necesiten instalar en su sistema o lo que es lo mismo ya la deben tener instalada.

Antes que nada este tutorial o serie de tutoriales va dedicado solamente a sistemas Linux de escritorio,no BSD,no Windows,no iOS, no Android,etc.Ya que estos tutoriales los vamos a realizar desde la misma shell de SQlite o sea desde la interfaz que nos ofrece la terminal de nuestro sistema Linux.

Bien el titulo de la entrada parece un poco raro ya que no acostumbro a hacer referencia a las introducciones de temas que hago,pero vamos a explicarlo un poco.porque en este caso es necesario:

SQL es un lenguaje de consulta mas en especifico un lenguaje de consulta estructurados ahora en ingles :

Structured Query Language

Los SQL se usan para hacer consultas a bases de datos,en este caso SQlite3 es nuestro consultor y aunque vamos a usar un nivel intermedio para comunicarnos con las bases de datos y no me refiero al nivel de dificultad,bueno un poco ya que por ejemplo hasta un usuario de una Pc que no sepa nada de programación o de nada,solo que entre a un navegador web y busque algo en google,por ejemplo ya esta manipulando una base de datos,pero a un nivel muy alto,de usuario final,en este caso nosotros usaremos un nivel intermedio gracias a SQL,en este caso SQLite.

El DML es llamado así por la abreviación de Lenguaje de Manipulación de Datos,ahora en ingles:

Data Manipulation Language

Los comandos(en rojo) se usan para lo siguiente(morado):

SELECT Consulta registros

INSERT Inserta datos en una sola operación.

DELETE Borra(modifica) los datos especificados de un registro.

UPDATE Actualiza(modifica) los datos especificados de un registro.

Esto se usa para manipular datos en una base de datos de modelo relacional ,lo que es SQLite.

DML es llamado así por la abreviación de Lenguaje de Definicion de Datos,en ingles:

Data definition language

Los comandos(en rojo) se usan para lo siguiente(morado):

CREATE Crea nuevas tablas e índices
DROP Elimina tablas e índices
ALTER Modifica las tablas agregando columnas o modificando su valor.

Bien no me gusta mucho meterme en esa parte pero bueno,primero que nada vamos a abrir una terminal y vamos a crear un archivo db llamado hola.db:

sqlite3 hola.db

Si no encuentras sqlite3 deben instalarlo según su distribución,pero lo mas seguro es que ya lo tengan.

En este caso crea un base de datos hola.db si ya existe la abre si no existe la crea.

Los comentarios en SQLite son similares a los de Lua para una sola linea,deben comenzar con dos guion medio:

-- Un comentario

Y para los de varias lineas se parecen a los de PHP:

/*
 Un comentario de varias lineas
 De varias lineas :D
*/;

Los comandos básicos que podemos usar son:

.help -- Muestra ayuda

.version -- Muestra la versión

.databases -- Muestra las bases de datos

..exit -- Sale

.quit -- Sale

.tables -- Muestra las tablas

.read script(lineas de ordenes SQL) -- Ejecuta scripts en .sqlite

.prompt estilo->PS1 estilo->PS2 -- Cambia el estilo de la prompt

Estos son los tipos de datos que podemos implementar en SQLite3:

NULL Valor nulo.

INTEGER Numero entero almacenado en 1, 2, 3, 4, 6 bytes.

REAL Valor de punto flotante, guardado en 8-byte como numero de coma flotante.

TEXT Texto.

BLOB Dato no especificado(Binario) que se guarda como entra.

De momento eso es todo en las siguientes partes veremos ejemplos del uso de DLL y DML.

miércoles, 16 de octubre de 2013

Enviar a disco extraible en ubuntu [Script]

En Linux ubuntu hay algo que no encontré desde el principio y es que por ejemplo en Windows cuando tenemos conectada una memoria usb nos da la opción de mandar los archivos seleccionados a esa memoria,en todo el universo de Linux no se si haya algo similar a esto,pero en el sistema que uso yo que es Ubuntu con Nautilus 3.4.x no,asi que programe algo en bash con un poco de Perl embebido para manejar esto,es facil emularlo con bash aunque en mi caso lo he usado y no me ha dado problemas si les da algún tipo de problemas comenten para arreglarlo o manden un aviso en la zona de contacto del sitio.

El script es el siguiente:

Enlace

El nivel de programación que use es un poco mas avanzado(en sintaxis de lo que hemos visto en este sitio) sin embargo los algoritmos son algo vulnerables, ya que solicitan texto de un archivo externo,pero no es un gran problema a menos que tengamos un espía en nuestro sistema que pueda agregar archivos mas rápido de lo que se ejecuta un script.

Bien para usar solo hay que hacer lo siguiente:

Abren una terminal(Ctrl+Alt+T) y escriben esto:

gedit ~/.gnome2/nautilus-scripts/enviar\ a... && chmod +x ~/.gnome2/nautilus-scripts/enviar\ a...

Se les va abrir gedit,copian de la web el codigo en bash y lo pegan en Gedit:

luego cierran Gedit y listo :D.

Seleccionan sus archivos luego le dan clic derecho:

Y elegimos nuestro disco:

Pequeña actualización:

Luego esperamos basado en el peso de nuestro archivo.

Eso es todo :D.

jueves, 26 de septiembre de 2013

[ Shell ] Buscar archivos desde terminal con find

En esta ocasión aprenderemos como buscar archivos desde la terminal,algo muy básico ya que es de lo mas común que se hace en un sistema,buscar archivos.

Tal vez en el futuro veamos tutoriales de seguridad informática y les aseguro que solo vamos a usar este tipo de comandos.

Para empezar para que queremos usar este buscador si el explorador cuenta con uno propio?

Find es un programa tipo consola un backend para buscar archivos,y no solo encuentra lo que le digamos sino que podemos ejecutar una accion basado en eso,como borrar,reproducir,copiar,mover,etc.

El filtrado es muy poderoso y la respuesta tambien(el tiempo que tarda en buscar).

La sintaxis mas básica del programa es la siguiente:

find ruta -name nombre

En donde ruta es la ruta,como hemos visto en Unix:

. => Directorio actual

../ => Un direcotorio para atras

~ => Nuestro home

/ => Raiz

etc.

-name => Va seguido de un argumento que es el nombre.

Para el nombre podemos hacer algo muy exacto como:

-name "archivo123.txt"

Y busca el archivo123.txt en la ruta que le indicamos,o podemos hacer un filtrado con regex de Unix:

-name 'archivo???.txt'

-name 'arc*.txt'

etc.

En el caso de una regex de comodines como los anteriores podemos usar esta sintaxis:

-name \arc*.txt

Ya que no hay problema de espacios,en otro caso usar la regex entre comillas simples,o incluso el parámetro -regex.

Podemos hacer uso del parámetro -user para encontrar solo archivos pertenecientes a un usuario en especial,por ejemplo buscar archivos de root que esten en nuestro home:

find ~ -name \* -user root

Podemos hacer uso del parámetro -group para buscar un archivo que pertenezca ha ese grupo:

find ~ -name \* -group 100

El parámetro es numérico,100 es el grupo users(para mas info googlear groups id unix)

Tenemos algunas opciones para enlaces simbólicos:

-P => Nunca seguir

-L => Seguir

Podemos buscar ejecutables(archivos con permisos de ejecucion) con el parametro -executable,por ejemplo buscar script's en shell ejecutables en nuestro home:

find ~ -name \*.sh -executable -user $LOGNAME

También podemos listar los detalles de los archivos encontrados,con el parámetro -ls:

find . -name \*.sh -executable -ls

El cual nos muestra: El usuario,el grupo al que pertenece,los permisos,la fecha del ultimo

Puede que halla archivos y directorios con el mismo nombre,así que podemos evitar encontrar archivos y directorios,mostrando solo lo que queramos con el argumento -type{d para directorios,f para archivos}:

find ~ -name \*py* -type d # Directorios de python(por ejemplo)

find ~ -name \*py* -type f # Ficheros de python(por ejemplo)

Otros argumentos,l link,p FIFO,s socket.

Podemos buscar archivos basados en permisos con el parámetro -perm,por ejemplo buscar todos los script's en shell con permisos 775:

find . -name \*.sh -perm \755

Por ultimo tenemos el parametro -exec que nos permite ejecutar un programa y pasale el resultado de la búsqueda como argumentos:

Por ejemplo buscar todas las fotos .png y verlas con feh:

find ~ -name \*.png exec `which feh` {} +

Se recomienda poner toda la ruta del ejecutable,pero si no sabemos donde esta podemos buscarla con el comando which seguido del nombre del programa encerrado en esas comillas que no recuerdo como se llaman :P.

Eso es todo,no es todo,pero es lo que me parece mas importante para uso basico,para mas info,en terminal:

man find

Ultimo ejemplo del poder de find:

Buscar todos los videos,mp4 y reproducirlos con totem:

find ~ -user $LOGNAME -name \*.mp4 -exec `which totem` {} +

Eso es todo :D.

jueves, 5 de septiembre de 2013

Tutorial lua en linux (variables,tipos)

Esta un poco muerto el sitio y como lo he dicho antes esto se debe a que no hay mucho de que hablar en linux,ya que mucha información que necesitemos esta a un simple comando:

man algo

Y es un poco aburrido hacer un tutorial de algo que nadie va a usar.

Lua es un buen lenguaje que se usa de diversas formas y aquí vamos a usarlo como script,como lo hacemos con Python,Perl y Bash.

Así que hola Lua :D y espero que les funcionen estos tutoriales.

Bien antes que nada vamos a instalar:

En ubuntu y derivados basta con:

sudo apt-get install lua5.2

Y es la versión que usaremos la 5.2,para otros sistemas solo usen los comandos que usan normalmente,por ejemplo:

En gentoo buscamos:

eix lua

Y luego instalamos el paquete.

Bien todo esto lo haremos desde la consola así que primero que nada vamos a crear una carpeta donde trabajar:

mkdir ~/Documentos/lua

Por ejemplo.

Y nos cambiamos a ese directorio:

cd ~/Documentos/lua

Ahora vamos a escribir el primer programa:

Con nuestro editor favorito(de consola) creamos un archivo llamado hola.lua:

Los archivos lua regularmente tienen la extensión .lua.

La primera linea del script puede ser el hashbang ya que podemos ejecutar el script como un ejecutable,así que es recomendable:

# : hash

! : bang

/usr/bin/env : Ruta del programa env que busca a lua

lua : Y el nombre del ejecutable que usa como parametro env

#!/usr/bin/env lua

Con eso ya podemos darle permisos de ejecución a nuestros scripts y los podremos correr sin llamar el lenguaje nosotros mismos,por ejemplo:

Con hashbang un programa se puede ejecutar así:

chmod +x /ruta/script.lua

/ruta/script.lua

o así:

lua /ruta/script.lua

Y sin el hashbang solo se puede ejecutar así:

lua /ruta/script.lua

Ahora la segunda linea puede ser un comentario los cuales inician con un doble guion medio,por ejemplo :

-- Este es mi primer script en lua5

Normalmente esas lineas son necesarias en todos los scripts aunque son opcionales,aunque menos opcionales que los módulos.

Así que todos nuestros script tendrán el hashbang y uno o mas comentarios.

El programa Hola mundo es un programa que se muestra por el stdout(standart ouput[Salida estándar]).

El cual podemos llevar a cabo con la función print de lua o con la función io.write:

print ("Mi primer programa en Lua :D")
io.write("Hola Mundo!!!\n")

Bien esa es la bienvenida,ahora vamos a ver algunos tipos de datos:

Primero que nada tenemos que almacenar nuestro valor en una variable:

Los cuales son string(cadenas de texto),encerradas en comillas o comillas dobles:

cadena = "Una cadena de texto"

Numeros (sin tipo,nada de flotante y entero,etc):

Por ejemplo:

num_f = 3.14

num_d = 10

Booleanos que son solo true y false(nada de 0 y 1),lua solo ve booleanos con las palabras especiales true o false.

bool = true

Funciones,como las que nosotros mismos crearemos en futuros tutoriales y las que trae programadas,como print.

Y nil que es un valor único el que se otorga a la nada(por así decirlo).

Si no me creen ejecuten este programa:

#!/usr/bin/env lua
-- Este es mi segundo script en lua5

cadena = "Una cadena de texto"
num_f = 3.14
num_d = 10
bool = true

print ("Variable cadena es : "..type(cadena))
print("Variable num_f es : "..type(num_f))
print("Variable num_d es : "..type(num_d))
print("Variable bool es : "..type(bool))
print("Print es :"..type(print))

Eso pudo haber salido mejor:

#!/usr/bin/env lua
-- Este es mi segundo script en lua5
--
cadena = "Una cadena de texto"
num_f = 3.14
num_d = 10
bool = true

vars = {cadena,num_f,num_d,bool}
tipos = {"Variable cadena","Variable num_f","Variable num_d","Variable bool"}

for i = 1,#tipos do
print (tipos[i].." es : "..type(vars[i]))
end

Y aun mejor,pero es lo que aprenderán en estos tutoriales,pero eso me recuerda que están también los tipos de datos table,que antes usamos para crear un menú para awesome:

El cual se define de esta manera:

tabla = {"Hola","Mundo"}

print (type(tabla))

Esa es una tabla básica de una dimensión,a la cual podemos acceder a sus elementos usando corchetes indicando su valor comenzando desde uno.

print(tabla[1].." "..tabla[2])

Aunque el valor 0 esta definido (como nil),podemos cambiarlo,por ejemplo por el nombre de la tabla,pero por defecto se comienza a contar desde 1:

tabla[0] = "tabla"

print(tabla[0])

O también podemos hacer algo como esto:

tabla = {[0] = "Hola","Mundo"}

Pero eso lo veremos en una entrada dedicada,a las tablas por ultimo veremos paso de argumentos y leer valor desde el teclado:

Para pasar un parámetro se usa la tabla especial arg,con el valor que queramos usar comenzando desde el cero:

#!/usr/bin/env lua
-- Mi tercer programa con lua5

print("Nombre del programa: "..arg[0])

for i = 1,#arg do -- El # quiere decir el numero de valores de la tabla
print(i..": Argumento => "..arg[i])
end

Podemos ejecutar nuestro script como esta en la imagen:

Otro ejemplo clásico:

#!/usr/bin/env lua
-- Mi cuarto programa en lua
--

if #arg > 0 then
print("Hola : "..arg[1])
else
print("Uso: "..arg[0].." <nombre>")
end

También cabe aclarar que los argumentos comienzan con el 0,pero también cuenta lo que esta antes del nombre,por ejemplo si ejecutamos de esta manera:

lua script.lua uno

Estos serian los argumentos:

lua = arg[-1]

script.lua = arg[0]

uno = arg[1]

Bien ahora vamos a ver como se haría esto fácilmente desde la lectura del teclado(stdin[Standart input]):

#!/usr/bin/env lua
-- Mi quinto programa en lua
--

print("exit para salir")

while true do
io.write("Escribe tu nombre: ")
nombre = io.read() -- Funcion que usamos para stdin
if nombre == "exit" then
print("Hola : "..nombre.." :P")
break
else
print("Hola : "..nombre)
end
end

Como ven lua es sencillo y podríamos usarlo en administración del sistema o muchas cosas ya que cuenta con modulos desde JSON,hasta MVC Web,pero aquí termina el primer tutorial.

miércoles, 4 de septiembre de 2013

[ Shell ] Acceder a formularios web desde terminal

Esto mas bien es de perl,pero entra en los tutoriales de shell por si necesitan esto y no conocen perl.

Bien,primero que nada voy a explicar de que se trata esto:

De lo que se trata esto de la posibilidad de poder rellenar formularios web desde la misma terminal,ya se solo por probar una url,o por otros propósitos.

Bien pondré de ejemplo mi sitio que tengo en mi localhost que se llama:

mi_blog_de_ejemplo.net/

El sitio esta en wordpress,así que el login se lleva a cabo en el url(wp-login.php):

http://mi_blog_de_ejemplo.php

Ahora como me puede logear desde la consola?

Bien,es un ejemplo esto,podemos usar esto con formularios como el de blogger,o como el search de esta pagina que esta arriba a la derecha:

Primero que nada vamos a instalar/actualizar los módulos perl necesarios:

sudo cpan WWW::Mechanize::GZip

sudo cpan LWP::UserAgent

Terminados de instalar,podemos comenzar a escribir el script:

#!/usr/bin/env perl

use warnings;
use strict;
use WWW::Mechanize::GZip;

Vamos a definir una variable con el url del sitio:

my $url = "http://mi_blog_de_ejemplo.php";

Ahora vamos a crear un objeto de Mechanize:

my $mech = WWW::Mechanize::GZip->new();

Vamos a llamar la url:

$mech->get($url) || die $!;

Y por ultimo vamos a pasar los parametros:

Los fields y el nombre del form,como sabemos o si no saben wordpress usa los fields,pwd y log en la form loginform:

Así que :

my $respuesta = $mech->submit_form(
form_id => "loginform",
fields => {
log => "user",
pwd => "password"
});

Y listo imprimimos la respuesta:

print $respuesta->content();
Esto nos imprime en la pantalla el contenido html de la pagina,sea o no sea el usuario y la contraseña,lo que hace es exactamente como si lo hiciéramos a clic desde el navegador.

También cuenta con opciones de cookies,user agent,y si por ejemplo no hay id del formulario podemos acceder a ellos con el numero que tendrían ordenándolos:

Por ejemplo :

#!/usr/bin/env perl
#
use warnings;
use strict;
use WWW::Mechanize::GZip;

my $url = "http://desdelinux.net";

my $mech = WWW::Mechanize::GZip->new();

$mech->agent_alias("Linux Mozilla");

$mech->get($url) || die $!;

my $respuesta = $mech->submit_form(
form_number => 1,
fields => {
s => "archlinux"
}
);

print $respuesta->content();

Y si por ejemplo metieron el script en un archivo llamado script.pl pueden probar este comando: