Bleichenbacher Attack in Chi with Basic Auth

A Bleichenbacher attack is a chosen-ciphertext attack originally described for RSA PKCS#1 v1.5 padding, but the adaptive chosen-ciphertext pattern also applies when an API reveals different behavior based on authentication validity. In Chi (a functional routing library for Clojure/Java), using HTTP Basic Auth without additional protections can expose a timing or error-difference side channel that an attacker can exploit iteratively to recover credentials.

Consider a Chi service that validates Basic Auth in a middleware layer before routing to handlers. If the middleware performs a string comparison or a non-constant-time check between the provided credentials and stored values, each request can leak information via response times or error messages. For example, a correct username with an incorrect password might result in a different code path (and therefore a slightly slower or differently formatted response) than a completely unknown username. An attacker can automate thousands of requests, slightly adjusting the password guess and observing subtle differences in status codes, response bodies, or latency. Over time, this adaptive process narrows down the valid password by exploiting the server’s behavioral distinctions—an operational Bleichenbacher-like scenario.

When combined with unauthenticated scanning, middleBrick’s security checks can surface this risk under the Authentication and Input Validation categories. The scanner tests the unauthenticated attack surface and flags inconsistent responses or missing rate limiting that make such adaptive attacks practical. Without mitigations like constant-time comparison and strict error handling, what begins as a theoretical cryptographic weakness becomes a practical credential-recovery path against Basic Auth endpoints in Chi.

Remediation focuses on eliminating timing differences and ensuring robust validation. Use constant-time comparison for credentials and avoid branching on secrets. Below are concrete, working examples in Clojure with the Ring/Chi stack.

Example 1: Constant-time credential validation

(ns myapp.auth
  (:require [ring.util.codec :refer [base64-decode]]))

(defn constant-time-equals? [a b]
  (let [a-bytes (.getBytes ^String a "UTF-8")
        b-bytes (.getBytes ^String b "UTF-8")]
    (when (= (alength a-bytes) (alength b-bytes))
      (loop [i 0
             result 0]
        (if (< i (alength a-bytes))
          (recur (inc i) (bit-xor result (bit-and 0xff (- (aget a-bytes i) (aget b-bytes i)))))
          (zero? result))))))

(defn validate-basic-auth [auth-header expected-user expected-pass]
  (when auth-header
    (let [[_ token] (re-find #"^Basic\s+(.+)$" auth-header)
          decoded (when token (String. (base64-decode token) "UTF-8"))
          [user pass] (when decoded (clojure.string/split decoded #":" 2))]
      (when (and user pass)
        (and (constant-time-equals? user expected-user)
             (constant-time-equals? pass expected-pass))))))

Example 2: Safe middleware usage in Chi routes

(ns myapp.routes
  (:require [compojure.core :refer [defroutes GET]]
            [ring.util.response :as resp]
            [myapp.auth :refer [validate-basic-auth]]))

(def expected-user "admin")
(def expected-pass "s3cur3P@ss!")

(defroutes app-routes
  (GET "/secure" request
    (let [auth-header (get-in request [:headers "authorization"])
          authenticated (validate-basic-auth auth-header expected-user expected-pass)]
      (if authenticated
        (resp/response "OK")
        (resp/response "Unauthorized")
        {:status 401
         :headers {"WWW-Authenticate" "Basic realm=\"api\""}}))))

Additional hardening measures

• Always return the same generic error (e.g., 401 with a static body) regardless of whether the username or password is incorrect.
• Enforce rate limiting at the endpoint or global level to slow down iterative attacks; combine with account lockout or exponential backoff where appropriate.
• Serve over TLS to prevent credential interception in transit.
• Prefer token-based authentication where feasible, reducing reliance on Basic Auth’s inherent vulnerabilities.

These changes align with OWASP API Security Top 10 controls for Authentication and Security Misconfiguration, and they reduce the feasibility of adaptive chosen-credential attacks against Chi-based services.