Rilevamento Vulnerabilità

Analizza il codice in cui l'input controllato dall'utente viene utilizzato per costruire query sul database. Cerca la concatenazione di input non sanificato o metodi ORM suscettibili di injection. Su mobile/desktop, controlla l'uso di database locali/SQLite.

Analizza il codice in cui l'input controllato dall'utente viene utilizzato per costruire query in database NoSQL (MongoDB, ecc.). Cerca l'uso non sicuro di operatori ($where, ecc.) o la costruzione di oggetti di query con dati non sanificati. Tipicamente una vulnerabilità del backend.

Analizza il codice in cui l'input controllato dall'utente potrebbe essere passato a comandi di sistema (es. exec, system, popen). Cerca l'input non sanificato utilizzato nelle stringhe di comando. Controlla le interazioni con codice nativo su mobile/desktop o librerie del sistema operativo.

Analizza il codice in cui l'input controllato dall'utente viene valutato o eseguito direttamente (es. eval, exec, motori di script) senza un'adeguata validazione o sandboxing. Controlla le WebView, il caricamento dinamico del codice o lo scripting incorporato su mobile/desktop/librerie.

Analizza il codice in cui oggetti serializzati da fonti non attendibili (input utente, file, rete) vengono deserializzati senza un'adeguata validazione, portando potenzialmente all'esecuzione di codice in remoto (es. pickle, serializzazione Java/PHP). Può verificarsi su client/server.

Analizza il codice in cui l'input controllato dall'utente (URL, hostname, percorsi) viene utilizzato per effettuare richieste HTTP lato server a risorse interne o esterne senza un'adeguata validazione. Controlla se le app mobile/desktop effettuano richieste basate su input esterno.

Analizza il codice in cui l'input controllato dall'utente viene incorporato direttamente nei template lato server senza un'adeguata sanificazione, consentendo potenzialmente l'esecuzione di codice all'interno del motore di template.

Analizza il codice o le configurazioni del server in cui l'input controllato dall'utente potrebbe essere incluso in file processati dal server web per le direttive SSI (es. ), consentendo potenzialmente l'inclusione di file o l'esecuzione di comandi se l'esecuzione SSI è abilitata.

Scansiona il codice alla ricerca di chiavi API, password, chiavi private, stringhe di connessione a database, credenziali predefinite o altri segreti sensibili hardcoded (cioè scritti direttamente nel codice).

Analizza il codice in cui l'input controllato dall'utente viene utilizzato nei percorsi dei file (lettura, scrittura, inclusione di file) senza un'adeguata sanificazione, consentendo potenzialmente l'accesso a file riservati (LFI/RFI sul server, accesso a file locali su mobile/desktop/librerie).

Analizza il codice lato client (JavaScript) in cui l'input controllato dall'utente (es. da frammenti di URL, parametri, postMessage) viene utilizzato per costruire URL o percorsi per richieste API o navigazione, portando potenzialmente ad accessi a risorse non intenzionali o a reindirizzamenti. Rilevante per WebView/framework JS su mobile/desktop.

Analizza il codice che effettua il parsing di input XML (locale o recuperato). Controlla se l'elaborazione di entità esterne è disabilitata e se l'input dell'utente può influenzare la struttura XML portando a una XXE.

Analizza il codice che gestisce l'upload di file (controlli lato client, validazione lato server). Controlla la validazione di tipi di file, nomi, dimensioni e percorsi di archiviazione per prevenire l'esecuzione di file caricati o il path traversal.

Analizza il codice alla ricerca di endpoint o funzioni sensibili prive di controlli di autenticazione (es. decoratori o middleware mancanti). Controlla i flussi di login, la manipolazione dei parametri o i bypass dell'autenticazione locale su mobile/desktop.

Analizza le policy delle password, la terminazione delle sessioni, i processi di eliminazione degli account e i meccanismi di recupero per individuare falle di sicurezza. Include la gestione delle credenziali locali su desktop/mobile.

Analizza il codice per verificare che i controlli di autorizzazione (ruoli, permessi) siano applicati correttamente lato server dopo l'autenticazione. Cerca falle logiche che consentano l'accesso non autorizzato a funzioni o dati. Controlla la logica di autorizzazione locale su desktop/mobile, se applicabile.

Analizza il codice alla ricerca di funzioni che consentono modifiche non sicure a ruoli/permessi o l'invocazione di funzioni di amministrazione da parte di utenti con privilegi inferiori. Controlla la gestione dei privilegi locali su desktop/mobile/librerie del sistema operativo.

Nelle applicazioni multi-tenant (cioè, se il sistema supporta tenant/organizzazioni), analizza il codice per assicurarsi che tutte le query e le operazioni sui dati siano rigorosamente filtrate dall'ID del tenant dell'utente autenticato. Se l'applicazione non è multi-tenant, questa voce potrebbe non essere pertinente.

Analizza il codice in cui identificatori controllati dall'utente (ID negli URL, parametri) vengono utilizzati per accedere a risorse senza verificare l'autorizzazione dell'utente per quella specifica risorsa. Controlla come le app desktop/mobile costruiscono le richieste.

Analizza funzioni come la registrazione, la modifica del profilo, il reset della password, ecc., alla ricerca di falle logiche che consentano l'account takeover (token prevedibili, mancanza di verifica, ecc.). Include la gestione locale di credenziali/token su desktop/mobile.

Analizza la logica per generare, verificare e gestire i codici OTP/MFA alla ricerca di vulnerabilità di bypass (rate limiting, prevedibilità, salto di passaggi). Controlla la gestione lato client su desktop/mobile.

Analizza l'uso di JWT: verifica della firma (alg 'none', chiavi deboli), validazione dei claim (exp, iss, aud), archiviazione non sicura (es. localStorage, archiviazione non sicura su mobile/desktop).

Se viene utilizzato SAML, analizza il codice di elaborazione: validazione della firma, XXE nel parsing, logica dell'ACS, validazione di condition/audience.

Analizza i flussi OAuth/OIDC: validazione del parametro 'state' (CSRF), gestione non sicura del codice, problemi del flusso implicito, validazione dell'URI di reindirizzamento. Controlla l'implementazione lato client su mobile/web/desktop.

Analizza le app multi-tenant con IDP configurabili dal tenant (SAML/OIDC): sicurezza della configurazione (SSRF, redirect), parsing (XXE), elaborazione delle asserzioni (bypass della firma, injection di claim), provisioning, rischi di ATO del tenant.

Analizza il codice alla ricerca di sequenze "check-then-act" (controlla-poi-agisci) senza lock, operazioni non atomiche, mancanza di vincoli sul DB, che possono portare a stati incoerenti o bypass. Può verificarsi su client/server.

Analizza il codice in cui l'input dell'utente viene riflesso in HTML/JS senza una corretta codifica contestuale (reflected, stored). Controlla le WebView, i browser incorporati o il rendering HTML dinamico su mobile/desktop.

Analizza il JS lato client in cui l'input da sorgenti (URL, postMessage) fluisce verso sink (eval, innerHTML, location) senza sanificazione (DOM-XSS, Open Redirect). Rilevante per WebView/framework JS su mobile/desktop.

Analizza il codice in cui l'input dell'utente viene inserito negli header HTTP senza sanificare CR (\r) e LF (\n), consentendo l'iniezione di header o lo splitting della risposta.

Analizza come l'applicazione elabora e si fida degli header HTTP in entrata come Host, X-Forwarded-For, X-Forwarded-Host e altri header controllabili dal client. Cerca vulnerabilità in cui la manipolazione di questi header può portare a bypassare i controlli di sicurezza (es. restrizioni basate su IP), web cache poisoning, SSRF, logica applicativa errata o a provocare altri comportamenti imprevisti. Assicurati che gli header siano validati correttamente prima dell'uso in contesti sensibili alla sicurezza.

Analizza il codice in cui l'input dell'utente determina le destinazioni di reindirizzamento senza una validazione rispetto a una lista di permessi (allow-list). Controlla WebView/gestori di schemi personalizzati/browser incorporati su mobile/desktop.

Analizza il codice per l'esposizione di dati sensibili: dettagli del server (errori, log, commenti), informazioni utente (risposte verbose, esposizione di PII, logging non sicuro). In particolare, cerca API o strutture dati che restituiscono più dati del necessario per la funzionalità, come l'esposizione di interi oggetti/modelli utente (inclusi campi sensibili come chiavi API, flag interni o PII non necessarie) quando è richiesto solo un sottoinsieme di informazioni. Controlla l'archiviazione locale/log/configurazioni su mobile/desktop.

Scansiona il codice alla ricerca di algoritmi deboli (MD5, SHA1, DES), modalità non sicure (ECB), confronti non a tempo costante, casualità non sicura, mancanza di crittografia/hashing adeguati per i dati sensibili.

Analizza le richieste che modificano lo stato: controlla l'implementazione/validazione dei token anti-CSRF, i cookie SameSite, gli header standard. Considera il CSRF tramite deeplink mobile o WebView.

Analizza il codice e i file di configurazione (es. Nginx, configurazioni cloud, Dockerfile, IaC) alla ricerca di errori di configurazione della sicurezza come modalità di debug, credenziali predefinite, header/cookie non sicuri, CORS permissivo, errori dettagliati o permessi impropri. Inoltre, revisiona i manifest delle app mobile/desktop, le impostazioni di build e le configurazioni delle applicazioni locali.

Analizza il codice in cui l'input dell'utente costruisce query LDAP senza sanificazione. Tipicamente una vulnerabilità del backend.

Analizza il codice che genera file scaricabili/esportabili (CSV, XLSX) utilizzando l'input dell'utente. Controlla la sanificazione/escaping dell'input che inizia con (=, +, -, @, ＝).

Analizza il codice che genera documenti (PDF, DOCX) utilizzando librerie. Cerca l'uso non sicuro dell'input che porta a XSS, SSRF, command injection o exploit di librerie. Può verificarsi su client/server.

Analizza il codice (specialmente C/C++, nativo per mobile/desktop/librerie) alla ricerca di operazioni aritmetiche su numeri controllati dall'utente senza controllo dei limiti, che possono portare a bypass o comportamenti inattesi.

(JavaScript/Node.js) Analizza il codice alla ricerca di pattern (unione ricorsiva, definizione di proprietà tramite percorso) in cui l'input dell'utente può modificare i prototipi degli oggetti globali (potenziale bypass, DoS, RCE). Rilevante per WebView/framework JS su mobile/desktop.

Analizza il codice del gestore WebSocket: validazione dell'input, controlli di autorizzazione (authz), XSS nei messaggi. Controlla la presenza di Cross-Site WebSocket Hijacking (CSWSH) tramite controlli deboli dell'origine. Controlla la gestione lato client su desktop/mobile.

Rivedi i file di configurazione dell'applicazione e del server e il codice correlato per impostazioni di cache non sicure. Ciò include l'uso improprio dell'header Vary, impostazioni di cache del framework mal configurate o header di controllo della cache espliciti errati che potrebbero portare alla memorizzazione errata di dati sensibili, cache poisoning o cache deception basati sulla configurazione stessa.

Analizza il codice alla ricerca di pattern di DoS: ReDoS, operazioni costose basate su input senza limiti, esaurimento delle risorse (zip bombs), attacchi di complessità algoritmica. Controlla la gestione delle risorse locali su desktop/mobile/librerie.

Analizza il codice in cui i framework collegano l'input dell'utente a oggetti/modelli. Controlla se il filtraggio impedisce l'impostazione di proprietà interne/sensibili alla sicurezza.

Analizza il codice in cui il tipo, il formato, la lunghezza o l'intervallo dell'input non vengono validati prima dell'uso nella logica, alterando potenzialmente il flusso di controllo, bypassando le regole o causando stati incoerenti.

Analizza il codice di pagamento/carrello/prezzi. Controlla la presenza di bypass della manipolazione dei prezzi lato client, validazione non sicura di articoli/quantità, problemi di valuta/arrotondamento, abuso di sconti/coupon e race condition durante il processo di acquisto iniziale (es. utilizzo di crediti più volte).

Analizza la logica per i webhook di pagamento di terze parti (es. Stripe, PayPal) e la gestione del ciclo di vita degli abbonamenti. Verifica la validazione della firma del webhook. Assicurati che tutti gli eventi pertinenti siano gestiti per aggiornare correttamente lo stato dell'utente/servizio (es. charge.refunded, customer.subscription.deleted, invoice.payment_failed). Controlla la presenza di race condition negli aggiornamenti di stato e la validazione non sicura dello stato del pagamento.

Analizza il codice (specialmente C/C++, nativo per mobile/desktop/librerie) alla ricerca di funzioni che gestiscono l'input dell'utente (strcpy, gets, memcpy) senza controllo dei limiti (corruzione della memoria, esecuzione di codice).

Analizza il codice (specialmente C/C++, nativo per mobile/desktop/librerie) alla ricerca di puntatori utilizzati dopo aver liberato la memoria (crash, corruzione dei dati, esecuzione di codice).

Analizza il codice (specialmente C/C++, nativo per mobile/desktop/librerie) alla ricerca di tentativi di liberare la stessa area di memoria due volte (corruzione della memoria, sfruttamento).

Analizza il codice (specialmente C/C++, nativo per mobile/desktop/librerie) in cui l'input dell'utente viene utilizzato direttamente come argomento della stringa di formato (printf, sprintf), consentendo la lettura/scrittura della memoria.

Analizza il codice dell'app mobile per l'archiviazione di dati sensibili (credenziali, PII, token) in posizioni non sicure (es. SharedPreferences senza crittografia, archiviazione esterna, log, database non sicuri) accessibili da altre app o utenti con accesso fisico.

Analizza il codice dell'app mobile per la presenza e l'efficacia dei meccanismi di rilevamento di root/jailbreak, anti-debugging e rilevamento di emulatori. Controlla se questi controlli possono essere facilmente bypassati (es. solo controlli lato client, logica prevedibile).

Analizza il codice dell'app mobile che gestisce schemi URL personalizzati (deeplink). Controlla la mancanza di validazione dell'input sui parametri (potenziale per XSS, Path Traversal, SQLi se passati al backend), i rischi di CSRF (se le azioni vengono attivate senza l'intenzione dell'utente) o gli Open Redirect.

Analizza il codice dell'app mobile che utilizza le WebView. Controlla se l'esecuzione di JavaScript è abilitata (setJavaScriptEnabled(true)), se il bridge JavaScript (addJavascriptInterface) espone funzioni native sensibili e se il contenuto caricato è validato correttamente (potenziale per XSS, caricamento di contenuti non attendibili).

Analizza la configurazione di rete e il codice dell'app mobile. Controlla la disabilitazione dell'App Transport Security (ATS) su iOS, il traffico in chiaro consentito su Android, la mancanza di certificate pinning o configurazioni TLS/SSL non sicure.

Analizza il codice dell'app mobile che legge/elabora file da archiviazione esterna o da posizioni accessibili da altre app. Controlla la presenza di Path Traversal, la mancanza di validazione sul contenuto del file o una gestione non sicura che potrebbe portare all'esecuzione di codice o alla fuga di dati se un'app dannosa modifica il file.

Analizza il codice dell'app mobile che utilizza meccanismi IPC (es. Intent, Content Provider, Broadcast Receiver su Android; XPC su iOS). Controlla la presenza di componenti protetti in modo improprio (permessi mancanti, filtri di intent troppo ampi), la fuga di dati o la capacità per le app dannose di inviare messaggi creati ad hoc per scatenare azioni non intenzionali.

Analizza il codice dell'app mobile che implementa l'autenticazione biometrica. Controlla se il risultato dell'autenticazione è validato lato server o se è possibile un bypass lato client. Assicurati che i meccanismi di fallback siano sicuri.

Analizza il codice degli smart contract per vulnerabilità di reentrancy, in cui chiamate esterne possono rientrare nel contratto chiamante prima che l'esecuzione iniziale sia completata, portando potenzialmente a incoerenze di stato o al drenaggio di fondi. Cerca pattern come "call-after-state-change" invece di "check-effects-interactions".

Analizza il codice degli smart contract per vulnerabilità di integer overflow o underflow nelle operazioni aritmetiche, specialmente quelle che coinvolgono saldi di token o calcoli critici. Assicurati che vengano utilizzate librerie matematiche sicure.

Analizza la logica degli smart contract che si basa su block.timestamp o block.number per operazioni critiche (es. sblocco di fondi, determinazione dei vincitori). Questi possono essere manipolati dai miner in una certa misura.

Analizza gli smart contract alla ricerca di funzioni o cicli che potrebbero consumare una quantità illimitata di gas, portando a un denial of service per gli utenti o per il contratto stesso. Cerca pattern come l'iterazione su array di grandi dimensioni o calcoli complessi che possono superare i limiti di gas del blocco.

Analizza la logica degli smart contract per vulnerabilità in cui l'esito di una transazione può essere influenzato dall'ordine in cui le transazioni vengono minate. Cerca scenari in cui un aggressore può osservare una transazione e inviarne una propria per sfruttare il sistema (es. exchange decentralizzati, aste).

Analizza gli smart contract che si basano su fonti di dati esterne (oracoli). Controlla come i dati vengono recuperati, validati e utilizzati. Cerca vulnerabilità in cui l'oracolo può essere manipolato o i suoi dati possono essere influenzati per sfruttare il contratto.

Analizza il codice degli smart contract che utilizza delegatecall. Assicurati che il layout dello storage del contratto di destinazione sia compatibile e che delegatecall non venga utilizzato con contratti non attendibili, il che potrebbe portare alla corruzione dello storage o all'esecuzione di codice arbitrario nel contesto del contratto chiamante.

Analizza le funzioni degli smart contract per meccanismi di controllo degli accessi adeguati (es. onlyOwner, require(msg.sender == authorized_address)). Cerca funzioni sensibili che possono essere chiamate da utenti non autorizzati.

Esegui una revisione generale della logica di business dello smart contract per identificare falle, casi limite o comportamenti non intenzionali che potrebbero essere sfruttati. Ciò richiede la comprensione dello scopo previsto del contratto.

Analizza gli smart contract che richiedono casualità. L'utilizzo di fonti on-chain come blockhash o block.timestamp per la casualità può essere prevedibile o influenzato dai miner. Controlla la dipendenza da tali fonti per decisioni critiche di sicurezza.

Analizza le configurazioni di server, proxy e gateway applicativi (es. Nginx, Apache, HAProxy, CloudFront, configurazioni di API Gateway, IaC come Terraform/CloudFormation) per impostazioni che potrebbero abilitare l'HTTP Request Smuggling. Cerca configurazioni che portano a un'analisi ambigua delle richieste tra i sistemi frontend e backend, come la gestione errata degli header Content-Length e Transfer-Encoding, o l'elaborazione errata della codifica chunked. Ciò può consentire agli aggressori di anteporre o aggiungere dati alle richieste di altri utenti.

Analizza il codice per Cross-Site Script Inclusion (XSSi) e Cross-Site Leaks (XS-Leaks). Cerca dati sensibili (JSON, CSV, immagini) restituiti senza un adeguato isolamento (es. mancanza di header X-Content-Type-Options: nosniff, COOP/COEP) o accessibili tramite tag script/frame da altre origini. Controlla i canali laterali (tempistica, eventi di errore) che potrebbero far trapelare informazioni tra le origini.

Analizza Infrastructure as Code (IaC) o file di configurazione per impostazioni di cloud storage non sicure (es. bucket S3, Azure Blobs). Cerca accesso pubblico, mancanza di crittografia, mancanza di logging/versioning o policy di bucket eccessivamente permissive.

Analizza IaC e configurazioni cloud per policy di Identity and Access Management (IAM) eccessivamente permissive. Cerca l'uso di caratteri jolly (*), mancato rispetto del principio di privilegio minimo, credenziali IAM hardcoded o policy di attendibilità per l'assunzione di ruoli non sicure.

Analizza Dockerfile e manifest Kubernetes. Cerca esecuzione come root, direttive utente mancanti, uso di tag 'latest', mount sensibili, modalità privilegiata o mancanza di limiti di risorse.

Analizza Terraform, CloudFormation o altri file IaC per le best practice di sicurezza. Cerca risorse non crittografate, gruppi di sicurezza aperti (0.0.0.0/0), backup mancanti o impostazioni predefinite non sicure.

Analizza il codice per identificare se l'applicazione utilizza parser diversi per lo stesso formato di dati (es. JSON, YAML, XML) tra diversi componenti (es. frontend vs backend, proxy vs applicazione). Le discrepanze nel parsing possono essere sfruttate per bypassare i controlli di sicurezza, portando a vulnerabilità come bypass dell'autenticazione, XSS o SQL injection. Ad esempio, un proxy potrebbe vedere un set di parametri mentre l'applicazione backend ne vede un altro.

Controlla se l'endpoint GraphQL ha l'introspezione abilitata negli ambienti di produzione. L'introspezione consente agli aggressori di interrogare l'intero schema, rivelando tutte le query, mutazioni, sottoscrizioni, tipi e campi disponibili. Questa fuga di informazioni aiuta significativamente gli aggressori a comprendere l'API e a scoprire potenziali vulnerabilità.

Indaga se l'endpoint GraphQL consente il batching delle query, dove più query possono essere inviate in una singola richiesta HTTP. Se non adeguatamente limitato, gli aggressori possono abusare di questa funzionalità per eseguire contemporaneamente un gran numero di query complesse, sovraccaricando il server e causando un attacco Denial of Service (DoS).

Analizza il codice di pagamento/carrello/prezzi: bypass della manipolazione dei prezzi lato client, validazione non sicura dello stato del pagamento, race condition (sconti/crediti), problemi di valuta/arrotondamento, validazione quantità/articolo.

Analizza i file di test (unitari, integrazione, e2e) per comprendere la logica aziendale, i casi limite e le potenziali lacune di sicurezza. Cerca test di sicurezza commentati, test per bug noti o dati di test che rivelano logica sensibile.

Analizza il codice che interagisce con Large Language Models (LLMs). Cerca vulnerabilità di Prompt Injection, gestione non sicura degli output LLM (XSS tramite LLM) o fuga di contesto sensibile nei prompt.

Esamina la documentazione del progetto e i commenti del codice. Le discrepanze tra documentazione e implementazione rivelano spesso bug o problemi di sicurezza. I commenti possono contenere TODO, avvisi o spiegazioni di logica complessa che suggeriscono vulnerabilità.