RedTeamCoin

RedTeamCoin Logo

RedTeamCoin ist eine Blockchain-basierte Kryptowährungs-Mining-Pool-Implementierung, die für autorisierte Sicherheitstests und Red-Team-Operationen entwickelt wurde. Es ist in Go geschrieben und unterstützt Java-Clients, simuliert reale Kryptomining-Angriffe und hilft Organisationen, ihre Erkennungsfähigkeiten zu bewerten und potenzielle Schäden durch Mining-Aktivitäten von Bedrohungsakteuren zu quantifizieren.

Dieses Tool ermöglicht es Sicherheitsteams, Kryptomining-Angriffsszenarien sicher und legal auf Unternehmenssystemen zu demonstrieren, umfassende Schadensberichte zu erstellen und Sicherheitskontrollen zu validieren – alles in einer kontrollierten Umgebung mit einer isolierten, nicht-öffentlichen Blockchain.

Übersicht

Warum RedTeamCoin nutzen?

Demonstrieren Sie die realen Auswirkungen von Cryptojacking-Angriffen
Testen und validieren Sie Sicherheitsüberwachungs- und Erkennungssysteme
Erstellen Sie quantifizierbare Schadensbewertungen für Führungskräfteberichte
Simulieren Sie Mining-Aktivitäten sicher, ohne sich mit öffentlichen Blockchains zu verbinden

Systemkomponenten:

Mining-Pool-Server – Verwaltet die Blockchain und koordiniert die Arbeitsverteilung
Client-Miner – CPU/GPU-Mining-Clients (Go- und Java-Implementierungen)
Web-Dashboard – Echtzeit-Überwachung, Steuerung und Statistiken
Analysetools – Erstellung umfassender Schadensbewertungsberichte

Funktionen

Blockchain-Implementierung: Benutzerdefinierte Proof-of-Work-Blockchain mit konfigurierbarem Schwierigkeitsgrad
Mining-Pool-Server: Verwaltet mehrere Miner und Arbeitsverteilung über gRPC
Client-Miner: Automatisierte Mining-Clients (Go und Java) mit Protokollierung von IP-Adressen und Hostnamen
Java-Standalone-Miner: Desktop-Miner mit grafischer Benutzeroberfläche
Java-gRPC-Client: Headless-gRPC-Client für Server und Automatisierung
Serverseitige Miner-Steuerung: Miner remote pausieren, fortsetzen, CPU-Auslastung drosseln und löschen
CPU-Drosselung: CPU-Auslastung des Miners von 0–100 % begrenzen, um Ressourcen zu verwalten
GPU-Mining-Unterstützung: CUDA- und OpenCL-Unterstützung für GPU-beschleunigtes Mining
Hybrid-Mining: Gleichzeitiges CPU- und GPU-Mining für maximale Leistung
Web-Dashboard: Echtzeit-Überwachung von Minern, Statistiken und Blockchain mit Steuerschaltflächen
REST-API-Authentifizierung: Token-basierte Authentifizierung für API-Endpunkte
Client-gRPC-TLS-Verschlüsselung: Optionale TLS-Verschlüsselung für sichere Client-Server-gRPC-Verbindungen
Duales IP-Tracking: Erfasst sowohl vom Client gemeldete als auch vom Server erkannte IP-Adressen
CPU- und GPU-Statistiken: Umfassende Ressourcennutzungsverfolgung und -berichterstattung
Protocol Buffers: Effiziente Client-Server-Kommunikation mittels protobuf/gRPC
Automatische Beendigung: Miner beenden und löschen sich automatisch, wenn sie vom Server entfernt werden

Schnellstart

RedTeamCoin in weniger als 5 Minuten zum Laufen bringen:

Voraussetzungen

Go 1.21 oder höher
Protocol Buffer Compiler (protoc)

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

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

Windows:

Installieren Sie Go von https://golang.org/dl/
Installieren Sie protoc von 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

### Überprüfung

Überprüfen Sie, ob der Build erfolgreich abgeschlossen wurde:```bash
ls -lh bin/
# Expected output: server and client binaries (1-5 MB each)

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

Betreiben Ihres ersten Mining-Pools

1. Starten Sie den Server:```bash make run-server

Sie sollten eine Ausgabe wie die folgende sehen:```text
RedTeamCoin Mining Pool Server
Authentication Token: abc123def456...
Dashboard URL: http://localhost:8080?token=abc123def456...
gRPC server listening on port 50051

2. Starten Sie einen Miner (in einem neuen Terminal):```bash make run-client

Sie sollten Mining-Aktivität sehen:```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. Dashboard anzeigen:

Öffnen Sie die URL aus Schritt 1 in Ihrem Browser, oder navigieren Sie zu:```text http://localhost:8080?token=YOUR_AUTH_TOKEN_HERE

Sie sehen Echtzeit-Statistiken, einschließlich aktiver Miner, Hashraten und abgebauter Blöcke.

**Hinweis:** Der Server lauscht auf allen Netzwerkschnittstellen – ersetzen Sie `localhost`
durch die IP Ihres Servers für Fernzugriff.

## Wie es funktioniert

Der Mining-Pool arbeitet mit einem Proof-of-Work-Konsensmechanismus:

1. Der Server initialisiert die Blockchain mit dem Genesis-Block
2. Miner verbinden sich über gRPC und registrieren sich mit IP/Hostname
3. Der Server verteilt Arbeitsaufträge (Blockvorlagen)
4. Miner berechnen SHA-256-Hashes, um gültige Nonces zu finden
5. Miner reichen Lösungen ein, wenn das Schwierigkeitsziel erreicht ist
6. Der Server validiert und fügt Blöcke zur Blockchain hinzu
7. Das Dashboard zeigt Echtzeit-Statistiken und Miner-Aktivität an

Jeder Block erfordert das Finden eines Hashs mit einer bestimmten Anzahl führender Nullen
(konfigurierbare Schwierigkeit). Miner erhalten 50 RTC pro abgebautem Block.

### Datenfluss```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----------|

Verwendung

Server starten

HTTP (Standard):```bash ./bin/server

- gRPC-Server: Port **50051**
- Web-Dashboard: **http://localhost:8080**

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

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

gRPC server: port 50051
Web dashboard: https://localhost:8443
HTTP redirect: http://localhost:8080

Hinweis #1: Bei HTTPS zeigen Browser eine Sicherheitswarnung für selbstsignierte Zertifikate an. Klicken Sie auf "Erweitert" → "Weiter zu localhost".

Hinweis #2: Das Web-Dashboard und der gRPC-Server laufen auf allen Schnittstellen des Servers und können anstelle von localhost verwendet werden.

Einen Miner ausführen

Go-Client (Natives Binärprogramm)

Grundlegende Verwendung:```bash ./bin/client

**Mehrere Miner ausführen:**
Öffnen Sie weitere Terminals und führen Sie in jedem `./bin/client` aus.

#### Java Miner

RedTeamCoin stellt zwei Java-Miner-Implementierungen bereit:

##### Java gRPC-Client (Headless)

Produktionsreifer gRPC-Client für Server und Automatisierung.

**Voraussetzungen:**

- Java 11 oder höher
- Maven (nur zum Bauen)

**Mit Makefile bauen:**```bash
make build-java-client

Oder manuell erstellen:```bash cd java-client mvn clean package

**Ausführen:**```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

Funktionen:

gRPC-Protokoll (kompatibel mit Go-Client)
Headless-Betrieb (keine GUI)
Serversteuerung (Pause/Fortsetzen/Drosseln)
Automatische Wiederverbindung
Selbstlöschung auf Serverbefehl

Java Standalone Miner (GUI)

Desktop-Miner mit grafischer Oberfläche.

Voraussetzungen:

Java 21 oder neuer
Maven (nur zum Bauen)

Erstellung mit Makefile:```bash make build-java-standalone

**Oder manuell erstellen:**```bash
cd java-standalone
mvn clean package

Ausführen:```bash

GUI mode (default)

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

CLI mode

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

**Features:**

- Desktop-GUI-Oberfläche
- Visuelle Statistikanzeige
- Einfaches JSON/Socket-Protokoll
- Eingebettet in Anwendungen

##### Erstellen aller Java-Miner```bash
make build-java-all

Vorteile der Java-Miner:

Einzelne JAR-Datei, einfach zu verteilen
Plattformübergreifend (Windows, Linux, macOS)
Keine Kompilierung auf Zielsystemen erforderlich
Benötigt nur die Java Runtime (JRE)

Siehe java-client/README.md für die vollständige Java gRPC-Client-Dokumentation.

Verbindung zu entfernten Servern

Standardmäßig verbinden sich Clients mit localhost:50051. Um eine Verbindung zu einem entfernten Server herzustellen:

Verwendung der Befehlszeilenoption (empfohlen):```bash ./bin/client -server 192.168.1.100:50051 ./bin/client -s mining-pool.example.com:50051

**Verwendung von Umgebungsvariablen:**```bash
export RTC_CLIENT_SERVER_ADDRESS=192.168.1.100:50051
./bin/client

Priorität: Befehlszeilen-Flag > Umgebungsvariable > Standard (localhost:50051)

GPU-Mining

RedTeamCoin unterstützt GPU-beschleunigtes Mining für NVIDIA (CUDA) und AMD/Intel (OpenCL) GPUs. GPU-Mining ist 100-400x schneller und deutlich energieeffizienter als CPU-Mining.

GPU-Installation

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

Automatische Erkennung:```bash make build-gpu # Automatically detects and builds for available GPU

### GPU-Nutzung```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

Leistungsvergleich

Hinweis: GPU-Mining ist 100-150x energieeffizienter als CPU-Mining.

GPU-Funktionalität testen```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

Siehe [docs/GPU_MINING.md](https://github.com/xyplex3/redteamcoin/blob/HEAD/docs/GPU_MINING.md) für die vollständige GPU-Mining-Anleitung.

## Konfiguration

RedTeamCoin verwendet [Viper](https://github.com/spf13/viper) für eine flexible Konfigurationsverwaltung. Einstellungen können über Umgebungsvariablen, YAML-Konfigurationsdateien oder Befehlszeilen-Flags mit folgender Priorität angegeben werden:

**Befehlszeilen-Flags** > **Umgebungsvariablen** > **Konfigurationsdateien** > **Standardwerte**

### Einrichtung

**Konfigurationsdateien initialisieren:**```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

Dies kopiert Beispiel-YAML-Dateien in Ihr Arbeitsverzeichnis zum Bearbeiten. Sie können Konfigurationsdateien auch in ~/.rtc/ oder /etc/rtc/ ablegen.

Überschreibung mit Umgebungsvariablen:```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

### Umgebungsvariablen

Alle Umgebungsvariablen verwenden Präfixe: `RTC_SERVER_` für den Server, `RTC_CLIENT_` für den Client.

**Server-Konfiguration:**

| Variable                                | Beschreibung                   | Standard          |
| --------------------------------------- | ------------------------------ | ----------------- |
| `RTC_SERVER_NETWORK_GRPC_PORT`          | gRPC-Server-Port               | `50051`           |
| `RTC_SERVER_NETWORK_API_PORT`           | HTTPS-API-Port                 | `8443`            |
| `RTC_SERVER_NETWORK_HTTP_PORT`          | HTTP-Weboberflächen-Port       | `8080`            |
| `RTC_SERVER_MINING_DIFFICULTY`          | Mining-Schwierigkeit (1-64)    | `6`               |
| `RTC_SERVER_MINING_BLOCK_REWARD`        | Blockbelohnung in Coins        | `50`              |
| `RTC_SERVER_TLS_ENABLED`                | HTTPS/TLS aktivieren           | `false`           |
| `RTC_SERVER_TLS_CERT_FILE`              | TLS-Zertifikatspfad            | `certs/server.crt`|
| `RTC_SERVER_TLS_KEY_FILE`               | TLS-Private-Key-Pfad           | `certs/server.key`|
| `RTC_SERVER_API_READ_TIMEOUT`           | API-Lese-Timeout               | `15s`             |
| `RTC_SERVER_API_WRITE_TIMEOUT`          | API-Schreib-Timeout            | `15s`             |
| `RTC_SERVER_API_IDLE_TIMEOUT`           | API-Leerlauf-Timeout           | `60s`             |
| `RTC_SERVER_LOGGING_UPDATE_INTERVAL`    | Statistik-Aktualisierungsintervall | `30s`          |
| `RTC_SERVER_LOGGING_FILE_PATH`          | Logdateipfad                   | `pool_log.json`   |
| `RTC_AUTH_TOKEN` *(Legacy)*             | Benutzerdefinierter Authentifizierungstoken | Automatisch generiert |

**Client-Konfiguration:**

| Variable                                          | Beschreibung                         | Standard          |
| ------------------------------------------------- | ------------------------------------ | ----------------- |
| `RTC_CLIENT_SERVER_ADDRESS`                       | Pool-Server-Adresse (Host:Port)      | `localhost:50051` |
| `RTC_CLIENT_SERVER_TLS_ENABLED`                   | TLS für gRPC-Verbindung aktivieren   | `false`           |
| `RTC_CLIENT_SERVER_TLS_INSECURE_SKIP_VERIFY`      | Zertifikatüberprüfung überspringen   | `true`            |
| `RTC_CLIENT_SERVER_TLS_CA_CERT_FILE`              | Pfad zur CA-Zertifikatsdatei         | `""`              |
| `RTC_CLIENT_MINING_GPU_ENABLED`                   | GPU-Mining aktivieren                | `true`            |
| `RTC_CLIENT_MINING_HYBRID_MODE`                   | Gleichzeitiges CPU+GPU-Mining aktivieren | `false`        |
| `RTC_CLIENT_MINING_AUTO_DELETE`                   | Automatisches Löschen beim Herunterfahren | `true`         |
| `RTC_CLIENT_GPU_NONCE_RANGE`                      | Nonce-Bereich pro GPU-Batch          | `500000000`       |
| `RTC_CLIENT_GPU_CPU_START_NONCE`                  | CPU-Start-Nonce (GPU-Überlappung vermeiden) | `5000000000` |
| `RTC_CLIENT_NETWORK_HEARTBEAT_INTERVAL`           | Statusaktualisierungsintervall       | `30s`             |
| `RTC_CLIENT_NETWORK_RETRY_INTERVAL`               | Verbindungswiederholungsverzögerung  | `10s`             |
| `RTC_CLIENT_NETWORK_MAX_RETRY_TIME`               | Maximale Wiederholungsdauer          | `5m`              |
| `RTC_CLIENT_BEHAVIOR_WORKER_UPDATE_INTERVAL`      | Worker-Fortschrittsbericht-Intervall | `100000`          |
| `POOL_SERVER` *(Legacy)*                          | Remote-Server-Adresse                | `localhost:50051` |
| `GPU_MINING` *(Legacy)*                           | GPU-Mining aktivieren/deaktivieren   | Auto-Erkennung    |
| `HYBRID_MINING` *(Legacy)*                        | CPU+GPU-Mining aktivieren            | `false`           |

### Beispiele für Konfigurationsdateien

**Server-Konfiguration** (`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

Client-Konfiguration (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

### Authentifizierung

Alle API-Endpunkte (außer der Dashboard-Startseite) erfordern eine Bearer-Token-Authentifizierung.

**Automatisch generierter Token:**
Der Server generiert beim Start einen sicheren Token und zeigt ihn in der Konsole an.

**Benutzerdefinierter Token:**```bash
export RTC_AUTH_TOKEN="your-secret-token"
./bin/server

Performance

Die erwarteten Mining-Zeiten variieren je nach CPU-Leistung und Glück:

Schwierigkeit 4: ~1-10 Sekunden/Block (einzelne CPU)
Schwierigkeit 5: ~10-60 Sekunden/Block
Schwierigkeit 6: ~1-10 Minuten/Block

HTTPS-Konfiguration```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

Siehe [docs/TLS_SETUP.md](https://github.com/xyplex3/redteamcoin/blob/HEAD/docs/TLS_SETUP.md) für detaillierte TLS-Konfiguration.

## API-Referenz

### REST-API-Endpunkte

**Öffentliche Endpunkte:**

- `GET /` - Web-Dashboard (HTML)
- `GET /blocks` - Alle Blöcke anzeigen (HTML)

**Authentifizierte Endpunkte:**

- `GET /api/stats` - Pool-Statistiken (JSON)
- `GET /api/miners` - Liste aller Miner (JSON)
- `GET /api/blockchain` - Vollständige Blockchain (JSON)
- `GET /api/blocks/{index}` - Details zu einem bestimmten Block (JSON)
- `GET /api/validate` - Blockchain-Integrität prüfen (JSON)
- `GET /api/cpu` - CPU- und GPU-Auslastungsstatistiken (JSON)
- `POST /api/miner/pause` - Mining für einen bestimmten Miner pausieren
- `POST /api/miner/resume` - Mining für einen bestimmten Miner fortsetzen
- `POST /api/miner/delete` - Einen Miner löschen (automatisch beenden und selbst löschen)
- `POST /api/miner/throttle` - CPU-Drosselungsprozentsatz festlegen (0-100%)

### Authentifizierungsbeispiele

**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())

gRPC-Dienste```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); }

## Architektur

### Technologie-Stack

- **Sprache**: Go 1.21+
- **RPC-Framework**: gRPC mit Protocol Buffers
- **Webserver**: Go net/http Standardbibliothek
- **Abhängigkeiten**: google.golang.org/protobuf, google.golang.org/grpc

## Entwicklung

### Build-Befehle```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

Testen

RedTeamCoin umfasst umfassende Unit-Tests für sowohl Server- als auch Client-Komponenten.

Alle Tests ausführen:```bash make test # Run all tests (server + client)

**Bestimmte Testsuiten ausführen:**```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

Testabdeckung:

Server: 76 Tests, 66,3% Abdeckung
- blockchain_test.go: 15 Tests - Blockchain-Validierung, Hash-Berechnung, paralleler Zugriff
- pool_test.go: 26 Tests - Miner-Verwaltung, Arbeitsverteilung, Statistiken
- grpc_server_test.go: 17 Tests - gRPC-Endpunkte, Miner-Steuerung, Heartbeats
- api_test.go: 18 Tests - REST-API, Authentifizierung, Miner-Operationen
Client: 41 Tests, 16,2% Abdeckung
- main_test.go: 24 Tests - Mining-Logik, Hash-Berechnung, Zustandsverwaltung
- gpu_test.go: 18 Tests - GPU-Erkennung, Geräteverwaltung, Statistiken

Gesamt: 117 Unit-Tests, die die Kernfunktionalität abdecken

Was getestet wird:

Blockchain-Validierung und Integrität
Block-Mining und Proof-of-Work
Arbeitsverteilung im Mining-Pool
Miner-Registrierung und -Verwaltung
Serverseitige Miner-Steuerung (Pause/Weiter/Löschen/Drosseln)
gRPC-Kommunikationsprotokolle
REST-API-Endpunkte und Authentifizierung
GPU-Erkennung und Initialisierung
Hash-Raten-Berechnung und Statistiken
Nebenläufige Operationen und Thread-Sicherheit
Fehlerbehandlung und Randfälle

CI/CD-Tests:

Alle Tests werden automatisch ausgeführt bei:

Pull Requests
Commits auf den Hauptzweig
Release-Builds

Siehe .github/workflows/build-verification.yaml für die CI-Konfiguration.

Cross-Compilation

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

Erstellt `bin/client.exe`

**Windows mit OpenCL (GPU-Unterstützung):**```bash
# Requires MinGW-w64 and Windows OpenCL SDK
make build-windows-opencl

Erzeugt bin/client-windows-opencl.exe

Siehe docs/WINDOWS_BUILD.md für vollständige Windows-Build-Anweisungen einschließlich:

Native Windows-Builds mit GPU-Unterstützung
Cross-Compilation-Setup von Linux
Authentifizierungs-Token-Konfiguration
Fehlerbehebungsanleitung

Mehrere Plattformen:```bash make build-all-platforms

Creates:

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

**Note:** Kreuzkompilierte Binärdateien sind CPU-only (CGO deaktiviert), es sei denn, `build-windows-opencl` wird verwendet.

### Analysetools

Erstellen Sie Schadensbewertungsberichte für die Analyse von Mining-Auswirkungen:```bash
make build-tools
./bin/generate_report -log pool_log.json

Bericht umfasst:

Ressourcenverbrauchsanalyse
Leistungsauswirkungsanalyse
Infrastrukturschäden
Sicherheitsauswirkungen
Zusammenfassung der finanziellen Auswirkungen
Systemweise Analyse
Sanierungsempfehlungen

Kostenannahmen:

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

**Anwendungsfälle:**

- Post-Incident-Analyse
- Executive Briefings
- Finanzielle Rechtfertigung
- Compliance-Dokumentation
- Versicherungsansprüche
- Rechtliche Beweise

Siehe [tools/README.md](https://github.com/xyplex3/redteamcoin/blob/HEAD/tools/README.md) für die vollständige Dokumentation.

## Fehlerbehebung

### Probleme bei der Fernverbindung

**Konnektivität testen:**```bash
# Test connection
ping <server_ip>
nc -zv <server_ip> 50051

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

Häufige Probleme:

Serveradresse und Port überprüfen
Sicherstellen, dass der Server läuft
Firewall-Regeln prüfen (Client und Server)
Netzwerkkonnektivität bestätigen
Sicherstellen, dass Port 50051 lauscht

GPU Mining-Probleme

Allgemeine Probleme

Build-Fehler:

Stellen Sie sicher, dass Go 1.21+ installiert ist
Führen Sie make deps aus, um Abhängigkeiten zu installieren
Führen Sie make install-tools für protoc-Tools aus

Verbindung abgelehnt:

Überprüfen, ob der Server läuft
Überprüfen, dass der Port nicht belegt ist: lsof -i :50051
Firewall-Einstellungen überprüfen

Authentifizierungsfehler:

Überprüfen, ob der Token mit der Serverausgabe übereinstimmt
Überprüfen des Header-Formats Authorization: Bearer TOKEN
Sicherstellen, dass der Token in der URL oder in Headern enthalten ist

Dokumentation

Benutzerhandbücher

docs/GPU_MINING.md - GPU-Mining mit CUDA und OpenCL
docs/WINDOWS_BUILD.md - Windows-Build-Anleitung (nativ und Cross-Kompilierung)
docs/TLS_SETUP.md - HTTPS/TLS-Konfiguration
java-client/README.md - Java-gRPC-Client (Headless-Miner)
tools/README.md - Analysetools und Schadensberichte

Technische Referenzen

docs/WORKFLOWS.md - CI/CD-Workflows und Entwicklungsprozesse

Beispiele

docs/examples/ - Beispielberichte und Nutzungsbeispiele

Mitwirken

Wir freuen uns über Beiträge! So können Sie loslegen:

Forken Sie das Repository
Erstellen Sie einen Feature-Branch: git checkout -b feature/amazing-feature
Nehmen Sie Ihre Änderungen vor und fügen Sie Tests hinzu
Führen Sie die Testsuite aus: make test
Committen Sie Ihre Änderungen: git commit -m 'Add amazing feature'
Pushen Sie zum Branch: git push origin feature/amazing-feature
Erstellen Sie einen Pull-Request

Entwicklungseinrichtung```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

### Code-Richtlinien

- Folgen Sie der Go-Standardformatierung (`gofmt`)
- Fügen Sie Unit-Tests für neue Funktionen hinzu
- Aktualisieren Sie die Dokumentation für benutzerseitige Änderungen
- Stellen Sie sicher, dass alle CI-Prüfungen bestanden sind, bevor Sie einen PR einreichen

## Sicherheitshinweis

Dies ist ein **Demonstrations-/Bildungsprojekt** für autorisierte Sicherheitstests
und Red-Team-Operationen. Es ist bestimmt für:

- Autorisierte Penetrationstest-Einsätze
- Validierung von Sicherheitskontrollen
- Bewertung der Erkennungsfähigkeiten
- Bildungs- und Schulungszwecke

Dieses Tool ist nicht für den produktiven Einsatz als echte Kryptowährung vorgesehen und
entbehrt viele Funktionen, die für ein Produktionssystem erforderlich sind (kryptografische Signaturen,
Wallets, Transaktionsvalidierung, Netzwerkkonsens usw.).

**Verwenden Sie es nur mit ausdrücklicher Genehmigung auf Systemen, die Ihnen gehören oder für die Sie die Erlaubnis zum Testen haben.**

## Lizenz

Dieses Projekt ist unter der GNU General Public License v3.0 lizenziert - siehe die
Datei [LICENSE](https://github.com/xyplex3/redteamcoin/blob/HEAD/LICENSE) für Details.

## Danksagungen

**Erstellt von:**

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

CPU (1 core)	~2 MH/s	Baseline	~0.02
CPU (8 cores)	~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
Hybrid (CPU+GPU)	~620 MH/s	310x	~2.0

CPU-Leistung	150W	Volllast
GPU-Leistung	250W	Volllast
Stromkosten	$0.12/kWh	An Region anpassen
Lebensdauerverkürzung	20-40%	Durch anhaltendes Mining

"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 langsam	`export RTC_CLIENT_MINING_GPU_ENABLED=true`
CGo-Build-Fehler	`sudo apt install build-essential`

RedTeamCoin

Beliebteste

RedTeamCoin

Inhaltsverzeichnis

Übersicht

Funktionen

Schnellstart

Voraussetzungen

Installation```bash

Clone the repository

Install dependencies

Build server and client

Betreiben Ihres ersten Mining-Pools

Verwendung

Server starten

Einen Miner ausführen

Go-Client (Natives Binärprogramm)

Java Standalone Miner (GUI)

GUI mode (default)

CLI mode

Verbindung zu entfernten Servern

GPU-Mining

GPU-Installation

Leistungsvergleich

GPU-Funktionalität testen```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

HTTPS-Konfiguration```bash

Generate certificates

Start with HTTPS using new config system

Custom certificates

gRPC-Dienste```protobuf

Testen

Cross-Compilation

PDF

HTML

DOCX

GPU Mining-Probleme

Allgemeine Probleme

Dokumentation

Benutzerhandbücher

Technische Referenzen

Beispiele

Mitwirken

Entwicklungseinrichtung```bash

Clone your fork

Install dependencies

Run tests

Build and test locally