> ## Content Index > Fetch the complete content index at: https://www.cowsayso.com/llms.txt > Use this file to discover other available public pages before exploring further. # Cifrate tutto: alternative a VeraCrypt su Linux, provate sui segreti di una mucca - URL: https://www.cowsayso.com/it/cifratura-linux-alternative-veracrypt/ - Published: 2025-10-10T07:00:00.000Z - Updated: 2026-11-09T06:29:25.000Z - Description: LUKS, gocryptfs, age e GnuPG per cifrare dischi, cartelle e file su Linux, più scp, magic-wormhole e rclone crypt per spedirli, con ogni comando eseguito davvero sui dati più (poco) importanti di una mucca. - Author: Vittorio Scala - Tags: Linux, Security, #whole-milk, #it La mucca Ercolina ha dei dati. Dati preziosi. Dati che, nelle mani sbagliate, potrebbero far cadere governi: una ricetta segreta, una password, un diario, un tiramisù e la formazione del fantacalcio. Oggi li cifriamo tutti, su Linux, senza VeraCrypt, e poi ne mandiamo un po’ all’amica Pina senza che il postino, il cloud o il Wi-Fi del bar possano leggerne una parola. Questo è un articolo a latte intero: tanto terminale. Ogni comando è stato eseguito davvero, su Debian 13, con cryptsetup 2.7, gocryptfs 2.5, age 1.2, GnuPG 2.4, magic-wormhole 0.18 e rclone 1.60, su due macchine chiamate `barn` (la stalla di Ercolina) e `farm` (la fattoria di Pina). Gli output sono quelli veri: abbiamo tolto solo qualche riga di rumore dei nostri container di prova, e i file hanno nomi inglesi perché le mucche, si sa, sono internazionali. Le passphrase che vedete sono solo dimostrative: per favore non usate `correct-horse-battery-moo`. Da oggi è la passphrase meno segreta di internet. ## Prima di tutto: cos’ha che non va VeraCrypt? Niente, in realtà. VeraCrypt è un fork di TrueCrypt, rilasciato per la prima volta nel giugno 2013 da Mounir Idrassi di IDRIX. Un anno dopo, il 28 maggio 2014, TrueCrypt fu abbandonato in circostanze misteriose, e VeraCrypt ne diventò l’erede naturale. Nel 2016 è stato sottoposto a un audit di QuarksLab, ha corretto i problemi trovati, e gira anche su Linux. Ma su Linux VeraCrypt è un ospite. La casa ha già i suoi attrezzi, nel kernel o nei pacchetti della distribuzione, ognuno specializzato: uno per i dischi, uno per le cartelle, uno per i singoli file, uno per spedire. E per giunta `cryptsetup`, il primo che vedremo, sa aprire anche i vecchi volumi TrueCrypt e VeraCrypt (`cryptsetup open --type tcrypt`): cambiare non vuol dire lasciare indietro niente. 🐄 La mucca dice: un buon attrezzo che fa tutto va bene. Quattro attrezzi piccoli che fanno bene una cosa ciascuno, quello è Linux. Scegliete in base al lavoro, non all’abitudine. ## Da cosa vi protegge la cifratura (e da cosa no) Prima di scrivere qualsiasi cosa, la domanda che nessuno si fa: da chi vi state nascondendo? La cifratura del disco protegge i dati *a riposo*: un portatile rubato da spento, una chiavetta dimenticata sul treno, un disco buttato senza cancellarlo. Chi lo trova vede solo rumore. **Non** protegge un computer acceso e sbloccato. Una volta inserita la passphrase, i dati sono leggibili da voi, dai vostri programmi e da qualunque malware giri con il vostro utente. La cifratura è la serratura della porta, non la guardia del corpo in salotto. 🐄 Lasciare il portatile sbloccato al bar mentre prendete il cappuccino, «tanto il disco è cifrato». **Sbagliato.** Un disco cifrato e sbloccato è un libro aperto con una copertina molto costosa. ## LUKS: la cassaforte di serie di Linux LUKS (Linux Unified Key Setup) è stato creato da Clemens Fruhwirth nel 2004 ed è *lo* standard per cifrare i dischi su Linux. Lo strumento che usate è `cryptsetup`; la cifratura vera la fa `dm-crypt`, nel kernel. È la cosa più vicina a un volume VeraCrypt, e da cryptsetup 2.1 il formato predefinito è LUKS2. ### Il modo più facile: in installazione Se state installando Linux su un portatile, la cifratura migliore è quella a cui non dovete pensare. L’installer di Debian, nel partizionamento guidato, propone di usare tutto il disco con LVM cifrato, e quello di Ubuntu ha un’opzione equivalente. Una passphrase all’avvio, e i vostri dati sono cifrati. 🐄 Cifrare il disco del portatile quando installate il sistema. **Giusto.** Costa una spunta nell’installer e una passphrase a ogni avvio. Farlo dopo costa un weekend e un backup. ### Una cassaforte in un file Per l’esperienza alla VeraCrypt, cioè un file che contiene un disco cifrato, LUKS funziona anche su un file normale. Tutto quello che c’è in questa sezione si esegue da root (o mettendo `sudo` davanti). Prima creiamo un file da 64 MB e lo formattiamo come LUKS: ```bash # fallocate -l 64M secrets.img # cryptsetup luksFormat secrets.img WARNING! ======== This will overwrite data on secrets.img irrevocably. Are you sure? (Type 'yes' in capital letters): YES Enter passphrase for secrets.img: Verify passphrase: ``` Poi lo apriamo (compare come disco virtuale in `/dev/mapper/vault`), creiamo un filesystem, lo montiamo e ci mettiamo dentro il documento più prezioso di Ercolina: la ricetta segreta del latte. ```bash # cryptsetup open secrets.img vault Enter passphrase for secrets.img: # mkfs.ext4 -q /dev/mapper/vault # mkdir -p /mnt/vault && mount /dev/mapper/vault /mnt/vault # echo '1. Eat grass. 2. Wait. 3. Milk.' > /mnt/vault/secret_recipe.txt # ls /mnt/vault lost+found secret_recipe.txt # umount /mnt/vault # cryptsetup close vault ``` Sì, la ricetta del latte è «mangia l’erba, aspetta». La conoscono tutte le mucche. Resta comunque il documento più riservato della stalla, e merita una cifratura di livello militare. Controlliamo che nel file non ci sia in chiaro: ```bash # grep -c 'Eat grass' secrets.img 0 # xxd -l 16 secrets.img 00000000: 4c55 4b53 babe 0002 0000 0000 0000 4000 LUKS..........@. ``` Zero risultati. L’unica cosa leggibile è la firma `LUKS` all’inizio: il file dichiara apertamente di essere cifrato, ma non cosa contiene. Guardiamo dentro l’intestazione: ```bash # cryptsetup luksDump secrets.img LUKS header information Version: 2 [...] Data segments: 0: crypt offset: 16777216 [bytes] length: (whole device) cipher: aes-xts-plain64 sector: 4096 [bytes] Keyslots: 0: luks2 Key: 512 bits Priority: normal Cipher: aes-xts-plain64 Cipher key: 512 bits PBKDF: argon2id Time cost: 21 Memory: 238814 Threads: 4 [...] ``` Due cose da sapere. I dati sono cifrati con AES in modalità XTS, con una chiave da 512 bit (due chiavi AES da 256 bit, come richiede XTS). E la vostra passphrase non cifra direttamente i dati: passa per **Argon2id**, una funzione volutamente lenta e golosa di memoria, per sbloccare uno slot che contiene la chiave vera. cryptsetup chiede ad Argon2id fino a 1 GiB di memoria e circa due secondi di lavoro per ogni tentativo; il nostro piccolo server di prova aveva meno memoria libera, quindi si è accontentato di circa 233 MB. È questo che rende dolorosi i tentativi di indovinare la passphrase: ogni singola prova costa all’attaccante la stessa fatica. ### Chiavi di riserva e intestazione Siccome la chiave vera è separata dalla passphrase, potete avere più passphrase (LUKS2 ha fino a 32 slot), per esempio una di riserva da tenere in un posto sicuro. E dovete **fare il backup dell’intestazione**: ```bash # cryptsetup luksAddKey secrets.img Enter any existing passphrase: Enter new passphrase for key slot: Verify passphrase: # cryptsetup luksDump secrets.img | grep -E '^ [0-9]: luks2' 0: luks2 1: luks2 # cryptsetup luksHeaderBackup secrets.img --header-backup-file secrets-header.img # du -h secrets-header.img 16M secrets-header.img ``` Il manuale di cryptsetup non usa giri di parole: se l’intestazione di un volume LUKS si danneggia, tutti i dati sono persi per sempre, a meno di avere un backup dell’intestazione. Pochi kilobyte rovinati all’inizio del disco, e il resto è rumore per l’eternità. Tenete il backup altrove, e ricordate che si apre con le passphrase valide nel momento in cui l’avete fatto. 🐄 Fare il backup dell’intestazione LUKS e tenerlo fuori dal disco cifrato. **Giusto.** Sono 16 MB che vi separano da un disco pieno di byte casuali, cifrati alla perfezione e perfettamente inutili. ## gocryptfs: una cartella cifrata, file per file LUKS ha un problema con il cloud. Se mettete in Dropbox un contenitore cifrato da 1 GB e cambiate una riga di un file, il programma di sincronizzazione vede un blob da 1 GB modificato. gocryptfs lo risolve cifrando *ogni file separatamente*, nomi compresi. È nato ispirandosi a EncFS, con l’obiettivo di correggerne i difetti di sicurezza; è arrivato alla versione 1.0 nel luglio 2016, e il suo progetto crittografico è stato esaminato da Taylor Hornby nel 2017\. Funziona nello spazio utente con FUSE: niente root. ```bash $ mkdir vault.enc vault $ gocryptfs -init vault.enc Choose a password for protecting your files. Password: Repeat: Your master key is: f04b5a2c-e9d3d500-d8069602-af81a998- 9ae78829-586598a1-205edcf1-8bd6df41 If the gocryptfs.conf file becomes corrupted or you ever forget your password, there is only one hope for recovery: The master key. Print it to a piece of paper and store it in a drawer. This message is only printed once. The gocryptfs filesystem has been created successfully. You can now mount it using: gocryptfs vault.enc MOUNTPOINT ``` Sì, abbiamo appena pubblicato su internet la nostra chiave principale. Protegge il diario di una mucca, e siamo pronti ad affrontarne le conseguenze. Voi invece fate esattamente quello che dice: stampatela e mettetela in un cassetto, perché se dimenticate la password è l’unica strada per tornare indietro. Ora la montiamo e ci trasferiamo i secondi dati più preziosi di Ercolina: la sua unica password, il diario e un album di foto. ```bash $ gocryptfs vault.enc vault Password: Decrypting master key Filesystem mounted and ready. $ echo 'moo123' > vault/passwords.txt $ echo 'Dear diary, today I ate grass.' > vault/diary.txt $ mkdir vault/photos && echo jpeg > vault/photos/me_in_the_meadow.jpg $ ls vault diary.txt passwords.txt photos $ ls vault.enc IOH1OaNoHynzsrt6kGTruQ gocryptfs.conf s-en7POhG6H0wPSm0d2v_Q gaJDrpg_xigkGQ4N-KTB-A gocryptfs.diriv $ fusermount -u vault $ ls vault $ ``` A sinistra, in `vault`, lavorate normalmente. A destra, in `vault.enc`, c’è quello che sincronizzate nel cloud: nomi illeggibili, contenuto cifrato e un file di configurazione. Smontate, e `vault` torna una cartella vuota. Notate che la foto `me_in_the_meadow.jpg` («io sul prato») è lunga cinque byte e contiene la parola «jpeg». Ercolina non è una grande fotografa. È cifrata lo stesso, perché la crittografia non giudica. 🐄 Scegliere `moo123` come password e poi proteggerla con AES-256\. **Sbagliato.** La serratura più robusta del mondo, con la chiave sotto lo zerbino. Una passphrase di più parole a caso, il famoso «correct horse battery staple» di xkcd, è più facile da ricordare e molto più difficile da indovinare. gocryptfs è anche onesto su ciò che non nasconde, e lo scrive nel suo modello delle minacce: chi possiede la cartella cifrata può calcolare la dimensione di ogni file da quella cifrata, e un fornitore cloud vede quali parti di un file cambiano quando scrivete. Il contenuto è al sicuro; la forma non del tutto. 🐄 gocryptfs su Dropbox, Google Drive o Nextcloud. **Dipende.** Il contenuto è protetto, ma numero dei file, dimensioni e momenti in cui li modificate si vedono. Per un diario va benissimo. Se il segreto è l’esistenza stessa di un certo insieme di file, usate altro. ## age: un file, zero drammi A volte non volete un disco né una cartella: volete cifrare *un file*. Qui VeraCrypt non ha niente da offrire, e su Linux c’è un attrezzo piccolo e moderno che fa esattamente questo: `age`, progettato da Ben Cartwright-Cox e Filippo Valsorda. Il suo motto: chiavi piccole ed esplicite, niente opzioni di configurazione. Con una passphrase: ```bash $ echo 'Milk: 2 litres. Grass: unlimited. Fantasy football: bench Ercolina.' > shopping_list.txt $ age -p -o shopping_list.txt.age shopping_list.txt Enter passphrase (leave empty to autogenerate a secure one): Confirm passphrase: $ head -3 shopping_list.txt.age age-encryption.org/v1 -> scrypt 389PovIwgB3dwl239zZMeQ 18 8TZe4/qJXGrBcpEFCB6g1UGMe/HROQa4MrQ1BrXmanc $ age -d shopping_list.txt.age Enter passphrase: Milk: 2 litres. Grass: unlimited. Fantasy football: bench Ercolina. ``` La lista della spesa contiene latte (evidente conflitto di interessi), erba, e una scelta di fantacalcio («Ercolina in panchina») capace di distruggere un’amicizia. Ora è al sicuro. Se lasciate la passphrase vuota, age ne genera una buona per voi: ```bash $ age -p -o diary.age shopping_list.txt Enter passphrase (leave empty to autogenerate a secure one): age: using autogenerated passphrase "decade-lawsuit-hair-devote-stumble-never-sister-health-menu-bicycle" ``` Dieci parole a caso, molto meglio di qualunque cosa possa inventarsi una mucca. Ma la vera forza di age sono le **chiavi**: una pubblica da dare a chiunque, e una privata da tenere per sé: ```bash $ age-keygen -o key.txt Public key: age18cvftg9ppuq7nsgs3axwpmds4xp90qhh6sx6qunnyqp5gxwyp4hq4v8cmw ``` Chi ha la vostra chiave pubblica può cifrare file che solo voi potete aprire. E questo ci porta alla parte più interessante. ## Spedire dati cifrati Cifrare i dati per sé è metà del lavoro. L’altra metà è mandarli a qualcuno, attraverso canali che per definizione non controllate: email, chat, cloud, una chiavetta in una busta. L’idea è sempre la stessa: **cifrare prima di spedire**, con una chiave che ha solo il destinatario, e a quel punto il canale non conta più. ### age + chiavi SSH + scp Ecco il trucco che rende age delizioso: sa cifrare verso una **chiave pubblica SSH**. Molti ne hanno già una, e chi usa GitHub ce l’ha perfino pubblica: `age -R` accetta l’elenco su `https://github.com/NOMEUTENTE.keys`. Pina dà a Ercolina il suo `~/.ssh/id_ed25519.pub`. Ercolina cifra la ricetta del tiramisù e la spedisce con `scp`: ```bash ercolina@barn:~$ cat pina.pub ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJhPpBdu1+7R6ChAMwCWGpz5cuXvt5BTnG6xBu3clAJC pina@farm ercolina@barn:~$ age -R pina.pub -o tiramisu.txt.age tiramisu.txt ercolina@barn:~$ scp tiramisu.txt.age pina@farm: tiramisu.txt.age 100% 299 881.7KB/s 00:00 ``` Pina, su `farm`, la decifra con la sua chiave privata SSH (che, da mucca beneducata, è protetta da una passphrase): ```bash pina@farm:~$ age -d -i .ssh/id_ed25519 tiramisu.txt.age Enter passphrase for ".ssh/id_ed25519": TOP SECRET tiramisu - 500 g mascarpone - 3 eggs - coffee - the milk is mine, obviously ``` «TOP SECRET tiramisù: 500 g di mascarpone, 3 uova, caffè, il latte è mio, ovviamente». Notate che `scp` cifrava già il trasferimento. Ma con age il file resta cifrato *anche dopo* l’arrivo: sul disco di Pina, nei suoi backup, in un allegato email. Cifrare il canale protegge il viaggio; cifrare il file lo protegge per sempre. ### GnuPG: il nonno, ancora in servizio GnuPG l’ha avviato Werner Koch; la versione 1.0 è uscita nel settembre 1999\. Implementa OpenPGP, lo standard delle email cifrate e firmate. È più complicato di age, ma fa una cosa che age non fa: le **firme**, per dimostrare chi ha scritto qualcosa. Pina crea la sua coppia di chiavi (i default di oggi: Ed25519 per firmare, Curve25519 per cifrare, scadenza a tre anni) ed esporta la parte pubblica: ```bash pina@farm:~$ gpg --quick-generate-key "Pina " About to create a key for: "Pina " Continue? (Y/n) Y [...] public and secret key created and signed. pub ed25519 2025-10-08 [SC] [expires: 2028-10-07] FF1C6348AFD6287C041CD576DD673AF363FF991F uid Pina sub cv25519 2025-10-08 [E] pina@farm:~$ gpg --armor --export pina@example.com > pina.asc pina@farm:~$ head -3 pina.asc -----BEGIN PGP PUBLIC KEY BLOCK----- mDMEaOY48BYJKwYBBAHaRw8BAQdAujNgL3QSzKzyqnsYNFsYBzIh7bjoDTaXPyQ1 ``` Ercolina la importa. Ed ecco il momento più importante di tutto l’articolo: ```bash ercolina@barn:~$ gpg --import pina.asc gpg: key DD673AF363FF991F: public key "Pina " imported gpg: Total number processed: 1 gpg: imported: 1 ercolina@barn:~$ gpg --fingerprint pina@example.com pub ed25519 2025-10-08 [SC] [expires: 2028-10-07] FF1C 6348 AFD6 287C 041C D576 DD67 3AF3 63FF 991F uid [ unknown] Pina sub cv25519 2025-10-08 [E] ``` Vedete quel `[ unknown]`? GnuPG sta dicendo: «Ho una chiave che *dice* di essere di Pina. Non ho idea se lo sia davvero.» Chiunque può creare una chiave con scritto dentro Pina. Se Ercolina prova a cifrare lo stesso, GnuPG la ferma («Non c’è alcuna garanzia che questa chiave appartenga all’utente indicato»): ```bash ercolina@barn:~$ gpg --encrypt --armor -r pina@example.com tiramisu.txt gpg: DAC0CC3B54FFFB3D: There is no assurance this key belongs to the named user [...] It is NOT certain that the key belongs to the person named in the user ID. If you *really* know what you are doing, you may answer the next question with yes. Use this key anyway? (y/N) ``` La risposta giusta non è «y». La risposta giusta è telefonare a Pina e farsi leggere l’impronta (fingerprint) della sua chiave (`FF1C 6348 …`). Se coincide, Ercolina certifica la chiave in locale, e da quel momento GnuPG si fida. Poi cifra *e firma*, con `--armor`, così il risultato è testo da incollare in un’email: ```bash ercolina@barn:~$ gpg --quick-lsign-key FF1C6348AFD6287C041CD576DD673AF363FF991F [...] The signature will be marked as non-exportable. ercolina@barn:~$ gpg --fingerprint pina@example.com | grep uid uid [ full ] Pina ercolina@barn:~$ gpg --encrypt --sign --armor -r pina@example.com tiramisu.txt ercolina@barn:~$ head -3 tiramisu.txt.asc -----BEGIN PGP MESSAGE----- hF4D2sDMO1T/+z0SAQdAzID0bafJXcqn2KUtcvXbOc+DbaYRBWPBFMBL1yMPwxow ``` Pina, che a sua volta aveva verificato e certificato la chiave di Ercolina, decifra e controlla la firma: ```bash pina@farm:~$ gpg --decrypt tiramisu.txt.asc gpg: encrypted with cv25519 key, ID DAC0CC3B54FFFB3D, created 2025-10-08 "Pina " Passphrase: TOP SECRET tiramisu - 500 g mascarpone - 3 eggs - coffee - the milk is mine, obviously gpg: Signature made Wed Oct 8 10:20:00 2025 UTC gpg: using EDDSA key 554769C545F4065054DC37485531F5071B2CF778 gpg: Good signature from "Ercolina " [full] ``` «Good signature», firma valida: il tiramisù viene davvero da Ercolina, e nessuno l’ha modificato per strada. È anche, legalmente, una dichiarazione scritta che il latte è suo. Pina farebbe bene a sentire un avvocato. 🐄 Controllare l’impronta di una chiave al telefono o di persona prima di fidarsi. **Giusto.** Cifrare con la chiave sbagliata è come sigillare benissimo una busta e consegnarla al truffatore. 🐄 Mandare il file cifrato e la sua password nella stessa email. **Sbagliato.** È come chiudere la cassaforte e attaccarci sopra la combinazione con lo scotch. La password viaggia per un’altra strada: una telefonata, un messaggio, un piccione viaggiatore. ### magic-wormhole: da computer a computer, con un codice E se dovete solo mandare un file a qualcuno, adesso, senza scambiarvi chiavi? magic-wormhole, di Brian Warner, usa un codice breve da leggere al telefono: ```bash ercolina@barn:~$ wormhole send lineup.txt Sending 61 Bytes file named 'lineup.txt' Wormhole code is: 2-midsummer-ahead On the other computer, please run: wormhole receive 2-midsummer-ahead Sending (->relay:tcp:magic-wormhole-transit.debian.net:4001).. 100% 61.0/61.0 [00:00<00:00, 115kB/s] File sent.. waiting for confirmation Confirmation received. Transfer complete. ``` (Stampa anche un QR code, che vi abbiamo risparmiato.) Pina scrive il codice, con il completamento automatico delle parole: ```bash pina@farm:~$ wormhole receive Enter receive wormhole code: 2-midsummer-ahead (note: you can use to complete words) Receiving file (61 Bytes) into: 'lineup.txt' ok? (Y/n): y Receiving (->relay:tcp:magic-wormhole-transit.debian.net:4001).. 100% 61.0/61.0 [00:00<00:00, 258kB/s] Received file written to lineup.txt pina@farm:~$ cat lineup.txt Fantasy football lineup: Ercolina captain. Do NOT tell Pina. ``` Dietro le quinte i due computer usano un PAKE (SPAKE2): il codice breve diventa una chiave condivisa robusta, e tutto quello che passa per i server di appoggio è cifrato da un capo all’altro. Il codice vale una volta sola, e un attaccante ha un solo tentativo con una probabilità su 65.536; un tentativo fallito si presenta come un errore, quindi ve ne accorgete. Il file è arrivato sano e salvo, cifrato da un capo all’altro, illeggibile per chiunque nel mezzo. Purtroppo dice «Formazione del fantacalcio: Ercolina capitana. NON dirlo a Pina», ed è stato mandato a Pina. La cifratura protegge il messaggio da tutti tranne che dal destinatario. Scegliere il destinatario resta compito vostro. 🐄 Leggere il codice di wormhole al telefono, o dirlo a chi vi siede accanto. **Giusto.** Breve, monouso, e inutile cinque minuti dopo. La mucca raccomanda comunque di controllare a chi state mandando le cose. ### rclone crypt: il cloud vede solo rumore Ultimo caso: i backup su un cloud di cui non vi fidate (cioè, di regola, qualunque cloud). rclone parla con decine di servizi di archiviazione, e il suo remote `crypt` cifra tutto dalla vostra parte prima di caricarlo. Per provarlo senza un account cloud, usiamo come «cloud» la macchina di Pina via SFTP: ```bash ercolina@barn:~$ rclone config create farm sftp host=farm user=pina key_file=~/.ssh/id_ed25519 [farm] type = sftp host = farm user = pina key_file = /home/ercolina/.ssh/id_ed25519 ercolina@barn:~$ rclone config create secretfarm crypt remote=farm:cloud password=correct-horse-battery-moo --obscure [secretfarm] type = crypt remote = farm:cloud password = *** ENCRYPTED *** ercolina@barn:~$ rclone copy diary secretfarm:diary ercolina@barn:~$ rclone ls secretfarm: 15 diary/monday.txt 7 diary/tax_return_2025.pdf 46 diary/tuesday.txt ``` Attraverso `secretfarm:` Ercolina vede in chiaro il diario e la dichiarazione dei redditi. Ecco invece cosa conserva davvero `farm`, il «cloud»: ```bash ercolina@barn:~$ rclone ls farm:cloud 94 qju1hn84i7nm8tqd5k73oaqvtg/5a13sotkaq3tdqcrafhluamiqc 55 qju1hn84i7nm8tqd5k73oaqvtg/94uo7ujqoc3rel61oi194s2uhuplk2gn36ev8bu67s8ok00gbjr0 63 qju1hn84i7nm8tqd5k73oaqvtg/s1oq8lj5hhci3o9jgua565pgl0 pina@farm:~$ xxd -l 16 cloud/qju1hn84i7nm8tqd5k73oaqvtg/5a13sotkaq3tdqcrafhluamiqc 00000000: 5243 4c4f 4e45 0000 5c45 40c8 0a1d f7f0 RCLONE..\E@..... ``` Nomi cifrati, contenuto cifrato (XSalsa20-Poly1305 per i dati, AES-256 per i nomi) e un’intestazione che comincia con `RCLONE`. Ogni file è esattamente 48 byte più grande dell’originale: 32 byte di intestazione più 16 byte di autenticazione per ogni blocco da 64 KiB. E per Ercolina tutto funziona come sempre («Martedì: altra erba. Pina mi ha guardata strano»): ```bash ercolina@barn:~$ rclone cat secretfarm:diary/tuesday.txt Tuesday: more grass. Pina looked at me funny. ``` La documentazione è chiara sui limiti: dimensioni e date di modifica si vedono, e così la struttura delle cartelle. Inoltre la password in `rclone.conf` è solo *offuscata*, non cifrata: chi legge quel file può recuperarla. rclone sa cifrare la propria configurazione con una password; usatela. 🐄 Pensare che `password = *** ENCRYPTED ***` nell’output voglia dire che il file di configurazione è al sicuro. **Sbagliato.** È offuscata, che nel linguaggio delle password vuol dire «con gli occhiali da sole». Proteggete `rclone.conf`, o cifrate la configurazione. ## Quale attrezzo per quale lavoro | Volete… | Usate | Come VeraCrypt? | | ----------------------------------------------------------- | -------------------------- | ------------------------ | | Cifrare tutto il disco del portatile | LUKS, in installazione | Sì, cifratura di sistema | | Portarvi dietro una «cassaforte» in un file o una chiavetta | LUKS su file o dispositivo | Sì, un volume | | Cifrare una cartella sincronizzata nel cloud | gocryptfs | Meglio: file per file | | Cifrare un singolo file, per voi o per qualcun altro | age (o GnuPG) | No, non lo fa | | Cifrare e *firmare* un’email | GnuPG | No | | Mandare un file a qualcuno, adesso | magic-wormhole | No | | Fare backup in un cloud di cui non vi fidate | rclone crypt | No | E una regola che vale per tutti: i dati cifrati senza la chiave sono indistinguibili da rumore casuale, anche per voi. Prima di cifrare qualcosa di importante, decidete dove vivranno la passphrase, la chiave di riserva, la chiave principale di gocryptfs e il backup dell’intestazione LUKS. Non dentro la cosa che state cifrando. 🐄 Tenere l’unica copia delle password in un file dentro il volume cifrato. **Sbagliato.** Ercolina l’ha fatto, con `passwords.txt`. È una cassaforte che contiene la propria combinazione. Sicurissima. Per sempre. 🐄 Morale: cifrate il portatile quando lo installate, usate gocryptfs per le cartelle nel cloud e age per i singoli file, controllate le impronte prima di fidarvi di una chiave, non spedite mai la password insieme al pacco, e tenete un backup di ogni chiave fuori dalla cassaforte. La mucca ha parlato, e la mucca è legge. Muuu. 🐄 Fonti Tutti i comandi sono stati eseguiti su Debian 13 con cryptsetup 2.7.5, gocryptfs 2.5.1, age 1.2.1, GnuPG 2.4.7, magic-wormhole 0.18.0 e rclone 1.60.1; gli output mostrati sono quelli reali, senza qualche riga di rumore dei container. - [Wikipedia, “VeraCrypt”](https://en.wikipedia.org/wiki/VeraCrypt?ref=cowsayso.com) - [Wikipedia, “Linux Unified Key Setup”](https://en.wikipedia.org/wiki/Linux%5FUnified%5FKey%5FSetup?ref=cowsayso.com) - [cryptsetup(8) manual page](https://man7.org/linux/man-pages/man8/cryptsetup.8.html?ref=cowsayso.com) - [cryptsetup 2.1.0 release notes (LUKS2 becomes the default)](https://gitlab.com/cryptsetup/cryptsetup/-/raw/main/docs/v2.1.0-ReleaseNotes?ref=cowsayso.com) - [Debian installation guide, guided partitioning](https://www.debian.org/releases/trixie/amd64/ch06s03.en.html?ref=cowsayso.com) - [gocryptfs, official site](https://nuetzlich.net/gocryptfs/?ref=cowsayso.com) - [gocryptfs, threat model](https://nuetzlich.net/gocryptfs/threat%5Fmodel/?ref=cowsayso.com) - [age, README](https://github.com/FiloSottile/age?ref=cowsayso.com) - [age, format specification](https://age-encryption.org/v1?ref=cowsayso.com) - [Wikipedia, “GNU Privacy Guard”](https://en.wikipedia.org/wiki/GNU%5FPrivacy%5FGuard?ref=cowsayso.com) - [Magic Wormhole documentation](https://magic-wormhole.readthedocs.io/en/latest/welcome.html?ref=cowsayso.com) - [rclone, Crypt remote documentation](https://rclone.org/crypt/?ref=cowsayso.com) - [Ubuntu Desktop documentation, advanced disk setup](https://documentation.ubuntu.com/desktop/en/24.04/reference/advanced-disk-setup-features/?ref=cowsayso.com) - [Wikipedia, “Disk encryption theory” (XTS)](https://en.wikipedia.org/wiki/Disk%5Fencryption%5Ftheory?ref=cowsayso.com) - [xkcd 936, “Password Strength”](https://xkcd.com/936/?ref=cowsayso.com)