Container Escape in Nestjs with Cockroachdb

A container escape in a NestJS application using CockroachDB typically arises when an API endpoint improperly handles user-supplied input that reaches the database layer, allowing an attacker to break out of the intended execution context. Because CockroachDB uses PostgreSQL-wire protocol, common SQL injection techniques remain relevant, and ORM usage in NestJS can still produce unsafe queries when developers concatenate or improperly interpolate values.

Consider a service that builds SQL dynamically to fetch tenant data:

// Unsafe: string concatenation enables injection
const tenantId = req.query.tenantId;
await this.cockroachQuery(`SELECT * FROM tenants WHERE id = ${tenantId}`);

If an attacker supplies ' OR 1=1; --, the query can return rows from other tenants or, in a misconfigured environment, enable further exploitation such as reading sensitive configuration tables or invoking administrative functions exposed via user-defined functions (UDFs). In containerized deployments, a compromised process running inside the container might leverage file system bindings mounted from the host (e.g., reading /etc/hosts or other container volumes) to escalate privileges or pivot laterally.

The risk is compounded when the application uses an unauthenticated endpoint or exposes an introspection route that reveals database metadata. An attacker can chain SQL injection with container escape techniques—such as reading Docker socket files or abusing misconfigured volume mounts—to execute arbitrary commands on the host. For example, a crafted payload that writes to a mounted volume or triggers a local binary can lead to host-level code execution, bypassing container isolation.

middleBrick scans for such issues by running active checks against the unauthenticated attack surface. It tests inputs that flow into CockroachDB queries, looking for injection patterns and unsafe consumption behaviors. The tool also inspects whether endpoints leak system information or allow SSRF-like behavior that could be chained to container escape paths. Findings are mapped to the OWASP API Top 10 and include severity and remediation guidance, without making changes to your environment.

Remediation centers on strict input validation, parameterized queries, and minimizing database privileges available to the application user. Never construct SQL by concatenating user input, and avoid dynamic query builders that interpolate values.

Parameterized queries with the pg driver

Use placeholders and pass values separately so the database distinguishes code from data:

import { Pool } from 'pg';
const pool = new Pool({ connectionString: process.env.COCKRACKDB_URL });

// Safe: parameterized query
const getTenant = async (id: string) => {
  const res = await pool.query('SELECT * FROM tenants WHERE id = $1', [id]);
  return res.rows[0];
};

Parameterized queries with TypeORM

When using TypeORM, prefer QueryBuilder with parameters instead of raw concatenation:

import { Repository } from 'typeorm';
import { Tenant } from './tenant.entity';

async function findTenant(repo: Repository, userInput: string) {
  return repo.createQueryBuilder('tenant')
    .where('tenant.id = :id', { id: userInput })
    .getOne();
}

Input validation and sanitization

Validate and sanitize all inputs before they reach the database layer. Use NestJS pipes to enforce strict formats:

import { PipeTransform, Injectable, BadRequestException } from '@nestjs/common';

export class TenantIdPipe implements PipeTransform {
  transform(value: string): string {
    if (!/^[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/i.test(value)) {
      throw new BadRequestException('Invalid tenant ID');
    }
    return value;
  }
}

Apply the pipe in your controller to ensure only properly formatted identifiers are used.

Least-privilege database user

Ensure the CockroachDB user your application uses has the minimum required permissions. Avoid granting superuser or DDL privileges to the application account; restrict to SELECT, INSERT, UPDATE on required tables only. This reduces the impact of any successful injection or container escape attempt.

Disable unsafe features

Turn off or tightly restrict features such as user-defined functions that allow filesystem access or network calls. If your deployment uses extensions or UDFs, audit them regularly and remove any that are not essential.

middleBrick’s LLM/AI Security checks can detect exposed endpoints and unsafe consumption patterns that may facilitate container escape. The tool runs multiple probes to identify injection risks and excessive agency, providing prioritized findings with remediation steps. Teams on the Pro plan can enable continuous monitoring to catch regressions early, and the GitHub Action can fail builds if the security score drops below the configured threshold.