Rintracciare laptop rubato con Gnu/Linux e Prey

 

 

Questo è un periodo di vacanze e di conseguenza è anche il periodo di furti e smarrimenti,  quindi mi sono messo subito alla ricerca di un sistema che mi permettesse in caso di bisogno di riuscire a ritrovare il mio netbook acer aspire one.  A questo punto bisogna fare certamente delle precisazioni poichè se il ladro è un geek e la prima cosa che fa è quella di formattare il pc è chiaro che di possibilità di ritrovarlo non ce ne sono, dato che il programma che sto per recensire risiede nell'hard disk e non nel bios. Ma volendo essere ottimisti e tenendo conto che la maggior parte dei ladruncoli non sono esperti ed è gente che frequenta il tuo stesso ambiente, non si sa mai che un giorno o l'altro ci si rincontri. Ma per poter agire bisogna sapere chi è, rintracciare il pc ed ottenere una sua foto, e a questo proposito vediamo come fare. Quello di cui abbiamo bisogno si chiama Prey ed è un programma rilasciato sotto licenza GPLv3, per Mac Linux e Windows, in grado di raccogliere informazioni da remoto sul pc rubato, come programmi in esecuzione, geo localizzazione wifi e soprattutto una bella foto di chi si trova davanti al pc, il tutto lavorando in background e cercando di connettersi alla prima rete disponibile.

Installazione e funzionamento:

Per Debian/Ubuntu esiste il .deb:

$ wget

una volta installato registrarsi sul sito per avere la Api Key ed aggiungere il device, per ottenere la Device Key, dopo avviare in Strumenti di Sistema > Prey Configurator ed inserire il tutto. A questo punto nella pagina https://control.preyproject.com/ si possono scegliere i parametri e soprattutto nel caso di smarrimento spuntare l'opzione missing per avviare i report.

Per altre distro:

$ wget

$ unzip prey-0.3.73-linux.zip

# mv prey /usr/share/

# nano /usr/share/prey/config

ed inserire le Key Api e Device:

aggiungere a crontab il controllo ogni 20 minuti:

$ (sudo crontab -l | grep -v prey; echo "*/20 * * * * /usr/share/prey/prey.sh > /dev/null") | sudo crontab -

per verificare:

$ sudo crontab -l

$ ps aux | grep cron

per modificare:

$ sudo crontab -e

c'è anche la possibilità dell'invio  via mail degli avvisi, basta inserire il proprio account e password, bisogna fare attenzione che l'inserimento della password è in chiaro, per ovviare al problema e criptarla:

$ echo -n "password_mail" | openssl enc -base64

per modificare i parametri della webcam il file si trova in /usr/share/prey/modules/webcam/config

ho fatto diverse prove e devo dire che tutto sommato non è niente male, i vari parametri ci sono tutti per un eventuale rintracciamento, ma la speranza è che le foto vengono abbastanza nitide per riconoscere il furfante e fargli un bel discorsetto. Io ne ho beccato uno….ma ho l'impressione che sarà dura fargli quel discorso che avevo in mente  🙂

Gnome Shell su Debian Squeeze-Sid

 

 

Per chi volesse provare Gnome-Shell  un nuovo componente del prossimo Gnome 3.0, che verrà rilasciato dopo l'estate, su Debian Squeeze-Sid, non deve fare altro che installaro dai repository:

# apt-get install gnome-shell

per avviarlo:

$ gnome-shell --replace

per terminare premere Alt+F2:

e poi inserire:

debugexit

oppure da terminale:

$ metacity --replace

Compiz-Nvidia-Xorg.conf e Debian

 

 

Dopo avere azzerato uno dei miei hard disk, ho iniziato a reinstallare gli OS che avevo su, al momento mi trovo a 8, ma me ne manca ancora qualche d'uno. Una delle prime cose che faccio di solito è quella di attivare compiz, ma come al solito mi dimentico le opzioni da settare in xorg.conf, quindi prendo spunto una volta per tutte di metterle nero su bianco, evitandomi ricerche varie. Le opzioni colorate di rosso sono d'aggiungere.Queste opzioni sono valide per schede grafiche Nvidia:

Section "ServerLayout"
    Identifier     "Layout0"
    Screen      0  "Screen0"
    InputDevice    "Keyboard0" "CoreKeyboard"
    InputDevice    "Mouse0" "CorePointer"
EndSection

Section "InputDevice"
    # generated from default
    Identifier     "Mouse0"
    Driver         "mouse"
    Option         "Protocol" "auto"
    Option         "Device" "/dev/psaux"
    Option         "Emulate3Buttons" "no"
    Option         "ZAxisMapping" "4 5"
EndSection

Section "InputDevice"
    # generated from default
    Identifier     "Keyboard0"
    Driver         "kbd"
EndSection

Section "Monitor"
    Identifier     "Monitor0"
    VendorName     "Unknown"
    ModelName      "Unknown"
    HorizSync       28.0 – 33.0
    VertRefresh     43.0 – 72.0
    Option         "DPMS"
EndSection

Section "Device"
    Identifier     "Device0"
    Driver         "nvidia"
    VendorName     "NVIDIA Corporation"

Option "AllowGLXWithComposite" "true"
Option "XAANoOffscreenPixmaps" "true"

EndSection

Section "Screen"
    Identifier     "Screen0"
    Device         "Device0"
    Monitor        "Monitor0"
    DefaultDepth    24
    SubSection     "Display"
        Depth       24

     Option "AddARGBGLXVisuals" "True"
EndsubSection
EndSection

Section "Module"
        #Load "dri"
        #Load "GLcore"
EndSection

Section "Extensions"
        Option "Composite" "enable"
EndSection

Convertire JPG-PNG-GIF in ASCII con Jp2a

 

 

Jp2a è una piccola utility che serve a convertire immagini JPG in ASCII, è scritto in C ed è rilasciato sotto licenza GPL. E' presente nei repo Debian,Gentoo,FreBSD, ed i comandi sono abbastanza semplice:

Convertire immagine jpg in ascii:

$ jp2a --width=60 image.jpg

Convertire immagine direttamente da un sito, tipo questa:

$ jp2a --width=70

a questo punto volendo convertire immagini png o gif, dobbiamo rivolgerci a ImageMagick con l'opzione convert:

$ convert image.png jpg:- | jp2a --width=60 -

$ convert image.gif jpg:- | jp2a --width=60 -

per altre opzioni consultare il man.

Driver nvidia module-assistant e Debian

 

 

Installare i driver Nvidia in maniera veloce con module-assistant:

# apt-get install nvidia-kernel-common module-assistant nvidia-glx nvidia-glx-dev nvidia-xconfig

# m-a -i prepare

passare in tty1 con Ctrl-Alt-F1

# m-a a-i -i -t -f nvidia-kernel

# depmod -a

# nvidia-xconfig

# /etc/init.d/gdm3 restart oppure /etc/init.d/gdm restart

Backup velocissimo di sistema

 

Questo è un semplice ma efficace metodo per effettuare un backup di sistema o parte di esso, infatti permette di scegliere cosa "backuppare" e cosa tralasciare. Nel mio caso ho escluso la /home in quanto si trova in un'altra partizione, e /mnt dove si trova la partizione contenente dati importanti, che si trova in un secondo disco.

Effettuare Backup:

# tar cvpjf backup.tar.bz2 --exclude=/proc --exclude=/lost+found --exclude=/backup.tar.bz2 --exclude=/mnt --exclude=/sys / --exclude=/tmp --exclude=/home

Ripristinare Backup:

# tar xvpfj backup.tar.bz2 -C /

Countdown bash script

 

 

Countdown bash script:

#!/bin/bash
 
if [ "$#" -lt "2" ] ; then
    echo "Incorrect usage ! Example:"
    echo './countdown.sh -d  "Jun 10 2011 16:06"'
    echo 'or'
    echo './countdown.sh -m  90'
    exit 1
fi
 
now=`date +%s`
 
if [ "$1" = "-d" ] ; then
    until=`date -d "$2" +%s`
    sec_rem=`expr $until - $now`
    echo "-d"
    if [ $sec_rem -lt 1 ]; then
        echo "$2 is already history !"
    fi
fi
 
if [ "$1" = "-m" ] ; then
    until=`expr 60 \* $2`
    until=`expr $until + $now`
    sec_rem=`expr $until - $now`
    echo "-m"
    if [ $sec_rem -lt 1 ]; then
        echo "$2 is already history !"
    fi
fi
 
 
while [ $sec_rem -gt 0 ]; do
    clear
    date
    let sec_rem=$sec_rem-1
    interval=$sec_rem
    seconds=`expr $interval % 60`
    interval=`expr $interval - $seconds`
    minutes=`expr $interval % 3600 / 60`
    interval=`expr $interval - $minutes`
    hours=`expr $interval % 86400 / 3600`
    interval=`expr $interval - $hours`
    days=`expr $interval % 604800 / 86400`
    interval=`expr $interval - $hours`
    weeks=`expr $interval / 604800`
    echo "----------------------------"
    echo "Seconds: " $seconds
    echo "Minutes: " $minutes
    echo "Hours:   " $hours
    echo "Days:    " $days
    echo "Weeks:   " $weeks
    sleep 1
done

salviamo il file come bash-countdown.sh:

$ chmod +x bash-countdown.sh

adesso siamo pronti per il conto alla rovescia:

countdown per le ferie:

$ ./bash-countdown.sh -d "AUG 07 2010"

sab 12 giu 2010, 16.49.59, CEST
—————————-
Seconds:  0
Minutes:  10
Hours:    7
Days:     6
Weeks:    7

countdown di 90 minuti:

$ ./bash-countdown.sh -m 90

countdown per Inghilterra-Stati Uniti stasera:

$ ./bash-countdown.sh -d 20:30:00

 

Questo lo script, per chi ha bisogno di un applet, esiste timer-applet.

Xdpyinfo utility per X con ffmpeg

 

 

 

 

 

Xdpyinfo è un utility che serve a visualizzare informazioni sul server X, e quindi si può anche usare per conoscere l'esatta risoluzione del nostro schermo e successivamente abbinarlo con ffmpeg per effettuare uno screencast,argomento questo che mi appassiona ed ho già affrontato nei Top 20 comandi per ffmpeg. Per conoscere la risoluzione:

$ xdpyinfo | grep 'dimensions:'|awk '{print $2}'

per lo screencast:

$ ffmpeg -f x11grab -s `xdpyinfo | grep 'dimensions:'|awk '{print $2}'` -r 30 -i :0.0 -sameq /tmp/screencast.mpg

SimpleBrowser il più piccolo ed il più veloce del mondo

 

 

Sembra un esagerazione ma è la pura è semplice verità, forse :), sto parlando di un browser in Python + Webkit/GTK dal peso di solo 1,5 KB che al test Acid3 ha 100/100 e non solo, mentre iceweasel si ferma a 93/100. Certo non si hanno tutte le comodità di un browser normale, ma considerando quanto risorse occupa ho deciso di adottarlo sul mio acer aspire one, del resto per una semplice navigazione è perfetto, quindi consiglio di provarlo. Faccio i complimenti all'autore che negli ultimi giorni non ha ricevuto i giusti meriti.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import sys
import gtk
import webkit
 
DEFAULT_URL = 'https://www.edmondweblog.com'
 
class SimpleBrowser:
 
    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_position(gtk.WIN_POS_CENTER_ALWAYS)
        self.window.connect('delete_event', self.close_application)
        self.window.set_default_size(800, 600)
 
        vbox = gtk.VBox(spacing=5)
        vbox.set_border_width(5)
 
        self.txt_url = gtk.Entry()
        self.txt_url.connect('activate', self._txt_url_activate)
 
        self.scrolled_window = gtk.ScrolledWindow()
        self.webview = webkit.WebView()
        self.scrolled_window.add(self.webview)
 
        vbox.pack_start(self.txt_url, fill=False, expand=False)
        vbox.pack_start(self.scrolled_window, fill=True, expand=True)
        self.window.add(vbox)
 
    def _txt_url_activate(self, entry):
        self._load(entry.get_text())
 
    def _load(self, url):
        self.webview.open(url)
 
    def open(self, url):
        self.txt_url.set_text(url)
        self.window.set_title('SimpleBrowser - %s' % url)
        self._load(url)
 
    def show(self):
        self.window.show_all()
 
    def close_application(self, widget, event, data=None):
        gtk.main_quit()
 
if __name__ == '__main__':
    if len(sys.argv) > 1:
        url = sys.argv[1]
    else:
        url = DEFAULT_URL
 
    gtk.gdk.threads_init()
    browser = SimpleBrowser()
    browser.open(url)
    browser.show()
    gtk.main()

salviamo questo script come browser.py

$ chmod a+x browser.py

e lo lanciamo con:

$ python browser.py

in caso di problemi con la formattazione del testo, si può scaricare da qua.