RedTeamCoin

RedTeamCoin Logo

RedTeamCoin est une implémentation de pool de minage de cryptomonnaies basée sur la blockchain, conçue pour les tests de sécurité autorisés et les opérations de red team. Développé en Go avec le support de clients Java, il simule des attaques de cryptomining réelles pour aider les organisations à évaluer leurs capacités de détection et à quantifier les dommages potentiels des opérations de minage menées par des acteurs malveillants.

Cet outil permet aux équipes de sécurité de démontrer en toute sécurité et légalement des scénarios d'attaques de cryptomining sur des systèmes d'entreprise, de générer des rapports d'impact complets, et de valider les contrôles de sécurité—le tout dans un environnement contrôlé utilisant une blockchain isolée et non publique.

Aperçu

Pourquoi utiliser RedTeamCoin ?

Démontrer l'impact réel des attaques de cryptojacking
Tester et valider les systèmes de surveillance et de détection de sécurité
Générer des évaluations quantifiables des dommages pour les rapports à destination des dirigeants
Simuler en toute sécurité des opérations de minage sans se connecter à des blockchains publiques

Composants du système :

Serveur de pool de minage - Gère la blockchain et coordonne la distribution du travail
Mineurs clients - Clients de minage CPU/GPU (implémentations Go et Java)
Tableau de bord web - Surveillance, contrôle et statistiques en temps réel
Outils d'analyse - Génèrent des rapports complets d'évaluation des dommages

Fonctionnalités

Implémentation de la blockchain : Blockchain personnalisée avec preuve de travail et difficulté configurable
Serveur de pool de minage : Gère plusieurs mineurs et la distribution du travail via gRPC
Mineurs clients : Clients de minage automatisés (Go et Java) avec journalisation des adresses IP et des noms d'hôte
Mineur Java autonome : Mineur de bureau compatible GUI avec interface visuelle
Client gRPC Java : Client gRPC sans interface pour serveurs et automatisation
Contrôle des mineurs côté serveur : Pause, reprise, limitation de l'utilisation du CPU et suppression des mineurs à distance
Limitation du CPU : Limiter l'utilisation du CPU des mineurs de 0 à 100 % pour gérer les ressources
Support du minage GPU : Prise en charge de CUDA et OpenCL pour le minage accéléré par GPU
Minage hybride : Minage CPU et GPU simultané pour des performances maximales
Tableau de bord web : Surveillance en temps réel des mineurs, statistiques et blockchain avec boutons de contrôle
Authentification REST API : Authentification sécurisée basée sur des jetons pour les points de terminaison API
Chiffrement TLS client gRPC : Chiffrement TLS optionnel pour des connexions gRPC client-serveur sécurisées
Suivi double IP : Enregistre les adresses IP déclarées par le client et détectées par le serveur
Statistiques CPU et GPU : Suivi et reporting complets de l'utilisation des ressources
Protocol Buffers : Communication client-serveur efficace avec protobuf/gRPC
Auto-terminaison : Les mineurs s'arrêtent automatiquement et se suppriment eux-mêmes lorsqu'ils sont retirés du serveur

Démarrage rapide

Faites fonctionner RedTeamCoin en moins de 5 minutes :

Prérequis

Go 1.21 ou version ultérieure
Compilateur Protocol Buffer (protoc)

Ubuntu/Debian :```bash sudo apt update sudo apt install -y golang-go protobuf-compiler

**macOS:**```bash
brew install go protobuf

Windows :

Installer Go à partir de https://golang.org/dl/
Installer protoc à partir de https://github.com/protocolbuffers/protobuf/releases

Installation```bash

Clone the repository

git clone https://github.com/xyplex3/RedTeamCoin.git cd RedTeamCoin

Install dependencies

make install-tools make deps

Build server and client

make build

### Vérification

Vérifiez que la compilation s'est terminée avec succès :```bash
ls -lh bin/
# Expected output: server and client binaries (1-5 MB each)

./bin/server --help
# Expected output: Usage information for the server

Lancer votre premier pool de minage

1. Démarrer le serveur :```bash make run-server

Vous devriez voir une sortie comme :```text
RedTeamCoin Mining Pool Server
Authentication Token: abc123def456...
Dashboard URL: http://localhost:8080?token=abc123def456...
gRPC server listening on port 50051

2. Lancez un mineur (dans un nouveau terminal):```bash make run-client

Vous devriez voir une activité de minage :```text
Connected to mining pool at localhost:50051
Registered as miner: miner-hostname-1234567890
Mining block #1... Hash rate: 2.5 MH/s
Block found! Nonce: 98765, Hash: 000000ab1cd...

3. Consultez le tableau de bord :

Ouvrez l'URL de l'étape 1 dans votre navigateur, ou accédez à :```text http://localhost:8080?token=YOUR_AUTH_TOKEN_HERE

Vous verrez des statistiques en temps réel, notamment les mineurs actifs, les taux de hachage et les blocs minés.

**Remarque :** Le serveur écoute sur toutes les interfaces réseau - remplacez `localhost`
par l'IP de votre serveur pour un accès distant.

## Comment ça marche

Le pool de minage fonctionne grâce à un mécanisme de consensus par preuve de travail :

1. Le serveur initialise la blockchain avec le bloc genesis
2. Les mineurs se connectent via gRPC et s'enregistrent avec leur IP/hostname
3. Le serveur distribue les tâches de travail (modèles de blocs)
4. Les mineurs calculent des hachages SHA-256 pour trouver des nonces valides
5. Les mineurs soumettent leurs solutions lorsque la cible de difficulté est atteinte
6. Le serveur valide et ajoute les blocs à la blockchain
7. Le tableau de bord affiche les statistiques en temps réel et l'activité des mineurs

Chaque bloc nécessite de trouver un hachage avec un nombre spécifique de zéros en tête
(difficulté configurable). Les mineurs reçoivent 50 RTC par bloc miné.

### Flux de données```text
Client Miner                    Server
    |                              |
    |--RegisterMiner(IP,Hostname)->|
    |<--RegistrationResponse-------|
    |--GetWork()------------------>|
    |<--WorkResponse(Block)--------|
    | [Mining: compute hashes]     |
    |--SubmitWork(nonce,hash)----->|
    |                              | [Validate proof-of-work
    |                              |  and add block to chain]
    |<--SubmissionResponse---------|
    |--Heartbeat(stats)----------->|
    |<--HeartbeatResponse----------|

Utilisation

Lancement du serveur

HTTP (par défaut):```bash ./bin/server

- Serveur gRPC: port **50051**
- Tableau de bord web: **http://localhost:8080**

**HTTPS/TLS (Recommandé):**```bash
# Generate certificates (one time)
./generate_certs.sh

# Start with TLS
RTC_SERVER_TLS_ENABLED=true ./bin/server

Serveur gRPC: port 50051
Tableau de bord web: https://localhost:8443
Redirection HTTP: http://localhost:8080

Note #1: Avec HTTPS, les navigateurs afficheront un avertissement de sécurité pour les certificats auto-signés. Cliquez sur « Avancé » → « Accéder à localhost ».

Note #2: Le tableau de bord web et le serveur gRPC s'exécuteront sur toutes les interfaces du serveur et peuvent être utilisés à la place de localhost.

Exécution d'un mineur

Client Go (binaire natif)

Utilisation de base:```bash ./bin/client

**Exécuter plusieurs mineurs :**
Ouvrez des terminaux supplémentaires et exécutez `./bin/client` dans chacun d'eux.

#### Mineurs Java

RedTeamCoin fournit deux implémentations de mineurs Java :

##### Client gRPC Java (sans interface)

Client gRPC prêt pour la production, destiné aux serveurs et à l'automatisation.

**Prérequis :**

- Java 11 ou version ultérieure
- Maven (uniquement pour la compilation)

**Construire avec le Makefile :**```bash
make build-java-client

Ou construisez manuellement:```bash cd java-client mvn clean package

**Exécuter :**```bash
# Connect to localhost
java -jar bin/redteamcoin-miner-client.jar

# Connect to remote server
java -jar bin/redteamcoin-miner-client.jar -server 192.168.1.100:50051

Fonctionnalités :

protocole gRPC (compatible avec le client Go)
Fonctionnement en mode headless (sans interface graphique)
Contrôle par le serveur (pause/reprise/limitation)
Reconnexion automatique
Auto-suppression sur commande du serveur

Mineur Java autonome (GUI)

Mineur de bureau avec interface graphique.

Prérequis :

Java 21 ou version ultérieure
Maven (uniquement pour la compilation)

Compilation avec Makefile :```bash make build-java-standalone

**Ou construire manuellement :**```bash
cd java-standalone
mvn clean package

Exécuter:```bash

GUI mode (default)

java -jar bin/redteamcoin-miner-standalone.jar

CLI mode

java -jar bin/redteamcoin-miner-standalone.jar --pool localhost:50051

**Caractéristiques :**

- Interface graphique de bureau
- Affichage des statistiques visuelles
- Protocole simple JSON/Socket
- Intégré dans les applications

##### Compiler tous les mineurs Java```bash
make build-java-all

Avantages des mineurs Java :

Fichier JAR unique, facile à distribuer
Multiplateforme (Windows, Linux, macOS)
Aucune compilation nécessaire sur les systèmes cibles
Nécessite uniquement le runtime Java (JRE)

Voir java-client/README.md pour la documentation complète du client gRPC Java.

Connexion à des serveurs distants

Par défaut, les clients se connectent à localhost:50051. Pour se connecter à un serveur distant :

Utilisation de l'option de ligne de commande (recommandé) :```bash ./bin/client -server 192.168.1.100:50051 ./bin/client -s mining-pool.example.com:50051

**Utilisation de la variable d'environnement :**```bash
export RTC_CLIENT_SERVER_ADDRESS=192.168.1.100:50051
./bin/client

Priorité: Option de ligne de commande > Variable d'environnement > Défaut (localhost:50051)

Minage GPU

RedTeamCoin prend en charge le minage accéléré par GPU pour les GPU NVIDIA (CUDA) et AMD/Intel (OpenCL). Le minage GPU est 100 à 400 fois plus rapide et nettement plus économe en énergie que le minage CPU.

Installation GPU

NVIDIA CUDA:```bash sudo apt install cuda-toolkit make build-cuda

**AMD/Intel OpenCL:**```bash
sudo apt install ocl-icd-opencl-dev
make build-opencl

Détection automatique :```bash make build-gpu # Automatically detects and builds for available GPU

### Utilisation du GPU```bash
# Auto-detect GPU (default)
./bin/client

# Force CPU only
RTC_CLIENT_MINING_GPU_ENABLED=false ./bin/client

# Hybrid mode (CPU + GPU)
RTC_CLIENT_MINING_HYBRID_MODE=true ./bin/client

# GPU with remote server
./bin/client -server mining-pool.example.com:50051

Performance Comparison

Remarque : Le minage par GPU est 100 à 150 fois plus économe en énergie que le minage par CPU.

Tester la fonctionnalité GPU```bash

Test GPU detection

./bin/client 2>&1 | grep -i "gpu|cuda|opencl"

Force CPU mining (verify fallback works)

RTC_CLIENT_MINING_GPU_ENABLED=false ./bin/client

Force GPU mining (if available)

RTC_CLIENT_MINING_GPU_ENABLED=true ./bin/client

Test hybrid CPU+GPU mode

RTC_CLIENT_MINING_HYBRID_MODE=true ./bin/client

Voir [docs/GPU_MINING.md](https://github.com/xyplex3/redteamcoin/blob/HEAD/docs/GPU_MINING.md) pour le guide complet d'extraction sur GPU.

## Configuration

RedTeamCoin utilise [Viper](https://github.com/spf13/viper) pour une gestion flexible de la configuration.
Les paramètres peuvent être spécifiés via des variables d'environnement, des fichiers de configuration YAML, ou
des drapeaux de ligne de commande avec la précédence suivante :

**Drapeaux de ligne de commande** > **Variables d'environnement** > **Fichiers de configuration** > **Valeurs par défaut**

### Configuration initiale

**Initialiser les fichiers de configuration :**```bash
# Initialize both server and client configs
make init-config

# Or initialize individually
make init-server-config  # Creates server-config.yaml
make init-client-config  # Creates client-config.yaml

Cela copie des exemples de fichiers YAML dans votre répertoire de travail pour modification. Vous pouvez également placer les fichiers de configuration dans ~/.rtc/ ou /etc/rtc/.

Remplacement via les variables d'environnement :```bash

Environment variables take precedence over config files

export RTC_SERVER_MINING_DIFFICULTY=8 export RTC_CLIENT_SERVER_ADDRESS=pool.example.com:50051 ./bin/server

### Variables d'environnement

Toutes les variables d'environnement utilisent des préfixes : `RTC_SERVER_` pour le serveur, `RTC_CLIENT_` pour le client.

**Configuration serveur :**

| Variable                                | Description                   | Défaut            |
| --------------------------------------- | ----------------------------- | ------------------ |
| `RTC_SERVER_NETWORK_GRPC_PORT`          | Port du serveur gRPC              | `50051`            |
| `RTC_SERVER_NETWORK_API_PORT`           | Port de l'API HTTPS                | `8443`             |
| `RTC_SERVER_NETWORK_HTTP_PORT`          | Port de l'interface web HTTP       | `8080`             |
| `RTC_SERVER_MINING_DIFFICULTY`          | Difficulté de minage (1-64)      | `6`                |
| `RTC_SERVER_MINING_BLOCK_REWARD`        | Récompense de bloc en pièces         | `50`               |
| `RTC_SERVER_TLS_ENABLED`                | Activer HTTPS/TLS              | `false`            |
| `RTC_SERVER_TLS_CERT_FILE`              | Chemin du certificat TLS          | `certs/server.crt` |
| `RTC_SERVER_TLS_KEY_FILE`               | Chemin de la clé privée TLS          | `certs/server.key` |
| `RTC_SERVER_API_READ_TIMEOUT`           | Délai d'attente de lecture de l'API              | `15s`              |
| `RTC_SERVER_API_WRITE_TIMEOUT`          | Délai d'attente d'écriture de l'API             | `15s`              |
| `RTC_SERVER_API_IDLE_TIMEOUT`           | Délai d'attente d'inactivité de l'API              | `60s`              |
| `RTC_SERVER_LOGGING_UPDATE_INTERVAL`    | Intervalle de mise à jour des statistiques         | `30s`              |
| `RTC_SERVER_LOGGING_FILE_PATH`          | Chemin du fichier journal                 | `pool_log.json`    |
| `RTC_AUTH_TOKEN` *(hérité)*             | Jeton d'authentification personnalisé   | Auto-généré     |

**Configuration client :**

| Variable                                          | Description                         | Défaut           |
| ------------------------------------------------- | ----------------------------------- | ----------------- |
| `RTC_CLIENT_SERVER_ADDRESS`                       | Adresse du serveur de pool (hôte:port)     | `localhost:50051` |
| `RTC_CLIENT_SERVER_TLS_ENABLED`                   | Activer TLS pour la connexion gRPC      | `false`           |
| `RTC_CLIENT_SERVER_TLS_INSECURE_SKIP_VERIFY`      | Ignorer la vérification du certificat       | `true`            |
| `RTC_CLIENT_SERVER_TLS_CA_CERT_FILE`              | Chemin du fichier de certificat CA         | `""`              |
| `RTC_CLIENT_MINING_GPU_ENABLED`                   | Activer le minage GPU                   | `true`            |
| `RTC_CLIENT_MINING_HYBRID_MODE`                   | Activer le minage simultané CPU+GPU  | `false`           |
| `RTC_CLIENT_MINING_AUTO_DELETE`                   | Suppression automatique à l'arrêt             | `true`            |
| `RTC_CLIENT_GPU_NONCE_RANGE`                      | Plage de nonces par lot GPU           | `500000000`       |
| `RTC_CLIENT_GPU_CPU_START_NONCE`                  | Nonce de départ CPU (éviter le chevauchement GPU) | `5000000000`      |
| `RTC_CLIENT_NETWORK_HEARTBEAT_INTERVAL`           | Intervalle de mise à jour du statut              | `30s`             |
| `RTC_CLIENT_NETWORK_RETRY_INTERVAL`               | Délai de nouvelle tentative de connexion              | `10s`             |
| `RTC_CLIENT_NETWORK_MAX_RETRY_TIME`               | Durée maximale de nouvelle tentative                  | `5m`              |
| `RTC_CLIENT_BEHAVIOR_WORKER_UPDATE_INTERVAL`      | Intervalle de rapport de progression du worker     | `100000`          |
| `POOL_SERVER` *(hérité)*                          | Adresse du serveur distant               | `localhost:50051` |
| `GPU_MINING` *(hérité)*                           | Activer/désactiver le minage GPU           | Détection automatique       |
| `HYBRID_MINING` *(hérité)*                        | Activer le minage CPU+GPU               | `false`           |

### Exemples de fichiers de configuration

**Configuration serveur** (`server-config.yaml`):```yaml
network:
  grpc_port: 50051
  api_port: 8443
  http_port: 8080
mining:
  difficulty: 8
  block_reward: 100
tls:
  enabled: true
  cert_file: /etc/rtc/certs/server.crt
  key_file: /etc/rtc/certs/server.key
logging:
  update_interval: 30s
  file_path: /var/log/rtc/pool.json

Configuration client (client-config.yaml):```yaml server: address: pool.example.com:50051 tls: enabled: false insecure_skip_verify: true ca_cert_file: "" mining: gpu_enabled: true hybrid_mode: false auto_delete: true gpu: nonce_range: 1000000000 cpu_start_nonce: 5000000000 network: heartbeat_interval: 30s retry_interval: 10s max_retry_time: 5m

### Authentification

Tous les points de terminaison de l'API (sauf la page d'accueil du tableau de bord) nécessitent une authentification par jeton Bearer.

**Jeton généré automatiquement :**
Le serveur génère un jeton sécurisé au démarrage et l'affiche dans la console.

**Jeton personnalisé :**```bash
export RTC_AUTH_TOKEN="your-secret-token"
./bin/server

Performance

Les temps de minage attendus varient selon les performances du CPU et la chance :

Difficulté 4 : ~1-10 secondes/bloc (CPU unique)
Difficulté 5 : ~10-60 secondes/bloc
Difficulté 6 : ~1-10 minutes/bloc

Configuration HTTPS```bash

Generate certificates

./generate_certs.sh

Start with HTTPS using new config system

export RTC_SERVER_TLS_ENABLED=true export RTC_AUTH_TOKEN="my-secure-token" ./bin/server

Custom certificates

export RTC_SERVER_TLS_CERT_FILE="/path/to/cert.pem" export RTC_SERVER_TLS_KEY_FILE="/path/to/key.pem" ./bin/server

Voir [docs/TLS_SETUP.md](https://github.com/xyplex3/redteamcoin/blob/HEAD/docs/TLS_SETUP.md) pour une configuration TLS détaillée.

## Référence API

### Points de terminaison de l'API REST

**Points de terminaison publics :**

- `GET /` - Tableau de bord web (HTML)
- `GET /blocks` - Page de visualisation de tous les blocs (HTML)

**Points de terminaison authentifiés :**

- `GET /api/stats` - Statistiques du pool (JSON)
- `GET /api/miners` - Liste de tous les mineurs (JSON)
- `GET /api/blockchain` - Blockchain complète (JSON)
- `GET /api/blocks/{index}` - Détails d'un bloc spécifique (JSON)
- `GET /api/validate` - Valider l'intégrité de la blockchain (JSON)
- `GET /api/cpu` - Statistiques d'utilisation du CPU et du GPU (JSON)
- `POST /api/miner/pause` - Mettre en pause le minage pour un mineur spécifique
- `POST /api/miner/resume` - Reprendre le minage pour un mineur spécifique
- `POST /api/miner/delete` - Supprimer un mineur (arrêt automatique et auto-suppression)
- `POST /api/miner/throttle` - Définir le pourcentage de limitation du CPU (0-100%)

### Exemples d'authentification

**cURL:**```bash
# Get stats
curl -H "Authorization: Bearer YOUR_TOKEN" http://localhost:8080/api/stats

# Get miners
curl -H "Authorization: Bearer YOUR_TOKEN" http://localhost:8080/api/miners

# Pause a miner
curl -X POST -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"miner_id":"miner-hostname-1234567890"}' \
  http://localhost:8080/api/miner/pause

# Set CPU throttle to 50%
curl -X POST -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"miner_id":"miner-hostname-1234567890","throttle_percent":50}' \
  http://localhost:8080/api/miner/throttle

# HTTPS (with self-signed cert)
curl -k -H "Authorization: Bearer YOUR_TOKEN" https://localhost:8443/api/stats

JavaScript:```javascript const token = "YOUR_TOKEN_HERE"; const headers = { Authorization: Bearer ${token} };

fetch("http://localhost:8080/api/stats", { headers }) .then((r) => r.json()) .then((data) => console.log(data));

**Python:**```python
import requests

headers = {'Authorization': 'Bearer YOUR_TOKEN'}
response = requests.get('http://localhost:8080/api/stats', headers=headers)
print(response.json())

Services gRPC```protobuf

service MiningPool { rpc RegisterMiner(MinerInfo) returns (RegistrationResponse); rpc GetWork(WorkRequest) returns (WorkResponse); rpc SubmitWork(WorkSubmission) returns (SubmissionResponse); rpc Heartbeat(MinerStatus) returns (HeartbeatResponse); rpc StopMining(MinerInfo) returns (StopResponse); }

## Architecture

### Stack technique

- **Langage**: Go 1.21+
- **Framework RPC**: gRPC avec Protocol Buffers
- **Serveur web**: bibliothèque standard net/http de Go
- **Dépendances**: google.golang.org/protobuf, google.golang.org/grpc

## Développement

### Commandes de build```bash
make proto                # Generate protobuf code
make build                # Build server and client (CPU only)
make build-gpu            # Build with GPU support (auto-detect)
make build-cuda           # Build with NVIDIA CUDA
make build-opencl         # Build with AMD/Intel OpenCL
make build-windows        # Cross-compile for Windows
make build-all-platforms  # Cross-compile for all platforms
make clean                # Remove build artifacts
make deps                 # Download dependencies
make init                 # Full initialization

Tests

RedTeamCoin comprend des tests unitaires complets pour les composants serveur et client.

Exécutez tous les tests :```bash make test # Run all tests (server + client)

**Exécuter des suites de tests spécifiques :**```bash
# Server tests
cd server && go test -v

# Client tests
cd client && go test -v -short

# With coverage
cd server && go test -cover
cd client && go test -cover

Couverture des tests :

Serveur : 76 tests, 66.3 % de couverture
- blockchain_test.go : 15 tests - validation de la blockchain, calcul de hachage, accès concurrent
- pool_test.go : 26 tests - gestion des mineurs, distribution du travail, statistiques
- grpc_server_test.go : 17 tests - points de terminaison gRPC, contrôle des mineurs, heartbeats
- api_test.go : 18 tests - API REST, authentification, opérations des mineurs
Client : 41 tests, 16.2 % de couverture
- main_test.go : 24 tests - logique de minage, calcul de hachage, gestion d'état
- gpu_test.go : 18 tests - détection GPU, gestion des périphériques, statistiques

Total : 117 tests unitaires couvrant les fonctionnalités de base

Ce qui est testé :

Validation et intégrité de la blockchain
Minage de blocs et preuve de travail
Distribution du travail du pool de minage
Enregistrement et gestion des mineurs
Contrôle des mineurs côté serveur (pause/reprise/suppression/limitation)
Protocoles de communication gRPC
Points de terminaison de l'API REST et authentification
Détection et initialisation des périphériques GPU
Calcul du taux de hachage et statistiques
Opérations concurrentes et sécurité des threads
Gestion des erreurs et cas limites

Tests CI/CD :

Tous les tests s'exécutent automatiquement sur :

Pull requests
Commits sur la branche principale
Builds de release

Voir .github/workflows/build-verification.yaml pour la configuration CI.

Compilation croisée

Windows (CPU uniquement) :```bash make build-windows

Crée `bin/client.exe`

**Windows avec OpenCL (support GPU) :**```bash
# Requires MinGW-w64 and Windows OpenCL SDK
make build-windows-opencl

Crée bin/client-windows-opencl.exe

Voir docs/WINDOWS_BUILD.md pour les instructions complètes de compilation Windows y compris:

Compilations Windows natives avec prise en charge GPU
Configuration de la compilation croisée depuis Linux
Configuration du jeton d'authentification
Guide de dépannage

Plusieurs plateformes:```bash make build-all-platforms

Créé :

- `client-linux-amd64` - Linux 64 bits
- `client-linux-arm64` - Linux ARM64
- `client-windows-amd64.exe` - Windows 64 bits
- `client-darwin-amd64` - macOS Intel
- `client-darwin-arm64` - macOS Apple Silicon

**Remarque :** Les binaires compilés en croisé sont uniquement CPU (CGO désactivé), sauf si vous utilisez `build-windows-opencl`.

### Outils d'analyse

Générer des rapports d'évaluation des dommages pour l'analyse d'impact minier :```bash
make build-tools
./bin/generate_report -log pool_log.json

Le rapport comprend :

Analyse de la consommation des ressources
Évaluation de l'impact sur les performances
Dommages à l'infrastructure
Implications en matière de sécurité
Résumé de l'impact financier
Analyse système par système
Recommandations de remédiation

Hypothèses de coût :

Conversion des rapports :```bash

PDF

pandoc Report_Miner_Activity_from_to.md -o report.pdf

HTML

pandoc Report_Miner_Activity_from_to.md -o report.html

DOCX

pandoc Report_Miner_Activity_from_to.md -o report.docx

**Cas d'utilisation :**

- Analyse post-incident
- Briefings exécutifs
- Justification financière
- Documentation de conformité
- Réclamations d'assurance
- Preuves légales

Voir [tools/README.md](https://github.com/xyplex3/redteamcoin/blob/HEAD/tools/README.md) pour la documentation complète.

## Dépannage

### Problèmes de connexion à distance

**Test de connectivité :**```bash
# Test connection
ping <server_ip>
nc -zv <server_ip> 50051

# Check server (on server side)
lsof -i :50051
ss -an | grep 50051

Problèmes courants :

Vérifier l'adresse et le port du serveur
S'assurer que le serveur est en cours d'exécution
Vérifier les règles du pare-feu (client et serveur)
Confirmer la connectivité réseau
Vérifier que le port 50051 est à l'écoute

Problèmes de minage GPU

Problèmes généraux

Échecs de compilation :

S'assurer que Go 1.21+ est installé
Exécuter make deps pour installer les dépendances
Exécuter make install-tools pour les outils protoc

Connexion refusée :

Vérifier que le serveur est en cours d'exécution
Vérifier que le port n'est pas utilisé : lsof -i :50051
Vérifier les paramètres du pare-feu

Erreurs d'authentification :

Vérifier que le jeton correspond à la sortie du serveur
Vérifier le format de l'en-tête Authorization: Bearer TOKEN
S'assurer que le jeton est inclus dans l'URL ou les en-têtes

Documentation

Guides d'utilisation

docs/GPU_MINING.md - Minage GPU avec CUDA et OpenCL
docs/WINDOWS_BUILD.md - Guide de compilation Windows (compilation native et croisée)
docs/TLS_SETUP.md - Configuration HTTPS/TLS
java-client/README.md - Client Java gRPC (mineur sans interface)
tools/README.md - Outils d'analyse et rapports de dommages

Références techniques

docs/WORKFLOWS.md - Workflows CI/CD et processus de développement

Exemples

docs/examples/ - Rapports d'exemple et exemples d'utilisation

Contribution

Nous accueillons les contributions ! Voici comment commencer :

Forkez le dépôt
Créez une branche de fonctionnalité : git checkout -b feature/amazing-feature
Apportez vos modifications et ajoutez des tests
Exécutez la suite de tests : make test
Validez vos modifications : git commit -m 'Add amazing feature'
Poussez la branche : git push origin feature/amazing-feature
Ouvrez une pull request

Configuration de développement```bash

Clone your fork

git clone https://github.com/YOUR_USERNAME/RedTeamCoin.git cd RedTeamCoin

Install dependencies

make install-tools make deps

Run tests

make test

Build and test locally

make build make run-server # Terminal 1 make run-client # Terminal 2

### Directives de code

- Suivre le formatage standard de Go (`gofmt`)
- Ajouter des tests unitaires pour les nouvelles fonctionnalités
- Mettre à jour la documentation pour les changements visibles par l'utilisateur
- S'assurer que toutes les vérifications CI passent avant de soumettre une PR

## Note de sécurité

Ceci est un **projet de démonstration/éducation** pour les tests de sécurité autorisés
et les opérations d'équipe rouge. Il est destiné à :

- aux engagements de tests d'intrusion autorisés
- à la validation des contrôles de sécurité
- à l'évaluation des capacités de détection
- à des fins éducatives et de formation

Cet outil n'est pas destiné à une utilisation en production comme une véritable cryptomonnaie et
ne dispose pas de nombreuses fonctionnalités requises pour un système de production (signatures cryptographiques,
portefeuilles, validation de transactions, consensus réseau, etc.).

**Utilisez-le uniquement avec une autorisation explicite sur des systèmes que vous possédez ou dont vous avez la permission de
tester.**

## Licence

Ce projet est sous licence GNU General Public License v3.0 - voir le
fichier [LICENSE](https://github.com/xyplex3/redteamcoin/blob/HEAD/LICENSE) pour plus de détails.

## Remerciements

**Créé par :**

- Peter Greko ([@Xyplex02](https://github.com/Xyplex02))
- Luciano Krigun ([@klucho](https://github.com/klucho))
- Jayson Grace ([@l50](https://github.com/l50))

CPU (1 cœur)	~2 MH/s	Baseline	~0.02
CPU (8 cœurs)	~16 MH/s	8x	~0.02
GPU (RTX 3080)	~500 MH/s	250x	~2.0
GPU (RTX 3090)	~600 MH/s	300x	~2.5
GPU (AMD MI250)	~800 MH/s	400x	~3.0
Hybride (CPU+GPU)	~620 MH/s	310x	~2.0

Puissance CPU	150W	Pleine charge
Puissance GPU	250W	Pleine charge
Électricité	$0.12/kWh	Ajuster par région
Réduction de durée	20-40%	Dû à un minage soutenu

"cannot find -lcuda"	`export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH`
"nvcc not found"	`sudo apt install cuda-toolkit`
"No OpenCL device"	`sudo apt install ocl-icd-opencl-dev`
GPU lent	`export RTC_CLIENT_MINING_GPU_ENABLED=true`
Erreur de build CGo	`sudo apt install build-essential`

RedTeamCoin

Populaires

RedTeamCoin

Table des matières

Aperçu

Fonctionnalités

Démarrage rapide

Prérequis

Installation```bash

Clone the repository

Install dependencies

Build server and client

Lancer votre premier pool de minage

Utilisation

Lancement du serveur

Exécution d'un mineur

Client Go (binaire natif)

Mineur Java autonome (GUI)

GUI mode (default)

CLI mode

Connexion à des serveurs distants

Minage GPU

Installation GPU

Performance Comparison

Tester la fonctionnalité GPU```bash

Test GPU detection

Force CPU mining (verify fallback works)

Force GPU mining (if available)

Test hybrid CPU+GPU mode

Environment variables take precedence over config files

Performance

Configuration HTTPS```bash

Generate certificates

Start with HTTPS using new config system

Custom certificates

Services gRPC```protobuf

Tests

Compilation croisée

PDF

HTML

DOCX

Problèmes de minage GPU

Problèmes généraux

Documentation

Guides d'utilisation

Références techniques

Exemples

Contribution

Configuration de développement```bash

Clone your fork

Install dependencies

Run tests

Build and test locally