En Pentester adskilte en hjemmesides kode for at bevise, at den var fuldstændig meningsløs

Forleden stødte jeg på en tjeneste, der bekræftede signaturen af anmodninger på serversiden. Det var et lille online casino, som for hver anmodning kontrollerede en værdi sendt af brugeren fra browseren. Uanset hvad du lavede i kasinoet: at placere et væddemål eller lave en indbetaling, var en ekstra parameter i hver anmodning værdien "tegn", bestående af et sæt tilsyneladende tilfældige tegn. Det var umuligt at sende en anmodning uden den - siden returnerede en fejl, og det forhindrede mig i at sende mine egne brugerdefinerede anmodninger.

Havde det ikke været for denne værdi, ville jeg have forladt siden i det øjeblik og aldrig tænkt på det igen. Men mod alle odds var det ikke følelsen af hurtig profit, der gjorde mig begejstret, men snarere den forskningsinteresse og udfordring, som kasinoet gav mig med sin idiotsikring.

Uanset formålet udviklerne havde i tankerne, da de tilføjede denne parameter, forekommer det mig, at det var spild af tid. Når alt kommer til alt, genereres selve signaturen på klientsiden, og enhver handling på klientsiden kan være genstand for reverse-engineering.

I denne artikel vil jeg diskutere, hvordan jeg formåede at:

1. Løs algoritmen til generering af anmodningssignatur
2. Skriv min egen udvidelse til Burp Suite, der automatiserer alt det beskidte arbejde

Denne artikel vil lære dig, hvordan du sparer din dyrebare tid og afviser ubrugelige løsninger, hvis du er en udvikler, der er interesseret i at lave sikre projekter. Og hvis du er en pentester, efter at have læst denne artikel, kan du lære nogle nyttige lektioner om fejlretning samt programmering af dine egne udvidelser til Swiss Knife of Security. Kort sagt, alle er på plussiden.

Lad os endelig komme til sagen.

Ariadnes tråd: optrævling af signaturalgoritmen

Så tjenesten er et online casino med et sæt klassiske spil:

• Plinko — et spil, hvor spillere taber en bold fra toppen af et pladefyldt bræt, og ser den hoppe ned for at lande i et slot med en gevinst eller tab af værdi;
• Billetter — spillere køber lotterisedler med et sæt numre og vinder, hvis deres numre matcher de tilfældigt udtrukne numre;
• LiveDealers — online casinospil udført af rigtige dealere i realtid, hvilket giver spillerne mulighed for at se og interagere via videostream.
• Double — et simpelt spil, hvor spillerne satser på, om det næste kort vil være højere eller lavere end det nuværende kort.
• Crash — spillere satser og ser en multiplikator stige med det formål at udbetale før multiplikatoren går ned;
• Nvuti — spillere satser på, om et tal vil falde under eller over et bestemt interval;
• Slots — kasinospil, hvor spillere spinder hjul med symboler og vinder, hvis visse kombinationer vises på skærmen.

Interaktion med serveren fungerer udelukkende på basis af HTTP-anmodninger. Uanset hvilket spil du vælger, skal hver POST-anmodning til serveren signeres - ellers vil serveren generere en fejl. Underskriftsanmodninger i hvert af disse spil fungerer efter samme princip - jeg tager kun ét spil til at undersøge, så jeg ikke behøver at udføre det samme arbejde to gange.

Og jeg vil tage et spil kaldet Dragon Dungeon.

Essensen af dette spil er at vælge dørene i slottet sekventielt i rollen som en ridder. Bag hver dør gemmer sig enten en skat eller en drage. Hvis spilleren støder på en drage bag en dør, stopper spillet, og han taber penge. Hvis skatten er fundet - stiger mængden af den oprindelige indsats, og spillet fortsætter, indtil spilleren tager gevinsten, taber eller passerer alle niveauer.

Før du starter spillet, skal spilleren angive indsatsens størrelse og antallet af drager.

Jeg indtaster tallet 10 som summen, efterlader en drage og ser på anmodningen, der vil blive sendt. Dette kan gøres fra udviklerværktøjerne i enhver browser, i Chromium er fanen Netværk ansvarlig for dette.

Her kan du også se, at anmodningen blev sendt til /srv/api/v1/dungeon -slutpunktet.

Fanen Nyttelast viser selve anmodningsteksten i JSON-format

De to første parametre er indlysende - jeg valgte dem fra brugergrænsefladen; den sidste, som du måske kan gætte, er timestamp eller den tid, der er gået siden 1. januar 1970, med den typiske Javascript-præcision på millisekunder.

Det efterlader én uløst parameter og, - og det er selve signaturen. For at forstå, hvordan det er dannet, går jeg til fanen Kilder - dette sted indeholder alle ressourcerne til den tjeneste, som browseren har indlæst. Herunder Javascript, som er ansvarlig for al logikken i klientdelen af webstedet.

Det er ikke så let at forstå denne kode – den er minificeret. Du kan prøve at deobfuskere det hele - men det er en lang og kedelig proces, der vil tage meget tid (mængden af kildekode taget i betragtning), jeg er ikke klar til at gøre det.

Den anden og nemmere mulighed er blot at finde den nødvendige del af koden ved hjælp af et nøgleord og bruge debuggeren. Det er det, jeg vil gøre, for jeg behøver ikke at vide, hvordan hele siden fungerer, jeg skal bare vide, hvordan signaturen genereres.

Så for at finde den del af koden, der er ansvarlig for at generere koden, kan du åbne en søgning gennem alle kilderne ved at bruge CTRL+SHIFT+F tastekombinationen og se efter tildelingen af en værdi til den sign , der sendes i anmodningen.

Heldigvis er der kun én kamp, hvilket betyder, at jeg er på rette vej.

Hvis du klikker på et match, kan du komme til kodeafsnittet, hvor selve signaturen genereres. Koden er sløret som før, så den er stadig svær at læse.

Modsat kodelinjen sætter jeg et breakpoint, opdaterer siden og giver et nyt bud i "dragons" - nu har scriptet stoppet sit arbejde præcis i det øjeblik, hvor signaturen dannes, og du kan se tilstanden for nogle variabler.

Den kaldede funktion består af et bogstav, variablerne også - men ikke noget problem. Du kan gå til konsollen og vise værdierne for hver af dem. Situationen begynder at blive klarere.

Den første værdi I output er værdien af variablen H , som er en funktion. Du kan klikke på det fra konsollen og flytte til det sted, hvor det er angivet i koden, nedenfor er listen.

Dette er et ret stort kodestykke, hvor jeg så et fingerpeg - SHA256. Dette er en hashing-algoritme. Du kan også se, at to parametre sendes til funktionen, hvilket antyder, at dette måske ikke bare er SHA256, men HMAC SHA256 med en hemmelighed.

Sandsynligvis de variabler, der sendes her (også output til konsollen):

• streng 10;1;6693a87bbd94061678473bfb;1732817300080;gRdVWfmU-YR_RCuSkWFLCUTly_GZfDx3KEM8 - direkte den værdi, som HMAC SHA256-operationen anvendes på.
• 31754cff-be0f-446f-9067-4cd827ba8707 er en statisk konstant, der fungerer som en hemmelighed

For at være sikker på dette, kalder jeg funktionen og får den formodede signatur

Nu går jeg til webstedet, der tæller HMAC SHA256 og sender værdier ind i det.

Og sammenligne den med den, der blev sendt i anmodningen, da jeg afgav buddet.

Resultatet er identisk, hvilket betyder, at mine gæt var korrekte - den bruger virkelig HMAC SHA256 med en statisk hemmelighed, som sendes en specielt dannet streng med hastigheden, antallet af drager og nogle andre parametre, som jeg vil fortælle dig om længere på i løbet af artiklen.

Algoritmen er ret enkel og ligetil. Men det er stadig ikke nok - hvis det var et mål i et arbejdsprojekt for pentest at finde sårbarheder, ville jeg skulle lære at sende mine egne forespørgsler ved hjælp af Burp Suite.

Og dette kræver helt sikkert automatisering, hvilket er det, jeg vil tale om nu.

Er det overhovedet nødvendigt at skrive din egen udvidelse?

Jeg har fundet ud af algoritmen til signaturgenerering. Nu er det tid til at lære at generere det automatisk for at abstrahere alle de unødvendige ting, når du sender forespørgsler.

Du kan sende anmodninger ved hjælp af ZAP, Caido, Burp Suite og andre pentest-værktøjer. Denne artikel vil fokusere på Burp Suite, da jeg synes, den er den mest brugervenlige og næsten perfekt. Community Edition kan downloades gratis fra det officielle websted, det er nok til alle eksperimenter.

Ud af boksen ved Burp Suite ikke, hvordan man genererer HMAC SHA256. For at gøre dette kan du derfor bruge udvidelser, der komplementerer Burp Suites funktionalitet.

Udvidelser oprettes både af fællesskabsmedlemmer og af udviklerne selv. De distribueres enten gennem den indbyggede gratis BApp Store, Github eller andre kildekodedepoter.

Der er to veje, du kan tage:

1. Brug en hyldeforlængelse fra BApp Store
2. Skriv din egen udvidelse

Hver af disse veje har sine fordele og ulemper, jeg vil vise dig begge.

Lær Hackvertor at kende

Metoden med en færdiglavet forlængelse er den nemmeste. Det er at downloade det fra BApp Store og bruge dets funktioner til at generere en værdi for sign .

Udvidelsen jeg brugte hedder Hackvertor . Det giver dig mulighed for at bruge XML som syntaks, så du dynamisk kan kode/dekode, kryptere/dekryptere, hash forskellige data.

For at installere det kræver Burp:

1. Gå til fanen Udvidelser

2. Skriv Hackvertor i søgningen

3. Vælg den fundne udvidelse på listen

4. Klik på Installer

   
   

Når det er installeret, vises en fane med samme navn i Burp. Du kan gå til den og evaluere udvidelsens muligheder og antallet af tilgængelige tags, som hver især kan kombineres med hinanden.

For at give et eksempel kan du kryptere noget med symmetrisk AES ved at bruge tagget <@aes_encrypt('supersecret12356','AES/ECB/PKCS5PADDING')>MySuperSecretText<@/aes_encrypt> .

Hemmeligheden og algoritmen er i parentes, og mellem taggene er selve teksten, der skal krypteres. Alle tags kan bruges i Repeater, Intruder og andre indbyggede Burp Suite-værktøjer.

Ved hjælp af Hackvertor-udvidelsen kan du beskrive, hvordan en signatur skal genereres på tag-niveau. Jeg vil gøre det på eksemplet med en rigtig anmodning.

Brug af Hackvertor i kamp

Så jeg laver et væddemål i Dragon Dungeon, opsnapper den samme anmodning, som jeg opsnappede i begyndelsen af denne artikel med Intercept Proxy, og understreger den i Repeater for at kunne redigere den og genindsende den.

Nu i stedet for ae04afe621864f569022347f1d1adcaa3f11bebec2116d49c4539ae1d2c825fc værdien, skal vi erstatte algoritmen for at generere HMAC SHA256 ved hjælp af tags leveret af Hackvertor.

Формула генерации у меня получилась следующая <@hmac_sha256('31754cff-be0f-446f-9067-4cd827ba8707')>10;1;6693a87bbd94061678473bfb;<@timestamp/>000;MDWpmNV9-j8tKbk-evbVLtwMsMjKwQy5YEs4<@/hmac_sha256> .

Overvej alle parametrene:

• 10 - indsatsbeløb
• 1 - antal drager
• 6693a87bbd94061678473bfb - unikt bruger-id fra MongoDB-databasen, jeg så det, mens jeg analyserede signaturen fra browseren, men jeg skrev ikke om det dengang. Jeg var i stand til at finde det ved at søge gennem indholdet af forespørgslerne i Burp Suite, det kommer tilbage fra /srv/api/v1/profile/me -slutpunktsforespørgslen.

• <@timestamp/>000 - tidsstempelgenerering, de sidste tre nuller justerer tiden til millisekunder
• MDWpmNV9-j8tKbk-evbVLtwMsMjKwQy5YEs4 - CSRF-token, som returneres fra /srv/api/v1/csrf slutpunkt og erstattes i hver anmodning i X-Xsrf-Token -headeren.

• <@hmac_sha256('31754cff-be0f-446f-9067-4cd827ba8707')> og <@/hmac_sha256> - åbnings- og lukketags til generering af HMAC SHA256 fra den substituerede værdi med hemmeligheden som en konstant 31754cff-be0f-446f-9067-4cd827ba8707 .

Vigtigt at bemærke: parametrene skal forbindes med hinanden via ; i streng rækkefølge, - ellers vil signaturen blive genereret forkert - som i dette skærmbillede, hvor jeg har byttet kursen og antallet af drager

Det er der, al magien ligger.

Nu laver jeg en korrekt forespørgsel, hvor jeg angiver parametrene i den rigtige rækkefølge, og får information om at alt var vellykket og spillet startede - det betyder at Hackvertor genererede en signatur i stedet for en formel, erstattede den i forespørgslen, og alt virker .

Denne metode har dog en væsentlig ulempe - du kan ikke slippe helt af med manuelt arbejde. Hver gang du ændrer hastigheden eller antallet af drager i JSON, skal du ændre det i selve signaturen for at få dem til at matche.

Hvis du sender en ny anmodning fra Proxy-fanen til Intruder eller Repeater, skal du også omskrive formlen, hvilket er meget, meget ubelejligt, når du har brug for mange faner til forskellige testcases.

Denne formel vil også mislykkes i andre forespørgsler, hvor andre parametre bruges.

Så jeg besluttede at skrive min egen udvidelse for at overvinde disse ulemper.

Oplev al magien ved Burp med din udvidelse

Indledende indstillinger

Du kan skrive udvidelser til Burp Suite i Java og Python. Jeg vil bruge det andet programmeringssprog, da det er enklere og mere visuelt. Men du skal forberede dig selv på forhånd: først skal du downloade Jython Standalone fra den officielle hjemmeside og derefter stien til den downloadede fil i Burp Suite-indstillingerne.

Derefter skal du oprette en fil med selve kildekoden og filtypenavnet *.py .

Jeg har allerede en billet, der definerer den grundlæggende logik, her er dens indhold:

Alt er intuitivt enkelt og ligetil:

• getActionName - denne metode returnerer navnet på den handling, der skal udføres af udvidelsen. Selve udvidelsen tilføjer en Session Handling Rule, der fleksibelt kan anvendes på enhver af anmodningerne, men mere om det senere. Det er vigtigt at vide, at dette navn kan være forskelligt fra udvidelsens navn, og at det vil kunne vælges fra grænsefladen.
• performAction - logikken i selve reglen, som vil blive anvendt på de valgte anmodninger, vil blive stavet her

Begge metoder er deklareret i henhold til ISessionHandlingAction- grænsefladen.

Nu til IBurpExtender- grænsefladen. Den erklærer den eneste nødvendige metode registerExtenderCallbacks , som udføres umiddelbart efter indlæsning af udvidelsen, og er nødvendig for at den overhovedet kan fungere.

Det er her den grundlæggende konfiguration udføres:

• callbacks.setExtensionName(EXTENSION_NAME) - registrerer den aktuelle udvidelse som en handling til at håndtere sessioner
• sys.stdout = callbacks.getStdout() - omdirigerer standardoutputtet (stdout) til Burp Suite-outputvinduet (panelet "Udvidelser")
• self.stderr = PrintWriter(callbacks.getStdout(), True) - opretter en strøm til udlæsning af fejl
• self.stdout.println(EXTENSION_NAME) - udskriver navnet på udvidelsen i Burp Suite
• self.callbacks = callbacks - gemmer tilbagekaldsobjektet som en selvattribut. Dette er nødvendigt for senere brug af Burp Suite API i andre dele af udvidelseskoden.
• self.helpers = callbacks.getHelpers() - får også nyttige metoder, der vil være nødvendige, når udvidelsen kører

Med de indledende forberedelser gjort, er det det. Nu kan du indlæse udvidelsen og sikre dig, at den overhovedet virker. For at gøre dette skal du gå til fanen Udvidelser og klikke på Tilføj.

Angiv i det vindue, der vises

• Udvidelsestype - Python, eller det programmeringssprog, som udvidelsen er skrevet på
• Udvidelsesfil - stien til selve forlængelsesfilen.

Og klik på Næste.

Hvis kildekodefilen er blevet korrekt formateret, bør der ikke opstå fejl, og fanen Output vil vise navnet på udvidelsen. Det betyder, at alt fungerer fint.

En test af pennen

Udvidelsen indlæses og virker - men alt, der blev indlæst, var en indpakning uden nogen logik, nu skal jeg bruge koden direkte for at underskrive anmodningen. Jeg har allerede skrevet det, og det er vist på skærmbilledet nedenfor.

Måden hele udvidelsen fungerer på er, at før anmodningen sendes til serveren, vil den blive ændret af min udvidelse.

Jeg tager først anmodningen om, at forlængelsen opsnappede, og få hastigheden og antallet af drager fra dens krop

 json_body = json.loads(message_body) amount_currency = json_body["amountCurrency"] dragons = json_body["dragons"]

Dernæst læser jeg det aktuelle tidsstempel og får CSRF-tokenet fra den tilsvarende header

 currentTime = str(time.time()).split('.')[0]+'100' xcsrf_token = None for header in headers: if header.startswith("X-Xsrf-Token"): xcsrf_token = header.split(":")[1].strip()

Derefter signeres selve anmodningen ved hjælp af HMAC SHA256

 hmac_sign = hmac_sha256(key, message=";".join([str(amount_currency), str(dragons), user_id, currentTime, xcsrf_token]))

Selve funktionen og konstanterne, der angiver hemmeligheden og bruger-id'et, blev forud erklæret øverst

 def hmac_sha256(key, message): return hmac.new( key.encode("utf-8"), message.encode("utf-8"), hashlib.sha256 ).hexdigest() key = "434528cb-662f-484d-bda9-1f080b861392" user_id = "zex2q6cyc4ba3gvkyex5f80m"

Derefter skrives værdierne til anmodningsteksten og konverteres til JSON

 json_body["sign"] = hmac_sign json_body["t"] = currentTime message_body = json.dumps(json_body)

Det sidste trin er at generere en underskrevet og ændret anmodning og sende den til

 httpRequest = self.helpers.buildHttpMessage(get_final_headers, message_body) baseRequestResponse.setRequest(httpRequest)

Det er alt, kildekoden er skrevet. Nu kan du genindlæse udvidelsen i Burp Suite (det bør gøres efter hver script-ændring), og sikre dig, at alt fungerer.

Test af den nye regel i aktion

Men først skal du tilføje en ny regel for behandling af anmodninger. For at gøre dette skal du gå til Indstillinger, til afsnittet Sessioner. Her finder du alle de forskellige regler, der udløses, når du sender forespørgsler.

Klik på Tilføj for at tilføje en udvidelse, der udløser visse typer anmodninger.

I vinduet der kommer frem lader jeg alt være som det er og vælger Tilføj i regelhandlinger

En rulleliste vises. I den skal du vælge Påkald en Burp-udvidelse.

Og angiv den udvidelse, der vil blive kaldt, når du sender anmodninger. Jeg har en, og det er Burp Extension.

Når jeg har valgt udvidelsen, klikker jeg på OK. Og jeg går til fanen Omfang, hvor jeg angiver:

• Værktøjsomfang - Repeater (udvidelsen skal udløses, når jeg sender anmodninger manuelt gennem Repeater)

• URL-omfang - Inkluder alle URL'er (så det fungerer på alle anmodninger, jeg sender).

  
  

Det skulle fungere som på skærmbilledet nedenfor.

Efter at have klikket på OK, dukkede udvidelsesreglen op på den generelle liste.

Endelig kan du teste alt i aktion! Nu kan du ændre en forespørgsel og se, hvordan signaturen opdateres dynamisk. Og selvom forespørgslen mislykkes, vil det være fordi jeg har valgt en negativ kurs, ikke fordi der er noget galt med signaturen (jeg vil bare ikke spilde penge 😀). Selve udvidelsen fungerer, og signaturen er genereret korrekt.

At bringe det til perfektion

Alt er fantastisk, men der er tre problemer:

1. CSRF-tokenet er taget fra overskriften. Generelt burde det være engangs, men sandsynligvis her har det en levetid (eller ej, hvilket er forkert). Under alle omstændigheder ville det være mere korrekt selv at fremsætte en separat anmodning om at få en ny og opdatere den. 2- Der anvendes et foruddefineret bruger-id. Hvis jeg vil tjekke IDOR på denne tjeneste, bliver mit tidligere script ugyldigt for en anden bruger, da ID'et er hardkodet.
2. Forskellige forespørgsler kan have forskellige parametre. Og den ordning, der blev beskrevet for scriptet oprindeligt, vil kun være gyldig for Dungeon Dragons og ingen anden. Og jeg vil gerne være i stand til at redigere og sende enhver anmodning.

For at løse dette skal vi tilføje to yderligere anmodninger, som kan udføres af det indbyggede Burp Suite-bibliotek, i stedet for tredjeparts, i stedet for requests .

For at gøre dette har jeg indpakket noget standardlogik for at gøre forespørgslerne mere bekvemme. Gennem Burps standardmetoder foregår interaktionen med forespørgsler i pleintext.

 def makeRequest(self, method="GET", path="/", headers=None, body=None): first_line = method + " " + path + " HTTP/1.1" headers[0] = first_line if body is None: body = "{}" http_message = self.helpers.buildHttpMessage(headers, body) return self.callbacks.makeHttpRequest(self.request_host, self.request_port, True, http_message)

Og tilføjet to funktioner, der ekstraherer de data, jeg har brug for, CSRF-token og UserID.

 def get_csrf_token(self, headers): response = self.makeRequest("GET", "/srv/api/v1/csrf", headers) message = self.helpers.analyzeRequest(response) raw_headers = str(message.getHeaders()) match = re.search(r'XSRF-TOKEN=([a-zA-Z0-9_-]+)', raw_headers) return match.group(1) def get_user_id(self, headers): raw_response = self.makeRequest("POST", "/srv/api/v1/profile/me", headers) response = self.helpers.bytesToString(raw_response) match = re.search(r'"_id":"([a-f0-9]{24})"', response) return match.group(1)

Og ved at opdatere selve tokenet i de sendte headers

 def update_csrf(self, headers, token): for i, header in enumerate(headers): if header.startswith("X-Xsrf-Token:"): headers[i] = "X-Xsrf-Token: " + token return headers

Signaturfunktionen ser sådan ud. Her er det vigtigt at bemærke, at jeg tager alle de brugerdefinerede parametre, der sendes i anmodningen, tilføjer standard user_id , currentTime , csrf_token til slutningen af dem og signerer dem alle sammen ved hjælp af ; som en separator.

 def sign_body(self, json_body, user_id, currentTime, csrf_token): values = [] for key, value in json_body.items(): if key == "sign": break values.append(str(value)) values.extend([str(user_id), str(currentTime), str(csrf_token)]) return hmac_sha256(hmac_secret, message=";".join(values))

Hovedgulvet blev reduceret til et par linjer:

1. CSRF-token og UserID-anskaffelse udføres
2. Tidsstempel beregnes og en signatur genereres baseret på alle parametre. Det er vigtigt at bemærke her, at jeg bruger OrderedDict , som genererer ordbogen i en stiv rækkefølge, da det er vigtigt at bevare den, mens du underskriver.
3. Den sidste del af anmodningen genereres, og den sendes videre

 csrf_token = self.get_csrf_token(headers) final_headers = self.update_csrf(final_headers, csrf_token) user_id = self.get_user_id(headers) currentTime = str(time.time()).split('.')[0]+'100' json_body = json.loads(message_body, object_pairs_hook=OrderedDict) sign = self.sign_body(json_body, user_id, currentTime, csrf_token) json_body["sign"] = sign json_body["t"] = currentTime message_body = json.dumps(json_body) httpRequest = self.helpers.buildHttpMessage(final_headers, message_body) baseRequestResponse.setRequest(httpRequest)

Et skærmbillede, bare for at være sikker

Nu, hvis du går til et andet spil, hvor brugerdefinerede parametre allerede er 3 i stedet for 2, og sender en anmodning, kan du se, at den vil blive sendt med succes. Det betyder, at min udvidelse nu er universel og fungerer til alle forespørgsler.

Eksempel på at sende en anmodning om kontoopfyldning

Konklusion

Udvidelser er en integreret del af Burp Suite. Tjenester implementerer ofte tilpasset funktionalitet, som ingen andre end dig vil skrive på forhånd. Derfor er det vigtigt ikke kun at downloade færdige udvidelser, men også at skrive dine egne, hvilket jeg forsøgte at lære dig i denne artikel.

Det var alt for nu, forbedre dig selv og bliv ikke syg.

Link til kildekoden for udvidelsen: *klik* .