Information Disclosure in Aspnet with Cockroachdb

Information disclosure in an ASP.NET application using CockroachDB can occur when error messages, stack traces, or debug output expose database schema details, connection strings, or query parameters to unauthenticated attackers. CockroachDB, while robust, does not inherently prevent sensitive information from being surfaced through application-level error handling. In ASP.NET, unhandled exceptions or verbose logging configurations may return detailed database errors, including SQL syntax issues or constraint violations, that reveal table names, column structures, or query patterns.

For example, consider an endpoint that queries user data by an integer identifier without validating input. If an attacker sends a malformed request that triggers a CockroachDB-specific error, the ASP.NET runtime might return a full exception stack trace. This can include details such as the table name (e.g., users), column names (e.g., id, email), and the exact SQL statement executed. Such information assists in crafting further attacks, such as injection or enumeration.

The combination of ASP.NET’s default development-mode error pages and CockroachDB’s detailed driver errors is particularly risky in production environments where structured error handling is missing. If the application uses the CockroachDB connection string directly from configuration without proper protection, a path traversal or insecure deserialization issue might expose the connection string in logs or error responses. MiddleBrick scans detect these patterns by correlating runtime behavior with OpenAPI specifications, identifying endpoints that return database-level details without appropriate error masking.

Additionally, improper use of ORMs or raw SQL queries in ASP.NET can lead to information leakage through verbose logging. If the application logs full SQL statements with parameter values, and those logs are accessible to unauthorized users, an attacker can infer database schema and data types. This is compounded when CockroachDB returns specific error codes, such as pq: relation "users" does not exist, which directly expose object names. The risk is elevated when security checks like authentication and rate limiting are not enforced, allowing unauthenticated probing to map the API surface and extract sensitive details.

MiddleBrick’s LLM/AI security checks and unauthenticated scanning help identify endpoints where information disclosure is likely, even without credentials. By testing error responses and analyzing OpenAPI specs alongside runtime behavior, the scanner highlights gaps in error handling, logging, and input validation that could lead to data exposure. This enables teams to apply targeted fixes before attackers leverage leaked information.

To mitigate information disclosure when using CockroachDB with ASP.NET, implement structured error handling, avoid exposing raw database errors, and sanitize logs. The following practices and code examples demonstrate secure patterns.

1. Use Global Exception Handling with Generic Error Responses

Configure ASP.NET to catch exceptions and return uniform error messages without database details. This prevents stack traces from revealing CockroachDB-specific errors.

// Program.cs
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

if (app.Environment.IsDevelopment()) {
    app.UseSwagger();
    app.UseSwaggerUI();
}

// Global exception handler
app.UseExceptionHandler(errorApp => {
    errorApp.Run(async context => {
        context.Response.StatusCode = 500;
        await context.Response.WriteAsJsonAsync(new { error = "Internal server error" });
    });
});

app.MapGet("/users/{id}", (int id, AppDbContext db) => {
    var user = db.Users.Find(id);
    if (user == null) throw new Exception("User not found");
    return Results.Ok(user);
});

app.Run();

2. Secure CockroachDB Connection String Management

Store connection strings securely using ASP.NET Core configuration and avoid logging them. Use environment variables or secret managers, and ensure logs do not include sensitive values.

// appsettings.json (do not commit to version control)
{
  "ConnectionStrings": {
    "CockroachDb": "postgresql://user:password@host:26257/dbname?sslmode=require"
  }
}

// In Program.cs, access securely
var connectionString = builder.Configuration.GetConnectionString("CockroachDb");
// Never log connectionString

3. Parameterized Queries with CockroachDB Driver

Always use parameterized queries to prevent SQL injection and avoid string interpolation that could expose values in logs or errors.

// Using Npgsql with CockroachDB
using var conn = new NpgsqlConnection(connectionString);
await conn.OpenAsync();

var sql = "SELECT id, email FROM users WHERE id = @id";
using var cmd = new NpgsqlCommand(sql, conn);
cmd.Parameters.AddWithValue("id", userId);

using var reader = await cmd.ExecuteReaderAsync();
while (await reader.ReadAsync()) {
    // Process data
}

4. Suppress Verbose Logging for Database Operations

Configure logging levels to avoid recording sensitive SQL or parameters. In ASP.NET Core, adjust log categories for Npgsql and Microsoft database components.

// Program.cs
builder.Logging.ClearProviders();
builder.Logging.AddConsole((options) => {
    options.IncludeScopes = true;
    options.TimestampFormat = "hh:mm:ss ";
});
builder.Logging.SetMinimumLevel(LogLevel.Warning);
builder.Logging.AddFilter("Npgsql", LogLevel.Warning); // Reduce DB noise

5. Validate and Sanitize Inputs Before Querying

Ensure input values conform to expected formats before using them in database queries. This reduces the chance of triggering error messages that disclose schema details.

// Example validation in a minimal API
app.MapGet("/users/{id}", (int id) => {
    if (id <= 0) return Results.BadRequest("Invalid user ID");
    // Proceed with safe query
});

By combining these practices, ASP.NET applications using CockroachDB can significantly reduce the risk of information disclosure. MiddleBrick scans validate these configurations by checking for insecure error handling, logging risks, and query patterns, helping teams maintain a secure posture without relying on detection of internal architecture.