Introducción.
Todo lo que necesitas para integrar Vericto por sus tres modos (proxy TCP, CLI y API REST), configurar reglas y entender el motor AST determinístico.
Inicio rápido
Vericto protege tus bases de datos evaluando cada consulta SQL contra reglas de seguridad antes de que llegue a tus datos. Tres modos de integración: se combinan, elige según el entorno:
Opción A: Proxy TCP (en tiempo de ejecución, PostgreSQL y MySQL)
Despliega un contenedor ligero en tu infraestructura. Tu aplicación se conecta al proxy en lugar de conectarse directamente a la base de datos: mismas credenciales, distinto host. Bloquea consultas inseguras en tiempo real. Disponible para PostgreSQL y MySQL, cuyos protocolos de cable habla el proxy. Para Oracle y SQL Server, usa la CLI o la API HTTP (todos los dialectos).
Opción B: CLI (shift-left: pre-commit y CI/CD, todos los dialectos)
La CLI vericto valida el SQL contra las reglas de tu workspace antes de que se ejecute, en hooks de pre-commit y pipelines de CI. Es un cliente ligero que envía el SQL a tu workspace y refleja el veredicto como código de salida del proceso (el SQL se analiza, nunca se ejecuta). Funciona con los cuatro dialectos y está disponible en todos los planes.
Opción C: API HTTP (integraciones personalizadas, todos los dialectos)
Evalúa consultas vía REST desde tus propias herramientas: sin proxy, sin CLI. Funciona para todos los dialectos: PostgreSQL, MySQL, Oracle y SQL Server. Es el mismo endpoint que usa la CLI; recurre a él solo cuando la CLI no encaje en tu flujo de trabajo.
Cero credenciales almacenadas: Vericto nunca almacena las credenciales de tu base de datos ni las envía a Vericto Cloud. El proxy se ejecuta en tu infraestructura y transmite el handshake de autenticación de PostgreSQL a tu base de datos sin modificarlo: las credenciales las verifica tu base de datos, no Vericto.
¿Listo para conectar? La Guía de integración tiene el paso a paso de los tres modos: despliegue del proxy (Docker, Kubernetes, ECS), instalación y uso de la CLI, y ejemplos de la API HTTP.
Arquitectura
Vericto usa análisis AST (árbol de sintaxis abstracta) determinístico para evaluar las consultas SQL. Sin IA, sin modelos probabilísticos, sin falsos positivos: la misma entrada siempre produce el mismo resultado.
Cómo funciona
Your App → Vericto Proxy (your infrastructure, port 5433)
│
├─ Parse SQL into full AST (pg_query for Postgres, sqlparser-rs for MySQL/Oracle/SQL Server)
├─ Evaluate AST against active security rules
├─ Resolve enforcement action (BLOCK / FLAG / MONITOR)
│
├── SAFE? → Forward to your real database → relay response
└── DESTRUCTIVE? → Return SQLSTATE 42501 (query never reaches DB)
Componentes
| Componente | Dónde se ejecuta | Propósito |
|---|---|---|
| vericto-proxy | Tu infraestructura | Interceptación del protocolo de cable TCP. Evalúa las consultas en el proceso usando vericto-engine. Reporta la telemetría a la API de Vericto. |
| Vericto API | Vericto Cloud | Dashboard, gestión de reglas, almacenamiento de telemetría, registro de auditoría y evaluación de consultas por HTTP. |
| vericto-engine | Embebido en el proxy | Parser AST + evaluador de reglas en Rust. P99 < 2ms. Sin llamadas de red en la ruta crítica. |
Proxy TCP (protocolo de cable de PostgreSQL y MySQL)
El proxy TCP es una capa de interceptación transparente. Cualquier driver que use el protocolo de cable de PostgreSQL o MySQL funciona sin cambios de código. Las credenciales de tu base de datos nunca salen de tu infraestructura.
¿Qué bases de datos pueden usar el proxy? El proxy TCP transparente habla los protocolos de cable de PostgreSQL y MySQL. Oracle y SQL Server se admiten a través de la API HTTP y la CLI (evalúan una consulta antes de ejecutarla): no hay proxy en su ruta de conexión. La CLI y la API HTTP cubren los cuatro dialectos.
| Base de datos | Proxy TCP (protocolo de cable) | CLI / API HTTP |
|---|---|---|
| PostgreSQL | ✓ | ✓ |
| MySQL | ✓ | ✓ |
| Oracle | — | ✓ |
| SQL Server | — | ✓ |
Cero credenciales almacenadas
Vericto nunca almacena las credenciales de tu base de datos ni las transmite a Vericto Cloud. El proxy se ejecuta en tu infraestructura y transmite el intercambio de autenticación de PostgreSQL —el flujo Authentication / PasswordMessage que sigue al StartupMessage— directamente a tu base de datos. Tu aplicación se conecta al proxy con el mismo usuario/contraseña que usaría para conectarse directamente, y las credenciales las verifica tu base de datos, no Vericto. Con SCRAM-SHA-256 (el valor por defecto moderno de PostgreSQL) la contraseña nunca se transmite en texto plano; el proxy solo retransmite el desafío-respuesta.
Cómo desplegarlo: el paso a paso completo del proxy (variables de entorno, Docker Compose, Kubernetes, AWS ECS, TLS, buffering de telemetría y dimensionamiento de recursos) está en la Guía de integración. Aquí cubrimos qué hace y cómo decide.
Compatibilidad de protocolo de cable
Vericto opera como una capa totalmente transparente dentro del protocolo de cable de PostgreSQL. El proxy detecta y evalúa automáticamente el SQL de ambos modos de protocolo, sin necesidad de configuración ni cambios de driver:
| Modo de protocolo | Descripción | Usado por |
|---|---|---|
Simple Query ('Q') |
El cliente envía la sentencia SQL completa como un único mensaje. Vericto extrae y evalúa el texto completo de la consulta en línea. | psql, ejecución de SQL en crudo, scripts de administración, aplicaciones heredadas |
Extended Protocol ('P') |
El cliente envía una sentencia preparada con marcadores de parámetros ($1, $2...). Vericto evalúa la estructura de la consulta en la fase Parse —antes de que se enlacen los valores— garantizando protección determinística independientemente de los parámetros en tiempo de ejecución. |
Prisma, SQLAlchemy, TypeORM, Drizzle, pg (node-postgres), Hibernate, ActiveRecord |
El proxy gestiona ambos modos de forma transparente dentro de la misma conexión. Todo el demás tráfico del protocolo (handshake de autenticación, resultados de consultas, notificaciones del servidor, operaciones COPY) pasa sin modificarse. No hay ninguna configuración necesaria para seleccionar entre modos: Vericto inspecciona el byte de tipo de cada mensaje y solo intercepta los frames que transportan SQL.
Qué evalúa Vericto (no solo los casos obvios)
Como Vericto recorre el AST completo de PostgreSQL (vía libpg_query, el mismo parser que usa la base de datos), detecta sentencias destructivas que la inspección superficial o por regex pasa por alto:
- Consultas de múltiples sentencias: cada sentencia de un lote se analiza y evalúa, y gana la violación de mayor severidad. Una cola destructiva no puede esconderse tras una cabeza benigna:
SELECT 1; DROP TABLE users;se bloquea en elDROP. - CTEs y subconsultas que modifican datos: se detectan operaciones destructivas anidadas dentro de cláusulas
WITHo subconsultas, p. ej.WITH x AS (DELETE FROM users RETURNING id) SELECT * FROM x. - Sentencias parametrizadas: las sentencias preparadas se evalúan en tiempo de Parse sobre la estructura de la consulta, por lo que la protección es determinística independientemente de los valores enlazados.
- Tautologías de inyección: los predicados siempre verdaderos como
OR 1=1en una cláusulaWHEREse marcan como patrones de inyección SQL. - Multidialecto: PostgreSQL, MySQL, Oracle y SQL Server se analizan con reglas conscientes del dialecto (p. ej. en MySQL
DELETE … LIMITes válido; Postgres no tiene esa forma). PostgreSQL y MySQL pueden pasar por el proxy transparente; Oracle y SQL Server se evalúan vía la API HTTP.
Manejo de errores nativo: una consulta bloqueada devuelve un error estándar de PostgreSQL con SQLSTATE 42501 (insufficient_privilege). Tu aplicación lo recibe por la misma ruta de manejo de errores que cualquier otro error de la base de datos: sin SDK, wrapper ni parsing de errores específico de Vericto.
Decisiones y acciones
Vericto separa la severidad (qué tan peligroso es: Critical / High / Medium / Low / Informational) de la acción de aplicación (qué hacer: BLOCK / FLAG / MONITOR). La acción la resuelve la política de aplicación del workspace.
| Decisión | Comportamiento | Señal |
|---|---|---|
ALLOWED |
La consulta no viola ninguna regla activa. El proxy TCP la reenvía al upstream; la CLI/API HTTP la reportan como segura. | proxy: reenviada · CLI/API: status: ALLOWED |
FLAGGED |
La consulta viola una regla con acción FLAG: se reenvía al upstream pero genera telemetría + alerta. Ejemplo: SELECT sin LIMIT (Medium → FLAG). | proxy: reenviada · CLI/API: status: FLAGGED |
MONITORED |
La consulta viola una regla con acción MONITOR: se reenvía y se registra, sin alerta. Ejemplo: INSERT sin columnas explícitas (Low → MONITOR). | proxy: reenviada · CLI/API: status: MONITORED |
BLOCKED |
La consulta viola una regla con acción BLOCK. El proxy TCP devuelve SQLSTATE 42501 (la consulta nunca llega a la base de datos); la CLI/API HTTP reportan status: BLOCKED con rule_code, ast_node_path y suggested_fix, y establecen exit_code: 1. |
proxy: SQLSTATE 42501 · CLI/API: exit_code 1 |
PARSE_ERROR |
La consulta tiene sintaxis inválida. Por defecto: fail-open (reenvía + registra; no establece un código de salida distinto de cero). Configurable como fail-closed (BLOCK) por workspace. | proxy: reenviada (por defecto) · CLI/API: status: PARSE_ERROR |
Política de aplicación por defecto
| Severidad | Acción por defecto | Reglas de ejemplo |
|---|---|---|
| Critical / High | BLOCK | VERICTO-001 (DELETE sin WHERE), VERICTO-010 (DROP TABLE) |
| Medium | FLAG | VERICTO-050 (SELECT sin LIMIT) |
| Low / Informational | MONITOR | VERICTO-060 (INSERT sin columnas) |
| Error de parseo | Permitir + reportar | Sintaxis SQL inválida |
Modo observación (dry-run): cuando está habilitado, todas las acciones BLOCK se degradan a FLAG: no se bloquea nada. Úsalo para validar el impacto de tu conjunto de reglas antes de habilitar la aplicación en producción.
Telemetría de consultas y privacidad
Por cada consulta que evalúa, el proxy emite un evento de telemetría a la API de Vericto (estado, severidad, código de regla, latencia y el texto de la consulta). Esto alimenta el dashboard, las métricas y el registro de auditoría. Las credenciales de tu base de datos nunca forman parte de la telemetría, pero el texto de la consulta puede contener valores sensibles en sus literales (p. ej. WHERE email = 'alice@acme.com').
El modo de telemetría de consultas es configurable por workspace (Dashboard → Settings → Privacidad de la telemetría):
| Modo | Qué se reporta | Compromiso |
|---|---|---|
| raw (por defecto) | El texto completo de la consulta, exactamente como se ejecutó. | Máximo detalle forense en el registro de auditoría. Los valores literales (posible PII) salen de tu red y los almacena Vericto. |
| sanitized | La consulta con los literales normalizados a marcadores ($1, $2, …) antes de que salga del proxy. |
Ningún dato de usuario sale de tu red. Pierdes los valores exactos, pero conservas la estructura de la consulta para métricas y agrupación. |
La aplicación de reglas no se ve afectada. La evaluación de reglas siempre se ejecuta contra la consulta completa en el proceso; la sanitización solo cambia lo que se reporta. Cambiar a sanitized nunca debilita el bloqueo: solo redacta la telemetría.
Cómo funciona la sanitización estructural sobre el AST, ejemplos y la recomendación por tipo de datos (GDPR, HIPAA, Ley 1581 de 2012) están en Privacidad de telemetría.
Autenticación e integración HTTP
El acceso programático de CI/CD a Vericto (evaluación de consultas, sync de reglas, telemetría) usa API keys. Crea una API key desde el dashboard (página API Keys) e inclúyela en cada solicitud en la cabecera X-API-Key. La API REST del dashboard (reglas custom, audit trail) usa el token de sesión con Authorization: Bearer.
X-API-Key: vtro_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Las API keys están limitadas a un workspace y heredan los límites de plan del workspace. Puedes crear varias keys con distintos nombres para distintos entornos (CI, staging, producción).
Endpoint de evaluación de consultas
Evalúa un lote de hasta 500 consultas SQL contra el conjunto de reglas activo. Devuelve un veredicto por consulta (ALLOWED, BLOCKED, FLAGGED, MONITORED) y un exit_code, sin ejecutar ninguna consulta contra tu base de datos. Requiere una API key con el scope ci_dryrun:execute. Es el endpoint que usa la CLI vericto: ideal para pipelines de CI/CD, comprobaciones previas al despliegue y automatización de revisiones de código.
La forma del request y la respuesta, ejemplos en cURL, Node.js y Python, y los códigos de respuesta están en la Guía de integración.
Reglas de seguridad
Vericto incluye un catálogo de reglas estándar (VERICTO-*) que detectan patrones destructivos y de inyección, agrupadas por severidad:
- CRITICAL Operaciones irreversibles a gran escala:
DELETE/UPDATEsinWHERE,DROP,TRUNCATEy tautologías de inyección (OR 1=1). Se bloquean por defecto. - HIGH Cambios de esquema y patrones peligrosos:
ALTER TABLE DROP COLUMN,DROP INDEX,INSERT … SELECTsin filtro,SLEEP(). - MEDIUM Riesgos de rendimiento o buenas prácticas:
SELECTsinLIMIT,SELECT *sinWHERE,INSERTsin columnas explícitas.
Consulta el catálogo completo, con cada regla, su severidad, los dialectos que cubre y su condición AST, en la Referencia de reglas AST. Puedes ajustar la acción de cada regla o crear reglas propias en Reglas personalizadas.
Códigos de error
| HTTP | Código | Descripción |
|---|---|---|
| 400 | VALIDATION_ERROR | Parámetros inválidos o faltantes |
| 401 | UNAUTHORIZED | API key / token inválido, expirado o ausente |
| 403 | FORBIDDEN | Permisos insuficientes para la operación |
| 403 | PLAN_UPGRADE_REQUIRED | La funcionalidad requiere un plan superior |
| 403 | QUERY_BLOCKED | Consulta bloqueada por una regla de seguridad AST |
| 404 | NOT_FOUND | Recurso no encontrado o purgado por la política de retención |
| 409 | CONFLICT | Email o nombre duplicado |
| 423 | ACCOUNT_LOCKED | Cuenta bloqueada tras intentos fallidos (15 min) |
| 429 | RATE_LIMIT_EXCEEDED | Demasiadas solicitudes. Consulta retry_after_seconds en la respuesta |
Planes y límites
Vericto tiene cuatro planes. Todos incluyen las reglas estándar y los tres modos de conexión (TCP, API HTTP y CLI); se diferencian en cuotas, retención y funciones enterprise:
- Free: 500K consultas/mes, 1 base de datos, 1K validaciones CLI/mes, retención de auditoría 7 días.
- Builder: 5M consultas/mes, 3 bases de datos, reglas personalizadas (YAML), alertas Slack/webhook, retención 30 días.
- Team: consultas ilimitadas, 10 bases de datos, exportación de auditoría (CSV/JSON), retención 90 días, cumplimiento SOC2/ISO 27001.
- Enterprise: bases de datos y retención a medida, SSO (SAML/OIDC), despliegue dedicado y SLA garantizado.
Consulta la comparativa completa de funciones y los precios en la página de precios.