exto

Ciao a tutti,
Volevo segnalarvi una lettura interessante appena uscita: Google Cloud ha rilasciato il suo Cybersecurity Forecast 2026.

Visto che lavoriamo nel settore, so che spesso questi report sembrano infiniti, quindi vado dritto al sodo per spiegarvi di che si tratta e perché vale la pena scaricarlo.

Download

Non è la solita "sfera di cristallo" con previsioni campate in aria. È un'analisi basata su dati reali raccolti da chi sta in prima linea (parliamo di Mandiant, Google Threat Intelligence e i team SOC di Google). In pratica, guardano i trend attuali per dirci come si evolveranno le minacce da qui al 2026.

3 cose veloci da sapere (spoiler alert):

1. L'IA è ovunque (nel bene e nel male): Gli attaccanti useranno l'IA non più come eccezione ma come norma, soprattutto per creare phishing vocale iper-realistico e scrivere malware più in fretta. Per noi difensori, invece, la sfida sarà gestire i "Shadow Agent": dipendenti che usano agenti IA autonomi senza permesso, creando buchi di sicurezza enormi.
2. Il Ransomware punta alle fondamenta: Occhio alla virtualizzazione. Gli hacker si stanno spostando dai singoli endpoint agli hypervisor (l'infrastruttura che regge tutto). Colpire lì significa bloccare centinaia di macchine in un colpo solo, bypassando spesso gli EDR classici.
3. Geopolitica sempre attiva: I soliti attori statali (Russia, Cina, ecc.) continueranno a spingere forte, non solo per spionaggio ma per obiettivi strategici a lungo termine.

Facciamo il punto

È un documento utile per capire dove orientare i budget e le strategie di difesa nei prossimi 12-24 mesi. Se volete anticipare le domande del management su "come ci proteggiamo dall'IA", qui trovate qualche risposta concreta.

Ciao a tutti, oggi vi scrivo perchè stavo usando la libreria Python fbchat. Il repository è stato dismesso il 23 settembre 2020, però è ancora utilizzabile e funziona.

Durante l'utilizzo mi sono accorto di un errore presente all'interno della libreria, nella funzione get_files_from_paths chiamata dalla funzione sendLocalFiles. La funzione esegue queste righe:

def sendLocalFiles(
        self, file_paths, message=None, thread_id=None, thread_type=ThreadType.USER
    ):
        """Send local files to a thread.

        Args:
            file_paths: Paths of files to upload and send
            message: Additional message
            thread_id: User/Group ID to send to. See :ref:`intro_threads`
            thread_type (ThreadType): See :ref:`intro_threads`

        Returns:
            :ref:`Message ID <intro_message_ids>` of the sent files

        Raises:
            FBchatException: If request failed
        """
        file_paths = require_list(file_paths)
        with get_files_from_paths(file_paths) as x:
            files = self._upload(x)
        return self._sendFiles(
            files=files, message=message, thread_id=thread_id, thread_type=thread_type
        )

Il problema risiede nella funzione get_files_from_paths che è così formata:

@contextmanager
def get_files_from_paths(filenames):
    files = []
    try:
        for filename in filenames:
            file_obj = open(filename, "rb")
            file_info = (basename(filename), file_obj, guess_type(filename)[0])
            files.append(file_info)
        yield files
    finally:
        for _, fp, _ in files:
            fp.close()

La funzione get_files_from_paths sembra essere implementata correttamente come un generatore usando il decoratore @contextmanager. Tuttavia, c'è un potenziale problema nella chiusura dei file aperti.

Nella riga che inizia con for fn, fp, ft in files:, la chiamata fp.close() viene effettuata per ogni file aperto. Tuttavia, se si verifica un'eccezione durante l'iterazione dei file, ad esempio durante la lettura o l'elaborazione dei dati, il codice salterà alla riga successiva dopo l'istruzione yield files. In questo caso, i file aperti non verranno chiusi correttamente.

Analizziamo il codice riga per riga:

1. @contextmanager è un decoratore fornito dal modulo contextlib che ci permette di definire un generatore come un gestore di contesto. In questo caso, il decoratore abilita la funzione get_files_from_paths per essere utilizzata in un blocco with.

2. get_files_from_paths prende un argomento filenames, che dovrebbe essere una lista di nomi di file.

3. La variabile files viene inizializzata come una lista vuota. Questa lista conterrà le informazioni sui file aperti.

4. Viene eseguito un ciclo for che itera su ciascun filename presente nella lista filenames.

5. Per ogni filename, viene eseguita la seguente operazione:

   • basename(filename) restituisce il nome base del file senza il percorso completo.
   • open(filename, "rb") apre il file in modalità di lettura binaria e restituisce un oggetto file.
   • guess_type(filename)[0] restituisce il tipo MIME del file, prendendo solo la prima parte del risultato restituito. La funzione guess_type viene importata da fbchat.

6. Il risultato dell'operazione precedente viene aggiunto come una tupla alla lista files, che conterrà le informazioni sui file aperti.

7. Viene eseguito l'istruzione yield files, che restituisce files come valore di ritorno del generatore. Questo è il punto in cui viene "parcheggiato" il generatore e viene fornito al blocco with che lo sta utilizzando.

8. Dopo che il blocco with ha completato la sua esecuzione, il controllo ritorna al generatore. Viene eseguito un altro ciclo for che itera su ciascuna tupla (fn, fp, ft) presente in files.

9. Per ogni tupla, viene eseguita l'operazione fp.close() per chiudere il file aperto.

Per garantire che i file vengano chiusi anche in caso di eccezioni, si può utilizzare il costrutto try-finally per assicurarci che la chiusura dei file avvenga correttamente. Ecco una versione modificata della funzione che gestisce la chiusura dei file in modo sicuro:

@contextmanager
def get_files_from_paths(filenames):
    files = []
    try:
        for filename in filenames:
            file_obj = open(filename, "rb")
            file_info = (basename(filename), file_obj, guess_type(filename)[0])
            files.append(file_info)
        yield files
    finally:
        for _, fp, _ in files:
            fp.close()
            
def sendLocalFiles(
    self, file_paths, message=None, thread_id=None, thread_type=ThreadType.USER
):
    """Send local files to a thread.

    Args:
        file_paths: Paths of files to upload and send
        message: Additional message
        thread_id: User/Group ID to send to. See :ref:`intro_threads`
        thread_type (ThreadType): See :ref:`intro_threads`

    Returns:
        :ref:`Message ID ` of the sent files

    Raises:
        FBchatException: If request failed
    """
    file_paths = require_list(file_paths)
    with get_files_from_paths(file_paths) as x:
        try:
            files = self._upload(x)
        except Exception as e:
            for fn, fp, ft in x:
                fp.close()
            raise e

    return self._sendFiles(
        files=files, message=message, thread_id=thread_id, thread_type=thread_type
    )