- La primera y menos recomendable, ejecutarlo y pensar que solo se “infectan” los demás. Nada recomendable

- La segunda, tener un sistema Windows virtualizado, ejecutarlo allí mientras monitorizamos con cosas como Filemon, Regmon, wireshark , etc…

Recientemente, he encontrado una forma más rápida, y que puede ayudarnos en casos muy concretos.

• VirusTotal – http://www.virustotal.com/es/
• Joebox – http://www.joebox.org/
• Anubis – http://anubis.iseclab.org/

Con VirusTotal podremos analizar ficheros con varios motores antivirus al mismo tiempo, nos dará una orientación sobre el tipo de ficheros que manejas. Además esta web viene de la mano de Hispasec Sistemas, muy buena referencia desde mi punto de vista.

Con Joebox podremos instalarnos una sandbox, y ejecutar en un entorno seguro virtual este ejecutable. Nos dará trazas con información relevante sobre su comportamiento. Este entorno virtual, es de fácil despliegue y con las mismas garantías de seguridad que una máquina virtual con sistema operativo independiente.

Por último Anubis, con su servicio online, analizará el binario y nos enviará un informe sobre su comportamiento. Un complemento ideal a cualquier sandbox, nos permitirá contrastar la información.

OpenTTD nación como una copia de Transport Tycoon Deluxe. Un grupo de desarrolladores consiguieron mediante ingeniería inversa, impresionante!

Más tarde, el proyecto fue creciendo con la colaboración de más gente: nuevos sonidos, nueva música, bastantes nuevos gráficos [estaciones, autobuses, camiones, carreteras, edificios, aka NewGRF], pero lo mejor de todo es la disponilidad para tres plataformas: GNU/Linux, Mac y Windows. Un modo multijugador: competitivo y/o colaborativo; con o sin servidor dedicado, con sus propios comandos de servidor. IA lista para jugar en un jugador o multijugador, y mucha gente que pertenece a la comunidad.

No lo pienses más, y pruébalo: www.openttd.org

No voy a entrar a valorar si este método es bueno o malo, porque deberíamos evaluar otros factores como si la máquina es administrada por varios admins, si es un servidor crítico, si realmente queda documentada esa nomenclatura, etc…

Pero si quiero mencionar, y poner algún ejemplo de una metodología que si es estándar, y que hay un probabilidad muy elevada de encontrarla en casi cualquier sistema GNU/Linux: RCS utils. Con este sistema, tendremos un control de versiones con todas sus ventajas aplicado a un único fichero sin crear ni configurar nada adicional (ni repositorios, ni demonios, ni dependencias de servicios), solo instalando el paquete necesario rcs. Es raro que no esté instalado.

Esta información ha sido obtenida de RCS Intro – http://www.daemon-systems.org/man/rcsintro.1.html

¿Qué operaciones se suelen realizar con más frecuencia en un sistema de control de versiones?

• Crear ficheros nuevos
• Modificar fichero existentes
• Bloquear para evitar modificaciones concurrentes
• Controlar versiones, y adjuntar comentarios para ver de forma rápida este Changelog
• Comprobar diferencias entre versiones
• Recuperar cualquier versión
• Controlar el quién y el cuando de una modificación de fichero a lo largo de su vida

Basándonos en esta pequeña lista, pondré los dos comandos que nos permitirán realizarlas:

co y ci

Sigue leyendo para ver los ejemplos …

Ejemplos:

$ vi fichero1 #Guardamos cambios

$ ci -u fichero 1 #Con esto creamos la primera revisión, y nos pedirá introducir un comentario con un breve resumen del contenido del fichero

A partir de este momento, tendremos dos ficheros parecidos: fichero1 y fichero1,v. Este segundo fichero contendrá todo el control de versiones, no será necesario nada más. El parámetro -u sirve para no borrar la copia local. En los sucesivos ci que hagamos, nos pedirá introducir un comentario, pero en este caso hará referencia a los cambios que hayamos realizado.

$ co -l fichero1 # Realizará un checkout, es decir obtendrá una copia de la última revisión del fichero, y además la bloquea por el -l.

A partir de este momento, estos dos comando serán los que más utilicemos para usar RCS sobre fichero concretos. Posteriormente podremos utilizar parámetros como -r1.24 para indicarle a mano la revisión con la que se guardará el fichero, o la revisión que se obtendrá.

Podremos utilizar rcsdiff para ver las diferencias entre dos revisiones, o el comando rlog para ver toda la evolución del fichero con sus comentarios. Existen muchas más opciones, y quiero remitiros al enlace que puse en el artículo para que comprobéis las que más se ajustarán a vosotros.

1.) stdin
2.) ¿qué stdout/stderr espero?
3.) stdin
4.) ¿qué stdout/stderr espero?
…..

Por ser breve, es un lenguaje pensado casi exclusivamente para convertir sesiones interactivas de ftp, telnet, ssh, etc… en sesiones automáticas. Casi más sorprendente, es que añadiendo el módulo TK, podremos automatizar sesiones de X11, wow!!!!

Pero este artículo no quiere ser un tutorial de expect, ni tampoco una presentación formal, su web es bastante buena para intentar hacer una copia . Pretendo enseñar, y en otros casos recordar, que no es necesario saber nada, o casi nada de expect para poder utilizarlo, gracias a autoexpect.

Este script nos abrirá una sesión de comando “script”, y grabará toda la sesión interactiva. Una vez que salgamos de la sesión con “exit”, creará un script de expect que podremos ejecutar directamente. wow!!!!

Cosas a tener en cuenta:

- Cualquier salida por pantalla variable, tipo fecha, hora, y cosas así, nos obligará a editar el script expect final, y poner expresiones regulares. Genial!
- Seguro que hay más, espero esos comentarios

En la siguiente página incluyo el código del autoexpect, no como referencia, sino como idea general. La recomendación que os hago es visitar la web oficial de expect, descargar las últimas fuentes de expect, descomprimir, y buscar en el directorio example/ el script autoexpect. En la versión que he descargado yo, he tenido que modificarlo para poner la ruta absoluta de expect en la primera línea:

#!/usr/bin/expect
# Name: autoexpect - generate an Expect script from watching a session
#
# Description:
#
# Given a program name, autoexpect will run that program.  Otherwise
# autoexpect will start a shell.  Interact as desired.  When done, exit
# the program or shell.  Autoexpect will create a script that reproduces
# your interactions.  By default, the script is named script.exp.
# See the man page for more info.
#
# Author: Don Libes, NIST
# Date: June 30 1995
# Version: 1.4b                                                         

set filename "script.exp"
set verbose 1
set conservative 0
set promptmode 0
set option_keys ""       

proc check_for_following {type} {
        if {![llength [uplevel set argv]]} {
                puts "autoexpect: [uplevel set flag] requires following $type"
                exit 1
        }
}                                                                             

while {[llength $argv]>0} {
        set flag [lindex $argv 0]
        if {0==[regexp "^-" $flag]} break
        set argv [lrange $argv 1 end]
        switch -- $flag \
          "-c" {
                set conservative 1
        } "-C" {
                check_for_following character
                lappend option_keys [lindex $argv 0] ctoggle
                set argv [lrange $argv 1 end]
        } "-p" {
                set promptmode 1
        } "-P" {
                check_for_following character
                lappend option_keys [lindex $argv 0] ptoggle
                set argv [lrange $argv 1 end]
        } "-Q" {
                check_for_following character
                lappend option_keys [lindex $argv 0] quote
                set argv [lrange $argv 1 end]
        } "-f" {
                check_for_following filename
                set filename [lindex $argv 0]
                set argv [lrange $argv 1 end]
        } "-quiet" {
                set verbose 0
        } default {
                break
        }
}                                                           

#############################################################
# Variables     Descriptions
#############################################################
# userbuf       buffered characters from user
# procbuf       buffered characters from process
# lastkey       last key pressed by user
#               if undefined, last key came from process
# echoing       if the process is echoing
#############################################################

# Handle a character that came from user input (i.e., the keyboard)
proc input {c} {
        global userbuf lastkey                                     

        send -- $c
        append userbuf $lastkey
        set lastkey $c
}                              

# Handle a null character from the keyboard
proc input_null {} {
        global lastkey userbuf procbuf echoing

        send -null

        if {$lastkey == ""} {
                if {$echoing} {
                        sendcmd "$userbuf"
                }
                if {$procbuf != ""} {
                        expcmd "$procbuf"
                }
        } else {
                sendcmd "$userbuf"
                if {$echoing} {
                        expcmd "$procbuf"
                        sendcmd "$lastkey"
                }
        }
        cmd "send -null"
        set userbuf ""
        set procbuf ""
        set lastkey ""
        set echoing 0
}                                         

# Handle a character that came from the process
proc output {s} {
        global lastkey procbuf userbuf echoing 

        send_user -raw -- $s

        if {$lastkey == ""} {
                if {!$echoing} {
                        append procbuf $s
                } else {
                        sendcmd "$userbuf"
                        expcmd "$procbuf"
                        set echoing 0
                        set userbuf ""
                        set procbuf $s
                }
                return
        }                                 

        regexp (.)(.*) $s dummy c tail
        if {$c == $lastkey} {
                if {$echoing} {
                        append userbuf $lastkey
                        set lastkey ""
                } else {
                        if {$procbuf != ""} {
                                expcmd "$procbuf"
                                set procbuf ""
                        }
                        set echoing 1
                }
                append procbuf $s                

                if {[string length $tail]} {
                        sendcmd "$userbuf$lastkey"
                        set userbuf ""
                        set lastkey ""
                        set echoing 0
                }
        } else {
                if {!$echoing} {
                        expcmd "$procbuf"
                }
                sendcmd "$userbuf$lastkey"
                set procbuf $s
                set userbuf ""
                set lastkey ""
                set echoing 0
        }
}                                                 

# rewrite raw strings so that can appear as source code but still reproduce
# themselves.
proc expand {s} {
        regsub -all "\\\\" $s "\\\\\\\\" s
        regsub -all "\r" $s "\\r"  s
        regsub -all "\"" $s "\\\"" s
        regsub -all "\\\[" $s "\\\[" s
        regsub -all "\\\]" $s "\\\]" s
        regsub -all "\\\$" $s "\\\$" s                                     

        return $s
}                

# generate an expect command
proc expcmd {s} {
        global promptmode   

        if {$promptmode} {
                regexp ".*\[\r\n]+(.*)" $s dummy s
        }                                         

        cmd "expect -exact \"[expand $s]\""
}                                          

# generate a send command
proc sendcmd {s} {
        global send_style conservative

        if {$conservative} {
                cmd "sleep .1"
        }                     

        cmd "send$send_style -- \"[expand $s]\""
}                                               

# generate any command
proc cmd {s} {
        global fd
        puts $fd "$s"
}                     

proc verbose_send_user {s} {
        global verbose      

        if {$verbose} {
                send_user -- $s
        }
}                              

proc ctoggle {} {
        global conservative send_style

        if {$conservative} {
                cmd "# conservative mode off - adding no delays"
                verbose_send_user "conservative mode off\n"
                set conservative 0
                set send_style ""
        } else {
                cmd "# prompt mode on - adding delays"
                verbose_send_user "conservative mode on\n"
                set conservative 1
                set send_style " -s"
        }
}                                                               

proc ptoggle {} {
        global promptmode

        if {$promptmode} {
                cmd "# prompt mode off - now looking for complete output"
                verbose_send_user "prompt mode off\n"
                set promptmode 0
        } else {
                cmd "# prompt mode on - now looking only for prompts"
                verbose_send_user "prompt mode on\n"
                set promptmode 1
        }
}                                                                        

# quote the next character from the user
proc quote {} {
        expect_user -re .
        send -- $expect_out(buffer)
}                                       

if {[catch {set fd [open $filename w]} msg]} {
        puts $msg
        exit
}
exec chmod +x $filename
verbose_send_user "autoexpect started, file is $filename\n"

# calculate a reasonable #! line
set expectpath /usr/local/bin           ;# prepare default
foreach dir [split $env(PATH) :] {      ;# now look for real location
        if {[file executable $dir/expect] && ![file isdirectory $dir/expect]} {
                set expectpath $dir
                break
        }
}                                                                              

cmd "#![set expectpath]/expect -f
#
# This Expect script was generated by autoexpect on [timestamp -format %c]
# Expect and autoexpect were both written by Don Libes, NIST."
cmd {#
# Note that autoexpect does not guarantee a working script.  It
# necessarily has to guess about certain things.  Two reasons a script
# might fail are:
#
# 1) timing - A surprising number of programs (rn, ksh, zsh, telnet,
# etc.) and devices discard or ignore keystrokes that arrive "too
# quickly" after prompts.  If you find your new script hanging up at
# one spot, try adding a short sleep just before the previous send.
# Setting "force_conservative" to 1 (see below) makes Expect do this
# automatically - pausing briefly before sending each character.  This
# pacifies every program I know of.  The -c flag makes the script do
# this in the first place.  The -C flag allows you to define a
# character to toggle this mode off and on.                               

set force_conservative 0  ;# set to 1 to force conservative mode even if
                          ;# script wasn't run conservatively originally
if {$force_conservative} {
        set send_slow {1 .1}
        proc send {ignore arg} {
                sleep .1
                exp_send -s -- $arg
        }
}                                                                       

#
# 2) differing output - Some programs produce different output each time
# they run.  The "date" command is an obvious example.  Another is
# ftp, if it produces throughput statistics at the end of a file
# transfer.  If this causes a problem, delete these patterns or replace
# them with wildcards.  An alternative is to use the -p flag (for
# "prompt") which makes Expect only look for the last line of output
# (i.e., the prompt).  The -P flag allows you to define a character to
# toggle this mode off and on.
#
# Read the man page for more info.
#
# -Don

}

cmd "set timeout -1"
if {$conservative} {
        set send_style " -s"
        cmd "set send_slow {1 .1}"
} else {
        set send_style ""
}

if {[llength $argv]>0} {
        eval spawn -noecho $argv
        cmd "spawn $argv"
} else {
        spawn -noecho $env(SHELL)
        cmd "spawn \$env(SHELL)"
}

cmd "match_max 100000"

set lastkey ""
set procbuf ""
set userbuf ""
set echoing 0

remove_nulls 0

eval interact $option_keys {
    -re . {
        input $interact_out(0,string)
    } -o -re .+ {
        output $interact_out(0,string)
    } eof {
        cmd "expect eof"
        return
    }
}

close $fd
verbose_send_user "autoexpect done, file is $filename\n"

- Todas las urls ahora tienen como base www.ticketrestaurantcard.es

- Se ha incluído un nuevo campo en el envío del POST: swlang

Como véis, son cambios normales y poco entrenidos; estaba deseando que me obligaran a cambiar la expresión regular, lástima!

¿Será un buen día para empezar con el laboratorio de expresiones regulares?

Como siempre, si alguien tiene alguna pregunta sobre el script, os invito a comentarlo.

#!/bin/bash

export AGENT="Mozilla/5.0 (X11; U; Linux i686; es-ES; rv:1.8) Gecko/20051111 Firefox/1.5"

export LOGINURL="https://www.ticketrestaurantcard.es/TRC/index.html"
export POSTLOGIN="https://www.ticketrestaurantcard.es/TRC/checkUserLogin.php"
export POSTDATA="swlang=es&user=usuario&passwd=password&type=trc"

curl -s -A '${AGENT}' -d "${POSTDATA}" -c ticketrestaurant.cookie -o login1.out -e ${LOGINURL} ${POSTLOGIN}
curl -s -A '${AGENT}' -b ticketrestaurant.cookie -o login2.out -e ${POSTLOGIN} https://www.ticketrestaurantcard.es/TRC/home.html
curl -s -A '${AGENT}' -b ticketrestaurant.cookie -o login3.out -e https://www.ticketrestaurantcard.es/TRC/home.html https://www.ticketrestaurantcard.es/TRC/consulta_tarjeta.html
curl -s -A '${AGENT}' -b ticketrestaurant.cookie -o login4.out -e https://www.ticketrestaurantcard.es/TRC/consulta_tarjeta.html https://www.ticketrestaurantcard.es/TRC/logout.html
SALDO=`cat login3.out | sed -n '/SALDO/p' | sed 's/.* \([0-9]*,[0-9]*\) .*/\1/g'`
clear
MAIL_BODY=`echo "Su saldo Sr. Señor: ${SALDO} euros" > /tmp/mail.body`
mail email@domain.com -s "Saldo Tarjeta Restaurant: ${SALDO} euros" < /dev/null