Brute Force Attack in Phoenix with Mutual Tls

A brute force attack against a Phoenix endpoint that uses mutual TLS (mTLS) focuses on exhausting authentication or session resources despite the presence of client certificates. In this setup, the server validates the client certificate during the TLS handshake, but application-level authentication (such as an API key or token verified after the handshake) may still be weak, rate-limited, or improperly enforced. An attacker who can present a valid client certificate (or one that the server accepts) can then launch credential or token brute force attempts against the Phoenix application without being blocked by network-level mTLS alone.

The risk is compounded when mTLS is used primarily for transport-layer identity and the application does not enforce strict per-client rate limiting or account lockout. For example, if the Phoenix service accepts mTLS client certificates but relies on a simple API key in the header for authorization, an attacker with a valid cert can iterate over many keys or sessions rapidly. Because the TLS handshake succeeds, the requests reach the application layer, and weak login or token validation logic may allow successful guessing of credentials or session identifiers.

Consider a Phoenix API that uses mTLS and exposes an endpoint like /api/v1/access. The client presents a certificate, and the server maps the certificate to an identity. If the endpoint also requires a bearer token that is validated with a weak algorithm or no rate limiting, the attacker can use the mTLS-authenticated channel to make many rapid requests, testing tokens or session IDs. The 12 parallel security checks in middleBrick will surface issues such as missing rate limiting and insufficient account protection even when mTLS is in place, because the scanner tests the unauthenticated attack surface and can probe endpoints that accept mTLS but lack additional controls.

Real-world attack patterns relevant here include OWASP API Top 10:2023 Broken Object Level Authorization (BOLA) and Excessive Data Exposure, where weak authorization after successful mTLS allows unauthorized data access. If the server does not tie the client certificate to a specific authorization context, an attacker can use a valid certificate to probe for IDOR or perform privilege escalation by manipulating requests that the endpoint trusts based solely on the certificate.

To harden Phoenix applications using mutual TLS, enforce strict mapping from client certificate attributes to application permissions and apply rate limiting at the identity level. Do not assume a valid certificate alone is sufficient; always couple mTLS with application-level authorization and anti-abuse controls.

Example Phoenix endpoint with mTLS and token-based authorization

defmodule MyAppWeb.ApiController do
  use MyAppWeb, :controller

  plug MyAppWeb.Plugs.VerifyClientCert
  plug MyAppWeb.Plugs.AuthorizeWithToken

  def access(conn, params) do
    # After cert and token validation, proceed with business logic
    json(conn, %{status: "ok", subject: conn.assigns.cert_subject})
  end
end

Plugs to validate client certificate and enforce per-identity rate limiting

defmodule MyAppWeb.Plugs.VerifyClientCert do
  import Plug.Conn

  @cert_whitelist %{~s|CN=alice,O=Example| => :alice, ~s|CN=bob,O=Example| => :bob}

  def init(opts), do: opts

  def call(conn, _opts) do
    case conn.state do
      :unset ->
        client_cert = List.first(conn.client_cert)
        subject = :public_key.pkix_decode_cert(client_cert, :otp)
                     |> :public_key.pkix_subject_name_to_string()
                     |> to_string()
      
      _ -> 
        subject = conn.private[:cert_subject]
    end

    if subject in Map.keys(@cert_whitelist) do
      assign(conn, :cert_subject, subject)
    else
      send_resp(conn, 403, "Client certificate not allowed")
      halt(conn)
    end
  end
end

defmodule MyAppWeb.Plugs.AuthorizeWithToken do
  import Plug.Conn
  import Phoenix.Controller, only: [json: 3]

  def init(rate_limit \ {10, 60}), do: init

  def call(conn, {limit, period}) do
    subject = conn.assigns.cert_subject
    key = {subject, conn.method, conn.request_path}

    case RateLimiter.check(key, limit, period) do
      {:allow, _} ->
        token = conn.req_headers["authorization"]
        case verify_token(token, subject) do
          {:ok, _claims} -> conn
          {:error, _}   -> send_resp(conn, 401, "Invalid token") |> halt()
        end
      {:deny, _} ->
        send_resp(conn, 429, "Too many requests for this identity") |> halt()
    end
  end

  defp verify_token(token, subject) do
    # Implement your token verification logic here
    # Return {:ok, claims} or {:error, reason}
    if token == "valid_token_for_#{subject}", do: {:ok, %{}}, else: {:error, :bad_token}
  end
end

Additional server-side protections

• Bind client certificate fields (such as CN or serial) to application roles and enforce role-based authorization on every request.
• Apply rate limiting per certificate identity, not just per IP, to prevent brute force attempts over the mTLS-accepted channel.
• Log certificate subject and token validation outcomes for audit, and ensure logs do not expose sensitive token material.
• Use strong cipher suites and keep your CA and certificate lifecycle management robust to prevent misuse of compromised certificates.

By combining mTLS with explicit identity mapping, strict rate limiting, and application-level authorization checks, you reduce the risk that an attacker can leverage a valid certificate to mount a successful brute force attack against Phoenix endpoints.