Libreria
Difesa
Difesa, robustezza dei propri account e crittografia completa.
Funzioni 44
apri_bustaapri_busta_filebusta_per_molticarica_chiavecifra_file_percifra_file_per_molticifra_percodice_otpcodice_otp_acodice_otp_contatorecodice_qr_svgconfronta_chiavicontrolla_permessi_filecrea_chiavi_riservatezzadecifra_dadecifra_file_daesporta_chiave_pubblicafirma_filegenera_frase_passwordgenera_password_pronunciabilegenera_pingenera_segreto_otpimporta_chiave_pubblicaimpronta_chiavemisura_forza_passwordmostra_attacco_dizionarioparole_improntapermessi_fileporte_locali_in_ascoltoprepara_sfida_cifrataprepara_sfida_firmaprepara_sfida_segretoqr_otp_svgrendi_file_privatosalva_chiavesalva_codice_qrsalva_qr_otpscrivi_firma_filespiega_forza_passworduri_otpverifica_bandieraverifica_codice_otpverifica_file_firmatoverifica_firma_file
misura_forza_password(password)#
Quanto è robusta una password, in un dizionario con il punteggio e i problemi.
Restituisce punteggio (da 0 a 4), livello ("pessima".."ottima"), bit (quanta casualità ha, in bit), tempo (stima di quanto ci vuole a indovinarla), comune (vero se è tra le più usate) e problemi (perché è debole). Nessuna password esce dal computer.
misura_forza_password("Password1")["livello"]spiega_forza_password(password)#
Un testo in italiano che spiega quanto è robusta una password e perché.
Dice il livello, la stima del tempo per indovinarla e, riga per riga, che cosa la rende debole e come migliorarla. Comodo da stampare.
stampa(spiega_forza_password("juventus"))genera_frase_password(parole = 6, separatore = "-", con_numero = vero, maiuscole = falso)#
Una frase-password robusta e facile da ricordare.
Sceglie a caso (in modo crittografico) parole italiane comuni, come "fiume-gatto-stella-...": lunga da indovinare ma facile da ricordare. Ogni parola aggiunge circa 8 bit; con 6 parole sei intorno ai 48 bit.
stampa(genera_frase_password(6))genera_password_pronunciabile(sillabe = 5, con_numero = vero)#
Una password casuale ma leggibile ad alta voce.
Alterna consonanti e vocali (come "bo-ki-ne-ta-ру"): più facile da dire e scrivere di una password a caso, un po' meno robusta.
stampa(genera_password_pronunciabile(5))genera_pin(cifre = 6)#
Un PIN numerico casuale che evita gli schemi deboli (1234, 1111, anni, date).
Usa il generatore crittografico del sistema.
stampa(genera_pin(6))genera_segreto_otp(byte = 20)#
Un nuovo segreto per i codici OTP, in Base32 (lo standard delle app come Google Authenticator).
Dà questo segreto UNA volta all'app di autenticazione (o mettilo nel QR con uri_otp/qr_otp_svg) e tienilo al sicuro: con quello si generano i codici a 6 cifre.
variabile s = genera_segreto_otp()codice_otp(segreto, cifre = 6, periodo = 30, algoritmo = "sha1")#
Il codice OTP di ADESSO per quel segreto.
È lo stesso codice che mostra l'app di autenticazione. Cambia ogni periodo secondi (di solito 30). Per proteggere i TUOI account.
stampa(codice_otp(mio_segreto))codice_otp_a(segreto, secondi, cifre = 6, periodo = 30, algoritmo = "sha1")#
Il codice OTP a un dato istante (in secondi dal 1970).
Come codice_otp ma per un momento preciso: utile per le prove e per capire come funziona.
stampa(codice_otp_a("GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ", 59, 8))codice_otp_contatore(segreto, contatore, cifre = 6, algoritmo = "sha1")#
Il codice OTP "a contatore" (HOTP) per quel numero.
Come TOTP ma invece del tempo usa un contatore che avanza di 1 a ogni uso.
stampa(codice_otp_contatore(s, 0))verifica_codice_otp(segreto, codice, finestra = 1, cifre = 6, periodo = 30, algoritmo = "sha1")#
Vero se il codice OTP è giusto in questo momento.
finestra accetta anche i codici di poco prima/dopo (per gli orologi non proprio allineati): 1 vuol dire i 30 secondi prima e dopo. Il confronto è a tempo costante.
stampa(verifica_codice_otp(s, chiedi("Codice: ")))uri_otp(segreto, conto, emittente = "", cifre = 6, periodo = 30, algoritmo = "sha1")#
L'indirizzo "otpauth://" da mettere in un QR per configurare l'app.
conto è il tuo nome o email sul servizio; emittente è il nome del servizio. Le app di autenticazione leggono questo testo (di solito da un QR) e iniziano a mostrare i codici.
stampa(uri_otp(s, "io@mail.it", "Leo"))qr_otp_svg(segreto, conto, emittente = "")#
Un'immagine QR (testo SVG) per configurare l'app di autenticazione.
Mostra o salva l'SVG e inquadralo con l'app: configurerà l'OTP del tuo account.
scrivi_testo("otp.svg", qr_otp_svg(s, "io@mail.it", "Leo"))salva_qr_otp(percorso, segreto, conto, emittente = "")#
Salva in un file PNG il QR per configurare l'OTP.
Inquadra il PNG con l'app di autenticazione. Restituisce il percorso.
salva_qr_otp("otp.png", s, "io@mail.it", "Leo")codice_qr_svg(testo, modulo = 4, correzione = "M")#
Un codice QR di un testo qualunque, come immagine SVG.
Comodo per link, contatti, testi brevi. correzione è "L", "M", "Q" o "H" (più alto = più resistente).
scrivi_testo("sito.svg", codice_qr_svg("https://esempio.it"))salva_codice_qr(percorso, testo, modulo = 8, correzione = "M")#
Salva un codice QR di un testo in un file PNG.
Restituisce il percorso.
salva_codice_qr("sito.png", "https://esempio.it")porte_locali_in_ascolto(porte = nulla)#
Quali servizi stanno ascoltando su QUESTO computer (solo 127.0.0.1).
Controlla alcune porte note (o quelle che indichi tu) SOLO su 127.0.0.1: serve a sapere che cosa hai acceso sul tuo computer, non a scansionare altri. Restituisce la lista delle porte in ascolto con il servizio tipico.
per ogni p in porte_locali_in_ascolto() fai stampa(p["porta"], p["servizio"]) finepermessi_file(percorso)#
Chi può leggere, scrivere ed eseguire un file (i tuoi file), in un dizionario.
Restituisce ottale (per
permessi_file("chiave.txt")["solo_proprietario"]controlla_permessi_file(percorso)#
Avvisi se un tuo file è troppo aperto (lo possono leggere o cambiare altri).
Restituisce una lista di avvisi in italiano (vuota se va bene). Pensato per file delicati come le chiavi.
per ogni a in controlla_permessi_file("chiave.txt") fai stampa(a) finerendi_file_privato(percorso)#
Toglie a tutti gli altri il permesso di leggere o scrivere un tuo file (permessi 600).
Per le cartelle usa 700. Restituisce vero se è riuscito. Su Windows i permessi funzionano diversamente: lì restituisce falso e conviene usare la cifratura o le impostazioni dell'account.
rendi_file_privato("chiave.txt")impronta_chiave(chiave)#
L'impronta di una chiave (la sua "carta d'identità") per controllarla a colpo d'occhio.
Vale per una chiave pubblica, privata o un dizionario di chiavi: l'impronta è sempre quella della parte pubblica, quindi la puoi confrontare con quella dell'altra persona.
stampa(impronta_chiave(chiavi["pubblica"]))parole_impronta(chiave, parole = 6)#
L'impronta di una chiave come poche parole italiane, da leggere a voce.
Due persone che leggono la stessa sequenza di parole hanno la stessa chiave: utile per accorgersi se qualcuno si è messo in mezzo.
stampa(parole_impronta(chiavi["pubblica"]))confronta_chiavi(prima, seconda)#
Vero se due chiavi hanno la stessa parte pubblica (stessa impronta).
Confronto a tempo costante. Comodo per controllare che una chiave ricevuta sia davvero quella attesa.
se confronta_chiavi(ricevuta, attesa) allora stampa("Chiave giusta") fineesporta_chiave_pubblica(chiave)#
Il testo della SOLA chiave pubblica, da dare agli altri senza rischi.
Accetta una chiave privata, una pubblica o un dizionario: restituisce sempre e solo la parte pubblica. La chiave privata non esce mai.
variabile pub = esporta_chiave_pubblica(chiavi)importa_chiave_pubblica(testo)#
Controlla e "pulisce" il testo di una chiave pubblica ricevuta da qualcuno.
Dà errore se per sbaglio è una chiave privata o un testo rovinato. Restituisce la chiave pubblica pronta da usare con cifra_per o verifica_firma.
variabile pub = importa_chiave_pubblica(ricevuta)salva_chiave(chiave, percorso, password = nulla, sovrascrivi = falso)#
Salva una chiave in un file, in modo sicuro.
Se la chiave è privata e dai una password, viene salvata CIFRATA; senza password il file viene reso privato (solo tu lo leggi). La chiave pubblica si salva in chiaro. Restituisce il percorso.
salva_chiave(chiavi["privata"], "mia.chiave", "una frase lunga")carica_chiave(percorso, password = nulla)#
Rilegge una chiave salvata con salva_chiave.
Se il file è cifrato serve la password giusta. Restituisce il testo della chiave (la privata NON viene mai stampata da Leo).
variabile priv = carica_chiave("mia.chiave", "una frase lunga")crea_chiavi_riservatezza()#
Una coppia di chiavi per CIFRARE i messaggi (X25519), in un dizionario.
"pubblica" si dà a chi deve scriverti in segreto (ci cifra con cifra_per); "privata" resta solo tua e serve a leggere (decifra_da). Diversa dalle chiavi di firma.
variabile mie = crea_chiavi_riservatezza()firma_file(percorso, chiave_privata)#
La firma digitale (un testo) di un file, con la tua chiave privata di firma.
Chi ha la tua chiave pubblica controlla con verifica_firma_file che il file venga da te e non sia cambiato.
variabile f = firma_file("programma.zip", chiavi["privata"])verifica_firma_file(percorso, firma, chiave_pubblica)#
Vero se la firma del file è giusta per quella chiave pubblica.
Falso se il file o la firma sono cambiati, o se ha firmato un altro.
stampa(verifica_firma_file("programma.zip", f, pub))scrivi_firma_file(percorso, chiave_privata, percorso_firma = nulla, sovrascrivi = falso)#
Firma un file e salva la firma accanto.
Senza percorso_firma crea un file con ".firma" in fondo al nome. Restituisce il percorso della firma.
scrivi_firma_file("programma.zip", chiavi["privata"])verifica_file_firmato(percorso, chiave_pubblica, percorso_firma = nulla)#
Legge il file ".firma" e verifica il file.
Senza percorso_firma cerca il file con ".firma" in fondo al nome.
verifica_file_firmato("programma.zip", pub)cifra_per(dati, chiave_pubblica)#
Cifra un testo (o byte) in modo che SOLO chi ha la chiave privata possa leggerlo.
Tu usi solo la chiave PUBBLICA del destinatario: non serve condividere password. Il risultato è un testo.
variabile busta = cifra_per("Ci vediamo alle 8", pub_di_anna)decifra_da(busta, chiave_privata, come_byte = falso)#
Legge un messaggio cifrato per te con cifra_per.
Serve la TUA chiave privata di riservatezza. Con come_byte = vero restituisce i byte.
decifra_da(busta, mie["privata"])cifra_file_per(percorso, chiave_pubblica, destinazione = nulla, sovrascrivi = falso)#
Cifra un file per un destinatario.
Solo chi ha la chiave privata corrispondente potrà aprirlo con decifra_file_da. Senza destinazione aggiunge ".busta" al nome. Restituisce il percorso.
cifra_file_per("foto.jpg", pub_di_anna)decifra_file_da(percorso, chiave_privata, destinazione = nulla, sovrascrivi = falso)#
Apre un file cifrato con cifra_file_per.
Serve la tua chiave privata di riservatezza. Senza destinazione toglie ".busta" dal nome. Restituisce il percorso del file in chiaro.
decifra_file_da("foto.jpg.busta", mie["privata"])busta_per_molti(dati, chiavi_pubbliche)#
Cifra un testo (o byte) UNA volta per PIÙ destinatari.
chiavi_pubbliche è la lista delle chiavi pubbliche di riservatezza. Ognuno la aprirà con apri_busta usando la propria chiave privata.
busta_per_molti("Riunione alle 9", [pub_anna, pub_bruno])apri_busta(busta, chiave_privata, come_byte = falso)#
Apre una busta fatta con busta_per_molti, se sei un destinatario.
Serve la tua chiave privata di riservatezza.
apri_busta(busta, mie["privata"])cifra_file_per_molti(percorso, chiavi_pubbliche, destinazione = nulla, sovrascrivi = falso)#
Cifra un file per più destinatari.
Ognuno lo aprirà con apri_busta_file e la propria chiave privata. Senza destinazione aggiunge ".busta". Restituisce il percorso.
cifra_file_per_molti("verbale.pdf", [pub_anna, pub_bruno])apri_busta_file(percorso, chiave_privata, destinazione = nulla, sovrascrivi = falso)#
Apre un file cifrato con cifra_file_per_molti.
Senza destinazione toglie ".busta" dal nome. Restituisce il percorso del file in chiaro.
apri_busta_file("verbale.pdf.busta", mie["privata"])prepara_sfida_segreto(cartella)#
Crea un file con un segreto nascosto dentro, da ritrovare per esercizio.
Il segreto (la "bandiera") è nascosto in mezzo ad altro testo, codificato in Base64. Restituisce percorso, un aiuto e un controllo (gettone per verifica_bandiera): la bandiera NON viene svelata.
variabile sfida = prepara_sfida_segreto("sfide")prepara_sfida_cifrata(cartella)#
Crea un file cifrato con una password, da decifrare per esercizio.
Restituisce percorso, la password (te la dà, è un esercizio di decifratura), un aiuto e un controllo. Decifra il file con decifra_file e la password per leggere la bandiera.
prepara_sfida_cifrata("sfide")prepara_sfida_firma(cartella)#
Crea due file quasi uguali ma uno solo è firmato davvero, da riconoscere.
Restituisce i percorsi dei file e della firma, la chiave_pubblica per controllare, un aiuto e il controllo: la bandiera è il nome del file autentico. Usa verifica_firma_file.
prepara_sfida_firma("sfide")verifica_bandiera(controllo, risposta)#
Vero se hai trovato la bandiera giusta di una sfida.
controllo è il gettone restituito da prepara_sfida_...; risposta è la bandiera che hai trovato. Il confronto è a tempo costante e non svela la bandiera.
stampa(verifica_bandiera(sfida["controllo"], trovata))mostra_attacco_dizionario(impronta, algoritmo = "sha256")#
Perché un'impronta SENZA SALE di una password comune si "rompe".
Prova le password dell'ELENCO LOCALE: se l'impronta (md5/sha1/sha256...) corrisponde a una di esse, la ritrova subito. Serve per capire perché le password NON si salvano come semplice impronta: usa impronta_password (scrypt con sale). Lavora solo sull'impronta che gli dai TU. Restituisce un dizionario con trovata, password (se trovata) e spiegazione.
mostra_attacco_dizionario(impronta("123456"))