Page d'accueil>Lié à la programmation>Autre code source
Télécharger

Rupture


Rupture


Rustredops est un référentiel qui abrite divers outils et projets liés aux opérations de l'équipe rouge, développés dans Rust. Ce référentiel est dédié à fournir des outils efficaces et efficaces pour les professionnels de la sécurité et les testeurs de pénétration qui souhaitent effectuer des évaluations de sécurité et des tests d'intrusion.

Table des matières

  • Contenu
  • Ressources
  • Autres projets de rouille
  • Exigences
  • Compiler
    • Compilation du projet
    • Ajout d'architectures de destination
    • Compilation pour une architecture spécifique
  • Comment commencer
  • Contribution aux Rustredops
  • Références
  • Licence

Contenu

Le référentiel est organisé en plusieurs projets, chacun avec son propre objectif et ses fonctionnalités. Voici quelques exemples des projets inclus:

  1. Injection APC

    • Ce projet exploite la technique APC (injection de code asynchrone (APC) pour exécuter du code malveillant dans les processus cibles.

  2. Accrocheur API

    • Démonstration sur le crochet de l'API qui est une technique de programmation qui vous permet d'intercepter et de manipuler les appels vers les fonctions de l'API Windows.

  3. Anti-débogue

    • Techniques anti-débugage.

  4. API martelant

    • Le martelage de l'API consiste à effectuer diverses actions pour retarder les logiciels malveillants.

  5. Anti-analyse

    • Techniques anti-analyse.

  6. Informations binaires

    • Ceci est juste une simple démonstration au cas où vous souhaitez inclure des métadonnées dans votre binaire de rouille ou changer l'icône associée.

  7. Bloquer la politique DLL

    • Éviter le chargement des DLL non signées par Microsoft.

  8. Créer un pilote

    • Il s'agit d'un projet pour montrer comment créer un pilote simple utilisant la rouille.

  9. Créer une DLL

    • C'est un projet pour démontrer comment créer une DLL à l'aide de la rouille.

  10. Exécution du code de rappel

    • Démonstration de l'exécution de ShellCode via le rappel.

  11. Créer UEFI

    • C'est un projet pour démontrer comment créer l'UEFI à l'aide de la rouille.

  12. Compiler la chaîne de crypte

    • Crypting des cordes au moment de compiler et les décrypter au moment de l'exécution.

  13. Extraire le wifi

    • L'extraction de mots de passe WiFi à l'aide de Winapis est une forme personnalisée de la commande netsh.

  14. Injection APC lève-tôt

    • Il se concentre sur une variation de l'injection APC, exécutant du code avant le début du processus principal.

  15. Cryptage (shellcode)

    • Encryport / décryport d'un shellcode à l'aide d'AES et RC4.

  16. Processus d'énumération

    • Énumération des processus avec de la rouille.

  17. Activer tous les jetons

    • Activer tous les jetons de privilège.

  18. Exécuter la commande

    • Commandes en cours d'exécution avec de la rouille.

  19. Hells / Halos / Tartarus Gate

    • Récupérer SSN à travers les techniques de la porte Hells / Halos / Tartarus

  20. Obfuscation IAT

    • IAT Obfuscation en remplaçant GetProcAddress et GetModuleHandle.

  21. Camouflage iat

    • Technique d'exportation des API (sans les exécuter) afin de camoufler l'IAT et d'éviter une apparence malveillante.

  22. LDROLODDLL TRAPOR

    • Une preuve de concept pour injecter un tremplin pour contourner les crochets EDR et utiliser LDRloaddll.

  23. Exécution de la charge utile locale

    • Ce projet aborde l'exécution directe des charges utiles malveillantes dans l'environnement local d'un système.

  24. Injection de cartographie locale

    • Effectuer une injection de code malveillante via la cartographie de la mémoire dans les processus locaux.

  25. Fonction locale piétiner l'injection

    • Il se concentre sur le remplacement des fonctions en cours d'exécution localement par un code malveillant, en modifiant leur comportement par défaut.

  26. Détournement de fil local

    • Ce projet traite du détournement des fils de processus exécutés sur le système local pour exécuter du code malveillant.

  27. Injection de PE locale

    • Exécuter un fichier PE en mémoire.

  28. Mini-rs

    • Vider le processus lsass.exe.

  29. Piétinement du module

    • La technique de piétinement du module se concentre sur l'injection d'un shellcode dans le point d'entrée de la DLL mappée ou chargée.

  30. NTDLL CHUROCHING

    • L'exécution de NTDLL en décroche un processus suspendu.

  31. Nommé Pipe Server / Client

    • Un projet simple montrant comment nous pouvons communiquer entre les processus à l'aide de tuyaux nommés.

  32. Surcharge de module

    • La surcharge du module est une technique qui mappe une DLL cible et remplace son contenu par un fichier EXE / DLL, puis l'exécute.

  33. OBFUSCATION CODE

    • ShellCode Obfuscation Utilisation d'IPv4, IPv6, Mac et UUIDS.

  34. Usurpation PPID

    • Démontrant la technique d'usurpation PPID.

  35. En-têtes PE d'analyse

    • Le code se concentre sur l'analyse de l'en-tête PE de tout fichier exécutable Windows.

  36. Patch etw

    • Patching ETW.

  37. Patch amsi

    • Patcher Amsi.

  38. Contrôle d'exécution de la charge utile

    • Contrôle de l'exécution de la charge utile via Mutex, des événements et des sémaphores.

  39. Traiter l'usurpation de l'argument

    • Exploite la technique de masquage ou de modification des arguments d'un processus pour cacher l'activité malveillante.

  40. Injection de processus (DLL)

    • Il se concentre sur l'injection des bibliothèques de liens dynamiques (DLL) dans des processus en cours d'exécution pour exécuter du code malveillant.

  41. Injection de processus (shellcode)

    • Il exploite l'injection de shellcode directement dans les processus en cours d'exécution pour contrôler ou exécuter des tâches malveillantes.

  42. Placement de charge utile

    • Stockage d'un shellcode dans la section .Text, puis l'exécutant.

  43. Traiter l'hypnose

    • Cette technique se concentre sur le contrôle du flux d'exécution d'un programme qui est débogué et en obtenant des informations pertinentes, telles que la création de nouveaux threads, des modules chargés, des exceptions et bien plus encore. Ou même exécuter un shellcode.

  44. Fibres d'exécution de la charge utile

    • Shellcode en cours d'exécution à l'aide de fibres.

  45. Mise en scène de la charge utile

    • Ce projet se concentre sur la démonstration de la façon d'effectuer ShellCode Retrieval à l'aide d'une demande HTTP et d'une clé de registre

  46. Processus fantôme

    • Chargement d'un fichier PE en utilisant la technique de fantôme de processus.

  47. Traiter Herpaderping

    • Obscurcir les intentions d'un processus en modifiant le contenu du disque après la cartographie de l'image.

  48. Détournement de fil distant

    • Il aborde le détournement des threads dans les processus système à distance pour effectuer des actions malveillantes.

  49. Fonction à distance piétiner l'injection

    • Il exploite la substitution des fonctions dans les systèmes éloignés pour mener des activités malveillantes.

  50. Injection de cartographie à distance

    • Effectuer une injection de code malveillante via la cartographie de la mémoire dans des processus distants.

  51. Retirer CRT

    • Il se concentre sur la minimisation de l'utilisation de la CRT (C Bibliothèque d'exécution C) pendant l'exécution et l'application de drapeaux supplémentaires pour éliminer les informations inutiles du binaire.

  52. Suppression de soi

    • Technique pour supprimer le binaire en cours d'exécution.

  53. Hachage des cordes

    • Création de hachages de chaînes pour effectuer la cachette.

  54. Systèmes

    • Exécution de systèmes directs et indirects.

  55. Injection sans fil

    • Effectuer une injection sans fil à l'aide de la rouille.

  56. IMM

    • Exécution des requêtes WMI (Windows Management Instrumentation).

  57. Webassembly shellcode

    • Exécution de ShellCode via WebAssembly.

Autres projets de rouille

Voici quelques autres exemples de projets que j'ai réalisés avec Rust:

  • Windows Kernel Rootkit
  • Chargeur de coffre
  • Exécution .net

Ressources

  • Chaque projet individuel peut inclure une section de fonctionnalités qui détaille les principales caractéristiques et fonctionnalités du projet.
  • Vous pouvez afficher les instructions d'installation, l'utilisation et les exemples pour chaque projet dans leurs répertoires respectifs.

Exigences

  • Rust: Rust est un langage de programmation moderne et sécurisé utilisé pour développer les outils de ce référentiel.
  • Cargo: La cargaison est le gestionnaire de packages et le compilateur de Rust, essentiel pour compiler et gérer des projets.

Compiler

Compilation du projet

Pour démarrer la compilation, utilisez la commande suivante: 

cargo build --release

Ajout d'architectures de destination

Si vous utilisez un système d'exploitation différent ou si vous devez compiler pour une architecture spécifique, vous pouvez répertorier toutes les architectures cibles disponibles avec la commande suivante: 

rustup target list

Une fois que vous avez identifié l'architecture cible souhaitée, ajoutez-la à l'aide de rustup: 

rustup target add < arch >

Remplacez par l'architecture souhaitée, telle que x86_64-pc-windows-gnU.

Compilation pour une architecture spécifique

Puis compilez le projet pour l'architecture spécifique: 

cargo build --release --target < arch >

Comment commencer

Suivez ces étapes pour commencer à utiliser les projets dans ce référentiel:

  1. Clone ce référentiel sur votre machine locale: 
    git clone https://github.com/joaoviictorti/RustRedOps.git
  2. Accédez au répertoire du projet qui vous intéresse: 
     cd RustRedOps/ < name-project >
  3. Suivez les instructions d'installation et d'utilisation spécifiques au projet comme décrit dans le Readme à l'intérieur de ce répertoire.

Contribution aux Rustredops

Pour contribuer à Rustredops , suivez ces étapes:

  1. Fourk ce référentiel.
  2. Créez une branche: git checkout -b <branch_name> .
  3. Faites vos modifications et engagez-les: git commit -m '<commit_message>' .
  4. Poussez vos modifications à votre branche: git push origin <branch_name> .
  5. Créez une demande de traction.

Alternativement, consultez la documentation GitHub sur la façon de créer une demande de traction.

Références

Je voudrais exprimer ma sincère gratitude aux créateurs de projets remarquables et de techniques fascinantes, qui m'ont fourni les outils et l'inspiration nécessaires pour créer ce référentiel extraordinaire.

  • https://github.com/Mem0ps
  • https://github.com/hasherezade
  • https://github.com/vxunderground
  • https://github.com/nul0x4c
  • https://github.com/mrd0x
  • https://github.com/cracked5pider
  • https://github.com/trickster0
  • https://github.com/blwasp
  • https://balwurk.com/shellcode-evasion-using-webassembly-and
  • https://github.com/janoglezcampos/rust_syscalls
  • https://github.com/microsoft
  • https://ired.team
  • https://github.com/rust-osdev/uefi-rous
  • https://github.com/stephanvanschaik/windows-kernel-round
  • https://discord.gg/rust-lang-communnity (Communauté Discord qui a beaucoup aidé)
  • https://github.com/ccob
  • https://github.com/anvie/litcrypt.rs

Licence

Ce projet est concédé sous licence MIT

Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout