Container Escape in Adonisjs with Api Keys

A container escape in AdonisJS when API keys are used typically arises from a combination of insecure key handling, overly permissive process execution, and weak runtime isolation. API keys in AdonisJS are often injected as environment variables and used to gate access to routes, services, or external integrations. If an application exposes a route or console command that processes untrusted input containing shell metacharacters, and that code uses the API key in a subprocess call without proper sanitization, an attacker may be able to break out of the container’s constraints.

Consider an AdonisJS service that validates an incoming API key and, based on its value, runs a system command to fetch external configuration. A vulnerable implementation might concatenate the key directly into a command string:

import { exec } from 'child_process';

export async function fetchConfig(key: string) {
  exec(`curl -H "Authorization: Bearer ${key}" https://config.example.com/settings`, (error, stdout) => {
    // handle output
  });
}

If an attacker can control the API key (e.g., via query parameters, headers, or a compromised client), they can inject shell operators such as ;, &&, or backticks to execute arbitrary commands inside the container. For example, setting the key to validkey; id or validkey && cat /etc/passwd can lead to command injection, which in a containerized environment may enable reading sensitive host files, reaching the Docker socket, or spawning additional processes.

Container escape is more likely when the AdonisJS process runs with elevated privileges or mounts sensitive host paths (e.g., /var/run/docker.sock) into the container. An attacker who achieves command injection can leverage these conditions to inspect the container’s environment, locate the socket, and issue Docker commands that allow them to create new containers or escalate privileges on the host. API keys that are logged in plaintext or stored in world-readable files also increase risk by exposing secrets that can be reused outside the container boundary.

The 12 checks in middleBrick run in parallel and include Unsafe Consumption and Input Validation, which help detect patterns like shell command construction with external-controlled API keys. Findings will highlight the presence of injection risks and advise on input sanitization and least-privilege execution, without claiming to fix or block the behavior.

Securing API keys in AdonisJS requires strict input validation, avoiding shell command construction, and using safe process execution patterns. The following examples demonstrate secure approaches.

1. Avoid shell metacharacters by using parameterized commands

Instead of concatenating values into shell commands, use child process methods that do not invoke a shell, or pass arguments as an array:

import { execFile } from 'child_process';

export async function fetchConfig(key: string) {
  execFile('curl', ['-H', `Authorization: Bearer ${key}`, 'https://config.example.com/settings'], (error, stdout) => {
    if (error) {
      // handle error
      return;
    }
    // process stdout
  });
}

Using execFile with an array of arguments prevents the shell from interpreting metacharacters in the API key, effectively neutralizing command injection attempts.

2. Validate and restrict API key format

Ensure API keys conform to an expected pattern before use. Reject keys containing shell-sensitive characters:

import { RegExpValidatorBuilder } from '@ioc:AdonisJS/Validator';

export function validateApiKey(key: string): boolean {
  const validator = new RegExpValidatorBuilder()
    .rule('regex', /^[A-Za-z0-9\-_]+$/);
  const validation = validator.build().validateSync({ key });
  return validation.isValid();
}

This validator allows only alphanumeric characters, hyphens, and underscores, reducing the risk of injection. If validation fails, return a 401 response and log the attempt.

3. Use environment variable isolation and least privilege

Ensure the AdonisJS process runs with a dedicated service account and does not mount sensitive host paths. Configure container runtimes to avoid sharing the Docker socket unless strictly necessary, and use read-only mounts for non-writable resources.

4. Secure logging and storage

Never log raw API keys. If you must record key usage, mask or hash portions of the key:

import logger from '@ioc:AdonisJS/Core/logger';

export function logKeyUsage(key: string) {
  const masked = key.slice(0, 4) + '****' + key.slice(-4);
  logger.info(`API key used: ${masked}`);
}

middleBrick’s LLM/AI Security checks can detect system prompt leakage and output scanning for secrets; however, remediation requires code and runtime configuration changes by the developer.