Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
NodeSecurityShield — Un pacchetto facile da usare per sviluppatori e ingegneri della sicurezza per proteggere applicazioni NodeJS. | Kitploit
Strumenti/GitHubGitHub/domdogsec/nodesecurityshield
Strumenti DifensiviAnalisi delle Vulnerabilità
GitHubdomdogsec/nodesecurityshield

NodeSecurityShield

Un pacchetto facile da usare per sviluppatori e ingegneri della sicurezza per proteggere applicazioni NodeJS.

Vedi Repository
2973 anni faRevisionato da Kitploit

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

Node Security Shield

Node Security Shield (NSS) è uno strumento Open source di Runtime Application Self-Protection (RASP) che mira a colmare il divario per una sicurezza NodeJS completa consentendo a Sviluppatore e Ingegnere della Sicurezza di dichiarare a quali risorse un'applicazione può accedere.

Ispirati dalla vulnerabilità Log4Shell (CVE-2021-44228) che può essere sfruttata perché un'applicazione può effettuare chiamate di rete arbitrarie, abbiamo ritenuto necessario che un'applicazione abbia un meccanismo per dichiarare quali privilegi consente, al fine di rendere più difficile lo sfruttamento di tali vulnerabilità implementando controlli aggiuntivi.

Per raggiungere questo obiettivo, NSS (Node Security Shield) ha una Resource Access Policy (RAP)

Resource Access Policy (RAP)

Resource Access Policy è simile a CSP (Content Security Policy).

Permette allo sviluppatore/ingegnere della sicurezza di dichiarare a quali risorse un'applicazione dovrebbe accedere. E Node Security Shield lo imporrà.

Installazione

Installare NodeSecurityShield tramite npm

root@kitploit:~
npm install nodesecurityshield

Utilizzo

root@kitploit:~
// Require Node Security Shield
let nodeSecurityShield = require('nodesecurityshield');

// Enable Attack Monitoring and/or Blocking
nodeSecurityShield.enableAttackMonitoring("Unique-App-Id",resourceAccessPolicy ,callbackFunction);

Esempio resourceAccessPolicy [BASE]

root@kitploit:~
const resourceAccessPolicy  = {
  "outBoundRequest" : {

      "blockedDomains" : ["compromised.domdog.io"],
    
      "allowedDomains" : []
   },
	"executedCommand": {

        "allowedCommands": ["pwd" , "(node)[](https://github.com/domdogsec/nodesecurityshield/blob/HEAD/helper%5C/)[a-z|0-9]*(.js)"]
   }
};
  • outBoundRequest: definisce il comportamento accettato per le Richieste in uscita
    • Nota: blockedDomains ha precedenza su allowedDomains.
    • cioè, le richieste vengono controllate prima rispetto a blockedDomains poi a allowedDomains.
  • executedCommand: definisce il comportamento accettato per Esecuzione di comandi
    • L'array allowedCommands accetta String. Puoi passare una RegEx per consentire un pattern di comandi.
    • Il comportamento predefinito è bloccare tutte le esecuzioni di comandi. A condizione che RAP abbia definita la proprietà executedCommand.
    • Quando viene utilizzata la RAP sopra, il comando pwd è consentito e i file all'interno di possono essere generati come processi node.

Esempio callbackFunction per registrare le violazioni della RAP nella console.

root@kitploit:~
var callbackFunction = function (violationEvent,violations,violationLimitPerMinReached) {
  console.log(JSON.stringify(violationEvent,null, 4));
}
  • violationEvent - Violazione RAP che si è verificata. Viene presentata come una violazione CSP.

  • violations - Conteggio delle violazioni RAP. Viene azzerato ogni minuto.

  • violationLimitPerMinReached - true se il conteggio delle violazioni RAP supera 'maxViolationsPerMinute' [un'opzione in RAP]

  • Per bloccare un attacco - genera un errore

    root@kitploit:~
    throw new Error("Request Blocked. It violates declared Resource Access Policy.")
    

Esempio violationEvent

root@kitploit:~
{
    "csp-report": {
        "document-uri": "https://Unique-App-Id",
        "blocked-uri": "https://compromised.domdog.io:443",
        "violated-directive": "connect-src",
        "effective-directive": "connect-src",
        "original-policy": "{\"outBoundRequest\":{\"blockedDomains\":[\"compromised.domdog.io\"],\"allowedDomains\":[]}}",
        "disposition": "report",
        "status-code": 200,
        "script-sample": "",
        "source-file": "Error\n    at TLSSocket.obj.<computed> [as connect] (/mnt/c/Ironwasp/Product/NodeSecurityShield/lib/hook.js:20:25)\n    at Object.connect (_tls_wrap.js:1606:13)\n    at Agent.createConnection (https.js:126:22)\n    at Agent.createSocket (_http_agent.js:273:26)\n    at Agent.addRequest (_http_agent.js:232:10)\n    at new ClientRequest (_http_client.js:302:16)\n    at request (https.js:310:10)\n    at Object.get (https.js:314:15)\n    at /mnt/c/Ironwasp/RD/Node/SimpleVulnerableNode/routes/ssrf.js:19:19\n    at Layer.handle [as handle_request] (/mnt/c/Ironwasp/RD/Node/SimpleVulnerableNode/node_modules/express/lib/router/layer.js:95:5)"
    }
}
  • document-uri: contiene Unique-App-Id, passato durante l'inizializzazione di NSS
  • blocked-uri: dominio della richiesta in uscita che ha violato la RAP
  • violated-directive: connect-src è un sinonimo di Richiesta in uscita, allo stesso modo script-src è un sinonimo di Esecuzione di comandi
  • original-policy: Resource Access Policy (RAP) violata
  • source-file: Stack Trace di dove si è verificata questa violazione.

Integrazione con Sentry

Esempio resourceAccessPolicy per integrazione con Sentry

root@kitploit:~
const resourceAccessPolicy  = {
  "outBoundRequest" : {

      "blockedDomains" : ["compromised.domdog.io"],
    
      "allowedDomains" : []
    },
	"executedCommand": {

        "allowedCommands": ["pwd" , "(node)[](https://github.com/domdogsec/nodesecurityshield/blob/HEAD/helper%5C/)[a-z|0-9]*(.js)"]
   },
	"reportUri": "https://ingest.sentry.io/api/6011856/security/?sentry_key=",

};
  • outBoundRequest: definisce il comportamento accettato per le Richieste in uscita
    • Nota: blockedDomains ha precedenza su allowedDomains.
    • cioè, le richieste vengono controllate prima rispetto a blockedDomains poi a allowedDomains.
  • executedCommand: definisce il comportamento accettato per Esecuzione di comandi
    • L'array allowedCommands accetta String. Puoi passare una RegEx per consentire un pattern di comandi.
    • Il comportamento predefinito è bloccare tutte le esecuzioni di comandi. A condizione che RAP abbia definita la proprietà executedCommand.
    • Quando viene utilizzata la RAP sopra, il comando pwd è consentito e i file all'interno di possono essere generati come processi node.

Screenshot dalla dashboard di Sentry sentry issues sentry issues

Esempio resourceAccessPolicy [Avanzato]

root@kitploit:~
const resourceAccessPolicy = {
    "outBoundRequest" : {
    
        "blockedDomains" : ["compromised.domdog.io"],
        
        "allowedDomains" : ["domdog.io","*.domdog.io", 
           
            {
                "domains": [
                    "domgo.at",
                ],
                "modules": [
                    {
                        "file": "\/routes\/ssrf.js",
                    },
                    {
                        "file": "\/node_modules\/axios\/",
                    }
                ]
            },
            {
                "domains": [
                    "cluster0-shard-00-00.lb9jm.mongodb.net",
                    "cluster0-shard-00-01.lb9jm.mongodb.net",
                    "cluster0-shard-00-02.lb9jm.mongodb.net"
                ],
                "modules": [
                    {
                        "file": "\/node_modules\/mongodb\/"
                    }
                ]
            }
          
        ]
    },
		"executedCommand": {

            "allowedCommands": ["pwd" , "(node)[](https://github.com/domdogsec/nodesecurityshield/blob/HEAD/helper%5C/)[a-z|0-9]*(.js)"]
	   },
    
    "reportUri": "https://endpoint-to-send-violations",
    
    "maxViolationsPerMinute": 50
  }
  • outBoundRequest: definisce il comportamento accettato per le Richieste in uscita
    • Nota: blockedDomains ha precedenza su allowedDomains.
    • cioè, le richieste vengono controllate prima rispetto a blockedDomains poi a allowedDomains.
  • executedCommand: definisce il comportamento accettato per Esecuzione di comandi
    • L'array allowedCommands accetta String. Puoi passare una RegEx per consentire un pattern di comandi.
    • Il comportamento predefinito è bloccare tutte le esecuzioni di comandi. A condizione che RAP abbia definita la proprietà executedCommand.
    • Quando viene utilizzata la RAP sopra, il comando pwd è consentito e i file all'interno di possono essere generati come processi node.

Funzionalità

  • Monitoraggio degli attacchi
    • Chiamate di rete in uscita
    • Esecuzione di comandi
  • Blocco degli attacchi
    • Chiamate di rete in uscita
    • Esecuzione di comandi
  • Controllo specifico per modulo

Roadmap

  • Monitoraggio degli attacchi
    • Chiamate ai file
  • Blocco degli attacchi
    • Chiamate ai file
  • Scanner di vulnerabilità

Autori

  • Lavakumar Kuppan
    • Github - @lavakumar
    • Twitter - @lavakumark
  • Sukesh Pappu
    • Github - @thelogicalbeard
    • Twitter - @thelogicalbeard

Contributori

  • Ayusman Samal
    • Github - @p1xxxel

Licenza

Apache License 2.0

Scarica lo strumento
.js
helper
  • Nota: Evita l'uso di .* nelle regex. Poiché ciò consentirebbe l'esecuzione di qualsiasi comando dopo una pipe |.
  • .js
    helper
  • Nota: Evita l'uso di .* nelle regex. Poiché ciò consentirebbe l'esecuzione di qualsiasi comando dopo una pipe |.
  • reportUri : Invia le violazioni a un dato endpoint. Poiché le violazioni sono simili a quelle della Content Security Policy, è possibile utilizzare qualsiasi soluzione di monitoraggio CSP. Nell'esempio sopra abbiamo usato l'endpoint di Sentry.
  • .js
    helper
  • Nota: Evita l'uso di .* nelle regex. Poiché ciò consentirebbe l'esecuzione di qualsiasi comando dopo una pipe |.
  • reportUri: Invia le violazioni a un dato endpoint. Poiché le violazioni sono simili a quelle della Content Security Policy, è possibile utilizzare qualsiasi soluzione di monitoraggio CSP. Nell'esempio sopra abbiamo usato l'endpoint di Sentry.
  • Controllo Specifico per Modulo: l'array allowedDomain accetta oggetti con i seguenti:
    • domain: Array di domini che devono essere consentiti per i file forniti.
    • modules: Array di oggetti contenenti percorsi di file. Solo le richieste in uscita effettuate tramite questi file verso i domini specificati sono consentite.
  • maxViolationsPerMinute: Numero massimo di violazioni da inviare a reportUri. Se non specificato, viene utilizzato il valore predefinito (100 violazioni).