Benvenuti nella serie “Prepariamoci alla Maturità 2026”, un percorso di ripasso pensato per gli studenti degli Istituti Tecnici – Informatica e Telecomunicazioni, articolazione Informatica, che si preparano ad affrontare l’Esame di Maturità. Sono Francesco Paolo Caforio, docente di Scienze e Tecnologie Informatiche (A-41), e in questa playlist vi accompagnerò attraverso i principali contenuti della disciplina Sistemi e Reti, con spiegazioni, schemi, esempi e collegamenti utili sia per la seconda prova scritta sia per il colloquio orale. L’obiettivo della serie è fornire un ripasso completo e accessibile degli argomenti più importanti del programma, aiutandovi a consolidare le conoscenze, chiarire eventuali dubbi e affrontare l’esame con maggiore sicurezza e consapevolezza. Ogni video è pensato per essere seguito in modo autonomo oppure come parte di un percorso strutturato di preparazione finale. 

#1 Indirizzamento IP. Approccio classfull
#2 Esercizi guidati su indirizzi IP e classi
#3 Maschere di rete
#4 Esercizi guidati su indirizzamento IP classfull
#5 Subnetting
#6 Esercizi guidati su subnetting

Buono studio e in bocca al lupo per la Maturità 2026!

L’argomento del quesito è l’Autenticazione e recita quanto segue: “In relazione al tema proposto nella prima parte, il candidato descriva le possibili forme di autenticazione qualificata (a più fattori) per consentire al singolo cittadino di consultare via web tutti i dati del proprio fascicolo sanitario elettronico (accertamenti e visite specialistiche)”.

Questo video è pensato per guidarvi nel redigere una risposta accurata e completa, ma vi ricordo che la soluzione dipende da un personale approccio e da una specifica interpretazione del quesito posto. 
Se avete dubbi o riflessioni non esitate a chiedere ulteriori chiarimenti. 
Buono studio! @prf.kekkaffo

Funzioni e procedure

Programmazione C++ – Esercizi

Implementazioni in Java

[2.5] Esercizio sul registro elettronico

ITADINFO ha proposto sessioni di diversa natura dedicate ai temi dell’insegnamento e dell’apprendimento dell’informatica nella scuola, favorendo il confronto fra docenti e ricercatori su esperienze sul campo, risultati di ricerca e formazione laboratoriale interattiva.

La partecipazione e il progetto presentato

In questo contesto ho presentato CriptoLab – Alla scoperta della crittografia, un laboratorio didattico sviluppato presso l’I.I.S.S. “Ettore Majorana” di Martina Franca (TA) nell’ambito del progetto PNRR SySTEM (DM 65/2023). Il laboratorio è stato concepito per avvicinare gli studenti al pensiero computazionale e alla sicurezza informatica attraverso lo studio e l’implementazione di algoritmi crittografici.

L’impianto formativo ha privilegiato un approccio che ha unito matematica applicata, programmazione in Python e riflessione etica sulla protezione dei dati, ponendo la crittografia come ponte fra astrazione teorica e applicazioni reali.

Struttura del laboratorio

Il percorso, della durata complessiva di 30 ore, è stato articolato in 10 incontri pomeridiani rivolti a 30 studenti del triennio (indirizzo Informatica e Liceo Scientifico opzione Scienze Applicate). I moduli hanno seguito una progressione dalla storia alle applicazioni contemporanee:

Tutti i materiali e i codici sviluppati sono stati raccolti in un repository GitHub per facilitarne la replicabilità in altri contesti scolastici.

Dalla teoria al codice

Le attività hanno valorizzato il passaggio dalla teoria alla programmazione. Attraverso l’ambiente Google Colab, gli studenti hanno realizzato e analizzato gli algoritmi studiati, rendendo trasparenti i meccanismi di sicurezza dell’informazione.

• Cifrario di Cesare: cifratura/decifratura e attacco a forza bruta.
• Cifrario di Vernam: generazione di chiavi casuali e operazioni XOR.
• DES: struttura di Feistel, permutazioni e sostituzioni (versione didattica semplificata).
• Firma digitale: generazione e verifica di digest mediante funzioni hash.

Metodologie didattiche

• Lezioni dialogate per la costruzione condivisa dei concetti.
• Cooperative learning e peer tutoring per l’interdipendenza positiva.
• Esercitazioni manuali e digitali di cifratura/criptoanalisi.
• Programmazione collaborativa in Python su Google Colab.
• Riflessione metacognitiva e autovalutazione sugli apprendimenti.

Risultati formativi

Dalle osservazioni e dalle autovalutazioni sono emersi miglioramenti significativi nelle seguenti aree:

Riflessioni conclusive

La presentazione di CriptoLab a ITADINFO 2025 ha confermato il valore della crittografia come ambito privilegiato per l’educazione logico-computazionale, capace di integrare rigore scientifico, creatività e consapevolezza civica. Il modello si è rivelato replicabile e scalabile, con prospettive di estensione a moduli su blockchain e intelligenza artificiale.

Materiali e risorse

Slide ITADINFO 2025 (PDF): Scarica
Articolo scientifico (PDF): Leggi
Repository GitHub del progetto: https://github.com/FrancescoCaforio/CriptoLab

La logica booleana è il linguaggio fondamentale dei sistemi digitali.
Lavora con due valori, vero (1) e falso (0), e usa operatori come AND (∧), OR (∨), NOT (¬), oltre a composti come NAND, NOR, XOR (⊕). Imparare a costruire e leggere le tavole di verità aiuta a sviluppare capacità di analisi, a comprendere il funzionamento dei circuiti e a ragionare sulle condizioni nei programmi.

Legenda operatori (richiamo veloce)

• ¬p (NOT): vero se p è falso.
• p ∧ q (AND): vero solo se p e q sono entrambi veri.
• p ∨ q (OR): vero se almeno uno tra p e q è vero.
• p ⊕ q (XOR): vero se esattamente uno tra p e q è vero.
• p NAND q: ¬(p ∧ q).
• p NOR q: ¬(p ∨ q).
• Equivalenza (≡): due enunciati sono equivalenti se hanno sempre lo stesso valore di verità.

(A) Valutare gli enunciati composti costruendo le tavole di verità

Per ogni voce, costruisci la tavola di verità (variabili come da enunciato) e calcola il valore dell’espressione.

1. (p ∨ ¬q) ∧ r
(p ∧ r) ∨ (¬q ∧ r)
2. ¬(p ∨ (q ∧ r))
(¬p) ∧ (¬q ∨ ¬r)
3. (p NAND q) ∧ (p NOR q)
4. (¬p ∨ q) ∧ (p ∨ ¬q)
5. (p ⊕ q) ⊕ r
p ⊕ (q ⊕ r)
6. ¬(p ⊕ q)
(p ∧ q) ∨ (¬p ∧ ¬q)
7. (p ∧ ¬q) ∨ (¬p ∧ r)
8. ¬p ∧ (q ∨ r)
(¬p ∧ q) ∨ (¬p ∧ r)
9. (p ∨ q) ∧ (¬p ∨ r)
10. ¬(p NOR r)
p ∨ r

(B) Equivalenze logiche: costruisci le tavole e stabilisci se sono equivalenti

1. p ∨ (q ∧ ¬r) ≡ (p ∨ q) ∧ (p ∨ ¬r)
2. (p ∧ ¬q) ∨ (¬p ∧ ¬q) ≡ ¬q
3. ¬(p ∧ q) ≡ ¬p ∨ ¬q
4. (p ∨ q) ∧ (p ∨ r) ≡ p ∨ (q ∧ r)
5. p ⊕ (q ⊕ r) ≡ (p ⊕ q) ⊕ r
6. p ⊕ q ≡ (p ∧ q) ∨ (¬p ∧ ¬q)
7. (p ∧ ¬q) ∨ (q ∧ ¬r) ≡ (p ∨ q) ∧ (¬q ∨ ¬r)
8. ¬(p ∨ (q ∨ r)) ≡ (¬p) ∧ (¬q) ∧ (¬r)
9. (p ⊕ q) ⊕ (¬r) ≡ p ⊕ (q ⊕ ¬r)

(C) Valutazione con enunciati semplici assegnati

Per ciascun esercizio: 1) costruisci la tavola di verità; 2) valuta gli enunciati semplici con i valori dati; 3) calcola il valore finale dell’enunciato composto.

1. (p ∨ ¬q) ∧ r
   p: (x ≥ 0) con x = −2
   q: (y < 5) con y = 7
   r: (z = 3) con z = 3
2. ¬(p ∧ q) ∨ r
   p: (a > 1) con a = 1
   q: (b ≠ 0) con b = 0
   r: (c ≤ 4) con c = 5
3. (p NAND q) ⊕ r
   p: (m < 10) con m = 12
   q: (n ≥ −1) con n = −1
   r: (k ≠ 2) con k = 2
4. ¬(p ∨ r) ∧ (q ∨ ¬r)
   p: (x = 0) con x = 0
   q: (y > 2) con y = 5
   r: (z ≤ 1) con z = 4
5. (¬p ∨ q) ∧ (p ∨ ¬q)
   p: (a ≥ 5) con a = 6
   q: (b ≤ −2) con b = −2
6. ¬(p ⊕ q) ∨ r
   p: (t ≠ 0) con t = 0
   q: (u = 7) con u = 7
   r: (v > 1) con v = −3
7. (p ∨ q) ∧ (¬p ∨ r)
   p: (x ≤ 4) con x = 5
   q: (y = −1) con y = −1
   r: (z < 10) con z = 8
8. ¬(p ∧ (q ∨ r))
   p: (a > 3) con a = 4
   q: (b ≠ 1) con b = 1
   r: (c ≤ 0) con c = −2

(D) Semplificazione algebrica (usa anche le leggi di De Morgan)

1. ¬(p ∨ (¬q))
   p: (x > 2)
   q: (y ≤ −1)
2. ¬((p ∧ r) ∨ q)
   p: (a < 5)
   q: (b ≥ 0)
   r: (c ≠ 2)
3. (¬p ∨ q) ∧ (¬p ∨ ¬q)
   p: (m ≥ 7)
   q: (n < 3)
4. ¬(p NOR q) ∧ ¬(p XOR q)
   p: (u ≠ 0)
   q: (v ≤ 4)
5. ¬((¬p ∧ q) ∨ (r ∧ ¬q))
   p: (k > 1)
   q: (h ≤ 8)
   r: (t = −5)

Cos’è il Cifrario di Cesare?

Il Cifrario di Cesare è un tipo di cifratura a sostituzione in cui ciascuna lettera del messaggio viene spostata di un numero fisso di posizioni nell’alfabeto. Ad esempio, con una chiave di 3, la lettera “A” diventa “D”, “B” diventa “E”, e così via. Una volta raggiunta la fine dell’alfabeto, si riparte dall’inizio.

Esempio:

• Testo in chiaro: CIFRA
• Chiave: 3
• Testo cifrato: FLIUD

L’alfabeto è semplicemente “ruotato” a seconda della chiave, spostando le lettere verso destra.

L’alfabeto italiano

Per la nostra implementazione useremo l’alfabeto italiano che contiene 21 lettere, escludendo “J”, “K”, “W”, “X” e “Y”. Questo ci permette di utilizzare un alfabeto adatto per testi in lingua italiana.

Ecco l’alfabeto italiano che utilizzeremo:

ABCDEFGHILMNOPQRSTUVZ

Implementazione in Python

Dividiamo l’implementazione in tre moduli principali:

1. Cifratura e decifratura.
2. Attacco a forza bruta.
3. Programma principale.

1. Cifratura e Decifratura

La prima parte riguarda le funzioni di cifratura e decifratura. La cifratura funziona spostando ogni lettera del messaggio di un numero di posizioni determinato dalla chiave. La decifratura è semplicemente l’operazione inversa: si spostano le lettere indietro.

Funzione di cifratura

Nella cifratura, prendiamo il testo, lo convertiamo in maiuscolo e poi, per ogni lettera, la spostiamo in avanti nell’alfabeto del numero di posizioni specificato dalla chiave. Se incontriamo caratteri non alfabetici, come spazi o punteggiatura, li lasciamo inalterati.

ALFABETO_ITALIANO = "ABCDEFGHILMNOPQRSTUVZ"

def cifra_cesare(testo, chiave):
    """
    Funzione che cifra un testo in chiaro usando il Cifrario di Cesare con una chiave data.
    :param testo: Il testo in chiaro da cifrare.
    :param chiave: La chiave di cifratura (numero di posizioni da spostare).
    :return: Il testo cifrato.
    """
    risultato = ""
    testo = testo.upper()  # Convertiamo tutto in maiuscolo per uniformità
    for carattere in testo:
        if carattere in ALFABETO_ITALIANO:
            indice = ALFABETO_ITALIANO.index(carattere)
            nuovo_indice = (indice + chiave) % len(ALFABETO_ITALIANO)
            risultato += ALFABETO_ITALIANO[nuovo_indice]
        else:
            risultato += carattere  # Mantiene i caratteri non alfabetici inalterati
    return risultato

Funzione di decifratura

La decifratura funziona allo stesso modo, ma le lettere vengono spostate all’indietro. Anche qui, i caratteri non alfabetici vengono mantenuti intatti.

def decifra_cesare(testo, chiave):
    """
    Funzione che decifra un testo cifrato usando il Cifrario di Cesare con una chiave data.
    :param testo: Il testo cifrato.
    :param chiave: La chiave usata per la cifratura.
    :return: Il testo in chiaro decifrato.
    """
    risultato = ""
    testo = testo.upper()
    for carattere in testo:
        if carattere in ALFABETO_ITALIANO:
            indice = ALFABETO_ITALIANO.index(carattere)
            nuovo_indice = (indice - chiave) % len(ALFABETO_ITALIANO)
            risultato += ALFABETO_ITALIANO[nuovo_indice]
        else:
            risultato += carattere
    return risultato

2. Attacco a Forza Bruta

Un cifrario di Cesare è facilmente vulnerabile a un attacco a forza bruta, perché ci sono solo 20 chiavi possibili con l’alfabeto italiano (poiché l’alfabeto ha 21 lettere). In un attacco a forza bruta, proviamo ogni possibile chiave e verifichiamo il risultato.

Nel nostro programma, scriveremo una funzione che prova tutte le chiavi possibili e visualizza ogni possibile decifratura. Questo ci permette di scoprire facilmente quale chiave è stata utilizzata per cifrare il messaggio originale.

from cesare import decifra_cesare, ALFABETO_ITALIANO

def attacco_forza_bruta(testo_cifrato):
    """
    Funzione che esegue un attacco a forza bruta su un testo cifrato con il Cifrario di Cesare.
    Prova tutte le chiavi da 1 a 20 e stampa i risultati.
    :param testo_cifrato: Il testo cifrato da decifrare.
    """
    for chiave in range(1, len(ALFABETO_ITALIANO)):
        testo_decifrato = decifra_cesare(testo_cifrato, chiave)
        print(f"Chiave {chiave}: {testo_decifrato}")

3. Programma Principale

Infine, il programma principale richiederà all’utente di inserire un testo e una chiave per cifrare il messaggio. L’utente potrà quindi decidere se eseguire un attacco a forza bruta per tentare di decifrare il messaggio.

from cesare import cifra_cesare, decifra_cesare, ALFABETO_ITALIANO
from attacco import attacco_forza_bruta

def main():
    # Informiamo l'utente che useremo l'alfabeto italiano
    print(f"Alfabeto usato: {ALFABETO_ITALIANO}")

    # Prendi il testo in chiaro dall'utente
    testo_in_chiaro = input("Inserisci il testo da cifrare (usa solo lettere dell'alfabeto italiano): ")
    
    # Prendi la chiave dall'utente
    chiave = int(input(f"Inserisci la chiave di cifratura (numero tra 1 e {len(ALFABETO_ITALIANO) - 1}): "))
    
    # Cifra il testo
    testo_cifrato = cifra_cesare(testo_in_chiaro, chiave)
    print(f"Testo cifrato: {testo_cifrato}")
    
    # Chiedi all'utente se desidera eseguire un attacco a forza bruta
    eseguire_attacco = input("Vuoi eseguire un attacco a forza bruta sul testo cifrato? (s/n): ").lower()
    
    if eseguire_attacco == 's':
        print("Risultati dell'attacco a forza bruta:")
        attacco_forza_bruta(testo_cifrato)

if __name__ == "__main__":
    main()

Attacco a Forza Bruta

Immaginiamo di aver ricevuto un messaggio cifrato con il Cifrario di Cesare ma senza conoscere la chiave. Un attacco a forza bruta ci permette di provare tutte le chiavi possibili per scoprire il testo originale. Questa tecnica è utile quando si sa che un messaggio è stato cifrato con un metodo semplice come il Cifrario di Cesare.

Esempio di Attacco

Supponiamo che il messaggio cifrato sia FLIUD. Non conoscendo la chiave, possiamo eseguire un attacco a forza bruta che prova tutte le chiavi possibili, da 1 a 20, e ci restituisce vari tentativi di decifratura.

Risultati dell’attacco:

Chiave 1: EHHTC
Chiave 2: DGGSB
Chiave 3: CFFRA
Chiave 4: BEEQZ
Chiave 5: ADDPY
...

Osservando i risultati, possiamo identificare facilmente il messaggio corretto, che in questo caso sarà CIFRA con la chiave 3.

Considerazioni sulla Sicurezza

Sebbene il Cifrario di Cesare sia affascinante per la sua semplicità storica, è estremamente insicuro per qualsiasi utilizzo pratico. Con solo 20 possibili chiavi, un attacco a forza bruta è molto semplice e veloce da eseguire. Per crittografie moderne si utilizzano metodi molto più sofisticati, come l’algoritmo AES (Advanced Encryption Standard), che rendono la decifratura senza la chiave praticamente impossibile.

Conclusione

Il Cifrario di Cesare è un eccellente punto di partenza per chiunque sia interessato alla crittografia. Sebbene non sia sicuro per applicazioni reali, è un metodo storico interessante che ci permette di comprendere i concetti fondamentali della cifratura e della decifratura.

Se sei interessato a vedere il codice completo che abbiamo usato per implementare il Cifrario di Cesare in Python, puoi trovarlo al link seguente:

Vedi il codice completo del progetto

Con questo articolo, spero di averti dato una buona panoramica del funzionamento del Cifrario di Cesare e di come possiamo implementarlo e attaccarlo usando Python. Se hai domande o suggerimenti, lascia un commento qui sotto!

Foto di Zanyar Ibrahim su Unsplash

Il quesito recita così: “Oltre ai tradizionali algoritmi di crittografia simmetrici e asimmetrici, molti protocolli di rete sicuri impiegano funzioni hash crittografiche. Descrivere scopo, caratteristiche e applicazioni di questa categoria di algoritmi”.

Questo video è pensato per guidarvi nel redigere una risposta accurata e completa, ma vi ricordo che la soluzione dipende da un personale approccio e da una specifica interpretazione del quesito posto. 
Se avete dubbi o riflessioni non esitate a chiedere ulteriori chiarimenti. 
Buono studio! @profcaforio