jsluice

jsluice è un pacchetto Go e uno strumento da riga di comando per estrarre URL, percorsi, segreti e altri dati interessanti dal codice sorgente JavaScript.

Se vuoi iniziare subito: dai un'occhiata allo strumento da riga di comando.

Se vuoi integrare le funzionalità di jsluice nel tuo progetto: guarda gli esempi e leggi la documentazione del pacchetto.

Installazione

Per installare lo strumento da riga di comando, esegui:

▶ go install github.com/BishopFox/jsluice/cmd/jsluice@latest

Per aggiungere il pacchetto al tuo progetto, esegui:

▶ go get github.com/BishopFox/jsluice

Estrazione degli URL

Invece di affidarsi solo alle espressioni regolari, jsluice usa go-tree-sitter per cercare i punti in cui è noto che gli URL vengano usati, ad esempio assegnati a document.location, passati a window.open() o a fetch(), ecc.

Un semplice programma di esempio è disponibile qui:

analyzer := jsluice.NewAnalyzer([]byte(`
    const login = (redirect) => {
        document.location = "/login?redirect=" + redirect + "&method=oauth"
    }
`))

for _, url := range analyzer.GetURLs() {
    j, err := json.MarshalIndent(url, "", "  ")
    if err != nil {
        continue
    }

    fmt.Printf("%s\n", j)
}

Eseguendo l'esempio:

▶ go run examples/basic/main.go
{
  "url": "/login?redirect=EXPR\u0026method=oauth",
  "queryParams": [
    "method",
    "redirect"
  ],
  "bodyParams": [],
  "method": "GET",
  "type": "locationAssignment",
  "source": "document.location = \"/login?redirect=\" + redirect + \"\u0026method=oauth\""
}

Nota che il valore del parametro della query string redirect è EXPR. Codice come questo è comune in JavaScript:

document.location = "/login?redirect=" + redirect + "&method=oauth"

jsluice comprende la concatenazione di stringhe e sostituisce con EXPR qualsiasi espressione di cui non possa conoscere il valore. Pur non essendo una soluzione infallibile, questo approccio produce un URL o un percorso valido nella maggior parte dei casi e permette di scoprire elementi che non sono facilmente individuabili con altri metodi. In questo caso, un'espressione regolare ingenua potrebbe facilmente non rilevare il parametro method della query string:

▶ JS='document.location = "/login?redirect=" + redirect + "&method=oauth"'
▶ echo $JS | grep -oE 'document\.location = "[^"]+"'
document.location = "/login?redirect="

Matcher URL personalizzati

jsluice include alcuni matcher URL integrati per scenari comuni, ma puoi aggiungerne altri con la funzione AddURLMatcher:

analyzer := jsluice.NewAnalyzer([]byte(`
    var fn = () => {
        var meta = {
            contact: "mailto:[email protected]",
            home: "https://example.com"
        }
        return meta
    }
`))

analyzer.AddURLMatcher(
    // The first value in the jsluice.URLMatcher struct is the type of node to look for.
    // It can be one of "string", "assignment_expression", or "call_expression"
    jsluice.URLMatcher{"string", func(n *jsluice.Node) *jsluice.URL {
        val := n.DecodedString()
        if !strings.HasPrefix(val, "mailto:") {
            return nil
        }

        return &jsluice.URL{
            URL:  val,
            Type: "mailto",
        }
    }},
)

for _, match := range analyzer.GetURLs() {
    fmt.Println(match.URL)
}

Una copia di questo esempio è disponibile qui. Puoi eseguirlo così:

▶ go run examples/urlmatcher/main.go
mailto:[email protected]
https://example.com

Di default jsluice non riconosce gli URI mailto:, ma questo è stato trovato dal URLMatcher personalizzato.

Estrazione dei segreti

Oltre agli URL, jsluice può estrarre segreti. Come per l'estrazione degli URL, è possibile fornire matcher personalizzati per integrare quelli predefiniti. C'è un breve programma di esempio qui che fa proprio questo:

analyzer := jsluice.NewAnalyzer([]byte(`
    var config = {
        apiKey: "AUTH_1a2b3c4d5e6f",
        apiURL: "https://api.example.com/v2/"
    }
`))

analyzer.AddSecretMatcher(
    // The first value in the jsluice.SecretMatcher struct is a
    // tree-sitter query to run on the JavaScript source.
    jsluice.SecretMatcher{"(pair) @match", func(n *jsluice.Node) *jsluice.Secret {
        key := n.ChildByFieldName("key").DecodedString()
        value := n.ChildByFieldName("value").DecodedString()

        if !strings.Contains(key, "api") {
            return nil
        }

        if !strings.HasPrefix(value, "AUTH_") {
            return nil
        }

        return &jsluice.Secret{
            Kind: "fakeApi",
            Data: map[string]string{
                "key":   key,
                "value": value,
            },
            Severity: jsluice.SeverityLow,
            Context:  n.Parent().AsMap(),
        }
    }},
)

for _, match := range analyzer.GetSecrets() {
    j, err := json.MarshalIndent(match, "", "  ")
    if err != nil {
        continue
    }

    fmt.Printf("%s\n", j)
}

Eseguendo l'esempio:

▶ go run examples/secrets/main.go
[2023-06-14T13:04:16+0100]
{
  "kind": "fakeApi",
  "data": {
    "key": "apiKey",
    "value": "AUTH_1a2b3c4d5e6f"
  },
  "severity": "low",
  "context": {
    "apiKey": "AUTH_1a2b3c4d5e6f",
    "apiURL": "https://api.example.com/v2/"
  }
}

Poiché disponiamo di un albero sintattico per l'intero sorgente JavaScript, è stato possibile ispezionare sia key che value e anche fornire facilmente l'oggetto padre come contesto per la corrispondenza.

jsluice

Più Popolari

jsluice

Installazione

Estrazione degli URL

Matcher URL personalizzati

Estrazione dei segreti