Eliminare richiesta passphrase all'avvio

[marfeca94]

Salve ho istallato Ubuntu e in fase di istallazione mi ha chiesto ( così credo perchè non ricordo benissimo) una password per la sicurezza.
Ora una volta terminata l'istallazione al ravvio, il sistema mi dice "unlocking the disk/dev/disk/by......." e di digitare la passphrase.
La password è la stessa del mio account quindi riesco ad entrare però vorrei togliere questa richiesta.
Come posso procedere?

Grazie

Federico

[giulux]

Se, come mi sembra di capire, hai scelto di criptare la partizone è ovvio che ti chieda la pass w dubito che tu possa eliminarne la richiesta (ma su questo aspetta il parere di qualcun altro, non ho esperienza nel campo)

[zdf_9]

Puoi usare una chiavetta esterna (o uno piccolissimo spazio nel tuo HD non utilizzato) in cui nascondi una chiave che decrypta l'intero FS all'avvio di ubuntu.

La soluzione più semplice sarebbe quella di editare solo il file /etc/crypttab in modo da far caricare la chiave su un dispositivo esterno (o partizione nascosta), ma da quello che ho capito c'è un bug nell'opzione timeout di luks... se perdi o modifichi i dati nella partizione della chiavetta non puoi più accedere al sistema (non ti chiederà mai più la password).

Ma in rete ho trovato un modo che ti permette di poter accedere in entrambi i modi (password o chiavetta)...
Guarda il paragrafo"USB Master Key" in http://www.cheshirekow.com/wordpress/?p=810

Sto finendo di scrivere uno script che automatizza il tutto... domani lo posto.

[Edit]:
Mi stavo dimenticando di dirti che la pagina che ti ho segnalato ha un errore di battitura nella riga:

Codice: Seleziona tutto

cryptsetup luksAddKey /dev/sdb1 keymaster_root.key

Al posto di "/dev/sdb1" devi mettere il device della partizione cryptata.

[zdf_9]

In fondo a questo post troverai lo script.

Prima di procedere dovrai EFFETTUARE UN BACKUP dei dati importanti, controllare la partizione che ubuntu usa come "root" e crearti una partizione nascosta delle giuste dimensioni.

Per controllare la partizione di "root", leggi il contenuto del file "/etc/crypttab".
Se il file contiene solo la riga:

Codice: Seleziona tutto

# <target name> <source device>         <key file>      <options>

non eseguire lo script.
Se hai effettuato un'installazione "standard", la partizione che dovrei usare nello script è "/dev/sda5"...

Dovrai creare una nuova partizione su una chiavetta oppure modificando le partizioni nel tuo HD.
Questo è il passaggio più delicato... bisogna impostare la nuova partizione come tipo "Empty".
In questa nuova partizione non viene creato nessun FileSystem, la chiave viene scritta direttamente nella partizione..
I dati in essa contenuti saranno persi.
Modifica il valore della variabile K_SDXY di conseguenza.

Nei comandi dell'url viene usata una chiave da 512 byte, io ho provato con una da 4096 e funziona ugualmente.
Prima di eseguire lo script come utente root (sudo -i), controlla le variabili che troverai in testa al file.

Lo script non accetta parametri, quindi dovrai modificarlo direttamente con un editor.
Lo script ti chiederà di commentare la riga originale del file "/etc/crypttab", e la passphrase per aggiungere la nuova chiave alla partizione cryptata.

Se hai dubbi o domande non eseguire lo script... chiedi chiarimenti.

Ecco lo script:

Codice: Seleziona tutto

#!/bin/bash
# script basato su comandi trovati alla pagina url:
# http://www.cheshirekow.com/wordpress/?p=810
# versione 03
#
# PRIMA DI ESEGUIRE LO SCRIPT, EFFETTUARE UN BACKUP DEI DATI
#
# lo script dovra' essere eseguito come utente "root".
#
# controllare il valore della variabile R_SDXY
# la partizione "/" del SO criptato (di solito è "/dev/sda5")
# per sicurezza controllare il contenuto del file "/etc/crypttab"

# modificare il valore della variabile K_SDXY
# la partizione indicata dovra' essere 'nascosta' e di dimensione adeguata (lo script non verifica queste due condizioni).
# prima di copiarvi la chiave (senza usare nessun FS) verra' riempita di numeri urandom,
# di conseguenza, se la partizione contiene dati essi saranno persi.

# modificare il valore della variabile K_LEN
# nei comandi dell'url originale viene usato 512
#
# se presente il file K_FILE_READ, il suo contenuto verrà usato come chiave.
# nel caso non esistesse, lo script lo crea e lo popola usando i valori di "/dev/random"
# di conseguenza sara' un'operazione che richiedera' molto tempo.


R_SDXY="sda5"
K_SDXY="sdz9"
K_POSIZIONE=7
K_DELETE=0
K_LEN=4096

K_FILE_READ="key-master.dd"
K_FILE_USE="/tmp/key-tmp-to-kill.dd"

if [ ! -b /dev/$R_SDXY ]; then
  echo "Il device /dev/$R_SDXY non esiste o non è un dispositivo a blocchi"
  exit 1
fi

if [ ! -b /dev/$K_SDXY ]; then
  echo "Il device /dev/$K_SDXY non esiste o non è un dispositivo a blocchi"
  exit 2
fi

aggiungiRigaSeNonEsiste(){
if [ ! `grep -e "${1}" "${2}"` ]; then
  echo "${1}" >> "${2}"
fi
}

crea__etc__initramfs-tools__hooks__usb_keymaster(){
cat <<'EOF' > /etc/initramfs-tools/hooks/usb_keymaster
#!/bin/sh
#/etc/initramfs-tools/hooks/usb_keymaster

PREREQ=""

prereqs() {
  echo "$PREREQ"
}

case "$1" in
  prereqs)
    prereqs
    exit 0
  ;;
esac

. "${CONFDIR}/initramfs.conf"
. /usr/share/initramfs-tools/hook-functions

copy_exec /sbin/usb_keymaster /sbin
EOF
}

crea__sbin__usb_keymaster(){
cat <<'EOF' >/sbin/usb_keymaster
#!/bin/sh
#/sbin/usb_keymaster

# define counter-intuitive shell logic values (based on /bin/true & /bin/false)
# NB. use FALSE only to *set* something to false, but don't test for
# equality, because a program might return any non-zero on error
TRUE=0
FALSE=1

# set DEBUG=$TRUE to display debug messages, DEBUG=$FALSE to be quiet
DEBUG=$TRUE

# default path to key-file on the USB/MMC disk
KEYFILE=".keyfile"

# maximum time to sleep waiting for devices to become ready before
# asking for passphrase
MAX_SECONDS=2

# is plymouth available? default false
PLYMOUTH=$FALSE
if [ -x /bin/plymouth ] && plymouth --ping; then
    PLYMOUTH=$TRUE
fi

# is usplash available? default false
USPLASH=$FALSE
# test for outfifo from Ubuntu Hardy cryptroot script, the second test
# alone proves not completely reliable.
if [ -p /dev/.initramfs/usplash_outfifo -a -x /sbin/usplash_write ]; then
    # use innocuous command to determine if usplash is running
    # usplash_write will return exit-code 1 if usplash isn't running
    # need to set a flag to tell usplash_write to report no usplash
    FAIL_NO_USPLASH=1
    # enable verbose messages (required to display messages if kernel boot option "quiet" is enabled
    /sbin/usplash_write "VERBOSE on"
    if [ $? -eq $TRUE ]; then
        # usplash is running
        USPLASH=$TRUE
        /sbin/usplash_write "CLEAR"
    fi
fi

# is stty available? default false
STTY=$FALSE
STTYCMD=false
# check for stty executable
if [ -x /bin/stty ]; then
    STTY=$TRUE
    STTYCMD=/bin/stty
elif [ `(busybox stty >/dev/null 2>&1; echo $?)` -eq $TRUE ]; then
    STTY=$TRUE
    STTYCMD="busybox stty"
fi

# print message to usplash or stderr
# usage: msg <command> "message" [switch]
# command: TEXT | STATUS | SUCCESS | FAILURE | CLEAR (see 'man usplash_write' for all commands)
# switch : switch used for echo to stderr (ignored for usplash)
# when using usplash the command will cause "message" to be
# printed according to the usplash <command> definition.
# using the switch -n will allow echo to write multiple messages
# to the same line
msg ()
{
    if [ $# -gt 0 ]; then
        # handle multi-line messages
        echo $2 | while read LINE; do
            if [ $PLYMOUTH -eq $TRUE ]; then
                # use plymouth
                plymouth message --text="$LINE"
            elif [ $USPLASH -eq $TRUE ]; then
                # use usplash
                /sbin/usplash_write "$1 $LINE"
            else
                # use stderr for all messages
                echo $3 "$2" >&2
            fi
        done
    fi
}

dbg ()
{
    if [ $DEBUG -eq $TRUE ]; then
        msg "$@"
    fi
}

# read password from console or with usplash
# usage: readpass "prompt"
readpass ()
{
    if [ $# -gt 0 ]; then
        if [ $PLYMOUTH -eq $TRUE ]; then
            PASS="$(plymouth ask-for-password --prompt "$1")"
        elif [ $USPLASH -eq $TRUE ]; then
            usplash_write "INPUTQUIET $1"
            PASS="$(cat /dev/.initramfs/usplash_outfifo)"
        else
            [ $STTY -ne $TRUE ] && msg TEXT "WARNING stty not found, password will be visible"
            /lib/cryptsetup/askpass "$1"
            # echo -n "$1" >&2
            # $STTYCMD -echo
            # read -r PASS </dev/console >/dev/null
            # [ $STTY -eq $TRUE ] && echo >&2
            # $STTYCMD echo
        fi
    fi
    echo -n "$PASS"
}

dbg STATUS "Executing usb_keymaster ..."

# flag tracking key-file availability
OPENED=$FALSE

for TRY in 1 2 3 4 5 6 7 8 9
do
  if ! [ -e "${CRYPTTAB_KEY}" ]; then
    dbg TEXT "Waiting for USB stick to be recognized [${TRY}]"
    sleep 1
  fi
done # for TRY
if [ -e "${CRYPTTAB_KEY}" ]; then
  dd if="${CRYPTTAB_KEY}" bs=1 skip=0 count=MY_K_LEN 2>/dev/nul
  OPENED=$TRUE
fi


# clear existing usplash text and status messages
[ $USPLASH -eq $TRUE ] && msg STATUS "                               " && msg CLEAR ""

if [ $OPENED -ne $TRUE ]; then
  # dbg TEXT "Failed to find suitable USB/MMC key-file ..."
  readpass "$(printf "Unlocking the disk $CRYPTTAB_SOURCE ($CRYPTTAB_NAME)\nEnter passphrase: ")"
else
  # dbg TEXT "Success loading key-file from $SFS ($LABEL)"
  # msg TEXT "Unlocking the disk $CRYPTTAB_SOURCE ($CRYPTTAB_NAME)"
  msg "Unlocking ${CRYPTTAB_SOURCE} (${CRYPTTAB_NAME}) from USB key"
fi

#
[ $USPLASH -eq $TRUE ] && /sbin/usplash_write "VERBOSE default"
EOF

#aggiorno valore della variabile $K_LEN nel file appena creato
sed -i "s/MY_K_LEN/$K_LEN/" /sbin/usb_keymaster
}

#--- INIZIO EFFETTIVO SCRIPT ---

if [ ! -e ${K_FILE_READ} ]; then
  echo "Genero la chiave ${K_FILE_READ}... attendere (per velocizzare, creare entropia)"
  dd if=/dev/random of=${K_FILE_READ} bs=1 count=$K_LEN
fi

echo "Copio la chiave"
if [ $(stat -c%s ${K_FILE_READ}) -ge $(($K_LEN)) ]; then
  cp ${K_FILE_READ} ${K_FILE_USE}
  truncate -s ${K_LEN} ${K_FILE_USE}
else
  echo "La dimensione del file con la chiave è minore di $K_LEN bytes"
  echo "Blocco lo script"
  exit 4
fi

echo "Aggiungo la chiave a luks"
cryptsetup luksAddKey --key-slot ${K_POSIZIONE} /dev/${R_SDXY} ${K_FILE_USE}
if [ "$?" != "0" ]; then
  echo "Blocco lo script"
  shred --remove --zero ${K_FILE_USE}
  exit 3
fi

echo "Genero e scrivo numeri urandom su /dev/${K_SDXY}"
dd if=/dev/urandom of=/dev/${K_SDXY} bs=512

echo "Copio la chiave su /dev/${K_SDXY}"
dd if=${K_FILE_USE} of=/dev/${K_SDXY} bs=1

R_UUID=$(eval ls -l /dev/disk/by-uuid | grep $R_SDXY | awk '{print $9}')
K_IDS=$(eval ls -l /dev/disk/by-id | grep $K_SDXY | awk '{print $9}')
K_ID=$(eval echo ${K_IDS} | awk '{print $1}')

echo "* Controllare l'esattezza della nuova riga e commentare quella originale"
echo "#controllare la riga seguente - commentare il riferimento originale" >> /etc/crypttab
echo "${R_SDXY}_crypt UUID=${R_UUID} /dev/disk/by-id/${K_ID} luks,keyscript=/sbin/usb_keymaster" >> /etc/crypttab
nano /etc/crypttab

echo "Creo il file /sbin/usb_keymaster"
crea__sbin__usb_keymaster
chown root:root /sbin/usb_keymaster
chmod +x /sbin/usb_keymaster

echo "Creo il file /etc/initramfs-tools/hooks/usb_keymaster"
crea__etc__initramfs-tools__hooks__usb_keymaster
chown root:root /etc/initramfs-tools/hooks/usb_keymaster

echo "Aggiungo i nuovi moduli a initramfs"
aggiungiRigaSeNonEsiste "uhci_hcd" /etc/initramfs-tools/modules
aggiungiRigaSeNonEsiste "ehci_hcd" /etc/initramfs-tools/modules
aggiungiRigaSeNonEsiste "usb_storage" /etc/initramfs-tools/modules

sync
sleep 5s
echo "update-grub"
update-grub
sleep 5s
echo "update-initramfs"
update-initramfs -u
sync

echo
if [ $((K_DELETE)) -eq 0 ]; then
  echo "Il file usato come chiave è ${K_FILE_USE} non è stato cancellato."
  echo "Per sicurezza puoi copiarlo in un luogo sicuro"
else
  shred --remove --zero ${K_FILE_USE}
  echo "Il file usato come chiave ${K_FILE_USE} è stato cancellato in modo sicuro"
fi

echo
echo "Il file con la chiave master ${K_FILE_READ} non è stato cancellato"

Edit: aggiunta cancellazione dell'intera partizione che conterrà al chiave con valori /dev/urandom

Edit2: modificate righe nello script dove venivano create le variabili R_UUID e K_ID