Sicurezza nel codice, vulnerabilità e rischi comuni

Dopo aver visto come utilizzare Claude Code per il debugging guidato e per il refactoring sicuro, possiamo affrontare un tema fondamentale nello sviluppo software moderno: la sicurezza del codice. Ogni applicazione, indipendentemente dalle dimensioni o dal settore in cui opera, è esposta a potenziali vulnerabilità che possono compromettere dati, servizi e infrastrutture. In molti casi gli incidenti di sicurezza non derivano da sofisticati attacchi informatici, ma da errori apparentemente banali introdotti durante lo sviluppo.

In questo contesto Claude Code può diventare uno strumento estremamente utile. Oltre a supportarci nella scrittura e nella correzione del codice, l'agente può aiutarci a identificare pattern rischiosi, verificare la presenza di vulnerabilità comuni e suggerire miglioramenti orientati alla sicurezza. Non dobbiamo però considerarlo un sostituto delle attività di security review o dei test specialistici. Il suo valore consiste nell'aggiungere un ulteriore livello di analisi durante il ciclo di sviluppo, permettendoci di individuare problemi prima che raggiungano gli ambienti di produzione. In questa lezione analizzeremo alcune delle vulnerabilità più diffuse e vedremo come Claude Code possa supportarci nella loro individuazione e mitigazione.

La sicurezza come responsabilità dello sviluppatore

Uno degli errori più frequenti consiste nel considerare la sicurezza come una responsabilità esclusiva dei team di cybersecurity. In realtà la maggior parte delle vulnerabilità nasce direttamente nel codice applicativo. Ogni scelta progettuale, ogni query verso il database e ogni gestione dell'input utente può influire sul livello di sicurezza complessivo del sistema. Utilizzando Claude Code possiamo iniziare a integrare verifiche di sicurezza direttamente durante lo sviluppo.

Ad esempio, invece di chiedere semplicemente se una funzione è corretta, possiamo domandare:

Analizza questa funzione dal punto di vista della sicurezza. Identifica possibili vulnerabilità e suggerisci miglioramenti.

Questo approccio trasforma l'agente in un supporto costante per l'analisi preventiva dei rischi.

Individuare vulnerabilità SQL Injection

Una delle vulnerabilità più note e ancora oggi diffuse è la SQL Injection. Essa si verifica quando dati controllati dall'utente vengono concatenati direttamente all'interno di una query SQL.

Consideriamo questo esempio:

app.get("/user", async (req, res) => {
    const username = req.query.username;
    const query =
        "SELECT * FROM users WHERE username = '" +
        username +
        "'";
    const result = await db.query(query);
    res.json(result);
});

A prima vista il codice sembra funzionare correttamente. Un utente malintenzionato potrebbe però manipolare il parametro username per alterare il comportamento della query.

Se chiediamo a Claude Code di analizzare questo frammento, l'agente evidenzierà immediatamente il problema e suggerirà l'utilizzo di query parametrizzate.

Una possibile correzione potrebbe essere:

app.get("/user", async (req, res) => {
    const username = req.query.username;
    const result = await db.query(
        "SELECT * FROM users WHERE username = ?",
        [username]
    );
    res.json(result);
});

In questo modo il database tratta il parametro come dato e non come parte del comando SQL.

Questo esempio dimostra come Claude Code possa aiutarci a riconoscere rapidamente vulnerabilità che, soprattutto in progetti complessi, potrebbero passare inosservate.

Gestire correttamente l'input degli utenti

Gran parte dei problemi di sicurezza nasce dalla fiducia eccessiva nei dati ricevuti dall'esterno. Qualsiasi input proveniente da utenti, API, file o servizi esterni dovrebbe essere considerato potenzialmente malevolo fino a prova contraria.

Consideriamo il seguente esempio:

function createUser(data) {
    return database.insert(data);
}

Il codice è estremamente semplice, ma non effettua alcuna validazione.

Possiamo chiedere a Claude Code:

Analizza questa funzione. Quali controlli di sicurezza dovrebbero essere aggiunti?

L'agente potrebbe suggerire verifiche sulla lunghezza dei campi, sul formato delle email, sulla presenza di caratteri inattesi e sulla validazione dei dati obbligatori.

Una versione migliorata potrebbe essere:

function createUser(data) {
    if (!data.email) {
        throw new Error("Email obbligatoria");
    }
    if (!data.email.includes("@")) {
        throw new Error("Formato email non valido");
    }
    return database.insert(data);
}

Naturalmente in applicazioni reali utilizzeremo librerie di validazione più sofisticate, ma il principio rimane lo stesso: ogni dato esterno deve essere verificato prima di essere utilizzato.

Sicurezza delle informazioni sensibili

Un altro errore molto diffuso riguarda la gestione delle informazioni sensibili. Password, token di accesso, chiavi API e credenziali di servizio non dovrebbero mai essere esposte nel codice sorgente.

Consideriamo questo esempio:

const apiKey =
    "MY_SUPER_SECRET_KEY";
const client =
    new PaymentClient(apiKey);

Claude Code riconoscerà immediatamente il problema e suggerirà di utilizzare variabili d'ambiente.

Una soluzione più sicura potrebbe essere:

const apiKey =
    process.env.PAYMENT_API_KEY;
const client =
    new PaymentClient(apiKey);

Questo approccio riduce il rischio di esposizione accidentale delle credenziali nei repository Git o nei sistemi di versionamento.

Durante le code review possiamo utilizzare Claude Code anche per individuare automaticamente segreti hardcoded presenti nel codice.

Sicurezza, error handling e informazioni eccessive

Gli errori applicativi rappresentano un'altra fonte frequente di vulnerabilità. Molti sistemi restituiscono dettagli tecnici che possono fornire informazioni preziose a un attaccante.

Consideriamo questo esempio:

app.get("/profile", async (req, res) => {
    try {
        const profile =
            await service.loadProfile();
        res.json(profile);
    } catch (error) {
        res.status(500).json(error);
    }
});

Restituire direttamente l'oggetto errore può esporre stack trace, percorsi di file, configurazioni interne o dettagli del database.

Claude Code suggerirà generalmente una gestione più prudente:

app.get("/profile", async (req, res) => {
    try {
        const profile =
            await service.loadProfile();
        res.json(profile);
    } catch (error) {
        logger.error(error);
        res.status(500).json({
            message:
                "Errore interno del server"
        });
    }
});

In questo modo i dettagli tecnici vengono registrati nei log interni senza essere esposti all'esterno.

Vulnerabilità Cross-Site Scripting (XSS)

Le applicazioni web che visualizzano contenuti generati dagli utenti devono prestare particolare attenzione agli attacchi XSS.

Immaginiamo di avere questo codice:

app.get("/comment", (req, res) => {
    const comment =
        req.query.comment;
    res.send(
        "
" + comment + "
"
    );
});

Se il valore di comment contiene codice JavaScript, esso potrebbe essere eseguito nel browser dell'utente.

Chiedendo a Claude Code un'analisi di sicurezza, l'agente individuerà il rischio e suggerirà la sanitizzazione o l'escaping dell'output.

In generale, una buona pratica consiste nel non fidarsi mai di contenuti provenienti dagli utenti e utilizzare sempre meccanismi di encoding appropriati.

Conclusioni

La sicurezza del codice rappresenta uno degli aspetti più importanti dello sviluppo software moderno. Vulnerabilità come SQL Injection, XSS, esposizione di credenziali, error handling non sicuro e controlli di autorizzazione insufficienti possono avere conseguenze molto gravi sia per gli utenti sia per le organizzazioni.

Claude Code può aiutarci a individuare questi problemi in modo rapido e contestuale, supportandoci nell'analisi del codice, nelle attività di revisione e nella progettazione di soluzioni più robuste. Il suo ruolo non è quello di sostituire gli strumenti specialistici di sicurezza o l'esperienza degli sviluppatori, ma di affiancarli attraverso un processo continuo di analisi e miglioramento.

Nella prossima e ultima lezione vedremo come portare queste competenze in un contesto operativo reale, affrontando il tema dell'hardening applicativo e dell'integrazione dei workflow agentici negli ambienti di produzione, dove affidabilità, sicurezza e automazione devono convivere in modo equilibrato ed efficace.