Blockchain - SidVal/dev.web GitHub Wiki

Historia

Te cuento algo, a raíz de mi canal de LocademiaCripto en youtube me ha escrito una persona de Venezuela por telegram, a ver si yo podría ayudarle a retirar un dinero que tiene en bitget. Cuando me pasa capturas, veo, 500 dolares en USDT en red Tron; Y 0.6 de gas en tron, me explica que necesita más gas para retirar USDT. Empecé a desconfiar... Así que le dije que me pase la trxID de un movimiento que tenía, y lo analicé vía la tron-chain el scan de movimientos, llegué a su billetera (su supuesta billetera). Parece que la cuenta tiene permisos cedidos, mala señal. Voy viendo que, a medida que recibe TRX, la misma billetera hace movimientos de salida hacia otra wallet. Le preugnto al usuario si es conciente de eso, y me dice que él no está haciendo nada. Entonces, caigo en la cuenta de que esta wallet debe ser de esas que son un sistema para captar bobos, que quieran retirar el USDT, mandan gas, y automáticamente el sistema lo drena a otra wallets, dejando al usuario interesado siempre en falta de gas

Análisis

Billetera que me pasa el usuario: https://tronscan.org/#/address/TUgTT9r2UDE9f1d4wc53JtaF8wTZUdUCqQ

Razones

  • ¿Para qué aprender sobre programar contratos inteligentes?

1) Por qué aprender esto es valioso (uso legítimo)

  • Para detectar y bloquear estafas (monitorizar patrones de drenaje).
  • Para auditar smart contracts y evitar vulnerabilidades.
  • Para construir herramientas que ayuden a víctimas (alerts, revocadores de permisos, guías).
  • Para trabajar en blockchain forensics, compliance o seguridad en exchanges.

2) Área de conocimiento / currículum recomendado (orden práctico)

Fundamentos (bloque imprescindible)

  • Criptografía básica: hashes, firmas digitales, claves públicas/privadas.
  • Fundamentos de blockchain: cómo funcionan bloques, transacciones, gas, mempool.
  • Economía de tokens: estándares (ERC-20/TRC-20), allowances/approvals, modelos de gas.
Desarrollo de Smart Contracts (para entender el lado técnico)
  • Lenguajes: Solidity (Ethereum) y el equivalente en TRON (TRC20/TVM - Solidity compatible).
  • Frameworks: Hardhat, Truffle, Brownie para Ethereum; herramientas específicas para TRON (TronBox, TronWeb).
  • Buenas prácticas: patrones seguros, OpenZeppelin, gestión de owner/roles.

Nota: estudiar esto es para auditoría y defensa, no para explotar.

Seguridad y auditoría de smart contracts
  • Análisis estático y dinámico: Slither, MythX, Manticore, Echidna.
  • Revisión manual: encontrar reentrancy, unchecked transfer, dangerous approvals.
  • Procesos de auditoría: checklists, pruebas unitarias, fuzzing.
Ingeniería de back-end y bots (para monitorización defensiva)
  • APIs de explorers: Etherscan/Tronscan API, Web3 providers (Infura, Alchemy o TRON equivalents).
  • Event-driven programming: escucha de eventos (Transfer, Approval) y procesamiento en tiempo real.
  • Bases de datos y colas: Kafka / Redis / Postgres para almacenar y procesar flujos.
Blockchain forensics y análisis on-chain
  • Herramientas comerciales: Chainalysis, CipherTrace, TRM (útiles para seguir flujos de fondos).
  • Técnicas abiertas: clustering de direcciones, análisis de patrones de mezcla, detección de “zombie wallets”.
  • Investigación legal: cómo preparar evidencia para exchanges y autoridades.
Seguridad operacional (defensa del usuario)
  • Gestión de claves y wallets: hardware wallets, BIP39, almacenamiento seguro.
  • UX seguro: cómo reducir errores humanos (phishing / approving contracts).
  • Remediation: cómo aconsejar a una víctima (revocar allowances, mover a wallet segura si procede).
Marco legal y ética
  • Legislación local/internacional sobre ciberdelitos, colaboración con exchanges y fuerzas de seguridad.
  • Ética profesional en seguridad y divulgación responsable (responsible disclosure).

3) Recursos prácticos (formación y lectura)

  • Cursos:

    • Blockchain Basics / Crypto (Coursera, edX) — para conceptos.
    • Ethereum and Solidity: The Complete Developer’s Guide (Udemy) — para solidity (enfoque dev).
    • Cursos específicos de smart contract security (Consensys Academy, Trail of Bits workshops).

  • Libros / lecturas:

    • Mastering Ethereum (Buterin & Wood) — fundamentos.
    • Documentación OpenZeppelin (patrones seguros).

  • Herramientas (para defensa/analítica): Tronscan, TronWeb, Etherscan, Tenderly, Slither, MythX, Chainalysis (si tenés acceso), wallet explorers.

  • Foros/comunidades: r/ethdev, foros de consultoria-sap (para temas fiscales), Twitter/X de investigadores de seguridad.

4) Proyectos éticos que podés desarrollar con ese saber

  • Detector público de “drenaje automático”: un servicio que monitorice wallets y dispare alertas si detecta patrones (p. ej. balance entrante seguido de múltiples salidas a nuevas direcciones).
  • Revocador y guía UX: una web que explique paso a paso cómo ver y revocar allowances con seguridad (sin pedir seed).
  • Dashboard de evidencia: herramienta para recopilar txIDs, snapshots y generar reportes para exchanges/autoridades.
  • Servicios de auditoría para smart contracts que validen que no hay funciones con permisos peligrosos.

5) Consejos finales y advertencias

  • Nunca uses estos conocimientos para construir sistemas que roben o automaticen el drenaje. Eso es delito y perjudica a personas reales.

  • Si tu interés es profesional (seguridad/forense), documentá todo, trabaja con ética y colabora con exchanges y autoridades para frenar estas estafas.

  • Si querés, te puedo:

    • pasar un temario detallado para aprender Solidity + seguridad; o
    • revisar (sin instruirte a explotar) una dirección/tx para explicarte qué patrones concretos muestra y cómo detectarlos.

Curso EIT

EIT es EducaciónIT

Este curso que pasás te sirve como base sólida (EVM, MetaMask, Solidity, tokens, Web3.js y oráculos son temas clave). Pero no es suficiente por sí solo si tu objetivo es auditar contratos y ofrecer protección profesional a clientes. Te explico por qué y qué completar.

Qué aporta el curso (ventajas)

  • Entiendes la pila técnica: cuentas/wallets, EVM, transacciones y desarrollo de smart contracts.
  • Aprendés a escribir y desplegar contratos y a integrar con frontend (Web3.js).
  • Es buena base para empezar a auditar, porque sin esto no podés leer ni probar contractos correctamente.

Qué NO cubre (y necesitas)

  • Seguridad avanzada de smart contracts (patrones inseguros, reentrancy, integer overflow, front-running, upgradability risks).
  • Herramientas de auditoría (Slither, MythX, Echidna, Manticore, Oyente, etc.) y técnicas: fuzzing, análisis estático/dinámico, fuzz testing, formal verification.
  • Frameworks modernos de testing & devops (Hardhat, Foundry, Tenderly, integración CI/CD, testing con redes locales).
  • Forense on-chain y monitorización (clustering de direcciones, detección de patrones de drenaje, uso de explorers/APIs, Chainalysis-like workflows).
  • Buenas prácticas y bibliotecas seguras (OpenZeppelin, patrones de upgrade seguro).
  • Procedimientos de respuesta / mitigación: cómo guiar a un cliente si hay compromise (revocar approvals, mover fondos con seguridad, coordinación con exchanges/autoridades).
  • Aspectos legales & cumplimiento (KYC/AML, responsabilidad profesional).

Currículum recomendado (complementos prácticos)

  1. Profundizar Solidity avanzado + patrones seguros (OpenZeppelin).
  2. Aprender y practicar con Hardhat/Foundry + test suites unitarios y de integración.
  3. Dominar herramientas de análisis: Slither (estático), MythX/Tenderly (dinámico/monitoring), Echidna/Manticore (fuzzing/formal).
  4. Auditorías reales: leer reportes públicos de auditoría (remediation notes) y replicar exploits en entornos controlados.
  5. Forense on-chain: usar APIs de explorers, clustering y seguimiento de flujos (práctica con casos reales).
  6. Operaciones de seguridad: procedimientos para revocar allowances, migrar fondos, crear playbooks de incident response.
  7. Ética y marco legal: cómo reportar y colaborar con exchanges/autoridades.

Recursos / vías de formación (buscá)

  • Cursos/bootcamps de security/auditing (Consensys Academy, Trail of Bits, OpenZeppelin trainings).
  • Documentación y “best practices” de OpenZeppelin y blogs de auditoras (leer reports públicos).
  • Practicar con CTFs/try-hackme/ethernaut y repositorios vulnerables (para entrenar exploitation y fixes).

Consejo final

Si vas a ofrecer consultoría, arma un paquete que incluya: auditoría técnica (code review + herramientas), monitorización on-chain y un playbook de respuesta. Y siempre actúa con ética: no ayudas a explotar vulnerabilidades, sino a proteger clientes.

Roadmap Personal

¡Genial! 🙌 Dale, te armo un roadmap en 2 etapas pensando que arrancás con el curso que me pasaste (desarrollo generalista con Solidity y DApps) y después apuntás a seguridad/auditoría blockchain.

🟢 Etapa 1: Desarrollador generalista (base sólida)

🎯 Objetivo: construir y entender DApps end-to-end, sentir si te gusta este mundo.

  1. Curso que ya viste (Solidity + DApps en Ethereum)

    • Resultado: deployás tu primera DApp en testnet, entendés Solidity, ERC-20/721 y Web3.js.

  2. Extra recomendados

    • CryptoZombies (gratuito): te enseña Solidity jugando.
    • OpenZeppelin docs: aprendé a usar contratos ya auditados y seguros.
    • Ethernaut (juego de CTF de OpenZeppelin): pequeños retos de seguridad que ya te van metiendo el bichito de la auditoría.

  3. Portfolio inicial

    • Subí tu proyecto final del curso a GitHub.
    • Agregá README claro con capturas, instrucciones de despliegue y el contrato verificado en testnet.

🔴 Etapa 2: Seguridad y Auditoría (especialización)

🎯 Objetivo: detectar vulnerabilidades en contratos, proteger a clientes y auditar proyectos.

  1. Seguridad avanzada en Solidity

    • Patrones de ataque: reentrancy, frontrunning, flash loans, overflow, delegatecall, fallbacks peligrosos.

    • Recursos:

      • Curso Smart Contract Security (Consensys Academy).
      • Reportes de auditorías públicos (Trail of Bits, OpenZeppelin, Hacken, Certik).

  2. Herramientas de auditoría

    • Slither (análisis estático).
    • MythX / Mythril (detección de vulnerabilidades).
    • Echidna / Manticore (fuzzing y testing automático).
    • Tenderly (debugger on-chain, excelente para simular fallos).

  3. Frameworks modernos de dev y testing

    • Hardhat (standard actual) y/o Foundry (más rápido y usado por auditores).
    • Aprender a escribir tests unitarios y de seguridad en contratos.

  4. Forense on-chain (para consultoría + casos de scams)

    • Aprender a usar Etherscan/Tronscan APIs.
    • Practicar clustering y tracing de transacciones.
    • Conocer Chainalysis / TRM Labs (aunque sean de pago, te sirve la documentación pública).

  5. Proyecto integrador de seguridad

    • Auditar un contrato real open source (ej: un token en GitHub).
    • Documentar findings, proponer fixes → subir tu auditoría simulada a GitHub.
    • Eso es oro para mostrar a clientes.

🚀 Resultado final

  • Etapa 1 → sabés programar y desplegar DApps.
  • Etapa 2 → sabés auditar, encontrar vulnerabilidades y proteger proyectos.
  • Te posicionás como consultor blockchain con foco en seguridad → un perfil muy buscado y bien pagado.