xyplex3/redteamcoinRed Team Coin para operações de mineração de criptomoedas.
# RedTeamCoin
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/10212/f2fb36901c69c8260d7dcd4fdfa21fc523e023efcff902e6b20640ac15b3409f.png" alt="RedTeamCoin Logo" width="400">
</p>
[](https://github.com/xyplex3/RedTeamCoin/blob/main/LICENSE)
[](https://github.com/xyplex3/RedTeamCoin/actions/workflows/pre-commit.yaml)
[](https://github.com/xyplex3/RedTeamCoin/actions/workflows/security.yaml)
[](https://github.com/xyplex3/RedTeamCoin/actions/workflows/goreleaser.yaml)
[](https://github.com/xyplex3/RedTeamCoin/actions/workflows/test-and-build.yaml)
[](https://github.com/xyplex3/RedTeamCoin/actions/workflows/windows-miner-test.yaml)
---
RedTeamCoin é uma implementação de pool de mineração de criptomoedas baseada em blockchain, projetada para testes de segurança autorizados e operações de red team. Desenvolvida em Go com suporte a cliente Java, simula ataques reais de criptomineração para ajudar organizações a avaliar suas capacidades de detecção e quantificar os danos potenciais de operações de mineração realizadas por atores maliciosos.
Esta ferramenta permite que equipes de segurança demonstrem de forma segura e legal cenários de ataque de criptomineração em sistemas corporativos, gerem relatórios de impacto abrangentes e validem controles de segurança — tudo dentro de um ambiente controlado usando uma blockchain isolada e não pública.
## Sumário
- [Visão Geral](#overview)
- [Recursos](#features)
- [Início Rápido](#quick-start)
- [Como Funciona](#how-it-works)
- [Uso](#usage)
- [Executando o Servidor](#running-the-server)
- [Executando um Minerador](#running-a-miner)
- [Conectando a Servidores Remotos](#connecting-to-remote-servers)
- [Mineração GPU](#gpu-mining)
- [Configuração](#configuration)
- [Referência da API](#api-reference)
- [Arquitetura](#architecture)
- [Desenvolvimento](#development)
- [Contribuição](#contributing)
- [Solução de Problemas](#troubleshooting)
- [Documentação](#documentation)
- [Licença](#license)
- [Agradecimentos](#acknowledgments)
## Visão Geral
**Por que usar RedTeamCoin?**
- Demonstrar o impacto real dos ataques de criptojacking
- Testar e validar sistemas de monitoramento e detecção de segurança
- Gerar avaliações de danos quantificáveis para relatórios executivos
- Simular operações de mineração com segurança sem conectar a blockchains públicas
**Componentes do Sistema:**
- **Servidor de Pool de Mineração** - Gerencia a blockchain e coordena a distribuição de trabalho
- **Mineradores Cliente** - Clientes de mineração CPU/GPU (implementações Go e Java)
- **Painel Web** - Monitoramento, controle e estatísticas em tempo real
- **Ferramentas de Análise** - Geram relatórios abrangentes de avaliação de danos
## Recursos
- **Implementação Blockchain**: Blockchain personalizada baseada em proof-of-work com dificuldade configurável
- **Servidor de Pool de Mineração**: Gerencia vários mineradores e distribuição de trabalho via gRPC
- **Mineradores Cliente**: Clientes de mineração automatizados (Go e Java) com registro de endereço IP e nome do host
- **Minerador Java Independente**: Minerador desktop com interface gráfica habilitada
- **Cliente Java gRPC**: Cliente gRPC headless para servidores e automação
- **Controle de Mineradores do Lado do Servidor**: Pausar, retomar, limitar uso da CPU e excluir mineradores remotamente
- **Limitação de CPU**: Limitar o uso da CPU do minerador de 0 a 100% para gerenciar recursos
- **Suporte a Mineração GPU**: Suporte a CUDA e OpenCL para mineração acelerada por GPU
- **Mineração Híbrida**: Mineração simultânea de CPU e GPU para máximo desempenho
- **Painel Web**: Monitoramento em tempo real de mineradores, estatísticas e blockchain com botões de controle
- **Autenticação API REST**: Autenticação segura baseada em token para endpoints da API
- **Criptografia TLS gRPC do Cliente**: Criptografia TLS opcional para conexões gRPC seguras entre cliente e servidor
- **Rastreamento Duplo de IP**: Registra tanto o IP reportado pelo cliente quanto o IP detectado pelo servidor
- **Estatísticas de CPU e GPU**: Rastreamento e relatórios abrangentes de uso de recursos
- **Protocol Buffers**: Comunicação eficiente cliente-servidor usando protobuf/gRPC
- **Auto-Terminação**: Mineradores desligam e se auto-excluem automaticamente quando removidos do servidor
## Início Rápido
Coloque o RedTeamCoin em funcionamento em menos de 5 minutos:
### Pré-requisitos
- **Go** 1.21 ou posterior
- **Compilador Protocol Buffer** (protoc)
**Ubuntu/Debian:**```bash
sudo apt update
sudo apt install -y golang-go protobuf-compiler
```
**macOS:**```bash
brew install go protobuf
```
**Windows:**
- Instale Go em https://golang.org/dl/
- Instale protoc em https://github.com/protocolbuffers/protobuf/releases
### Instalação```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
```
### Verificação
Verifique se a compilação foi concluída com sucesso:```bash
ls -lh bin/
# Expected output: server and client binaries (1-5 MB each)
./bin/server --help
# Expected output: Usage information for the server
```
### Executando Seu Primeiro Pool de Mineração
**1. Inicie o servidor:**```bash
make run-server
```
Você deve ver uma saída como:```text
RedTeamCoin Mining Pool Server
Authentication Token: abc123def456...
Dashboard URL: http://localhost:8080?token=abc123def456...
gRPC server listening on port 50051
```
**2. Iniciar um minerador** (em um novo terminal):```bash
make run-client
```
Você deve ver atividade de mineração:```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. Ver o painel de controlo:**
Abra o URL do passo 1 no seu navegador, ou navegue para:```text
http://localhost:8080?token=YOUR_AUTH_TOKEN_HERE
```
Você verá estatísticas em tempo real, incluindo mineradores ativos, taxas de hash e blocos minerados.
**Nota:** O servidor escuta em todas as interfaces de rede - substitua `localhost` pelo IP do seu servidor para acesso remoto.
## Como Funciona
O pool de mineração opera usando um mecanismo de consenso de prova de trabalho:
1. O servidor inicializa a blockchain com o bloco gênese
2. Os mineradores se conectam via gRPC e registram com IP/hostname
3. O servidor distribui atribuições de trabalho (modelos de bloco)
4. Os mineradores calculam hashes SHA-256 para encontrar nonces válidos
5. Os mineradores enviam soluções quando a meta de dificuldade é atingida
6. O servidor valida e adiciona blocos à blockchain
7. O painel exibe estatísticas em tempo real e atividade dos mineradores
Cada bloco requer encontrar um hash com um número específico de zeros à esquerda (dificuldade configurável). Os mineradores recebem 50 RTC por bloco minerado.
### Fluxo de Dados```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----------|
```
## Utilização
### Executando o Servidor
**HTTP (Padrão):**```bash
./bin/server
```
- Servidor gRPC: porta **50051**
- Painel web: **http://localhost:8080**
**HTTPS/TLS (Recomendado):**```bash
# Generate certificates (one time)
./generate_certs.sh
# Start with TLS
RTC_SERVER_TLS_ENABLED=true ./bin/server
```
- servidor gRPC: porta **50051**
- Painel web: **https://localhost:8443**
- Redirecionamento HTTP: **http://localhost:8080**
**Nota #1:** Com HTTPS, os navegadores mostrarão um aviso de segurança para certificados autoassinados. Clique em "Avançado" → "Prosseguir para localhost".
**Nota #2:** O painel web e o servidor gRPC serão executados em todas as interfaces do servidor e podem ser usados no lugar de localhost.
### Executando um Minerador
#### Cliente Go (Binário Nativo)
**Uso básico:**```bash
./bin/client
```
**Executar múltiplos mineradores:**
Abra terminais adicionais e execute `./bin/client` em cada um.
#### Mineradores Java
O RedTeamCoin fornece duas implementações de mineradores Java:
##### Cliente gRPC Java (Headless)
Cliente gRPC pronto para produção para servidores e automação.
**Pré-requisitos:**
- Java 11 ou posterior
- Maven (apenas para compilação)
**Compilar usando Makefile:**```bash
make build-java-client
```
**Ou construir manualmente:**```bash
cd java-client
mvn clean package
```
**Executar:**```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
```
**Recursos:**
- Protocolo gRPC (compatível com cliente Go)
- Operação headless (sem GUI)
- Controle do servidor (pausar/retomar/limitar)
- Reconexão automática
- Auto-exclusão por comando do servidor
##### Minerador Java Autônomo (GUI)
Minerador desktop com interface gráfica.
**Pré-requisitos:**
- Java 21 ou posterior
- Maven (apenas para compilação)
**Compilar usando Makefile:**```bash
make build-java-standalone
```
**Ou construir manualmente:**```bash
cd java-standalone
mvn clean package
```
**Executar:**```bash
# GUI mode (default)
java -jar bin/redteamcoin-miner-standalone.jar
# CLI mode
java -jar bin/redteamcoin-miner-standalone.jar --pool localhost:50051
```
**Funcionalidades:**
- Interface gráfica de ambiente de trabalho
- Exibição de estatísticas visuais
- Protocolo JSON/Socket simples
- Incorporado em aplicações
##### Compilar Todos os Miners Java```bash
make build-java-all
```
**Benefícios dos Java Miners:**
- Arquivo JAR único, fácil de distribuir
- Multiplataforma (Windows, Linux, macOS)
- Nenhuma compilação necessária nos sistemas de destino
- Apenas requer Java Runtime (JRE)
Consulte [java-client/README.md](https://github.com/xyplex3/redteamcoin/blob/main/java-client/README.md) para obter a documentação completa do cliente Java gRPC.
### Conectando-se a Servidores Remotos
Por padrão, os clientes se conectam a `localhost:50051`. Para se conectar a um servidor remoto:
**Usando a flag de linha de comando (recomendado):**```bash
./bin/client -server 192.168.1.100:50051
./bin/client -s mining-pool.example.com:50051
```
**Usando variável de ambiente:**```bash
export RTC_CLIENT_SERVER_ADDRESS=192.168.1.100:50051
./bin/client
```
**Prioridade:** Flag de linha de comando > Variável de ambiente > Padrão (localhost:50051)
## Mineração em GPU
RedTeamCoin suporta mineração acelerada por GPU para GPUs NVIDIA (CUDA) e AMD/Intel (OpenCL). A mineração em GPU é 100-400x mais rápida e significativamente mais eficiente em termos energéticos do que a mineração em CPU.
### Instalação da 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
```
**Detecção automática:**```bash
make build-gpu # Automatically detects and builds for available GPU
```
### Uso da 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
```
### Comparação de Desempenho
| Configuração | Taxa de Hash | Aceleração | Eficiência (MH/W) |
| ---------------- | --------- | -------- | ----------------- |
| CPU (1 core) | ~2 MH/s | Referência | ~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 |
| Híbrido (CPU+GPU) | ~620 MH/s | 310x | ~2.0 |
**Nota:** A mineração por GPU é 100-150x mais eficiente em energia do que a mineração por CPU.
### Testando a Funcionalidade da 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
```
Veja [docs/GPU_MINING.md](https://github.com/xyplex3/redteamcoin/blob/main/docs/GPU_MINING.md) para o guia completo de mineração GPU.
## Configuração
RedTeamCoin usa [Viper](https://github.com/spf13/viper) para gerenciamento flexível de configuração. As configurações podem ser especificadas por meio de variáveis de ambiente, arquivos de configuração YAML ou flags de linha de comando com a seguinte precedência:
**Flags de linha de comando** > **Variáveis de ambiente** > **Arquivos de configuração** > **Padrões**
### Configuração
**Inicialize os arquivos de configuração:**```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
```
Isso copia arquivos YAML de exemplo para o seu diretório de trabalho para edição. Você também pode colocar arquivos de configuração em `~/.rtc/` ou `/etc/rtc/`.
**Substituir com variáveis de ambiente:**```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
```
### Variáveis de Ambiente
Todas as variáveis de ambiente usam prefixos: `RTC_SERVER_` para servidor, `RTC_CLIENT_` para cliente.
**Configuração do Servidor:**
| Variável | Descrição | Padrão |
| --------------------------------------- | ----------------------------- | ------------------ |
| `RTC_SERVER_NETWORK_GRPC_PORT` | Porta do servidor gRPC | `50051` |
| `RTC_SERVER_NETWORK_API_PORT` | Porta da API HTTPS | `8443` |
| `RTC_SERVER_NETWORK_HTTP_PORT` | Porta da interface web HTTP | `8080` |
| `RTC_SERVER_MINING_DIFFICULTY` | Dificuldade de mineração (1-64) | `6` |
| `RTC_SERVER_MINING_BLOCK_REWARD` | Recompensa do bloco em moedas | `50` |
| `RTC_SERVER_TLS_ENABLED` | Habilitar HTTPS/TLS | `false` |
| `RTC_SERVER_TLS_CERT_FILE` | Caminho do certificado TLS | `certs/server.crt` |
| `RTC_SERVER_TLS_KEY_FILE` | Caminho da chave privada TLS | `certs/server.key` |
| `RTC_SERVER_API_READ_TIMEOUT` | Timeout de leitura da API | `15s` |
| `RTC_SERVER_API_WRITE_TIMEOUT` | Timeout de escrita da API | `15s` |
| `RTC_SERVER_API_IDLE_TIMEOUT` | Timeout de ociosidade da API | `60s` |
| `RTC_SERVER_LOGGING_UPDATE_INTERVAL` | Intervalo de atualização de estatísticas | `30s` |
| `RTC_SERVER_LOGGING_FILE_PATH` | Caminho do arquivo de log | `pool_log.json` |
| `RTC_AUTH_TOKEN` *(legado)* | Token de autenticação personalizado | Auto-gerado |
**Configuração do Cliente:**
| Variável | Descrição | Padrão |
| ------------------------------------------------- | ----------------------------------- | ----------------- |
| `RTC_CLIENT_SERVER_ADDRESS` | Endereço do servidor do pool (host:porta) | `localhost:50051` |
| `RTC_CLIENT_SERVER_TLS_ENABLED` | Habilitar TLS para conexão gRPC | `false` |
| `RTC_CLIENT_SERVER_TLS_INSECURE_SKIP_VERIFY` | Pular verificação de certificado | `true` |
| `RTC_CLIENT_SERVER_TLS_CA_CERT_FILE` | Caminho para o arquivo de certificado CA | `""` |
| `RTC_CLIENT_MINING_GPU_ENABLED` | Habilitar mineração GPU | `true` |
| `RTC_CLIENT_MINING_HYBRID_MODE` | Habilitar mineração simultânea CPU+GPU | `false` |
| `RTC_CLIENT_MINING_AUTO_DELETE` | Exclusão automática ao desligar | `true` |
| `RTC_CLIENT_GPU_NONCE_RANGE` | Intervalo de nonce por lote de GPU | `500000000` |
| `RTC_CLIENT_GPU_CPU_START_NONCE` | Nonce inicial da CPU (evitar sobreposição com GPU) | `5000000000` |
| `RTC_CLIENT_NETWORK_HEARTBEAT_INTERVAL` | Intervalo de atualização de status | `30s` |
| `RTC_CLIENT_NETWORK_RETRY_INTERVAL` | Atraso de retentativa de conexão | `10s` |
| `RTC_CLIENT_NETWORK_MAX_RETRY_TIME` | Duração máxima de retentativa | `5m` |
| `RTC_CLIENT_BEHAVIOR_WORKER_UPDATE_INTERVAL` | Intervalo de relatório de progresso do worker | `100000` |
| `POOL_SERVER` *(legado)* | Endereço do servidor remoto | `localhost:50051` |
| `GPU_MINING` *(legado)* | Habilitar/desabilitar mineração GPU | Auto-detectar |
| `HYBRID_MINING` *(legado)* | Habilitar mineração CPU+GPU | `false` |
### Exemplos de Arquivos de Configuração
**Configuração do servidor** (`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
```
**Configuração do cliente** (`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
```
### Autenticação
Todos os endpoints da API (exceto a página inicial do dashboard) exigem autenticação via token Bearer.
**Token gerado automaticamente:**
O servidor gera um token seguro na inicialização e o exibe no console.
**Token personalizado:**```bash
export RTC_AUTH_TOKEN="your-secret-token"
./bin/server
```
### Performance
Os tempos de mineração esperados variam de acordo com o desempenho da CPU e a sorte:
- **Dificuldade 4**: ~1-10 segundos/bloco (CPU única)
- **Dificuldade 5**: ~10-60 segundos/bloco
- **Dificuldade 6**: ~1-10 minutos/bloco
### Configuração 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
```
See [docs/TLS_SETUP.md](https://github.com/xyplex3/redteamcoin/blob/main/docs/TLS_SETUP.md) para configuração detalhada de TLS.
## Referência da API
### Endpoints da API REST
**Endpoints públicos:**
- `GET /` - Painel web (HTML)
- `GET /blocks` - Ver página de todos os blocos (HTML)
**Endpoints autenticados:**
- `GET /api/stats` - Estatísticas da pool (JSON)
- `GET /api/miners` - Lista de todos os mineradores (JSON)
- `GET /api/blockchain` - Blockchain completo (JSON)
- `GET /api/blocks/{index}` - Detalhes do bloco específico (JSON)
- `GET /api/validate` - Validar integridade da blockchain (JSON)
- `GET /api/cpu` - Estatísticas de uso de CPU e GPU (JSON)
- `POST /api/miner/pause` - Pausar mineração para um minerador específico
- `POST /api/miner/resume` - Retomar mineração para um minerador específico
- `POST /api/miner/delete` - Excluir um minerador (auto-termina e auto-exclui)
- `POST /api/miner/throttle` - Definir porcentagem de limitação de CPU (0-100%)
### Exemplos de Autenticação
**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 Serviços```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);
}
```
## Arquitetura
### Stack de Tecnologia
- **Linguagem**: Go 1.21+
- **Framework RPC**: gRPC com Protocol Buffers
- **Servidor Web**: Biblioteca padrão Go net/http
- **Dependências**: google.golang.org/protobuf, google.golang.org/grpc
## Desenvolvimento
### Comandos 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
```
### Testes
RedTeamCoin inclui testes unitários abrangentes tanto para o servidor quanto para os componentes do cliente.
**Execute todos os testes:**
```bash
python -m pytest
``````bash
make test # Run all tests (server + client)
```
**Executar suítes de teste específicas:**```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
```
**Cobertura de Testes:**
- **Servidor**: 76 testes, 66,3% de cobertura
- `blockchain_test.go`: 15 testes - Validação de blockchain, cálculo de hash,
acesso concorrente
- `pool_test.go`: 26 testes - Gerenciamento de mineradores, distribuição de trabalho, estatísticas
- `grpc_server_test.go`: 17 testes - Endpoints gRPC, controle de mineradores, heartbeats
- `api_test.go`: 18 testes - API REST, autenticação, operações de mineradores
- **Cliente**: 41 testes, 16,2% de cobertura
- `main_test.go`: 24 testes - Lógica de mineração, cálculo de hash, gerenciamento de estado
- `gpu_test.go`: 18 testes - Detecção de GPU, gerenciamento de dispositivos, estatísticas
**Total**: 117 testes unitários cobrindo funcionalidades principais
**O que é testado:**
- Validação e integridade do blockchain
- Mineração de blocos e prova de trabalho
- Distribuição de trabalho em pool de mineração
- Registro e gerenciamento de mineradores
- Controle de mineradores no servidor (pausar/retomar/excluir/limitar)
- Protocolos de comunicação gRPC
- Endpoints da API REST e autenticação
- Detecção e inicialização de dispositivos GPU
- Cálculo de taxa de hash e estatísticas
- Operações concorrentes e segurança de threads
- Tratamento de erros e casos extremos
**Testes CI/CD:**
Todos os testes são executados automaticamente em:
- Pull requests
- Commits no branch principal
- Builds de release
Veja [.github/workflows/build-verification.yaml](https://github.com/xyplex3/redteamcoin/blob/main/.github/workflows/build-verification.yaml) para configuração de CI.
### Compilação Cruzada
**Windows (somente CPU):**```bash
make build-windows
```
Cria `bin/client.exe`
**Windows com OpenCL (suporte a GPU):**```bash
# Requires MinGW-w64 and Windows OpenCL SDK
make build-windows-opencl
```
Cria `bin/client-windows-opencl.exe`
Consulte [docs/WINDOWS_BUILD.md](https://github.com/xyplex3/redteamcoin/blob/main/docs/WINDOWS_BUILD.md) para obter instruções completas de compilação no Windows, incluindo:
- Compilações nativas do Windows com suporte a GPU
- Configuração de compilação cruzada a partir do Linux
- Configuração do token de autenticação
- Guia de solução de problemas
**Múltiplas plataformas:**```bash
make build-all-platforms
```
Cria:
- `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
**Nota:** Binários compilados de forma cruzada são apenas CPU (CGO desabilitado) a menos que use `build-windows-opencl`.
### Ferramentas de Análise
Gere relatórios de avaliação de danos para análise de impacto de mineração:```bash
make build-tools
./bin/generate_report -log pool_log.json
```
**O relatório inclui:**
- Análise de consumo de recursos
- Avaliação de impacto no desempenho
- Danos à infraestrutura
- Implicações de segurança
- Resumo do impacto financeiro
- Análise sistema por sistema
- Recomendações de remediação
**Premissas de Custo:**
| Parâmetro | Padrão | Notas |
| ------------------ | --------- | --------------------- |
| Potência da CPU | 150W | Carga total |
| Potência da GPU | 250W | Carga total |
| Eletricidade | $0,12/kWh | Ajuste conforme a região |
| Redução da Vida Útil | 20-40% | Devido à mineração contínua |
**Convertendo Relatórios:**```bash
# PDF
pandoc Report_Miner_Activity_from_<date>_to_<date>.md -o report.pdf
# HTML
pandoc Report_Miner_Activity_from_<date>_to_<date>.md -o report.html
# DOCX
pandoc Report_Miner_Activity_from_<date>_to_<date>.md -o report.docx
```
**Casos de Uso:**
- Análise pós-incidente
- Briefings executivos
- Justificativa financeira
- Documentação de conformidade
- Reivindicações de seguro
- Evidências legais
Consulte [tools/README.md](https://github.com/xyplex3/redteamcoin/blob/main/tools/README.md) para documentação completa.
## Solução de Problemas
### Problemas de Conexão Remota
**Testando conectividade:**```bash
# Test connection
ping <server_ip>
nc -zv <server_ip> 50051
# Check server (on server side)
lsof -i :50051
ss -an | grep 50051
```
**Problemas comuns:**
- Verifique o endereço e a porta do servidor
- Certifique-se de que o servidor está em execução
- Verifique as regras de firewall (cliente e servidor)
- Confirme a conectividade de rede
- Verifique se a porta 50051 está escutando
### Problemas com Mineração GPU
| Problema | Solução |
| -------------------- | --------------------------------------------------------------- |
| "não é possível encontrar -lcuda" | `export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH` |
| "nvcc não encontrado" | `sudo apt install cuda-toolkit` |
| "Nenhum dispositivo OpenCL" | `sudo apt install ocl-icd-opencl-dev` |
| GPU lenta | `export RTC_CLIENT_MINING_GPU_ENABLED=true` |
| Erro de compilação CGo | `sudo apt install build-essential` |
### Problemas Gerais
**Falhas de compilação:**
- Certifique-se de que o Go 1.21+ está instalado
- Execute `make deps` para instalar as dependências
- Execute `make install-tools` para as ferramentas protoc
**Conexão recusada:**
- Verifique se o servidor está em execução
- Verifique se a porta não está em uso: `lsof -i :50051`
- Verifique as configurações de firewall
**Erros de autenticação:**
- Verifique se o token corresponde à saída do servidor
- Verifique o formato do cabeçalho `Authorization: Bearer TOKEN`
- Certifique-se de que o token está incluído na URL ou nos cabeçalhos
## Documentação
### Guias do Usuário
- [docs/GPU_MINING.md](https://github.com/xyplex3/redteamcoin/blob/main/docs/GPU_MINING.md) - Mineração GPU com CUDA e OpenCL
- [docs/WINDOWS_BUILD.md](https://github.com/xyplex3/redteamcoin/blob/main/docs/WINDOWS_BUILD.md) - Guia de compilação para Windows (nativa e compilação cruzada)
- [docs/TLS_SETUP.md](https://github.com/xyplex3/redteamcoin/blob/main/docs/TLS_SETUP.md) - Configuração HTTPS/TLS
- [java-client/README.md](https://github.com/xyplex3/redteamcoin/blob/main/java-client/README.md) - Cliente gRPC Java (minerador headless)
- [tools/README.md](https://github.com/xyplex3/redteamcoin/blob/main/tools/README.md) - Ferramentas de análise e relatórios de danos
### Referências Técnicas
- [docs/WORKFLOWS.md](https://github.com/xyplex3/redteamcoin/blob/main/docs/WORKFLOWS.md) - Fluxos de trabalho CI/CD e processos de desenvolvimento
### Exemplos
- [docs/examples/](https://github.com/xyplex3/redteamcoin/blob/main/docs/examples) - Relatórios de exemplo e exemplos de uso
## Contribuindo
Aceitamos contribuições! Veja como começar:
1. Faça um fork do repositório
2. Crie um branch de funcionalidade: `git checkout -b feature/amazing-feature`
3. Faça suas alterações e adicione testes
4. Execute a suíte de testes: `make test`
5. Faça commit das suas alterações: `git commit -m 'Add amazing feature'`
6. Envie para o branch: `git push origin feature/amazing-feature`
7. Abra um Pull Request
### Configuração de Desenvolvimento```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
```
### Diretrizes de Código
- Siga a formatação padrão do Go (`gofmt`)
- Adicione testes unitários para novas funcionalidades
- Atualize a documentação para alterações voltadas ao usuário
- Garanta que todas as verificações de CI passem antes de enviar o PR
## Nota de Segurança
Este é um **projeto de demonstração/educacional** para testes de segurança autorizados e operações de equipe vermelha. Ele é destinado a:
- Engajamentos de teste de penetração autorizados
- Validação de controles de segurança
- Avaliação de capacidade de detecção
- Fins educacionais e de treinamento
Esta ferramenta não é destinada ao uso em produção como uma criptomoeda real e carece de muitos recursos necessários para um sistema de produção (assinaturas criptográficas, carteiras, validação de transações, consenso de rede, etc.).
**Use apenas com autorização explícita em sistemas que você possui ou tem permissão para testar.**
## Licença
Este projeto é licenciado sob a GNU General Public License v3.0 - consulte o arquivo [LICENSE](https://github.com/xyplex3/redteamcoin/blob/main/LICENSE) para mais detalhes.
## Agradecimentos
**Criado por:**
- Peter Greko ([@Xyplex02](https://github.com/Xyplex02))
- Luciano Krigun ([@klucho](https://github.com/klucho))
- Jayson Grace ([@l50](https://github.com/l50))