Seguridad de contratos inteligentes: reentrancy, control de acceso y verificación
Los bugs que más valor drenan — reentrancy, control de acceso — y las herramientas simbólicas y de prueba de teoremas que los cazan antes de la auditoría.
Casi toda pérdida grande en DeFi proviene de un conjunto pequeño de errores que ya se conocían antes de escribir el código. Esa es la parte incómoda de la seguridad de contratos inteligentes: las clases de bug son públicas, están documentadas y se siguen explotando cada año, porque las condiciones que las producen — una llamada externa antes de actualizar el estado, un precio spot leído de un pool delgado, un inicializador que cualquiera puede llamar — reaparecen en formas nuevas.
Las clases de bug que de verdad drenan dinero
Reentrancy. Un contrato hace una llamada externa antes de actualizar su propio estado, así que el llamado puede reentrar y actuar sobre el estado viejo. El drenaje de The DAO en 2016, unos 60 millones de dólares en ETH, fue el original. Las variantes modernas son más sutiles: reentrancy de solo lectura a través de una función view en la que otros protocolos confían, reentrancy entre funciones donde el segundo punto de entrada es otra función, y hooks de ERC-777 o callbacks que convierten una transferencia aparentemente segura en una reentrante. El arreglo es el orden (checks, effects, interactions) más un guard de reentrancy, y ninguno de los dos es opcional.
La diferencia entre la versión vulnerable y la corregida son cuatro líneas de orden, y por eso esta clase nunca muere:
// Vulnerable: la llamada externa ocurre ANTES de actualizar el estado
function withdraw() external {
uint256 amount = balances[msg.sender];
(bool ok,) = msg.sender.call{value: amount}("");
require(ok);
balances[msg.sender] = 0; // demasiado tarde — msg.sender acaba de reentrar
}
// Corregida: effects antes de interactions
function withdraw() external {
uint256 amount = balances[msg.sender];
balances[msg.sender] = 0; // primero el efecto
(bool ok,) = msg.sender.call{value: amount}(""); // la interacción, al final
require(ok);
}
Copy link
Leída una vez, la versión vulnerable parece correcta: se lee el saldo, la transferencia debe tener éxito, la contabilidad ocurre. El exploit vive entero en la secuencia: durante el call, el fallback del llamado se ejecuta con balances mostrando todavía dinero que lógicamente ya se fue. Toda revisión de reentrancy empieza dibujando exactamente esta secuencia.
Control de acceso. Modificadores ausentes, comprobaciones de rol que validan la dirección equivocada, un onlyOwner que resuelve a la wallet caliente del deployer, o un inicializador que nunca se llamó y por tanto cualquiera puede llamar. Vale la pena detenerse en el último: un proxy sin inicializar es un contrato completamente abierto, y es un error que se despliega constantemente porque los tests corren contra una instancia ya inicializada.
El mecanismo, en seis líneas por lado:
// El proxy delega todo en la implementación...
function initialize() external initializer {
owner = msg.sender; // si nadie llamó a esto, no hay owner
}
// ...y un proxy sin inicializar deja que cualquiera lo sea:
attacker.initialize(); // el atacante ya es owner
attacker.upgrade(newImpl); // y posee todos los saldos proxeados
Copy link
Los tests pasan porque el fixture llama a initialize() en el setup; el script de despliegue también tiene que llamarlo, y la carrera entre desplegar e inicializar es una ventana de ataque en sí misma. El patrón maduro elimina la carrera: inicializa en la misma transacción que el despliegue, o transfiere la propiedad a un multisig con timelock inmediatamente.
Manipulación de oráculos. Leer un precio de un pool spot que un atacante puede mover dentro de una sola transacción, o de un feed cuya cadencia de actualización es más lenta que el ataque. Esta clase explica buena parte de los mayores exploits, y con frecuencia es un fallo de diseño más que de código: el código hace exactamente lo que dice, contra un precio que nunca fue fiable.
Fallos de proxy y upgrade. Colisión de almacenamiento entre versiones de implementación, una ruta de upgrade protegida por una sola clave, un delegatecall hacia una dirección que puede cambiar. La actualizabilidad cambia riesgo de inmutabilidad por riesgo de gobernanza, y el segundo suele ser más fácil de explotar porque no requiere un bug nuevo.
Errores económicos y de lógica. Código correcto usado mal: una dirección de redondeo que filtra valor en cada llamada, un invariante contable que se rompe en silencio en un límite, un cálculo de recompensas manipulable dividiendo una posición.
Qué cubre y qué no cubre una auditoría
Una auditoría es una revisión por humanos que han visto esta clase de bug muchas veces. Es buena encontrando errores de lógica, fallos de control de acceso y desviaciones de patrones establecidos. No es una prueba, y el informe normalmente lo dice. El tiempo acotado hace que los revisores muestreen en lugar de agotar el código, y una auditoría limpia es una afirmación sobre el código revisado en ese momento, no sobre un upgrade posterior, una integración nueva o un supuesto económico que nadie cuestionó.
Herramientas que extienden la auditoría
Análisis estático (Slither y similares) recorre el código y señala patrones peligrosos conocidos. Rápido, barato, con mucho ruido, y mejor ejecutarlo en cada commit que una sola vez.
Fuzzing y pruebas de invariantes ejecutan el contrato contra entradas aleatorias y adversariales, afirmando propiedades que siempre deben cumplirse: el suministro total es igual a la suma de saldos, los activos del protocolo siempre superan sus pasivos. Foundry ha convertido esto en la actividad de mayor valor por hora disponible, porque los invariantes codifican lo que de verdad te importa y el fuzzer encuentra el camino que tú no.
Un invariante que vale la pena escribir es una frase con «siempre» traducida a código: «nadie puede retirar más de lo que depositó», «un protocolo en pausa no puede perder fondos», «la suma de obligaciones con los usuarios nunca supera el saldo de la bóveda». El oficio está en elegir invariantes bastante fuertes para atrapar bugs reales y bastante simples para seguir siendo ciertos: un invariante que codifica por sí mismo una fórmula con bug solo demuestra el bug. Empieza por las identidades contables, porque son las más fáciles de enunciar y las que todo exploit grande termina violando.
Ejecución simbólica (Halmos, y Manticore antes) reemplaza valores concretos por simbólicos y pregunta a un solver si existe un camino violatorio. Encuentra bugs reales y produce un contraejemplo, a cambio de una explosión del espacio de estados en código complejo.
Verificación formal (Certora Prover, KEVM) deriva una prueba de que la implementación satisface una especificación. Es potente, y su producto real suele ser la propia especificación: escribir lo que el contrato debe hacer encuentra bugs antes de que corra el prover.
Lo que la verificación no puede probar
Conviene decir cuatro límites con claridad, porque los equipos sobreinterpretan un resultado en verde.
La verificación no dice nada sobre corrección económica. La contabilidad puede ser internamente impecable mientras la entrada de precio es manipulable: la prueba cubre la aritmética, no el supuesto.
No dice nada sobre composabilidad. Todo contrato que llamas queda sin verificar en esta prueba, así que el sistema completo no es lo que se probó.
Y puede quedar invalidada por la gobernanza. Si el upgrade es posible, cada propiedad probada se cumple solo hasta el siguiente upgrade, lo que significa que la ruta de upgrade es parte de la superficie de seguridad y no una nota operativa.
Finalmente asume corrección del oráculo. Si el feed está mal, un contrato probado está fielmente equivocado.
El pipeline que los atrapa
Las herramientas no son alternativas; son estaciones en un orden, y el orden lo marca el coste por hallazgo. El análisis estático corre en cada commit: segundos de cómputo, salida ruidosa, y el ruido es más barato de leer en esta etapa. El fuzzing de invariantes corre cada noche y en cada PR que toca lógica de estado: horas, muchos menos falsos positivos, y atrapa las interacciones que el análisis estático no ve. La ejecución simbólica corre en las funciones donde una prueba es factible: acotada, cara, decisiva. La auditoría llega cuando el pipeline está callado, porque pagar a auditores por encontrar lo que Slither encuentra es la forma más cara de comprar un hallazgo. La monitorización corre después del despliegue, para siempre, porque todo lo anterior era una afirmación sobre una foto.
Los equipos que invierten el orden (primero la auditoría, las herramientas después, la monitorización nunca) compran sus hallazgos al peor precio posible: descubiertos en producción, pagados por los usuarios.
Qué reduce el riesgo de verdad
Superpón los controles baratos que evitan que un bug se convierta en catástrofe: límites de tasa y topes a lo que una sola transacción o un solo firmante pueden mover, un timelock en los cambios de parámetros para que una clave comprometida no sea letal al instante, un mecanismo de pausa que funcione y que alguien vigile, y monitoreo que avise antes de que la pérdida sea irrecuperable. Después añade el bug bounty, para que quien encuentre el bug tenga motivo para reportarlo en lugar de usarlo. Nada de eso sustituye a escribir código con cuidado.
Leer la postura de seguridad de un protocolo sin leer código
La mayoría de quienes interactúan con contratos no son quienes los escribieron, y la buena noticia es que las señales que deciden la interacción no exigen leer Solidity. Qué mirar, en el orden en que filtra: ¿el código está verificado y el repositorio es público — los contratos no verificados no son un riesgo, son una declaración; ¿quién firma la auditoría, si más de una firma la revisó, y si la auditoría es anterior al último cambio material (una auditoría del código del año pasado es contexto, no garantía); cuál es el timelock de las actualizaciones, y si ese retraso basta para que los usuarios se vayan; y si existe un bug bounty público, porque un bounty es una etiqueta de precio sobre la confianza del equipo en su propio código.
Ninguna señal es fuerte por sí sola. Juntas separan los protocolos que tratan la seguridad como práctica de los que la tratan como ítem de checklist de lanzamiento — y la diferencia es donde pertenecen los depósitos.
La primera hora de un incidente
Cuando algo se rompe, la primera hora decide si la pérdida es el exploit o todo lo que viene después. La secuencia que funciona: pausa lo pausable — para eso existen la autoridad de pausa y el ensayo; congela los frontends para que los usuarios dejen de depositar en un contrato roto; y comunica con una frase honesta — qué pasó, qué está seguro, qué no, qué no sabes todavía. El silencio durante un exploit se lee como negligencia o complicidad, y ambas cuestan más que la verdad.
Lo que no hacer importa tanto: no arregles en silencio y finjas que no pasó nada — el forense on-chain convierte eso en una mentira con marca de tiempo; no publiques especulación sobre la identidad o los motivos del atacante; y no negocies respuestas de pánico en hilos públicos. Los incidentes se juzgan menos por el bug que por la primera hora, y los equipos que ensayaron esta secuencia — quién pausa, quién habla, quién congela — recuperan depósitos y reputaciones que los que improvisan no.
La capa operativa que las auditorías nunca ven
Cada control de arriba tiene una persona detrás, y las personas son donde las auditorías se quedan ciegas: revisan código, no plantillas. Cuatro preguntas deciden si los controles existen en la práctica o solo en la documentación:
¿Quién puede pausar de verdad? La función de pausa que describe la documentación vale lo que valga el conjunto de firmantes que pueda invocarla un domingo a las 3 de la mañana. Si pausar exige un multisig cuatro de siete con firmantes en tres zonas horarias, la autoridad de pausa efectiva es quien esté despierto, y el ensayo (ver abajo) es como descubres que es nadie.
¿Dónde viven las claves? La wallet caliente del deployer que sobrevive al lanzamiento es la clave residual más común del sector. Un inventario de claves con fecha de retirada (qué existe, quién lo guarda, cuándo se barre y se quema) cuesta una tarde y cierra el hueco que la mayoría de post-mortems llama «firma desconocida».
¿Qué retrasa de verdad el timelock? Un timelock de 48 horas en cambios de parámetros es un control fuerte contra una clave comprometida y débil contra una votación de gobernanza capturada, porque un atacante con mayoría simplemente agenda el robo. Saber a qué atacante detiene tu timelock es la diferencia entre un control y una decoración.
¿Cuándo se ensayó el plan de incidentes por última vez? El plan de respuesta que existe como página de Notion falla en su primer uso real. Un ejercicio de mesa de una hora (una alerta falsa, la gente real, el procedimiento de pausa real, el canal de comunicación real) dos veces al año es todo el coste de volver real el plan. Todo post-mortem serio lleva una línea sobre lo que el equipo tenía pensado haber ensayado.
Son controles poco glamurosos, y ahí está el punto: cuando el incidente empieza, el código es el que es, y el resultado lo decide la capa operativa que se construyó o se saltó.