RedTeamCoin — Red Team Coin per operazioni di crypto-mining. | Kitploit

### Verifica

Verifica che la build sia completata con successo:```bash
ls -lh bin/
# Expected output: server and client binaries (1-5 MB each)

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

Dovresti vedere un output simile a:```text
RedTeamCoin Mining Pool Server
Authentication Token: abc123def456...
Dashboard URL: http://localhost:8080?token=abc123def456...
gRPC server listening on port 50051

Dovresti vedere attività di mining:```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...

Vedrai statistiche in tempo reale inclusi minatori attivi, tassi di hash e blocchi minati.

**Nota:** Il server ascolta su tutte le interfacce di rete - sostituisci `localhost` con l'IP del tuo server per l'accesso remoto.

## Come Funziona

Il pool di mining opera utilizzando un meccanismo di consenso proof-of-work:

1. Il server inizializza la blockchain con il blocco genesis
2. I minatori si connettono tramite gRPC e si registrano con IP/hostname
3. Il server distribuisce assegnazioni di lavoro (modelli di blocco)
4. I minatori calcolano hash SHA-256 per trovare nonce validi
5. I minatori inviano soluzioni quando viene raggiunta la difficoltà target
6. Il server convalida e aggiunge blocchi alla blockchain
7. La dashboard mostra statistiche in tempo reale e attività dei minatori

Ogni blocco richiede di trovare un hash con un numero specifico di zeri iniziali (difficoltà configurabile). I minatori ricevono 50 RTC per blocco minato.

### Flusso dei Dati```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----------|

- Server gRPC: porta **50051**
- Dashboard web: **http://localhost:8080**

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

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

**Esegui più miner:**
Apri terminali aggiuntivi ed esegui `./bin/client` in ciascuno.

#### Miner Java

RedTeamCoin fornisce due implementazioni di miner Java:

##### Client gRPC Java (Headless)

Client gRPC pronto per la produzione per server e automazione.

**Prerequisiti:**

- Java 11 o successivo
- Maven (solo per la compilazione)

**Compila usando Makefile:**```bash
make build-java-client

**Caratteristiche:**

- Interfaccia GUI desktop
- Visualizzazione statistica visiva
- Protocollo JSON/Socket semplice
- Incorporato in applicazioni

##### Compila tutti i miner Java```bash
make build-java-all

### Uso 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

Configurazione	Tasso di hash	Accelerazione	Efficienza (MH/W)
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
Ibrido (CPU+GPU)	~620 MH/s	310x	~2.0

See [docs/GPU_MINING.md](https://github.com/xyplex3/redteamcoin/blob/main/docs/GPU_MINING.md) per la guida completa al mining GPU.

## Configurazione

RedTeamCoin utilizza [Viper](https://github.com/spf13/viper) per una gestione flessibile della configurazione. Le impostazioni possono essere specificate tramite variabili d'ambiente, file di configurazione YAML o flag da riga di comando con la seguente precedenza:

**Flag da riga di comando** > **Variabili d'ambiente** > **File di configurazione** > **Valori predefiniti**

### Impostazione

**Inizializza i file di configurazione:**```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

### Variabili d'ambiente

Tutte le variabili d'ambiente usano i prefissi: `RTC_SERVER_` per il server, `RTC_CLIENT_` per il client.

**Configurazione Server:**

| Variabile                                | Descrizione                    | Default           |
| --------------------------------------- | ------------------------------ | ----------------- |
| `RTC_SERVER_NETWORK_GRPC_PORT`          | Porta del server gRPC          | `50051`           |
| `RTC_SERVER_NETWORK_API_PORT`           | Porta API HTTPS                | `8443`            |
| `RTC_SERVER_NETWORK_HTTP_PORT`          | Porta interfaccia web HTTP     | `8080`            |
| `RTC_SERVER_MINING_DIFFICULTY`          | Difficoltà di mining (1-64)    | `6`               |
| `RTC_SERVER_MINING_BLOCK_REWARD`        | Ricompensa del blocco in monete | `50`              |
| `RTC_SERVER_TLS_ENABLED`                | Abilita HTTPS/TLS              | `false`           |
| `RTC_SERVER_TLS_CERT_FILE`              | Percorso del certificato TLS   | `certs/server.crt`|
| `RTC_SERVER_TLS_KEY_FILE`               | Percorso della chiave privata TLS | `certs/server.key`|
| `RTC_SERVER_API_READ_TIMEOUT`           | Timeout di lettura API         | `15s`             |
| `RTC_SERVER_API_WRITE_TIMEOUT`          | Timeout di scrittura API       | `15s`             |
| `RTC_SERVER_API_IDLE_TIMEOUT`           | Timeout di inattività API      | `60s`             |
| `RTC_SERVER_LOGGING_UPDATE_INTERVAL`    | Intervallo aggiornamento statistiche | `30s`        |
| `RTC_SERVER_LOGGING_FILE_PATH`          | Percorso del file di log       | `pool_log.json`   |
| `RTC_AUTH_TOKEN` *(legacy)*             | Token di autenticazione personalizzato | Generato automaticamente |

**Configurazione Client:**

| Variabile                                          | Descrizione                         | Default           |
| ------------------------------------------------- | ----------------------------------- | ----------------- |
| `RTC_CLIENT_SERVER_ADDRESS`                       | Indirizzo del server pool (host:porta) | `localhost:50051` |
| `RTC_CLIENT_SERVER_TLS_ENABLED`                   | Abilita TLS per connessione gRPC    | `false`           |
| `RTC_CLIENT_SERVER_TLS_INSECURE_SKIP_VERIFY`      | Salta verifica certificato          | `true`            |
| `RTC_CLIENT_SERVER_TLS_CA_CERT_FILE`              | Percorso del file del certificato CA | `""`              |
| `RTC_CLIENT_MINING_GPU_ENABLED`                   | Abilita mining GPU                  | `true`            |
| `RTC_CLIENT_MINING_HYBRID_MODE`                   | Abilita mining simultaneo CPU+GPU   | `false`           |
| `RTC_CLIENT_MINING_AUTO_DELETE`                   | Eliminazione automatica allo spegnimento | `true`        |
| `RTC_CLIENT_GPU_NONCE_RANGE`                      | Intervallo nonce per batch GPU      | `500000000`       |
| `RTC_CLIENT_GPU_CPU_START_NONCE`                  | Nonce di avvio CPU (evita sovrapposizione GPU) | `5000000000` |
| `RTC_CLIENT_NETWORK_HEARTBEAT_INTERVAL`           | Intervallo aggiornamento stato      | `30s`             |
| `RTC_CLIENT_NETWORK_RETRY_INTERVAL`               | Ritardo tentativo riconnessione     | `10s`             |
| `RTC_CLIENT_NETWORK_MAX_RETRY_TIME`               | Durata massima tentativi            | `5m`              |
| `RTC_CLIENT_BEHAVIOR_WORKER_UPDATE_INTERVAL`      | Intervallo rapporto progresso worker | `100000`          |
| `POOL_SERVER` *(legacy)*                          | Indirizzo server remoto             | `localhost:50051` |
| `GPU_MINING` *(legacy)*                           | Abilita/disabilita mining GPU       | Rilevamento automatico |
| `HYBRID_MINING` *(legacy)*                        | Abilita mining CPU+GPU              | `false`           |

### Esempi di file di configurazione

**Configurazione server** (`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

### Autenticazione

Tutti gli endpoint API (eccetto la dashboard homepage) richiedono l'autenticazione tramite Bearer token.

**Token generato automaticamente:**
Il server genera un token sicuro all'avvio e lo visualizza nella console.

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

Vedi [docs/TLS_SETUP.md](https://github.com/xyplex3/redteamcoin/blob/main/docs/TLS_SETUP.md) per la configurazione TLS dettagliata.

## Riferimento API

### Endpoint REST API

**Endpoint pubblici:**

- `GET /` - Dashboard web (HTML)
- `GET /blocks` - Pagina di visualizzazione di tutti i blocchi (HTML)

**Endpoint autenticati:**

- `GET /api/stats` - Statistiche del pool (JSON)
- `GET /api/miners` - Elenco di tutti i miner (JSON)
- `GET /api/blockchain` - Blockchain completa (JSON)
- `GET /api/blocks/{index}` - Dettagli di un blocco specifico (JSON)
- `GET /api/validate` - Convalida dell'integrità della blockchain (JSON)
- `GET /api/cpu` - Statistiche di utilizzo CPU e GPU (JSON)
- `POST /api/miner/pause` - Pausa mining per un miner specifico
- `POST /api/miner/resume` - Riprendi mining per un miner specifico
- `POST /api/miner/delete` - Elimina un miner (auto-terminazione e auto-eliminazione)
- `POST /api/miner/throttle` - Imposta percentuale di limitazione CPU (0-100%)

### Esempi di Autenticazione

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

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

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

## Architettura

### Stack Tecnologico

- **Linguaggio**: Go 1.21+
- **Framework RPC**: gRPC with Protocol Buffers
- **Server Web**: Go net/http standard library
- **Dipendenze**: google.golang.org/protobuf, google.golang.org/grpc

## Sviluppo

### Comandi di Compilazione```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

**Esegui suite di test specifiche:**```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

Creates:

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

**Nota:** I binari cross-compilati sono solo CPU (CGO disabilitato) a meno di usare `build-windows-opencl`.

### Strumenti di Analisi

Genera report di valutazione dei danni per l'analisi dell'impatto del mining:```bash
make build-tools
./bin/generate_report -log pool_log.json

**Casi d'uso:**

- Analisi post-incidente
- Briefing esecutivi
- Giustificazione finanziaria
- Documentazione di conformità
- Richieste di risarcimento assicurativo
- Prove legali

Vedi [tools/README.md](https://github.com/xyplex3/redteamcoin/blob/main/tools/README.md) per la documentazione completa.

## Risoluzione dei problemi

### Problemi di connessione remota

**Test di connettività:**```bash
# Test connection
ping <server_ip>
nc -zv <server_ip> 50051

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

Problema	Soluzione
"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 lento	`export RTC_CLIENT_MINING_GPU_ENABLED=true`
Errore di build CGo	`sudo apt install build-essential`

### Linee guida per il codice

- Segui la formattazione standard di Go (`gofmt`)
- Aggiungi test unitari per nuove funzionalità
- Aggiorna la documentazione per modifiche visibili all'utente
- Assicurati che tutti i controlli CI siano superati prima di inviare una PR

## Nota sulla sicurezza

Questo è un **progetto dimostrativo/educativo** per test di sicurezza autorizzati
e operazioni red team. È pensato per:

- Impegni di penetration testing autorizzati
- Validazione dei controlli di sicurezza
- Valutazione delle capacità di rilevamento
- Scopi educativi e di formazione

Questo strumento non è destinato all'uso in produzione come criptovaluta reale e
manca di molte funzionalità richieste per un sistema di produzione (firme crittografiche,
portafogli, validazione delle transazioni, consenso di rete, ecc.).

**Utilizzare solo con autorizzazione esplicita su sistemi di tua proprietà o per i quali hai
il permesso di testare.**

## Licenza

Questo progetto è concesso in licenza secondo la GNU General Public License v3.0 - consulta il
file [LICENSE](https://github.com/xyplex3/redteamcoin/blob/main/LICENSE) per i dettagli.

## Riconoscimenti

**Creato da:**

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

Parametro	Predefinito	Note
Potenza CPU	150W	Carico massimo
Potenza GPU	250W	Carico massimo
Elettricità	$0,12/kWh	Regolare in base alla regione
Riduzione durata	20-40%	Da mining sostenuto

RedTeamCoin

Più Popolari

RedTeamCoin

Sommario

Panoramica

Funzionalità

Avvio rapido

Prerequisiti

Installazione```bash

Clone the repository

Install dependencies

Build server and client

Esecuzione del tuo primo pool di mining

Utilizzo

Avvio del Server

Esecuzione di un Miner

Client Go (Binario Nativo)

Miner Java Standalone (GUI)

GUI mode (default)

CLI mode

Connessione a Server Remoti

Mining GPU

Installazione GPU

Confronto delle prestazioni

Test della funzionalità 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

Prestazioni

Configurazione HTTPS```bash

Generate certificates

Start with HTTPS using new config system

Custom certificates

Servizi gRPC```protobuf

Testing

Cross-compilazione

PDF

HTML

DOCX

Problemi di mining GPU

Problemi Generali

Documentazione

Guide per l'utente

Riferimenti tecnici

Esempi

Contribuire

Development Setup```bash

Clone your fork

Install dependencies

Run tests

Build and test locally