L'importanza di chiamarsi Zeitgeist

Una spia a tempo pieno

"Strano gioco la guerra, l'unica mossa vincente è non giocarci. Che ne direbbe di una bella partita a scacchi ?", diceva lo W.O.P.R. in un famoso film degli anni 80.

Non so cosa c'entri esattamente questa frase, però mi è venuta spontanea pensando al fatto che la continua guerra termonucleare globale, che alcuni conducono in difesa della "dignità" di potersi fare gli affari propri almeno quando si è disconnessi dalla rete, è talmente sfiancante e misteriosa da convincere anche i più volenterosi ad abiurare.

È lo Zeitgeist appunto, cioè lo spirito dei tempi, tempi in cui il tuo computer e con lui gran parte del mondo, deve sapere più cose di te di quante tu stesso ne sappia e usarle nel tuo interesse, per sollevarti dal gravoso impegno di scegliere. Si chiama integrazione cibernetica o in linguaggio Borg : "Assimilazione".

Capita così che mentre scorri un backup e vai a vederti la lista dei pacchetti installati, sulla tua Free Debian o una Ubuntu qualsiasi con il più classico dei :

/usr/bin/dpkg --get-selections

scopri proprio in fondo all'elenco in ordine alfabetico un pacchetto dal nome curioso : zeitgeist , che qualche dipendenza ha voluto donarti.

Nel mio caso, da utilizzatore Debian, è stato Cairo Dock , su Ubuntu è una cosettina come Unity .

Fase 1 - La Consapevolezza

Conseguenza per la classica mente malata dell'utente cantinaro e paranoico, è andare a digitare la parolina in Google e trovare l'immancabile articolo di Wikipedia ... cito perché è interessante  :

"Zeitgeist è un servizio che registra le attività degli utenti, ovunque dai file aperti ai siti visitati e alle conversazioni: queste informazioni diventano disponibili per altre applicazioni per essere usati come linee del tempo e statistiche."

Eeh ?!?! Cosa ?!??

Cioè ... sul mio computer che monta Linux c'è un "demone" che legge tutto quello che faccio, i files che apro, le mie conversazioni , le pagine che visito e le memorizza in un database per metterle a disposizione di altre applicazioni ? Soprattutto quali applicazioni ?

Poi si legge "per essere usati come linee del tempo e statistiche" che, benché non significhi essenzialmente nulla, è piuttosto tranquillizzante.

Fase 2 - La paura

Peccato che due righe più sotto, nella ricerca ci sia un video su YouTube, dove un altro cittadino della rete ha postato una feature meravigliosa di Cairo Dock , quella che si interfaccia appunto, con zeitgeist (che ricordo è un punto cardine di Ubuntu Unity). Eccolo qui :

Da questo video apprendiamo che il nostro cittadino è Francese, che Venerdì 4 febbraio alle 14.40 ha ricevuto una mail scam del provider francese di Alice, per una offerta di una adsl a 10 euro, probabilmente è asiatico o ha simpatie asiatiche e ciò è dimostrato dal fatto che il 3 febbraio alle 23.43 ha visto un filmato MKV "Rabbit - Force", probabilmente scaricato da un torrent asiatico chiamato "Asian Drama Torrents"... e siamo solo al secondo 7 degli 85 che dura il filmato.

Più avanti si vedono anche immagini e thumbnails di varia natura.

So cosa starei pensando io se fossi in Voi, ma siccome Voi non siete me probabilmente starete pensando ad altro, posso però dire che la descrizione data da Wikipedia è un pochino limitata.

Questo mi fa pensare ad un articolo che casualmente pubblicai su questo piccolo blog autarchico l'anno scorso, che riguardava l'altra interfaccia operativa usata principalmente negli ambienti Open, cioè KDE  dove i mostri semantici avevano altri nomi esotici : "Akonadi" e in particolare "Nepomuk", i quali per altro erano mostruosi anche dal punto di vista architetturale.

In quei tempi parlai anche del Tracker di Gnome 2 che però aveva l'aria molto più innocua, zeitgeist è molto più infido.

Fase 3 - Conosci il tuo nemico e annientalo

Esaminando i packages, si scopre che vi sono diversi pacchetti che in linea di massima sono installati da Cairo Dock  :

1. zeitgeist
2. zeitgeist-core
3. zeitgeist-datahub
4. libzeitgeist
5. python-zeitgeist

Ma potrebbero essere di più o di meno.

La struttura è simile a quella di un database, cioè ci sono il server e il client.

Il classico metapachetto è zeitgeist che carica il core e il data-hub . Questi due elementi si occupano di raccogliere dati e permetterne la comunicazione.

I punti 4 e 5 del nostro elenco invece sono integrati con i veri e propri programmi e servono per comunicare con zeitgeist ,  sono cioè quelle da cui dipendono di solito i programmi, nella fatispecie Cairo Dock.

Rimuoverle provocherebbe dei broken packages, rimuoverli fisicamente risolverebbe il problema (se non si usasse il plugin) ma al primo upgrade saremmo da capo.

D'altra parte rimuovendo il server coi relativi dati l'utilizzo del client diventa inutile, quindi apprestiamoci alla rimozione.

Prima di tutto vediamo dove sono i dati di zeitgeist, cioè nella cartella dell'utente (per fortuna) nel posto più logico dove trovarli e cioè :

.local/share/zeitgeist

Vedo subito che il log della mia attività è molto completo, infatti ci sono mega di cose private, compreso tutti i film che ho visto e cancellato, le immagini e i testi con nomi, cognomi e addirittura delle password.

Tutti lì a disposizione di ogni widget python o applet varia che li voglia inviare a chicchessia. Poi io uso Debian, ma in Ubuntu sarebbe un vero spasso, visto che zeitgeist è integrato con la barra delle ricerche  connessa al web , per giunta con un sacco di applet closed.

Dal mio punto di vista, preferisco annientare il tutto con :

sudo apt-get purge zeitgeist zeitgeist-core zeitgeist-datahub

operazione molto salubre che consiglio anche a voi.

Questo dovrebbe rimuovere completamente la cartella privata coi dati degli utenti, se non lo fa, fatelo voi a mano.

Ora potete dare logout e rientrare, per cancellare la situazione temporanea.

Ora se avete a disposizione un client valido, tipo il recent-events di Cairo Dock, usatelo contro se stesso e andate a vedere la lista che a questo punto dovrebbe risultare perfettamente vuota, altrimenti fidatevi sulla parola che non fa mai male.

E questo è tutto ?

Assolutamente no, perché Zeitgeist è appunto lo spirito dei tempi e i tempi di solito non si possono cambiare, a meno di non rinunciare a tutto e rifugiarsi sulle montagne a vivere da eremita (che per inciso è dove vivo io), però possiamo auto-congratularci e vantarci di avere non-risolto un serio non-problema.

Chromix III - PanMenu and Go !

Segue dalla puntata precedente.

 

Un buon Menu

Siamo giunti agli ultimi passaggi del progetto Chromix e ci serve il Menu.

Ma Perché ci serve un Menu ?

Ci serve perché il Menu di LXDE così come la maggior parte dei Menu delle varie interfacce grafiche, è studiato per far funzionare un Desktop e attinge alle relative applicazioni, mentre il nostro obiettivo è creare qualcosa di semplice che si interfacci con le Web-App di Chromium.

Devo dire che dopo molte titubanze, tipo la ricerca di un plugin adatto o l'idea di scriverlo, mi è venuto in mente che in fondo la cosa più facile era fare uno  scriptino in Python.

Uno scriptino in Python ?  

Si uno scriptino che usasse Python e le GTK, con tanto di supporto CAIRO.

Per installare ciò che ci serve occorre usare il terminale di root cioè quello rosso e poi dare il comando :

apt-get install python-gtk

e per quanto riguarda le operazioni come root abbiamo finito.

Aperto un terminale normale, invece creiamo due folder nascosti come chromix nella nostra HOME :

mkdir .panmenu
mkdir .menu
cd .panmenu

E siamo dentro la neonata cartella dove dobbiamo scrivere (se vogliamo con leafpad) il primo file che si chiama config e che contiene la configurazione del pannello :

Potrebbe essere  :

bottom=50
minrows=3
maxrows=8
mincols=3
maxcols=12

Altra riga accettata da questo file è defaulticon che indica il nome dell'icona di default, la quale se non indicata diventa /.local/share/icons/default.png.

Nella stessa cartella dobbiamo inserire l'icona del programma che si chiama panmenu.png , io ho scelto questa :

La stessa icona la potete copiare con un :

mkdir ~/.local/share/icons

cp panmenu.png  ~/.local/share/icons/default.png

Oppure potete sceglierne una completamente diversa.

Ora aggiungiamo il link chiamato : panmenu.desktop e scriviamo le seguenti righe di testo :

[Desktop Entry]
Version=1.0
Name=PanMenu
Comment=MenuPanel
Exec=/home/chromix/.panmenu/panmenu
Terminal=false
X-MultipleArgs=false
Type=Application
Icon=/home/chromix/.panmenu/panmenu.png

Lo script

Dopo avere aggiunto le parti secondarie arriviamo ora al vero e proprio pannello in python-gtk il cui codice è questo :

#!/usr/bin/python
#
#  PANMENU
#  A simple menu panel for Linux written in Python GTK
#
#  Copyright 2013 by ElDuraMinga (elduraminga.blogspot.com)
#
#  This program is free software: you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation, either version 3 of the License, or
#  (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  See <http://www.gnu.org/licenses/>.
#

import pygtk
import gtk
import os
import fileinput
import gtk, gobject, cairo

global inside
inside=False

global page
page=0

global profile,home,folderlist

home=os.getenv("HOME")
folderlist=[]

global GLX,GLS
GLX=64
GLS=48

global bottom,minrows,mincols,maxrows,maxcols,defaulticon

bottom=0
minrows=5
mincols=3
maxrows=8
maxcols=8
defaulticon=home+"/.local/share/icons/default.png"


global nRows,nCols,nIndex,nCount
nRows=0
nCols=0
nIndex=-1
nCount=0

global pixmaps
pixmaps=[]


#Check single instance
def singleInstance() :
  if os.access("/run/lock/panmenu.lock",os.F_OK):
    quit()
  else :
    f=open("/run/lock/panmenu.lock","w")
    f.close()

def killInstance() :
  os.unlink("/run/lock/panmenu.lock")


# Read Global Profile
def profileRead() :
  global bottom
  global minrows
  global mincols
  global maxrows
  global maxcols
  global defaulticon
  global home
  for i in fileinput.input(home+"/.panmenu/config") :
    v=i.strip().split('=')
    if len(v)==2 :
      if (v[0]=='bottom') :
        bottom=int(v[1])
      if (v[0]=='minrows') :
        minrows=int(v[1])
      if (v[0]=='maxrows') :
        maxrows=int(v[1])
      if (v[0]=='mincols') :
        mincols=int(v[1])
      if (v[0]=='maxcols') :
        maxcols=int(v[1])
      if (v[0]=='defaulticon') :
        defaulticon=v[1]

def checkIcon( iconname ) :
    global defaulticon
    global home
    for dirname, dirnames, filenames in os.walk(home+"/.local/share/icons"):
      for i in filenames :
        if i[:len(iconname)]==iconname :
          return dirname+"/"+i
    return defaulticon



def parseApplicationFile( name ) :
  global folderlist
  fname=""
  ficon=""
  fexec=""
  for i in fileinput.input(name) :
    v=i.strip()
    if v[:5]=="Icon=" :
      if v[5]=='/' :
        ic=v[5:]
      else :
        ic=checkIcon(v[5:]+".png")
      ficon=ic
    if v[:5]=="Exec=" :
      fexec=v[5:]
    if v[:5]=="Name=" :
      fname=v[5:]
  folderlist.append([fname,ficon,fexec]) 
   

#Read the local applications directory
def applicationsRead() :
  global home
  dirlist=os.listdir(home+"/.menu")
  dirlist.sort()
  for i in dirlist :
    j=home+"/.menu/"+i
    if (os.path.isfile(j)) :
      if (i[-8:]==".desktop") :
        parseApplicationFile(j)
  dirlist=os.listdir(home+"/.local/share/applications")
  dirlist.sort() 
  for i in dirlist :
    j=home+"/.local/share/applications/"+i
    if (os.path.isfile(j)) :
      if (i[-8:]==".desktop") :
        parseApplicationFile(j)
       

def iconShow(surface,cr,x,y,w,h,alpha) :
    cr.save(); 
    width = surface.get_width()
    height = surface.get_height()   
    width=w/width;
    height=h/height;
    cr.scale(width, height);
    cr.set_source_surface(surface, x/width, y/height)
    if alpha :     
      cr.paint_with_alpha(0.5)
    else : 
      cr.paint();
    cr.restore();



# Create a GTK+ widget on which we will draw using Cairo
class Screen(gtk.DrawingArea):

    # Draw in response to an expose-event
    __gsignals__ = { "expose-event": "override" }

    # Handle the expose-event by drawing
    def do_expose_event(self, event):

        # Create the cairo context
        cr = self.window.cairo_create()

        # Restrict Cairo to the exposed area; avoid extra work
        cr.rectangle(event.area.x, event.area.y,
                event.area.width, event.area.height)
        cr.clip()

        self.draw(cr, *self.window.get_size())

    def draw(self, cr, width, height):
        global iconlist
        global nIndex
        j=page
        for i in range(nRows*nCols) :
          cx=GLX*((i%nCols)+1);
          cy=GLX*((i/nCols)+1);
          if (nIndex==j) :
            iconShow(folderlist[j][3],cr,float(cx-GLS/2),float(cy-GLS/2),float(GLS),float(GLS),True);
          else :
            iconShow(folderlist[j][3],cr,float(cx-GLS/2),float(cy-GLS/2),float(GLS),float(GLS),False);
          j+=1 
          if (j>=len(folderlist)) :
            break 
        if nIndex!=-1 : 
          cr.save(); 
          cr.set_source_rgb(0, 0, 0)
          
          cr.select_font_face("Nimbus Sans L", cairo.FONT_SLANT_NORMAL,cairo.FONT_WEIGHT_NORMAL)
          cr.set_font_size(20)
         
          cr.move_to(GLX/2, height-26)
          cr.show_text(folderlist[nIndex][0]) 
          cr.restore(); 
         

def motionEvent(widget, event):
  global folderlist
  global nIndex
  global inside
  inside=True
  j=page
  q=-1
  for i in range(nCols*nRows) :
    cx=GLX*((i%nCols)+1);
    cy=GLX*((i/nCols)+1);   
    if ( (event.x>=float(cx-GLX/2)) and (event.x<=float(cx+GLX/2)) and (event.y>=float(cy-GLX/2)) and (event.y<=float(cy+GLX/2)) ) :
      q=j
      break;
    j+=1
    if (j>=len(folderlist)) :
      break
  if (q!=nIndex) :
    nIndex=q
    widget.queue_draw();   
  return True

def buttonEvent(widget, event):
  global nIndex 
  global folderlist
  global page
  if event.type == gtk.gdk.BUTTON_PRESS  :
    if event.button == 1:
      killInstance()
      if (nIndex!=-1) :
        os.execl("/bin/sh","/bin/sh","-c",folderlist[nIndex][2]);
      gtk.main_quit()
    if event.button == 3:
      page+=nCols*nRows
      if page>=len(folderlist) :
        page=0
      widget.queue_draw()
  return True



def quitAll(widget, event):
  global inside
  if inside :
    killInstance()
    gtk.main_quit()
    return True
  
# Panel intialization and run
def run(Widget):
    global nRows
    global nCols
    global nIndex
    global nCount
    global folderlist
    global iconlist
   
    nRows=minrows
    nCols=mincols
    nCount=len(folderlist)
   
    while (nRows*nCols<nCount) :
      nRows+=1;
      if (nRows>maxrows) :
        nCols+=1;
        nRows=minrows
      if (nCols>maxcols) :
        nRows=maxrows
        nCols=maxcols
        nCount=nRows*nCols;
        break; 
       
       
    for i in folderlist :
      try:
        f = cairo.ImageSurface.create_from_png(i[1])
      except Exception, e:
        f = cairo.ImageSurface.create_from_png(defaulticon)
      i.append(f)
 
    window = gtk.Window()
    window.connect("delete-event", quitAll)
    widget = Widget()
    widget.show()
    window.add(widget)
   
   
    widget.connect("motion_notify_event", motionEvent)
    widget.connect("button_press_event", buttonEvent)
    widget.connect("leave_notify_event", quitAll)

    widget.set_events(gtk.gdk.EXPOSURE_MASK
                            | gtk.gdk.LEAVE_NOTIFY_MASK
                            | gtk.gdk.BUTTON_PRESS_MASK
                            | gtk.gdk.POINTER_MOTION_MASK
                            | gtk.gdk.POINTER_MOTION_HINT_MASK)
   
   
   
    color = gtk.gdk.Color(red=65535, green=65535, blue=65535, pixel=0)
    window.background=color
    window.resize(GLX*(nCols+1), GLX*(nRows+1)+32);
    window.move(5, gtk.gdk.screen_height() - bottom - 32 - GLX*(nRows+1));
    window.present()
    window.set_name ("menupanel")
    window.set_title("Menu Panel")
    window.set_decorated(False)
    gtk.main()
   
if __name__ == "__main__":
    singleInstance()

    try :
      profileRead()
      applicationsRead()
      run(Screen)

    except e:

      killInstance()

Lo dovete copia-incollare dentro un file chiamato panmenu nella stessa cartella, menù e renderlo eseguibile tipo :

chmod 755 panmenu

Come funziona PanMenu

Panmenu recupera le applicazioni dai desktop link contenuti in .menu, cioè quelle che aggiungeremo noi e .local/share/applications che invece sono quelle che aggiunge Chromium, ossia le web-app.

Entrambi andranno a reperire le icone relative in .local/share/icons . Notare che questo menù non usa le libmenu, ma fa per conto suo ed è estremamente dinamico.

Il suo funzionamento è la costruzione di una finestra a sinistra in basso BOTTOM righe sopra l'ultima linea, individuando la serie di icone del pannello mettendole in ordine alfabetico, infine visualizzando un rettangolo che si estende da MINROWS MINCOLS a MAXROWS MAXCOLS, in modo progressivo.

Oltre il termine di MAXROWS/MAXCOLS si procede a pagine e per andare sulle successive si usa il Right-Click del mouse a rotazione.

Il pannello scompare quando si esce dal menu col mouse o quando si preme su un link, nel qual caso viene usato un execl con sh per lanciare il comando, che resta così regolarmente "figlio" del pannello.

Nota : Se il menù non si apre più controllare ed eventualmente rimuovere il lock per l'istanza singola : /run/lock/panmenu.lock

Integrare PanMenu nel launcher di LXDE

 

Per prima cosa, con leafpad si va a modificare il file :

 ~/.config/lxpanel/LXDE/panels/panel

Aggiungendo al primo launcher una altro Button, col seguente codice :

...

Plugin {
    type = launchbar
    Config {
        Button {
            id=/home/chromix/.panmenu/panmenu.desktop

        }
        Button {
            id=/usr/share/applications/chromium.deskto       

        }
    }
}

...

poi dobbiamo fare in modo che l'applicazione non sia visualizzata nella taskbar, modificando opportunamente la configurazione di openbox cioè il file :

~/.config/openbox/lxde-rc.xml

aggiungendo in fondo, prima della chiusura del tag XML </applications> quattro righe:

...
  # end of the example
-->

    
 <application name="panmenu" >
   <skip_taskbar>yes</skip_taskbar>
   <skip_pager>yes</skip_pager>
 </application>
  </applications>
</openbox_config>
...

Ora non ci resta che popolare, con due applicazioni di base il .menu e per far questo diamo la sequenza dei comandi :

cd ~/.menu
cp /usr/share/applications/lxterminal.desktop .
cp /usr/share/applications/pcmanfm.desktop .
cd ~/.local/share/icons/
cp /usr/share/icons/nuoveXT2/48x48/apps/terminal.png lxterminal.png
cp /usr/share/icons/nuoveXT2/48x48/apps/file-manager.png system-file-manager.png

Cioè copiamo sia il link a queste due applicazioni (in .menu) che le relative icone (in .local/share/icons), come indicate all'interno dei link.

Abbiamo scelto icone 48x48 che è la dimensione standard per il menu.

Siccome non sono accettate le sostituzioni tipo %U nei links, andiamo nuovamente in .menu e sostituiamo la riga di exec di pcmanfm.desktop con :

...

Exec=pcmanfm ~/Downloads
...

A questo punto possiamo riavviare.

 Riavvio

Se avete fatto i regolari passaggi, cliccando sul nuovo launcher nel pannello del menù vedrete qualcosa tipo :

Facendo click sul file manager per altro, entreremo direttamente in Downloads, dove ci si aspetta che Chromium metta ciò che scarichiamo.

Inoltre sul tab sinistro di pcmanfm troviamo Applications , se clicchiamo qui, scopriamo che si tratta di un altro menu completo da cui possiamo avviare tutte le applicazioni installate :

dunque possiamo rimuovere quello sul pannello e lasciare solo il nostro PanMenu e Chromium.

 

 

Aggiungere Web-Apps e Links

Se apriamo Chromium sulla new-tab classica, dovremmo trovare l'elenco di tutte le applicazioni che abbiamo integrato.

All'inizio c'è solo il Chrome Web Store che però è un Web-App come tutte le altre dunque possiamo benissimo inserirlo come applicazione.

Per farlo clicchiamo col tasto destro sull'icona stessa e scegliamo Create Shortcuts :

Qui scegliamo di mettere il link nel menu e non sul desktop.

Ora, se andiamo a vedere il nostro menù, sarà diventato così :

E potremo lanciare l'applicazione come se fosse locale :

 

Come possiamo osservare nella finestra non c'è alcuna barra e l'icona nella taskbar non è quella di Chromium ma dello store !

Questo ovviamente, si può fare con tutte le applicazioni che vogliamo e ciò è abbastanza grandioso.

Ma c'è molto altro, tipo inserire un LINK come se fosse una web-app, con l'unico problema che l'icona sarà quella dello standard web di solito 16x16, poi scalata di tre volte.

Comunque apriamo Chromium , andiamo su un sito tipo www.twitter.com e clicchiamo sul menù di Chromium , sotto Tools troviamo Create Application Shortcut .

Stessa operazione di prima, cioè creazione del link non sul desktop ma nel menu ed ecco il nostro nuovo menu con l'uccellino.

 

Ed ecco il nostro Chromix

Abbiamo praticamente concluso il lavoro su Chromix.

Se volete, potete portare avanti piccole rifiniture, tipo cambiare la PNG che sta in /usr/share/lxde/images/logout-banner.png, con l'icona di Chromium 256x256, in modo da avere un menu di chiusura più raffinato e tante altre cose che lascio fare a voi.

Per ora arrivederci.

Chromix II - The making of

Segue dalla puntata precedente.
 
Dopo avere capito cosa è Chromix vediamo di installarlo, cioè di installare Debian, e trasformarla in Chromix.

La scelta

Allo stato attuale sta per uscire la Debian Wheezy, ma siamo ancora a Squeeze cioè la 6.0, anzi per l'esattezza la 6.06.

Ho detto che Chromix dovrebbe essere una rolling release cioè un qualcosa che si aggiorni in eterno, però dovremmo limitare il più possibile i cambiamenti radicali di versione del software, a parte quelli di Chromium che è il core di Chromix.

Infatti per lavorare coerentemente, dovremo modificare diversi script e quando cambiamo la "versione" dei pacchetti, ci potrebbe essere richiesto di fare un merge a mano tra la vecchia e la nuova versione. Questo accade piuttosto raramente ma può accadere.

Per ovviare a questi inconvenienti restiamo su Wheezy per poi pensare a cambiare il tutto fa 4 anni, mentre vedremo di avere gli aggiornamenti veloci del browser in altro modo.

Base

Scaricata la versione netinst di Debian 6, si può copiare su una chiavetta, inserirla nel NetBook e iniziare il boot.

L'idea è ovviamente quella di rimuovere tutto ciò che c'era prima e installare la "base", cioè eseguire la classica installazione full disk.

È importante scegliere il giusto file system per la partizione, visto che di solito Debian è indietro (attualmente formatta ext3, mentre per tutti è meglio ext4).

È essenziale invece creare oltre al classico utente root  anche l'utente :

chromix  

che sarà il nostro utente di autologin.

La password di chromix non ha molta importanza, perché ne avrà di più quella del ring.

Arrivati in fondo sceglieremo solo la base, cioè Laptop e Standard system utilities :

Se abbiamo fatto tutto bene, partiremo dalla linea di comando loggandoci come root ed a quel punto potremo decidere di aggiornare e continuare se siamo già in Wheezy o di cambiare /etc/apt/sources.list e metterci wheezy al posto di squeeze se siamo partiti da Squeeze.

Sperando che sia tutto chiaro, alla fine per essere sicuri diamo :

apt-get update
apt-get dist-upgrade
apt-get autoremove 

Così mettiamo a posto le pendenze.

Una volta riavviato il sistema avremo la nostra base già pronta.

I pacchetti di Chromix

La base dei pacchetti di Chromix è molto semplice. Ovviamente poi potremo aggiungere quello che ci piace ma l'essenziale è :

apt-get purge xscreensaver
apt-get install lxde
apt-get install alsa alsa-oss oss-compat
apt-get install feh
apt-get install evince
apt-get install ffmpeg
apt-get install chromium
apt-get install flashplugin-nonfree
apt-get autoremove 

Al termine dell'aggiornamento riavviamo ed eseguiamo il login come chromix .

Al primo impatto ciò che dovremmo ottenere è questo :

E ciò ci fa intuire che ci dovremo lavorare un po` su.

Modifiche al pannello

 

Premetto che presto presenterò un menu degno di questo nome ma per il momento mettiamo a posto il pannello nel modo più semplice.

Per far questo col tasto destro sul pannello, scegliamo Panel Settings e ci troviamo una dialog con alcuni tab, i quali sono da impostare in questo modo :

Portiamo la dimensione delle icone e della barra a 48 pixel :

Poniamo uno sfondo trasparente :

Modifichiamo nel la sequenza dei plugin del pannello con Add,Remove, Up e Down in questo modo :

Usando Edit invece, si possono modificare le due Application Launch Bar e la Task Bar.

Nella prima Application Launch ci mettiamo solo Chromium :

Nella seconda, quella in fondo, lasciamo solo il Logout :

La TaskBar invece la trasformiamo in questo modo :

 

 

Così facendo, abbiamo una bellissima barra trasparente con solo le icone.

A questo punto lasciamo le impostazioni del pannello e dal menù andiamo su Preferenze per impostare il tema di OpenBox.

Io ho scelto ClearLook-3.4 che e in linea con la barra di Chromium :

L'ultima modifica è Dektops, dove mettiamo un desktop solo :

Modifiche di sistema

Bene, fatte le modifiche come utente chromix, tra li accessori ci dovrebbe essere un terminale rosso di amministrazione (root) da usarsi per modificare i files di sistema.

Da questo terminale è possibile lanciare senza difficoltà anche leafpad che è l'editor di testi di LXDE.

Prima però dobbiamo scegliere una immagine di sfondo, per far questo apriamo Chromium e cerchiamo su Internet una bella immagine, possibilmente di risoluzione in linea col nostro schermo che per un normale netbook è 1024x600.

Trovata l'immagine mettiamola nella home di chromix , poi con il file manager rinominiamola come .background.img . È molto importante ricordarsi il . all'inizio e se avete fatto le cose correttamente, l'immagine dovrebbe "sparire".

Ora dal terminale rosso andiamo a modificare il file di autostart e cioè diamo :
 

leafpad /etc/xdg/lxsession/LXDE/autostart

Bene. Il file deve essere cambiato così :

@xset s 120
@feh --bg-scale ~/.background.img
@lxpanel --profile LXDE 

La prima riga imposta lo screen saver di risparmio energetico sui due minuti di inattività .

La seconda sostituisce il desktop con il solo background e impedisce di metterci icone (pur lasciando la cartella Desktop).

La terza dovrebbe già esserci e lancia il pannello. È come vediamo una configurazione estremamente minimale.

Il programma feh visualizza solo l'immagine, tuttavia OpenBox continua comunque a mostrarci il suo menu col tasto destro.

Opzionale :
 
Per ovviare a questo inconveniente antiestetico, potremmo agire aprendo normalmente leafpad da chromix e modificando il file :

~/.config/openbox/lxderc-xml

Per eliminare tutti i blocchi con riferiementi a :

<action name="ShowMenu"> 
 

ma se non siete preoccupati per un comodo menù, lasciate pure perdere.

Autologin

Dopo avere modificato l'autostart di LXDE vediamo come impostare l'Autologin, il Power Management e Chromium.

Tanto per iniziare, considerando un solo sistema operativo, non abbiamo bisogno del menù di GRUB. Per modificarlo occorre dal terminale root (quello rosso) editare con leafpad il file :

/etc/default/grub

e modificare nelle le prime righe :
 

GRUB_DEFAULT=0

GRUB_TIMEOUT=0

io ho anche tolto il commento a :
 

GRUB_TERMINAL=console

Per salvare la configurazione usiamo l'apposito script e diamo con attenzione :
 

grub-mkconfig >/boot/grub/grub.cfg

Il nuovo file, dovrebbe far partire GRUB automaticamente.

Per quanto riguarda l'autologin di lightdm, c'è invece uno script molto nascosto, che modifica /etc/lightdm/lightdm.conf  e si può lanciare in questo modo :

/usr/lib/i386-linu-gnu/lightdm/lightdm-set-defaults --autologin chromix

e il gioco è fatto.

 Power Management

Dunque, abbiamo già ridotto il tempo di accensione del display a 2 minuti di inattività, ora però dobbiamo modificare due parametri essenziali, il primo è la policy del governor e il secondo è la chiusura del LID.

Da quando sono stati introdotti i sistemi per la gestione dell'energia nelle CPU, Linux ha incominciato ad adottare alcuni algoritmi per controllarne la frequenza.

Gli algoritmi sono sostituibili in run time e sono chiamati governor, attualmente ce ne sono 5 :  userspace, conservative, powersave, ondemand, performance.


Tra questi i due interessanti sono ondemand e conservative. 

La differenza tra i due è che il primo, molto usato, pur facendo funzionare il computer alla minima frequenza, appena si opera al 100%, scala alla massima frequenza, mentre il secondo per arrivarci scala lentamente per tutti gli steps disponibili.

La seconda soluzione sarebbe più corretta ma a volte, specie se gli steps sono molti come in un ARM,  è un limite per la rapidità di risposta all'operatore.

Qui useremo comunque conservative, che su un ATOM e in un NetBook va più che bene.

Prima accertiamoci del numero e delle frequenze di lavoro dei nostri core CPU e per questo che lanciamo :

cpufreq-info 

con questo io ho osservato che il mio netbook è "scarsino", ha due core, cioè CPU0 e CPU1 e i seguenti hardware limits :

-->

hardware limits: 800 MHz - 1.60 Ghz

Dal terminale di root (sempre quello rosso), modifichiamo il file jolly per le impostazioni di sistema cioè /etc/rc.local .

Io ho inserito quindi prima di exit 0 le seguenti righe :

-->

export PATH=$PATH:/bin:/sbin:/usr/bin:/usr/sbin

cpufreq-set -c 0 -g conservative -d 800Mhz -u 1.6Ghz

cpufreq-set -c 1 -g conservative -d 800Mhz -u 1.6Ghz

exit 0

Che mi sembrano autoesplicative o quanto meno nulla che un semplice man non possa chiarire.

Resta il problema del LID cioè dello sportello (cioè quando chiudete il computer) che per default non lo manda in sleep, ma spegne solo la retroilluminazione del display.

Ciò può essere brutto, specie per un NetBook ma anche per un Notebook ed è probabilmente retaggio di tempi oscuri, in cui il power management non funzionava e il computer, una volta andato in sleep, non si svegliava più.
-->

Si può modificare per questo il file :

/etc/default/acpi-support

con le seguenti impostazioni :

# Comment the next line to disable ACPI suspend to RAM

ACPI_SLEEP=true

# Comment the next line to disable suspend to disk

ACPI_HIBERNATE=true

# Use Radeontool to switch the screen off? Seems to be needed on some machines

# RADEON_LIGHT=true

# Comment this out to disable screen locking on resume

# LOCK_SCREEN=true

# Uncomment this to enable ACPI sleep when the lid screen is closed.

LID_SLEEP=true

Sul mio NetBook NON HO una RADEON, quindi RADEON LIGHT è commentato.

L'importante è ovviamente LID_SLEEP=true, gli altri sono aggiustamenti.

Dovremmo quasi esserci, ci manca solo la modifica di Chromium.

Chromium Settings

-->

Alcuni si sorprenderanno nel sapere che Chromium dispone di decine di switches in linea di comando, che possono abilitare e disabilitare anche funzionalità avanzate e non presenti nelle impostazioni generali.

Per esempio su un NetBook con autologin come il nostro, sarebbe indispensabile proteggere in qualche modo le proprie passwords.

In questo caso, mentre Firefox consente l'uso di una password di sblocco principale che decripta le altre, Chromium o usa sqlite in chiaro o i tools di sistema che si chiamano gnome-ring o kwallet.

Non stiamo usando KDE, però tra i pacchetti di LXDE c'è gnome-ring.

Il problema vero è che mentre sarebbe facile modificare il launcher di Chromium, per metterci gli switches, i link alle web-apps in Linux sono generabili automaticamente da Chromium e non ci mette quei flags.

Tuttavia esiste una variabile di sistema poco nota, che possiamo inserire in /etc/environment, un file che nell'installazione standard di Debian non dovrebbe ancora esistere o essere vuoto.

Quindi apriamolo e scriviamoci :

CHROMIUM_USER_FLAGS="--password-store=gnome"

e tutta la serie di altri flags che ci piace di più. 

Io per esempio disabilito il sync di Google con -–disable-sync in modo che non me lo chieda nemmeno.

Se facciamo questo ci conviene definire una password piuttosto complessa per gnome-ring e diversa dalla classica password di login che è automatico, quindi dobbiamo "uccidere" il keyring dal terminale di root con :

killall gnome-keyring-daemon

e ripulire la cartella keyring dell'utente :

rm -r /home/chromix/.gnome2/keyrings/*

o direttamente dal suo terminale (non root) con rm -r ~/.gnome2/keyrings/* .

Così la prima volta che si accederà ad una pagina di login, vedremo spuntare la richiesta della prima password di keyring, che non dobbiamo dimenticare mai perché le altre volte che facciamo reboot ce la richiederà.

Aggionamenti

Abbiamo detto che il nostro target è di non aggiornare spesso il sistema operativo nel suo insieme, tuttavia è quasi indispensabile tenere aggiornati Chromium e Flash per esempio, oltre ad eventuali altri plugins messi a disposizione da Debian.

Per fare questo useremo un trucchetto particolare che potrebbe rilevarsi molto interessante.

Apriamo il terminale di root (quello rosso) e andiamo nella cartella :

cd /etc/apt/preferences.d

A questo punto scriviamo due files contenenti tre righe :


00Default

Package: *
Pin: release a=wheezy
Pin-Priority: 900

10Testing

Package: *
Pin: release a=testing
Pin-Priority: -100

Questo sta ad indicare che lasciamo aperta la strada a due profili, il principale con priorità 900 è il Default che è esplicitamente wheezy, mentre il secondario che deve essere attivato su specifica richiesta e con priorità -100 è il Testing che è rolling ma potrebbe anche essere la sid.

L'unica aggiunta che dobbiamo fare è a questo punto nel file :

/etc/apt/sources.list 

che ormai conosciamo molto bene, per aggiungere la riga :

...
deb http://<debian mirror>/debian testing main contrib non-free
...
 

cioè una riga sul repository di testing.

Così facendo, potremo continuare ad usare :

apt-get update

apt-get upgrade

per aggiornare il sistema di Wheezy, ma parallelamente saremo anche in grado di aggiornare solo uno o più pacchetti alla versione più nuova della testing, per esempio con :

apt-get update

apt-get install -t testing chromium-browser chromium-browser-l10n  flashplugin-nonfree

Autoupdate al Boot

Chrome OS, esegue automaticamaente un aggiornamento al boot, se trova pacchetti più nuovi.

Siccome non ci facciamo mancare nulla possiamo provare a farlo anche noi con una particolare avvertenza, cioè che potrebbe non funzionare, quindi stiamo un attimino attenti.

Bene, ora che ci siamo capiti andiamo nella cartella :

cd /usr/local/sbin

e inseriamo uno script autoupdate, tipo questo :

#!/bin/bash
function realUpdate
{
    /bin/sleep 120
    /usr/bin/apt-get update -q=2
    /usr/bin/apt-get install -q=2 --download-only -t testing $(</usr/local/etc/testing.package)
}
/usr/bin/apt-get install -q=2 --no-download -t testing $(</usr/local/etc/testing.package)
realUpdate &

Infine inseriamo prima di exit 0 in /etc/rc.local la seguente riga :

...
/usr/local/sbin/autoupdate
exit 0

e la lista di pacchetti speciali da aggiornare tutti in fila nel file :

/usr/local/etc/testing.package

con un contenuto tipo appunto :

chromium-browser  chromium-browser-l10n  flashplugin-nonfree

Cosa fa tutto ciò ?


Ho suddiviso il funzionamento in due parti, prima l'installazione sincronizzata con lo startup di sistema e poi l'aggiornamento dopo due minuti.

Questo è più o meno il sistema usato da windows quando fa aggiornamenti importanti, cioè scarica gli aggiornamenti eventuali e li installa allo startup nella fase successiva.


In questo modo si incrementa la sicurezza che non si spenga il computer durante l'installazione, sebbene l'installazione stessa avvenga in background in quanto come sappiamo, nelle nuove versioni di Debian, l'init di sistema non è più sequenziale.


Dopo due minuti dalla partenza del invece, quando si suppone che la rete sia pronta, lo script tenta di scaricare eventuali aggiornamenti disponibili rigorosamente in background e li lascia lì per il prossimo riavvio.


Questo avviene solo per i pacchetti indicati nel file : /usr/local/etc/testing.package, gli altri si possono aggiornare dal terminale di root con il classico :

apt-get upgrade 

Nel caso invece qualcosa non funzioni sappiamo che c'è sempre :

dpkg --configure -a

eccetera.

E infine il riavvio

 

Terminati tutti questi passaggi possiamo riavviare e dopo l'autologin otterremo questo :

Il sistema non è ancora completo, perchè una interessante capacità di Chromium è quella di creare links alle Web-Apps e agli URL come se fossero applicazioni.

Ci servirà un menù degno di questo nome, in grado di gestire sia le applicazioni native che quelle web e vedremo di procurarcelo in qualche modo, ovviamente nella prossima puntata.

Chromix I - A History Of NetBooks

NetBooks

 

Qualche anno fa, sul mercato furono lanciati una serie di computer destinati ad essere il futuro della comunicazione mobile, cioè i NetBooks.

Dopo qualche mese, esattamente come mi capitò di prevedere, il lancio divenne letterale e cambiarono destinazione d'uso, diventando pratici fermaporta, livellatori per tavolini o portatovaglioli.

Molti affermano che il dramma di questi oggetti fu la nascita del mercato dei Tablet e questo è certamente vero, tuttavia per vedere le cose dal giusto punto di vista dovremmo considerare anche la loro storia, l'indecente campagna di marketing che ne seguì e le relative implementazioni techologiche.

Infatti l'idea di ciò che è chiamato oggi NetBook nacque come realizzazione dal sogno di Negroponte di costuire PC a 100$, con Linux per paesi in via di sviluppo, oggetti che una volta realizzati furono ribaltati sul mercato occidentale con Windows ad un prezzo paragonabile, se non superiore, a quello di un NoteBook da 15 o 17 pollici.

Per ottenere implementazioni compatibili con tecnologia i386, si usarono processori ATOM che avevano un buonissimo livello di consumo a parità di prestazioni, però le celle delle batterie furono ridotte (cioè 6 celle invece di 12 o 18) e così l'autonomia divenne di due ore scarse, inferiori a quelle di un NoteBook della stessa fascia di prezzo.

Queste ed altre fantastiche soluzioni tecnologiche, li resero di fatto dei semplici soprammobili, tranne che per alcuni modelli come il Samsung che riusciva ad offrire una autonomia normale per un sistema mobile di 9 ore ma aveva costi molto più elevati.

ChromeBooks

Alcuni anni dopo, mentre la Microsoft scatena il suo nuovo Windows8 - Surface, un po`tablet e un po`NoteBook, dando un addio alla tecnologia Intel a favore la tecnologia ARM e mentre la Samsung realizza ibridi di varia natura, la grande G che ospita anche questo blog autarchico, dopo aver svezzato Android, riprende l'idea del Full-Cloud, con il suo progetto Chrome-Os cioè un sistema operativo integrato sul browser Chrome.

Forse non tutti sono a conoscenza, che il progetto Chrome non è altro che una integrazione made in Google, di un progetto open source chiamato Chromium e sostenuto dalla stessa azienda, a cui Google attinge periodicamente, colora l'iconcina, ci aggiunge due o tre moduli proprietari come il visore pdf integrato e un supporto multimediale decente e quindi lo sforna in upgrade come nuova release.

Casualmente questo è più o meno lo stesso modello di sviluppo di Android, cioè un progetto Open Source a cui Google aggiunge le sue applicazioni ma se ne può fare benissimo a meno. La differenza è che per Android le applicazioni di Google sono un must per avere un minimo di servizi, mentre Chromium funziona benissimo anche senza le estensioni di Chrome. 

Diversamente il progetto Chromium, è un po`difficile da scaricare ed usare, se girate un po` per il sito dopo immani tentativi nel farvi installare Chrome, forse dovreste trovare delle daily-builds, probabilmente dentro uno sgabuzzino col cartello "attenti al leopardo" (cit.).

I ChromeBooks dicevamo, utilizzano Chrome-OS che allo stesso modo è ospitato sul sito di Chromium in versione open source detta "Chromium OS", scaricabile e compilabile dallo stesso sito.

Se volete invece avere le builds di Chromium OS già pronte stanno sul sito di Hexxeh, ovviamente le trovate per chiavetta o macchina virtuale perché installarle è tutta un'altra storia.

Ah ... dimenticavo una ovvietà : Chrome OS è chiaramente Linux, come Android.

Chrome OS e poi ?

La storia diversa è che se avete un NetBook e Chrome OS non avete risolto nulla, perché Chrome OS nasce per essere preinstallato su un ChromeBook e solo in quelle condizioni si aggiorna (che per un browser può anche essere utile)  oltre a tante altre cose.

Queste tante altre cose, ci portano alla conclusione che nel momento in cui possedete un ChromeBook, avete un Linux blindato con una essenziale dipendenza dalla rete e da Google stessa.

Vi loggate nella macchina con il vostro login di Google che diventa il vostro mondo, proprio come un telefono o un Tablet Android e la vostra vita diventa Google, nel senso che se dovete stampare qualcosa o ve lo scaricate su chiavetta e andate su un altro computer oppure stampate cloud e vi portano i fogli di carta a casa.

Questo è l'essenziale motivo per cui, invece di tentare di operare sul progetto di Chromium OS per inserire i drivers di vari hardware ( invece del frame-buffer dei bundles precompilati ), ho optato per riprende un mio vecchio progetto.
 

Chromix 

Dopo aver tanto criticato i NetBook fin dalla loro origine, un giorno uscendo di casa in periodo post iPAD mi capitò di vedere un  Acer  Packard Bell in una vetrina, in svendita per un pugno di dollari e ovviamente lo acquistai.

Dopo avere immediatamente rasato al suolo Windows XP  mi avventurai ad installare l'Ubuntu di allora che era la 10.04 con grande successo, di cui feci pure un video, ricevendo pesanti critiche sui mie gusti musicali autarchici :

Fui molto contento del risultato, come potete vedere dal video, l'ATOM del mio piccolo "gioiello" era usato benissimo.

Ma poi un giorno il Patron Mark, si trasformò da Dr. Jekyll in Mister Hide e il mondo Ubuntu mutò, tant'è che al primo aggiornamento, il mio NetBook tornò prima a XP, a cui seguirono un paio di giorni, tesi a cancellare un paio di centinaia di BloatWares , due o Tre Spywares, un Virus Nativo e il Norton Antivirus disattivato da aggiornare e dopo breve vita al ruolo primevo di inutile soprammobile.

Un giorno però mentre lavoravo su un PC aziendale e avevo bisogno di navigare un po` per gli affari miei (durante le pause ovviamente), misi a punto una cosina con Ubuntu - LXDE e Chromium, una chiavettina USB da inserire nel PC, che partisse direttamente col browser con tanto di Splash Screen e customizations e la chiamai Chromix.

Chromix, giace ancora qui accanto a me e ormai il browser non si aggiorna più, in realtà non si è mai aggiornato, trattandosi appunto di una chiavetta USB ma è il pensiero che conta perché se l'avessi installato nel NetBook oggi non si aggiornerebbe e questo non è bello.
 

Menare il can per l'aia

Ordunque spiegata la storia inesistente di Chromix, oggi ho deciso di ripartire da capo, creando una piccola distribuzione rolling per Netbook che chiamerò Chromix fortemente basata su Chromium ma con la possibilità di lanciare applicazioni native.

Tutto ciò non sarà facile, perché si riparte da Debian in un mondo che non sarà scevro di sorprese e che scopriremo nei prossimi post.

Foto 3D

Scripta Manent III

 

Pinguini per la testa

Proprio oggi, sfruttando un istante di sole invernale, gironzolavo per una montagna dalle mie parti, sforzandomi di dedicare la giornata a pensieri cauti ed evasivi, in cui i pinguini non erano annoverati.

Così come la bettola non è il miglior posto ove l'Alcolista Anonimo possa disintossicarsi, passeggiare tra la neve non è una attività che tende a farti dimenticare i pinguini, specie quando il panorama è molto bello e ti chiedi come portarne un pezzettino a casa (di panorama, non di pinguino).

Ed è lì che ti rendi conto che le foto sono così piatte e poco aiutano a rappresentare quello spettacolo, quindi è inevitabile che una mente ormai deviata inizi a vagare, pensando al fatto che il suo PC ha un monitor 3D, che ha un software per vedere le foto 3D e da lì all'idea, il passo è breve e mentre tutto questo accade, il passo rischia anche di scivolare.

Ma bando alle ciance torniamo sul pezzo e non prima di ossessionarvi con un po` di cultura informatica.

PNM

Perhapsnoteveryoneknowsthat ,  i sistemi come Linux hanno un formato jolly molto particolare chiamato netpbm di cui esistono varie estensioni, uno per formato.

La più simpatica è il portable anymap format che è un formato studiato appositamente per essere semplice e comodo , cioè un formato che non ti obbliga a strane manipolazioni e scorrimenti di bit o formati binari alieni (ogni riferimento alle .bmp è puramente casuale).

Lascio a voi la gioia di capirne la semplicità e la completezza formale.

Ciò che è importante comprendere è che per questa sua questa versatilità di solito non lo si usa per memorizzare le immagini (cosa che poco si adatta ad un formato lossless non compresso) ma per ogni genere di manipolazione, con pipes e programmi vari.

E su Linux c'è tutta una serie di programmini di cui vanno pazzi quelli che scrivono (o scrivevano) le CGI e che in Debian per esempio possiamo trovare nel pacchetto netpbm (i programmini, non quelli che li usano).

 

Scattare foto 3D!

Beh scattare foto 3D non è complicato. Si trova un piano oppure se si va in montagna come me si evita di bere grappa e si prova a mantenere il polso fermo, poi si scatta una foto col cellulare e si fa scorrere orizzontalmente, di 3 o 4 centimetri da destra a sinistra, scattando una seconda fotografia, così  :

Come si può facilmente intuire dal disegno che compongono le due freccette gialle la foto risulterà in questo modo incrociata. I più intuitivi avranno anche capito che se fate il contrario e invertite le foto il risultato sarà lo stesso.

In un modo o nell'altro si otterranno due foto la prima delle quali è il punto di vista dell'occhio destro e la seconda di quello sinistro.

 

Lo scriptino finale

I capitoli della serie Scripta Manent, non sono ovviamente scripts completi ma piuttosto cenni su cosa si può fare con Linux, spesso sono solo righe, giusto per capirci.

Ed è quindi seguendo questo spirito avventuriero che dopo aver scaricato le foto, possiamo applicare questo script che ho chiamato sbs3d :

#!/bin/bash
tmpfile=`mktemp`
jpegtopnm $1 >$tmpfile
jpegtopnm $2 | pnmcat -lr $tmpfile - | pnmtojpeg --quality=85 >$3
rm $tmpfile

Scrivendolo, rendendolo eseguibile (chmod 755), magari copiandolo in /usr/local/bin e quindi invocandolo in questo modo :

sbs3d <first> <second> <output>

che nel mio caso diventa :

sbs3d IMG_20130203_131945.jpg IMG_20130203_131949.jpg lamiafoto3d.jpg

Lo script, crea un file temporaneo, ci salva la prima immagine convertita in pnm, poi con una sola riga di codice e una serie di pipes, passa la seconda immagine, ci fa il cat lr cioè left-right e riconverte in jpg con qualità 85 (che è abbastanza alta), passando infine il risultato nel terzo nome file indicato, poi si cancella il file temporaneo.

Lo Stereogramma

Se siete stati abbastanza bravi da non aver confuso o sovrapposto le foto, e di non aver cancellato importantissimi lavori su cui potrete piangere per i prossimi vent'anni, dovreste trovarvi le stesse foto di prima, più un file chiamato lamiafoto3d.jpg tipo questo :

A questo punto avete creato una SBS-Cross-Eye-3D-Photo e cioè uno stereogramma, così se incrociate gli occhi fissandolo dovreste vedere apparire al centro la foto 3D.

Con gli occhi dritti

Il formato SBS spesso ridotto ad HSBS (cosa che si ottiene scalando orizzontalmente la foto al 50%), è un formato molto noto e usato spesso anche per i film 3D.

Se ne deduce che se volete vedere la foto con gli occhi dritti, dovete procurarvi un monitor 3D con relativo software.

Se proprio non volete, potete cercare da qualche parte se avete in giro un paio di occhiali anaglifici e provare con le diverse centinaia di programmi che li gestiscono anche sui monitor normali, compresa la versione ora GIT di VLC.

Ossequi.

Debian Live

Living in Debian

L'altro giorno, gironzolando al centro commerciale, così per passare il tempo, ho visto le nuove chiavette USB in svendita e tra i maialini e i pupazzetti di varia natura, ho trovato chiavette da decine di Giga a prezzi veramente stracciati.

Sarà per deformazione professionale, o perché il primo hard disk che vidi nella mia vita, era di 20Mb e costava come un'automobile, che tutte le volte che mi cade l'occhio su una chiavetta USB o una Micro-Sd da decine di Gb, incomincio a fantasticare sulle incredibili possibilità che un tale dispositivo potrebbe darci con il sistema operativo giusto.

Un paio di anni fa realizzai con Ubuntu un live su chiavetta che usavo per collegarmi alla mia banca dai computer con Windows, poi Ubuntu lentamente si è trasformata in tutt'altro e io sono migrato a Debian che per altro è molto pulita ... ma qui ho dovuto scontrarmi con l'amara realtà.

Tools come Casper e UCK da queste parti ce li si può scordare, così, come tutti i tecnici per bene, sono  andato ad indagare Googlando qui e là per cercare come realizzarsi un Live Cd della più famosa distribuzione e l'impatto è stato traumatico, visto il gran numero di specchi e di persone che cercavano di arrampicarvisi, per spiegare l'inspiegabile.

live-build

Per fortuna, da qualche anno a questa parte c'è un nuovo orizzonte per la realizzazione di Live Debian, ovviamente è un insieme di script e si chiama live-build.

Per usarlo si deve partire da una distribuzione Debian e installarlo sulla stessa e qui iniziano diverse difficoltà.

Capita infatti che insieme a live-build, vi siano una serie di altri pacchetti dello stesso tipo, come live-config che sono "usati" ma non "installati".

Infatti i pacchetti aggiuntivi, benché abbiano il nome di comandi che sono interni a live-build, saranno installati direttamente sulla macchina che andremo a fare e cioè, per intenderci noi lanceremo i comandi da live build e in particolare il comando "lb" con i vari parametri, e gli script di cui si compone scaricheranno i giusti pacchetti, come quelli per la gestione del boot e li installeranno sulla live che faremo, nella giusta versione.

Detto questo vediamo come si può procedere.

Innanzi tutto iniziamo a diventare root della macchina su cui operiamo che è la scelta migliore, quindi diamo su.

Diventati root, se non l'abbiamo ancora fatto, installiamo il pacchetto che ci serve e cioè live-build.

Poi con particolare attenzione dobbiamo creare una cartella live dentro la directory /root ed entrarci. Riporto qui di seguito la possibile sequenza dei comandi da eseguire, anche se ovvia :

$ su
# apt-get install live-build
# cd
# mkdir /root/live
# cd /root/live

ok ? Perfetto, ora che siete in live e in perfetta forma, possiamo dare il : grande comando che tutti vogliamo sapere e cioè :

# lb config -a i386 --binary-filesystem fat32 --distribution wheezy --debian-installer false --archive-areas "main contrib non-free" --package-lists xfce  --interactive shell -b hdd

Nonostante il comando sia intuitivo e non necessiti spiegazioni ( ovviamente scherzo), diamo un dettaglio delle singole opzioni :

• lb config è il comando che si compone di lb e di config come prima opzione. Questo comando provvederà a lanciare la configurazione, nella cartella corrente, cioè live.
• -a i386 è l'opzione che imposta l'architettura. Allo stato attuale è meglio che la live sia compatibile con le macchine a 32 bit, invece che quelle a 64, visto che il nostro obiettivo è quella di farla girare sul maggior numero possibile di macchine.
• --binary-filesystem fat32, ci dice che scegliamo la fat32 come File System, perché vogliamo fare una chiavetta USB e non un obsoleto e lento DVD.
• --distribution wheezy . Ed ecco che nella live, possiamo scegliere subito quale distribuzione installare e non passare per l'installazione standard. Ricordo che in questo momento wheezy è ancora in testing , e se si scaricano le immagini standard dal sito, c'è la squeeze.
• --debian-installer false , significa che non stiamo facendo una chiavetta di installazione ma una live, quindi non ci servono cartelle coi pacchetti o live installer.
• --archive-areas "main contrib non-free" , ci dice i repositories di riferimento, quelli cioè a cui attingeremo, in questo caso li ho messi tutti, perché come ho spiegato, ci sono parecchi casi in cui potrebbero servirci i drivers closed per il nostro hardware. Premetto che dal punto di vista della sicurezza non è il massimo, e lascio alle scelte personali.
• --package-lists xfce. Questo parametro merita un discorso a parte. Infatti nelle vecchie versioni dello script lb,c'era un altro parametro e cioè --packages che ora non funziona più o per lo meno secondo il puro stile Debian funziona a giorni alterni, a seconda della versione dello script e io suggerisco di non usarlo. Per quanto riguarda il nome che c'è dopo package-lists, le varie liste dovreste trovarle in  /usr/share/live/build/package-lists e c'è riportato il profilo base del sistema.
• --interactive shell , questa è una opzione importantissima perché ci permetterà di personalizzare la live come piace a noi. Similmente a quanto fa UCK ci permetterà infatti di accedere al sistema e alla gestione dei pacchetti da un prompt di shell, direttamente durante la realizzazione della live stessa.
• -b hdd, definisce e forza la tipologia del dispositivo da realizzare ad hdd, che significa esclusivamente "immagine binaria per disco esterno" o file .img.

Il comando terminerà subito o quasi, ma si sarà preoccupato di costruire alcune cartelle all'interno della nostra live. Non resta che lanciare il comando fondamentale per costruire il tutto e cioè :

# lb build

e attendere un poco fino al prompt interattivo.

Il Prompt Interattivo

Ad un certo punto dell'esecuzione di lb build, che proseguirà a installare e configurare varie cose, appariranno tre righe :

P: Begin interactive build...
P: Pausing build: starting interactive shell...
(live)root@<hostname>:/#

Qui non siamo più nella nostra macchina, ma siamo già nel nuovo sistema operativo che stiamo installando. Ciò è possibile grazie al famoso chroot, uno dei comandi che i sistemisti arditi, amano di più.

Il chroot è eseguito automaticamente nella cartella che ora è /root/live/chroot e dove ha sede il sistema che stiamo costruendo ed è da qui che possiamo costruire tutto il resto.

Customizing

La prima cosa da fare è individuare un set di pacchetti adatti all'occasione.

Io procederò a realizzare una distribuzione con "Persistenza Parziale" e file system cryptato.

File System Criptato ?

Si, e il motivo è evidente. Dobbiamo tenere conto che la Memory Stick in qualsiasi forma essa sia, si può perdere molto più facilmente di un PC o la si può lasciare su un tavolo ed è quindi sempre opportuno criptarne i contenuti, specialmente se questo è facile come con Linux. Per questo introdurremo il pacchetto cryptosetup che useremo sul resto dello spazio a disposizione nella chiavetta.

 

 La lista dei pacchetti

Teniamo in considerazione che stiamo parlando di una live, quindi non potremo né aggiungere né aggiornare pacchetti dopo l'installazione.

Se in futuro avremo bisogno di qualche cosa, potremo in piccola parte rimediare col meccanismo della persistenza parziale (che vedremo) e poi ce la potremo annotare per la prossima riscrittura della chiavetta.

Visto che nel file di configurazione generale ho indicato xfce, adatto o inadatto a più o meno tutte le macchine, ho scelto la seguente lista dei pacchetti.

# apt-get install cryptsetup icedove iceweasel enigmail ffmpeg vlc mplayer mozilla-plugin-gnash libreoffice evince cpufreqd firmware-linux-nonfree wicd xfce4-terminal

ma voi potete fare come preferite, e lasciare che il comando poi faccia il suo corso.

Con lo stesso sistema possiamo configurare intere parti della nostra live ed in particolare implementare la persistenza parziale.

 

Persistenza Parziale

Nel mondo delle Live Linux ci sono quelle persistenti e quelle non persistenti.

Le prime usano come home per l'utente o per l'intero sistema un spazio opportunamente configurato sulla chiavetta. Personalmente non apprezzo molto questa soluzione, per due motivi :

1. La flash è un tipo di memoria a scritture limitate e pensare che mentre navigo, la cache del mio browser tortura lentamente la mia chiavetta mi da fastidio.
2. Uno dei motivi per cui prediligo una chiavetta ad un computer è che i dati che lasciano tracce come le cronologie di navigazione, i cookies, e la stessa cache, spariscono per sempre quando spengo la macchina.

Il secondo tipo di live, perdono tutto e hanno i seguenti difetti :

1. Ti obbligano a salvare ciò che non vuoi perdere sulla parte rimanente della chiavetta o su cloud ed è una operazione come minimo fastidiosa ma può diventare addirittura drammatica se hai fretta e non te lo ricordi.
2. La cosa più importante è che, con questo sistema, ogni modifica sarà persa per sempre e ciò non è una cosa buona, specialmente se vogliamo cambiare qualcosa senza rifare tutto da capo.

Per ovviare a questo inconveniente personalmente ho sempre seguito una terza strada che è quella che ho definito della "persistenza parziale" che assomiglia molto ad una live del secondo tipo (cioè senza persistenza) ma ha tre features fondamentali :

1. Monta automaticamente il resto della chiavetta che di solito è un file system sicuro e codificato, come parte integrante di quello corrente, lasciando uno spazio per aggiungere comandi e dati.
2. È in grado di eseguire uno script presente su questo file system che a sua volta può lanciare altri processi, creare links e modificare il sistema in base al contenuto della sua parte volatile. 
3. I link simbolici lanciati da questo script, con i giusti permessi, consentono anche di inserire nella home dell'utente ( che nelle live si chiama user ), una cartella persistente "Documents" scrivibile, o sostituire la cartella contenente la posta, le password di Firefox , e in generale tutto ciò che vogliamo tenere, direttamente sulla parte persistente della chiavetta e il bello è che tutto questo lo possiamo fare dinamicamente in un secondo momento. 

Implementare il tutto

Premesso che il file system,  userà cryptosetup e quindi sarà codificato, dobbiamo sceglierne il tipo.

Usando un file system che sfugge al sistema degli inodes, tipo fat32, troveremo diverse limitazioni, specialmente per quanto concerne links e files speciali.

Usando invece una normale struttura tipo ext3/ext4, che sono journalized , aumenteremo a dismisura la quantità di scritture sulla nostra povera chiavetta.

Andremo quindi ad usare un ext2 che provvederemo a far controllare dal sistema alla ripartenza, mediante l'apposita opzione in fstab.

A questo punto dobbiamo editare il file  /etc/crypttab che è l'impostazione del cryptosetup ma prima ci serve un UUID che useremo per il disco, sia durante questa fase, sia ancora più avanti per formattare la parte rimanente della chiavetta.

Lanciamo quindi il comando :

# uuidgen

che ci darà l'UUID nella classica forma Linux : 

XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX

Teniamo da parte questo valore che nelle nostre spiegazioni chiameremo <UUID> , conservandolo per esempio in una schermata di un editor di testo in un'altra finestra.

A questo punto si dovrà editare il file /etc/crypttab e inserirvi qualcosa tipo :

# <target name>    <source device>        <key file>    <options>
encrypted    UUID=<UUID>    none    luks

dove <UUID> è appunto quel valore.

Ora editiamo /etc/fstab che è vuota e scriviamo :

/dev/mapper/encrypted  /ext   ext2    noatime  0       1

Creiamo il punto di mount :

# mkdir /ext

E abbiamo così terminato le modifiche al sistema live per poter gestire il file system criptato, poi vedremo il dettaglio di come creare la partizione relativa.

La richiesta per "system.init"

Posto che ext sarà il punto di mount del file system codificato e residente nella seconda partizione che faremo nella chiavetta, chiederemo di lanciare al sistema (a livello root) un semplice script, ivi residente e che potremo modificare a nostro piacimento :

Il posto migliore dove lanciare questo script in modo che sia eseguito al boot è /etc/rc.local e quindi si può editare lo script in questo modo :

#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.

( . /ext/system.init )
exit 0

Teniamo in considerazione che nelle nuove versioni di Debian l'esecuzione degli script di partenza è parallela e quindi questo sarà eseguito parallelamente e non sequenzialmente al caricamento della parte grafica, ciò comporterà alcuni vantaggi e svantaggi.

Ora comunque terminiamo con un semplice :

# exit

e il sistema costruirà l'immagine del disco che ci serve.

Trasferimento su USB Dongle

Per il trasferimento su USB, abbiamo bisogno di una chiavetta USB che cancelleremo completamente e abbiamo bisogno assolutamente di individuare come si chiama il device fisico su cui è montata.

Se il computer su cui stiamo facendo le prove ha un solo disco, di solito questo si identifica in /dev/sda, per cui è pensabile che la chiavetta vada ad occupare /dev/sdb, come sulla mia macchina.

Per aumentarne la certezza è buona norma usare il comando :

# cat /proc/partitions

8        0  312581242 sda

...
11       0    1048578 sr0

che ci fornisce un elenco di tutti i dischi presenti sul computer in quel momento, con le relative partizioni.

Dopo avere inserito la chiavetta sacrificale (cioè che sarà cancellata) dovremmo vedere apparire almeno sdb ed eventualmente una o più partizioni sdb1,sdb2 ....

8       16    3922944 sdb
8       17     425952 sdb1

quella sarà la nostra chiavetta dal punto di vista fisico. A noi le partizioni non interessano perché le riscriveremo con un disk dump.

La chiavetta si identifica facilmente, anche perché il numerino che c'è prima del device è il numero di settori da 1K, in questo caso circa 4 milioni cioè 4 Giga.

Per intenderci, la chiamerò <device>, che nel mio caso è appunto /dev/sdb , mentre indicando <device>1, <device>2 ecc... , indicherò le singole partizioni /dev/sdb1, /dev/sdb2 eccetera. Voi le sostituirete col device che avete trovato.

Attenzione perché di solito quando inserite la chiavetta a desktop attivo, questa ha la buona abitudine di apparire sul desktop stesso. La mossa giusta è non rimuoverla con il desktop, altrimenti rischia di sparire dal sistema ma smontare singolarmente le varie partizioni da linea di comando e cioè, visto che avete già aperto un terminale dare :

# umount <device>1...n

ossia :

# umount /dev/sdb1
# umount /dev/sdb2
...

e se avete centrato la chiavetta, le iconcine dovrebbero sparire dal vostro desktop, così avrete una ulteriore conferma di quale sia il vostro <device>.

Se tutto è andato bene, nella cartella live, troveremo ora un file piuttosto voluminoso e chiamato binary.img dell'ordine di qualche centinaio di megabytes, a seconda dei pacchetti che avete installato.

Quello è il file che dovremo copiare fisicamente e questa operazione va svolta come ho già detto, CON LA MASSIMA ATTENZIONE !!!, perché se sbagliate device, porterà inevitabilmente alla cancellazione del disco sbagliato, con tutte le conseguenze del caso.

Per farlo useremo il famigerato disk dump dd , che penso sia il comando più pericoloso che abbiamo a disposizione nel sistema, visto che da solo può far saltare l'intero contenuto del disco, senza possibilità di recupero.

Noi operiamo in questo modo, dalla cartella live :

# dd if=binary.img of=<device>

cioè eseguiamo un dump fisico dell'immagine sul device che nel mio caso è /dev/sdb come ho già più volte detto (non indicate alcuna partizione ma il device generico).

Ci vorrà un pochino e se avete una chiavetta con il LED, vedrete anche la lucina lampeggiare.

Cryptosetup

Dopo l'operazione di trasferimento, è il momento di creare la famosa partizione codificata, quindi rimuovete la chiavetta e reinseritela.

Dovreste vedere apparire sul computer un disco chiamato : "DEBIAN_LIVE" che dovrete smontare sempre da linea di comando, dovrebbe essere la partizione 1 e quindi date :

# umount <device>1

che nel mio caso è umount /dev/sdb1.

Fatto sparire dal file system il mount del dispositivo, possiamo usare il comando cfdisk, in questo modo :

# cfdisk <device>

cfdisk, è un programma scritto con le curses, e quindi sarà a pieno schermo terminale in formato testo e quindi relativamente facile da usare, non sto a spiegare come funziona nel dettaglio visto che, se avete resistito fino a qui, probabilmente per voi non sarà un problema.

Dovreste vedere la partizione 1 che è una fat32, come avete indicato precedentemente. Andate quindi sullo spazio libero e create una nuova partizione 2, che occupi tutto lo spazio restante a partire dall'inizio e indicando come tipologia del file system il formato ext2 ma non create alcun file system.

Le nuove versioni di cfdisk richiedono il "Commit" prima del Quit , per convalidare le modifiche, fate pure.

Ora, anche senza riavviare se date il famoso comando :

# cat /proc/partitions

dovreste vedere oltre che il device anche due partizioni, cioè nel mio caso /dev/sdb, /dev/sdb1 e /dev/sdb2.

Dopo aver creato la partizione, bisogna prima formattarla in modo codificato e poi mettevi il file system ext2,

Alcuni suggeriscono di introdurre il comando opzionale :

# dd if=/dev/urandom of=<device>2 

Che sostituisce ai tranquilli bytes pre-formattati, della nostra chiavetta, una sequenza casuale di valori, allo scopo di rendere indistinguibili i blocchi codificati dal "background" e aumentarne così la sicurezza. Se volete fate pure ma ricordate che cryptosetup usa per lo meno CBC a differenza del vecchio EBC, quindi è molto meno sensibile agli attacchi sui patterns. Se invece non avete capito di cosa sto parlando, lasciate perdere e state tranquilli.

L'operazione suddetta comunque è lunghetta e occupa parecchi minuti anche su chiavette di piccole dimensioni.

Ora, comunque, è il momento di ripescare l'UUID che avevate salvato nell'editor e inserirlo nel seguente comando :

# cryptsetup luksFormat <device>2 --uuid="<UUID>"

quindi seguire le indicazioni.

Vi verrà chiesta una password che sarà la password unica della chiavetta.

Attenzione perché se la dimenticate, non ci sarà più alcun modo di accedere ai vostri dati, visto che per fortuna non è salvata da nessuna parte.

A questo punto "apriamo" il device in questo modo :

# cryptsetup luksOpen <device>2 encrypted

e poi, dopo avere dato la password per sbloccare il device, creiamo il file system ext2  con :

# mkfs.ext2 /dev/mapper/encrypted

e infine chiudiamo con :

# cryptsetup luksClose encrypted

e dovremmo avere terminato.

Riavviamo la macchina e facciamo boot dalla chiavetta.

Nota : Poiché tutte le volte che rifacciamo la procedura, dal primo disk dump , dobbiamo cancellare l'intero contenuto della chiavetta, per eventuali aggiornamenti, consiglio : per prima cosa di aprire il file system codificato ( dovrebbe bastare inserirla su una macchina con Linux e attendere la richiesta del computer ),  poi salvare il tutto in un bel tar col preserve dei permessi e quindi richiudere per poi ricostruire tutto in seguito, montando temporaneamente il file system ed espandendovi il tar prima di chiudere con luksClose.

Aggiustare /ext

Una volta fatto ripartire il sistema, il boot si fermerà ad un certo punto chiedendoci di inserire una password, che sarà quella che abbiamo inserito per il file system codificato, da montare automaticamente in /ext.

Se tutto va bene entrando nella cartella /ext dovremmo trovare la famosa "lost+found".

Ora possiamo diventare root, con sudo bash  (senza password) e iniziare a modificare.

Entriamo nella cartella /ext ed eseguiamo :

# cd /ext
# mkdir bin etc lib sbin share init var

Per creare un po` di cartelle. 

Poi c'è lo script /ext/system.init che può essere realizzato sullo stile del "profile" così :

#!/bin/sh
for i in /ext/init/*
do
 ( . $i )
done

in questo modo ogni script inserito nella cartella init, sarà eseguito e attingendo alle varie informazioni, contenute nelle altre cartelle montate sotto /ext, potrà modificare a piacimento il sistema all'atto dello startup.

Varie ed eventuali 

Una delle cose che faccio fare al mio sistema quando riparte, è quello di ripristinare nella cartella /home/user, un tar dell'intero contenuto della mia user e alcuni links, in modo che il sistema riparta, non nello stato di default con l'orribile "ratto" di xfce , ma in modo esteticamente più accettabile ( per quanto possibile).

Mettendo alcune voci .desktop in .local/share/applications ho poi arricchito i menù con programmi che stanno in /ext/bin e il .profile, fa in modo che tali directory siano anche nel PATH.

Ho anche uno script che installa il pacchetto " tor ", preso direttamente dal sito, e aggiornato di volta in volta nella parte scrivibile, estraendo semplicemente il tar e giochicchiando con processi e iptables, per vincolare la connessione di rete all'exclusivo passaggio dal proxy.

Di fatto una distribuzione volatile, con i dati criptati e tor , non è proprio identica a quell'affascinante progetto del famoso romando di Cory Doctorow e denominato Paranoid Linux ma è comunque un sistema più che decente, perché sta su una chiavetta, non mantiene memoria di ciò che fate a meno che non lo vogliate e lo potete portare sempre con voi in un portachiavi.

In ogni caso potremo fare tutte le modifiche che vogliamo, sia dinamicamente che in ulteriori versioni, creare le live utili per la diagnostica anche di Windows ( c'è un apposito package list per questo detto : debian-forensics ) o accedere ai vari clouds (anche in questo caso troviamo una package list detta : ubuntu-cloud ) .

Una volta che abbiamo capito come funziona, il tutto diventa facile.

Aggiornamento

 

Xfce Forensics

Tra i packages a disposizione, c'è debian-forensics, una comoda distribuzione per l'analisi dei problemi del disco e altre cose divertenti.

Come variazione sul tema, anche per spiegare come agire nel caso non si voglia il file system codificato, realizzerò una xfce-forensics , facilmente applicabile ad ogni computer e utile per eseguire qualsiasi tipo di operazione di copia e controllo anche della rete.

Fino al Prompt

La procedura iniziale è esattamente la stessa, con il solito comando lb config che installa xfce :

# lb config -a i386 --binary-filesystem fat32 --distribution wheezy --debian-installer false --archive-areas "main contrib non-free" --package-lists xfce  --interactive shell -b hdd

e il conseguente :

lb build 

fino al famoso prompt.

Ciò che cambia è la lista dei pacchetti che per far le cose in grande diventa :

# apt-get install cryptsetup-bin encfs zenity icedove iceweasel enigmail ffmpeg vlc mplayer mozilla-plugin-gnash libreoffice evince cpufreqd firmware-linux-nonfree wicd xfce4-terminal python ext3grep galleta gpart wireshark tcpdump  grokevt memdump missidentify myrescue pasco reglookup scrounge-ntfs sleuthkit ssdeep tableau-parm unhide wipe aesfix aeskeyfind afflib-tools chaosreader ed2k-hash guymager ewf-tools libguytools2 libphash0 md5deep nasty pipebench recoverdm rifiuti rifiuti2 safecopy shed drbl parted gparted sleuthkit system-tools-backends nfdump-flow-tools dff dcfldd autopsy dc3dd scalpel vinetto hfsplus iproute iptables nmap iptraf discover harden-remoteaudit doscan ssh

così dovrebbe bastare  ;)  per un buon rescue-disk, utile in caso di backup e crash di sistema, anche per andare ad indagare sulle possibili cause e recuperare dati fisicamente dal disco.

Unencrypted File System

Nel caso della xfce-forensics e in molti altri casi, è scomodo dover inserire la password all'inizio, specie se si tratta di una chiavetta diagnostica, dove la partizione in più ci serve solo per comodità e non per tenerci dati privati.

Dunque la scelta più ovvia è non usare il cryptosetup , infatti nella lista dei pacchetti c'è solo la versione bin che ci serve per accedere ai dati, senza gli script di partenza e la procedura ovviamente cambia.

Infatti qui non abbiamo più la /etc/crypttab che di fatto costruiva un device virtuale sul nostro device fisico, ma agiamo direttamente su /etc/fstab indicando il device fisico  :

/etc/fstab :

UUID=<UUID>  /ext   ext2    noatime  0       1

a questo punto, alla fine della procedura quando creeremo il file system ext2, invece di usare cryptosetup format .... ,  andremo direttamente a creare il file system con il codice UUID corretto in questo modo :

# mkfs.ext2 <device>2 -U "<UUID>"

Con questo trucco, analogamente a come accadeva prima, alla ripartenza il sistema cercherà il device in base all'UUID e lo monterà in automatico di conseguenza, solo che questa volta non dovrà essere prima decifrato e non sarà richiesta alcuna password.

Due parole finali sull'UUID

È importante comprendere l'importanza dell'UUID, che spiega anche il motivo della sua introduzione nel mondo Linux, avvenuta col proliferare di dischi e unità aggiuntive.

Se usassimo il device fisico in base alle caratteristiche del portatile su cui andiamo ad inserire la chiavetta, ad esempio /dev/sdb , ci troveremmo in serie difficoltà non solo su altre macchine con un numero di dischi diverso, ma anche sullo stesso portatile, aggiungendo per esempio temporaneamente un disco esterno USB che ci va ad occupare sdb. Sia chiaro che esistono metodi alternativi, tipo andare a vedere dalla mtab il device fisico della chiavetta ma questo è per me un buon sistema, anche perché fa tutto in automatico.

Nel caso del file system codificato, il sistema è anche piuttosto sicuro, visto che l'eventuale spoofing, dell'UUID del disco richiederebbe anche di conoscere la password del volume che l'utente sta inserendo, mentre nel caso di un file system in chiaro è relativamente facile ma non serve a nulla, dato l'utilizzo dell'oggetto in se.