RedTeamCoin

RedTeamCoin Logo

RedTeamCoin es una implementación de pool de minería de criptomonedas basada en blockchain, diseñada para pruebas de seguridad autorizadas y operaciones de red team. Desarrollado en Go con soporte para clientes Java, simula ataques reales de criptominería para ayudar a las organizaciones a evaluar sus capacidades de detección y cuantificar el daño potencial de las operaciones de minería de actores malintencionados.

Esta herramienta permite a los equipos de seguridad demostrar de forma segura y legal escenarios de ataques de criptominería en sistemas corporativos, generar informes completos de impacto y validar los controles de seguridad—todo dentro de un entorno controlado que utiliza una blockchain aislada y no pública.

Overview

¿Por qué usar RedTeamCoin?

Demostrar el impacto real de los ataques de criptojacking
Probar y validar los sistemas de monitoreo y detección de seguridad
Generar evaluaciones cuantificables de daños para informes ejecutivos
Simular de forma segura operaciones de minería sin conectarse a blockchains públicas

Componentes del Sistema:

Servidor de Pool de Minería - Gestiona la blockchain y coordina la distribución del trabajo
Clientes Mineros - Clientes de minería CPU/GPU (implementaciones en Go y Java)
Panel Web - Monitoreo, control y estadísticas en tiempo real
Herramientas de Análisis - Generan informes completos de evaluación de daños

Features

Implementación de Blockchain: Blockchain de proof-of-work personalizada con dificultad configurable
Servidor de Pool de Minería: Gestiona múltiples mineros y la distribución del trabajo mediante gRPC
Clientes Mineros: Clientes de minería automatizados (Go y Java) con registro de direcciones IP y nombres de host
Minero Java Independiente: Minero de escritorio con interfaz gráfica (GUI) y visual
Cliente gRPC de Java: Cliente gRPC sin interfaz gráfica para servidores y automatización
Control de Mineros desde el Servidor: Pausar, reanudar, limitar el uso de CPU y eliminar mineros de forma remota
Limitación de CPU: Limitar el uso de CPU del minero del 0-100% para gestionar recursos
Soporte de Minería GPU: Soporte de CUDA y OpenCL para minería acelerada por GPU
Minería Híbrida: Minería simultánea de CPU y GPU para máximo rendimiento
Panel Web: Monitoreo en tiempo real de mineros, estadísticas y blockchain con botones de control
Autenticación de API REST: Autenticación segura basada en tokens para endpoints de API
Cifrado TLS gRPC del Cliente: Cifrado TLS opcional para conexiones gRPC seguras cliente-servidor
Seguimiento Dual de IP: Registra tanto las direcciones IP reportadas por el cliente como las detectadas por el servidor
Estadísticas de CPU y GPU: Seguimiento y reporte integral del uso de recursos
Protocol Buffers: Comunicación eficiente cliente-servidor mediante protobuf/gRPC
Auto-Terminación: Los mineros se apagan y se autoeliminan automáticamente cuando se eliminan del servidor

Quick Start

Pon RedTeamCoin en funcionamiento en menos de 5 minutos:

Requisitos previos

Go 1.21 o superior
Compilador de Protocol Buffers (protoc)

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

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

Windows:

Instala Go desde https://golang.org/dl/
Instala protoc desde https://github.com/protocolbuffers/protobuf/releases

Instalación```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

### Verificación

Verifique que la compilación se completó correctamente:```bash
ls -lh bin/
# Expected output: server and client binaries (1-5 MB each)

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

Ejecutando tu primer pool de minería

1. Inicia el servidor:```bash make run-server

Deberías ver una salida como esta:```text
RedTeamCoin Mining Pool Server
Authentication Token: abc123def456...
Dashboard URL: http://localhost:8080?token=abc123def456...
gRPC server listening on port 50051

2. Iniciar un minero (en una nueva terminal):```bash make run-client

Deberías ver actividad de minería:```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 el panel de control:

Abre la URL del paso 1 en tu navegador, o navega a:```text http://localhost:8080?token=YOUR_AUTH_TOKEN_HERE

You'll see real-time statistics including active miners, hash rates, and mined blocks.

**Note:** The server listens on all network interfaces - replace `localhost` with your server's IP for remote access.

## How It Works

The mining pool operates using a proof-of-work consensus mechanism:

1. Server initializes blockchain with genesis block
2. Miners connect via gRPC and register with IP/hostname
3. Server distributes work assignments (block templates)
4. Miners compute SHA-256 hashes to find valid nonces
5. Miners submit solutions when difficulty target is met
6. Server validates and adds blocks to the blockchain
7. Dashboard displays real-time statistics and miner activity

Each block requires finding a hash with a specific number of leading zeros (configurable difficulty). Miners receive 50 RTC per block mined.

### Data Flow```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----------|

Uso

Ejecutando el servidor

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

- Servidor gRPC: puerto **50051**
- Panel 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: puerto 50051
Panel web: https://localhost:8443
Redirección HTTP: http://localhost:8080

Nota #1: Con HTTPS, los navegadores mostrarán una advertencia de seguridad por certificados autofirmados. Haz clic en "Avanzado" → "Continuar a localhost".

Nota #2: El panel web y el servidor gRPC se ejecutarán en todas las interfaces del servidor y se pueden usar en lugar de localhost.

Ejecutar un Minero

Cliente Go (Binario nativo)

Uso básico:```bash ./bin/client

**Ejecutar múltiples mineros:**
Abra terminales adicionales y ejecute `./bin/client` en cada una.

#### Mineros Java

RedTeamCoin proporciona dos implementaciones de mineros Java:

##### Cliente gRPC Java (Headless)

Cliente gRPC listo para producción para servidores y automatización.

**Requisitos previos:**

- Java 11 o posterior
- Maven (solo para compilar)

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

O construir manualmente:```bash cd java-client mvn clean package

**Ejecutar:**```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

Features:

Protocolo gRPC (coincide con el cliente Go)
Operación sin interfaz gráfica (sin GUI)
Control del servidor (pausa/reanudación/límite de velocidad)
Reconexión automática
Autoeliminación por comando del servidor

Minero independiente en Java (GUI)

Minero de escritorio con interfaz gráfica.

Requisitos previos:

Java 21 o posterior
Maven (solo para compilar)

Compilar con Makefile:```bash make build-java-standalone

**O construir manualmente:**```bash
cd java-standalone
mvn clean package

Ejecutar:```bash

GUI mode (default)

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

CLI mode

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

**Características:**

- Interfaz gráfica de escritorio
- Visualización de estadísticas visuales
- Protocolo JSON/Socket simple
- Integrado en aplicaciones

##### Compilar Todos los Mineros Java```bash
make build-java-all

Ventajas de los mineros Java:

Archivo JAR único, fácil de distribuir
Multiplataforma (Windows, Linux, macOS)
No se necesita compilación en los sistemas de destino
Solo requiere Java Runtime (JRE)

Consulte java-client/README.md para obtener la documentación completa del cliente Java gRPC.

Conexión a servidores remotos

De forma predeterminada, los clientes se conectan a localhost:50051. Para conectarse a un servidor remoto:

Uso del indicador de línea de comandos (recomendado):```bash ./bin/client -server 192.168.1.100:50051 ./bin/client -s mining-pool.example.com:50051

**Usando variable de entorno:**```bash
export RTC_CLIENT_SERVER_ADDRESS=192.168.1.100:50051
./bin/client

Prioridad: Indicador de línea de comandos > Variable de entorno > Predeterminado (localhost:50051)

Minería con GPU

RedTeamCoin admite minería acelerada por GPU para GPUs NVIDIA (CUDA) y AMD/Intel (OpenCL). La minería con GPU es 100-400 veces más rápida y considerablemente más eficiente en el consumo de energía que la minería con CPU.

Instalación de 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

Detección automática:```bash make build-gpu # Automatically detects and builds for available GPU

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

Comparación de rendimiento

Nota: La minería con GPU es de 100 a 150 veces más eficiente energéticamente que la minería con CPU.

Probando la funcionalidad de 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

See [docs/GPU_MINING.md](https://github.com/xyplex3/redteamcoin/blob/HEAD/docs/GPU_MINING.md) para la guía completa de minería GPU.

## Configuración

RedTeamCoin utiliza [Viper](https://github.com/spf13/viper) para una gestión de configuración flexible. Los ajustes se pueden especificar mediante variables de entorno, archivos de configuración YAML o indicadores de línea de comandos con la siguiente precedencia:

**Indicadores de línea de comandos** > **Variables de entorno** > **Archivos de configuración** > **Predeterminados**

### Configuración

**Inicialice los archivos de configuración:**```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

Este comando copia archivos YAML de ejemplo a tu directorio de trabajo para editarlos. También puedes colocar archivos de configuración en ~/.rtc/ o /etc/rtc/.

Sobrescribir con variables de entorno:```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 de Entorno

Todas las variables de entorno usan prefijos: `RTC_SERVER_` para el servidor, `RTC_CLIENT_` para el cliente.

**Configuración del servidor:**

| Variable                                | Descripción                   | Predeterminado            |
| --------------------------------------- | ----------------------------- | ------------------ |
| `RTC_SERVER_NETWORK_GRPC_PORT`          | Puerto del servidor gRPC              | `50051`            |
| `RTC_SERVER_NETWORK_API_PORT`           | Puerto de la API HTTPS                | `8443`             |
| `RTC_SERVER_NETWORK_HTTP_PORT`          | Puerto de la interfaz web HTTP       | `8080`             |
| `RTC_SERVER_MINING_DIFFICULTY`          | Dificultad de minería (1-64)      | `6`                |
| `RTC_SERVER_MINING_BLOCK_REWARD`        | Recompensa de bloque en monedas         | `50`               |
| `RTC_SERVER_TLS_ENABLED`                | Habilitar HTTPS/TLS              | `false`            |
| `RTC_SERVER_TLS_CERT_FILE`              | Ruta del certificado TLS          | `certs/server.crt` |
| `RTC_SERVER_TLS_KEY_FILE`               | Ruta de la clave privada TLS          | `certs/server.key` |
| `RTC_SERVER_API_READ_TIMEOUT`           | Tiempo de espera de lectura de la API              | `15s`              |
| `RTC_SERVER_API_WRITE_TIMEOUT`          | Tiempo de espera de escritura de la API             | `15s`              |
| `RTC_SERVER_API_IDLE_TIMEOUT`           | Tiempo de espera de inactividad de la API              | `60s`              |
| `RTC_SERVER_LOGGING_UPDATE_INTERVAL`    | Intervalo de actualización de estadísticas         | `30s`              |
| `RTC_SERVER_LOGGING_FILE_PATH`          | Ruta del archivo de registro                 | `pool_log.json`    |
| `RTC_AUTH_TOKEN` *(heredado)*             | Token de autenticación personalizado   | Generado automáticamente     |

**Configuración del cliente:**

| Variable                                          | Descripción                         | Predeterminado           |
| ------------------------------------------------- | ----------------------------------- | ----------------- |
| `RTC_CLIENT_SERVER_ADDRESS`                       | Dirección del servidor del pool (host:puerto)     | `localhost:50051` |
| `RTC_CLIENT_SERVER_TLS_ENABLED`                   | Habilitar TLS para la conexión gRPC      | `false`           |
| `RTC_CLIENT_SERVER_TLS_INSECURE_SKIP_VERIFY`      | Omitir verificación del certificado       | `true`            |
| `RTC_CLIENT_SERVER_TLS_CA_CERT_FILE`              | Ruta al archivo de certificado CA         | `""`              |
| `RTC_CLIENT_MINING_GPU_ENABLED`                   | Habilitar minería GPU                   | `true`            |
| `RTC_CLIENT_MINING_HYBRID_MODE`                   | Habilitar minería simultánea CPU+GPU  | `false`           |
| `RTC_CLIENT_MINING_AUTO_DELETE`                   | Eliminación automática al apagar             | `true`            |
| `RTC_CLIENT_GPU_NONCE_RANGE`                      | Rango de nonce por lote de GPU           | `500000000`       |
| `RTC_CLIENT_GPU_CPU_START_NONCE`                  | Nonce inicial de CPU (evitar solapamiento con GPU) | `5000000000`      |
| `RTC_CLIENT_NETWORK_HEARTBEAT_INTERVAL`           | Intervalo de actualización de estado              | `30s`             |
| `RTC_CLIENT_NETWORK_RETRY_INTERVAL`               | Retardo de reintento de conexión              | `10s`             |
| `RTC_CLIENT_NETWORK_MAX_RETRY_TIME`               | Duración máxima de reintento                  | `5m`              |
| `RTC_CLIENT_BEHAVIOR_WORKER_UPDATE_INTERVAL`      | Intervalo de informe de progreso del trabajador     | `100000`          |
| `POOL_SERVER` *(heredado)*                          | Dirección del servidor remoto               | `localhost:50051` |
| `GPU_MINING` *(heredado)*                           | Habilitar/deshabilitar minería GPU           | Auto-detección       |
| `HYBRID_MINING` *(heredado)*                        | Habilitar minería CPU+GPU               | `false`           |

### Ejemplos de archivos de configuración

**Configuración del 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

Configuración del 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

### Autenticación

Todos los endpoints de la API (excepto la página de inicio del panel) requieren autenticación mediante token Bearer.

**Token generado automáticamente:**
El servidor genera un token seguro al iniciarse y lo muestra en la consola.

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

Rendimiento

Los tiempos de minería esperados varían según el rendimiento de la CPU y la suerte:

Dificultad 4: ~1-10 segundos/bloque (una sola CPU)
Dificultad 5: ~10-60 segundos/bloque
Dificultad 6: ~1-10 minutos/bloque

Configuración 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

Consulta [docs/TLS_SETUP.md](https://github.com/xyplex3/redteamcoin/blob/HEAD/docs/TLS_SETUP.md) para la configuración detallada de TLS.

## Referencia de la API

### Endpoints de la API REST

**Endpoints públicos:**

- `GET /` - Panel web (HTML)
- `GET /blocks` - Página para ver todos los bloques (HTML)

**Endpoints autenticados:**

- `GET /api/stats` - Estadísticas del pool (JSON)
- `GET /api/miners` - Lista de todos los mineros (JSON)
- `GET /api/blockchain` - Cadena de bloques completa (JSON)
- `GET /api/blocks/{index}` - Detalles de un bloque específico (JSON)
- `GET /api/validate` - Validar la integridad de la cadena de bloques (JSON)
- `GET /api/cpu` - Estadísticas de uso de CPU y GPU (JSON)
- `POST /api/miner/pause` - Pausar la minería de un minero específico
- `POST /api/miner/resume` - Reanudar la minería de un minero específico
- `POST /api/miner/delete` - Eliminar un minero (finaliza y se elimina automáticamente)
- `POST /api/miner/throttle` - Establecer el porcentaje de limitación de CPU (0-100 %)

### Ejemplos de autenticación

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

Servicios 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); }

## Arquitectura

### Stack Tecnológico

- **Lenguaje**: Go 1.21+
- **Framework de RPC**: gRPC con Protocol Buffers
- **Servidor web**: biblioteca estándar de Go net/http
- **Dependencias**: google.golang.org/protobuf, google.golang.org/grpc

## Desarrollo

### Comandos de compilación```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

Pruebas

RedTeamCoin incluye pruebas unitarias exhaustivas para los componentes del servidor y del cliente.

Ejecutar todas las pruebas:```bash make test # Run all tests (server + client)

**Ejecutar suites de pruebas 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 pruebas:

Servidor: 76 pruebas, 66.3% de cobertura
- blockchain_test.go: 15 pruebas - Validación de blockchain, cálculo de hash, acceso concurrente
- pool_test.go: 26 pruebas - Gestión de mineros, distribución de trabajo, estadísticas
- grpc_server_test.go: 17 pruebas - Endpoints gRPC, control de mineros, heartbeats
- api_test.go: 18 pruebas - API REST, autenticación, operaciones de mineros
Cliente: 41 pruebas, 16.2% de cobertura
- main_test.go: 24 pruebas - Lógica de minería, cálculo de hash, gestión de estado
- gpu_test.go: 18 pruebas - Detección de GPU, gestión de dispositivos, estadísticas

Total: 117 pruebas unitarias que cubren la funcionalidad principal

Lo que se prueba:

Validación e integridad de blockchain
Minería de bloques y prueba de trabajo
Distribución de trabajo del pool de minería
Registro y gestión de mineros
Control de mineros en el servidor (pausar/reanudar/eliminar/limitar)
Protocolos de comunicación gRPC
Endpoints de API REST y autenticación
Detección e inicialización de dispositivos GPU
Cálculo de tasa de hash y estadísticas
Operaciones concurrentes y seguridad de hilos
Manejo de errores y casos límite

Pruebas CI/CD:

Todas las pruebas se ejecutan automáticamente en:

Pull requests
Commits a la rama principal
Builds de release

Consulta .github/workflows/build-verification.yaml para la configuración de CI.

Compilación cruzada

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

Crea `bin/client.exe`

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

Crea bin/client-windows-opencl.exe

Consulta docs/WINDOWS_BUILD.md para obtener instrucciones completas de compilación en Windows, incluyendo:

Compilaciones nativas de Windows con soporte para GPU
Configuración de compilación cruzada desde Linux
Configuración del token de autenticación
Guía de solución de problemas

Múltiples plataformas:```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

**Nota:** Los binarios compilados de forma cruzada son solo de CPU (CGO deshabilitado), a menos que se use `build-windows-opencl`.

### Herramientas de análisis

Genera informes de evaluación de daños para el análisis de impacto de minería:```bash
make build-tools
./bin/generate_report -log pool_log.json

El informe incluye:

Análisis del consumo de recursos
Evaluación del impacto en el rendimiento
Daños a la infraestructura
Implicaciones de seguridad
Resumen del impacto financiero
Análisis sistema por sistema
Recomendaciones de remediación

Supuestos de costos:

Conversión de informes:```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

**Casos de uso:**

- Análisis posterior al incidente
- Informes ejecutivos
- Justificación financiera
- Documentación de cumplimiento
- Reclamaciones de seguros
- Evidencia legal

Consulta [tools/README.md](https://github.com/xyplex3/redteamcoin/blob/HEAD/tools/README.md) para obtener la documentación completa.

## Solución de problemas

### Problemas de conexión remota

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

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

Problemas comunes:

Verifica la dirección y el puerto del servidor
Asegúrate de que el servidor esté en ejecución
Revisa las reglas del firewall (cliente y servidor)
Confirma la conectividad de red
Verifica que el puerto 50051 esté escuchando

Problemas de Minería GPU

Problemas Generales

Errores de compilación:

Asegúrate de tener Go 1.21+ instalado
Ejecuta make deps para instalar dependencias
Ejecuta make install-tools para las herramientas protoc

Conexión rechazada:

Comprueba que el servidor esté en ejecución
Verifica que el puerto no esté en uso: lsof -i :50051
Revisa la configuración del firewall

Errores de autenticación:

Verifica que el token coincida con la salida del servidor
Comprueba el formato del encabezado Authorization: Bearer TOKEN
Asegúrate de que el token esté incluido en la URL o en los encabezados

Documentación

Guías de Usuario

docs/GPU_MINING.md - Minería con GPU usando CUDA y OpenCL
docs/WINDOWS_BUILD.md - Guía de compilación para Windows (nativa y compilación cruzada)
docs/TLS_SETUP.md - Configuración de HTTPS/TLS
java-client/README.md - Cliente gRPC de Java (minero headless)
tools/README.md - Herramientas de análisis e informes de daños

Referencias Técnicas

docs/WORKFLOWS.md - Flujos de trabajo CI/CD y procesos de desarrollo

Ejemplos

docs/examples/ - Informes de muestra y ejemplos de uso

Contribuciones

¡Agradecemos las contribuciones! Así puedes comenzar:

Haz un fork del repositorio
Crea una rama de funcionalidad: git checkout -b feature/amazing-feature
Haz tus cambios y añade pruebas
Ejecuta la suite de pruebas: make test
Confirma tus cambios: git commit -m 'Add amazing feature'
Sube a la rama: git push origin feature/amazing-feature
Abre una Pull Request

Configuración de Desarrollo```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

### Directrices de código

- Sigue el formato estándar de Go (`gofmt`)
- Añade pruebas unitarias para las nuevas funcionalidades
- Actualiza la documentación para los cambios visibles al usuario
- Asegúrate de que todas las comprobaciones de CI pasen antes de enviar el PR

## Nota de seguridad

Este es un proyecto **de demostración/educativo** para pruebas de seguridad autorizadas
y operaciones de equipo rojo. Está pensado para:

- Participación en pruebas de penetración autorizadas
- Validación de controles de seguridad
- Evaluación de capacidades de detección
- Fines educativos y de formación

Esta herramienta no está pensada para su uso en producción como una criptomoneda real y
carece de muchas características necesarias para un sistema de producción (firmas criptográficas,
carteras, validación de transacciones, consenso de red, etc.).

**Úsala solo con autorización explícita en sistemas que poseas o sobre los que tengas
permiso para probar.**

## Licencia

Este proyecto está licenciado bajo la GNU General Public License v3.0; consulta el
archivo [LICENSE](https://github.com/xyplex3/redteamcoin/blob/HEAD/LICENSE) para obtener más detalles.

## Agradecimientos

**Creado por:**

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

CPU (1 núcleo)	~2 MH/s	Referencia	~0.02
CPU (8 núcleos)	~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

Potencia de CPU	150W	Carga completa
Potencia de GPU	250W	Carga completa
Electricidad	$0.12/kWh	Ajustar según región
Reducción de vida útil	20-40%	Por minería sostenida

"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 lenta	`export RTC_CLIENT_MINING_GPU_ENABLED=true`
Error de compilación CGo	`sudo apt install build-essential`

RedTeamCoin

Más Populares

RedTeamCoin

Tabla de Contenidos

Overview

Features

Quick Start

Requisitos previos

Instalación```bash

Clone the repository

Install dependencies

Build server and client

Ejecutando tu primer pool de minería

Uso

Ejecutando el servidor

Ejecutar un Minero

Cliente Go (Binario nativo)

Minero independiente en Java (GUI)

GUI mode (default)

CLI mode

Conexión a servidores remotos

Minería con GPU

Instalación de GPU

Comparación de rendimiento

Probando la funcionalidad de 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

Rendimiento

Configuración HTTPS```bash

Generate certificates

Start with HTTPS using new config system

Custom certificates

Servicios gRPC```protobuf

Pruebas

Compilación cruzada

PDF

HTML

DOCX

Problemas de Minería GPU

Problemas Generales

Documentación

Guías de Usuario

Referencias Técnicas

Ejemplos

Contribuciones

Configuración de Desarrollo```bash

Clone your fork

Install dependencies

Run tests

Build and test locally