CVE-2026-65634 Erlang/OTP ASN.1 Decoder DoS Vulnerability – Analysis & Mitigation

Executive Summary

CVE-2026-65634 is a denial-of-service (DoS) vulnerability in the Erlang/OTP ASN.1 OBJECT IDENTIFIER (OID) decoder that allows remote, unauthenticated attackers to cause significant CPU consumption and service disruption. The vulnerability stems from quadratic algorithmic complexity in the BER OID decoding process, which processes specially crafted OIDs during TLS handshakes. Organizations running Erlang/OTP versions prior to 27.3.4.18, 28.5.0.7, or 29.1.1 should prioritize patching immediately, as exploitation requires minimal effort and no authentication.

Key Facts:

• CVSS Score: High severity
• Attack Vector: Network, unauthenticated
• Affected Versions: OTP 17.0 through 27.3.4.17, 28.x before 28.5.0.7, 29.x before 29.1.1
• Primary Impact: Service availability degradation or complete outage
• Exploitation Difficulty: Low

Vulnerability Overview

What is CVE-2026-65634

CVE-2026-65634 is a computational complexity vulnerability affecting the ASN.1 OBJECT IDENTIFIER decoder in Erlang/OTP. The vulnerability exists in three decoder implementations:

• asn1rtt_ber:dec_subidentifiers/3 (BER encoding)
• asn1rtt_per_common:dec_subidentifiers/3 (PER encoding)
• asn1rtt_jer:json2oid/1 (JSON encoding)

When processing OIDs with large arc values, these functions exhibit quadratic time complexity rather than linear complexity. An attacker can exploit this by crafting a malicious OID containing a single subidentifier with approximately 262 KB of continuation bytes, consuming roughly 13 seconds of CPU time on standard hardware.

Why the ASN.1 Decoder is Critical to Your Security

The ASN.1 decoder is fundamental to TLS/SSL certificate processing. Every TLS handshake requires parsing the peer’s certificate, which contains OIDs identifying certificate extensions, key algorithms, and signature methods. Because certificate parsing occurs before signature verification or trust chain validation, the decoder processes untrusted input from any connecting client or server.

This early processing window is critical: an attacker can trigger the vulnerability without:

• Possessing a valid certificate
• Completing the TLS handshake
• Authenticating to the service
• Having any prior relationship with the target

Severity Classification and CVSS Context

The vulnerability carries high severity due to three factors:

1. Accessibility: Unauthenticated remote exploitation via standard TLS connections
2. Impact: Complete service unavailability through CPU exhaustion
3. Ease of Exploitation: Minimal technical sophistication required; a single malformed OID triggers the condition

The attack is particularly dangerous because it targets the TLS handshake itself—the mechanism designed to establish secure communications. Services cannot distinguish between legitimate and malicious connections until after the vulnerable decoding occurs.

Affected Systems and Versions

Erlang/OTP Versions at Risk

The following Erlang/OTP versions contain the vulnerable ASN.1 decoder:

Organizations using any version prior to the patched releases should treat this as a critical priority.

ASN.1 Module Versions Impacted

The vulnerability affects the following asn1 module versions:

How to Identify If You’re Vulnerable

Step 1: Determine Your Erlang/OTP Version

erl -eval 'erlang:system_info(otp_release)' -s init stop

This command returns your current OTP version (e.g., “27.3.4.17”).

Step 2: Check ASN.1 Module Version

erl -eval 'application:load(asn1), application:get_key(asn1, vsn)' -s init stop

Step 3: Compare Against Patched Versions

If your version is earlier than the patched releases listed above, your system is vulnerable.

Step 4: Identify Services Using TLS

Vulnerable services include:

• Any Erlang application using ssl module for TLS connections
• Services accepting client certificates (mutual TLS)
• Services connecting to external TLS endpoints
• Distributed Erlang nodes using TLS for inter-node communication

Technical Root Cause

How the BER OID Decoder Works

OBJECT IDENTIFIERs in ASN.1 are encoded as a sequence of numeric arcs (subidentifiers). The first two arcs are encoded as a single byte, while subsequent arcs use a base-128 variable-length encoding with continuation bits.

For example, the OID 1.2.840.113549.1.1.1 (RSA encryption) encodes as:

• First two arcs: 0x2A (represents 1.2)
• Remaining arcs: variable-length base-128 encoded

The vulnerable decoder accumulates each subidentifier using this algorithm:

% Simplified vulnerable pattern
dec_subidentifiers(Bytes, Acc, Result) ->
    case Bytes of
        [H|T] when H >= 128 ->
            % Continuation byte - accumulate with bit shift
            NewAcc = (Acc << 7) + (H band 127),
            dec_subidentifiers(T, NewAcc, Result);
        [H|T] ->
            % Final byte - complete the subidentifier
            FinalValue = (Acc << 7) + H,
            dec_subidentifiers(T, 0, [FinalValue|Result]);
        [] ->
            lists:reverse(Result)
    end.

The Algorithmic Complexity Flaw

The vulnerability emerges when processing a subidentifier with many continuation bytes. Each iteration performs:

1. A bit shift operation: Acc << 7
2. An addition: (Acc << 7) + (H band 127)

In Erlang, integers have arbitrary precision. When Acc becomes very large (after many iterations), the bit shift and addition operations on large integers become computationally expensive. The cost grows quadratically with the number of continuation bytes.

Why Quadratic? Each bit shift operation on an N-bit integer takes O(N) time. With M continuation bytes, the total work is:

Iteration 1: shift 7-bit number   = O(7)
Iteration 2: shift 14-bit number  = O(14)
Iteration 3: shift 21-bit number  = O(21)
...
Iteration M: shift 7M-bit number  = O(7M)
Total: O(7 + 14 + 21 + ... + 7M) = O(M²)

Why Quadratic Complexity Creates DoS Conditions

A single OID with a 262 KB subidentifier (approximately 2,097,152 continuation bytes) requires:

• Iterations: 2,097,152
• Final integer size: ~14.7 million bits
• CPU time: ~13 seconds on standard hardware
• Memory: Significant temporary allocation for large integer operations

During this time, the Erlang scheduler is blocked processing the single OID, preventing other operations. In a TLS handshake, this occurs before the connection is established, allowing an attacker to exhaust server resources with minimal bandwidth.

Real-World Performance Impact Examples

Scenario 1: Single Attack Connection

• Attacker sends one TLS ClientHello with malicious certificate
• Server begins TLS handshake, parses certificate OID
• Decoder consumes 13 seconds of CPU
• Connection timeout occurs after 30 seconds
• Server CPU utilization: 100% for 13 seconds

Scenario 2: Multiple Concurrent Attacks

• Attacker sends 10 simultaneous connections
• Each triggers 13-second CPU consumption
• Total CPU time: 130 seconds across 10 cores
• Service becomes unresponsive to legitimate traffic
• Cascading failures in dependent services

Scenario 3: Load-Balanced Environment

• Attack targets all servers in a load-balanced pool
• Each server experiences CPU exhaustion
• Load balancer marks servers as unhealthy
• Remaining capacity insufficient for legitimate traffic
• Service degradation or complete outage

Attack Vectors and Exploitation

TLS Handshake Exploitation Method

The primary attack vector exploits the TLS handshake process:

Attack Steps:

1. Attacker crafts malicious certificate containing an OID with a large subidentifier (262+ KB of continuation bytes)
2. Attacker initiates TLS connection to target service, sending ClientHello
3. Target server responds with ServerHello and requests client certificate (or sends its own)
4. Attacker sends malicious certificate in the TLS handshake
5. Server’s ASN.1 decoder processes the OID, consuming 13+ seconds of CPU
6. Server becomes unresponsive during this period
7. Attack repeats with multiple concurrent connections to amplify impact

The attacker doesn’t need to complete the handshake or provide a valid certificate—the vulnerability triggers during parsing.

Mutual-TLS Attack Scenarios

Mutual TLS (mTLS) configurations are particularly vulnerable because:

1. Server parses client certificates before verifying trust
2. Client parses server certificates before verifying trust
3. Both directions can be exploited

Attack Scenario:

• Attacker connects to mTLS service
• Service requests client certificate
• Attacker sends malicious certificate
• Service’s decoder is blocked for 13+ seconds
• Legitimate clients experience timeout

Alternatively:

• Attacker compromises or spoofs a server endpoint
• Legitimate clients connect to attacker’s server
• Attacker sends malicious server certificate
• Client’s Erlang application hangs during TLS handshake
• Application becomes unresponsive

Why Unauthenticated Access is Critical

This vulnerability is particularly dangerous because:

• No authentication required: Attacker doesn’t need valid credentials
• No trust chain required: Certificate doesn’t need to be signed by a trusted CA
• No prior relationship: Attacker can target any exposed TLS endpoint
• No rate limiting by default: Most services accept multiple simultaneous connections

An attacker can exploit this vulnerability against any Erlang service with TLS enabled, regardless of security posture.

Attack Prerequisites and Ease of Execution

Minimal Prerequisites:

1. Network access to target’s TLS port (typically 443, 8443, or custom port)
2. Ability to generate a certificate with a malicious OID (trivial with OpenSSL)
3. Standard TLS client library

Proof of Concept:

# Generate a certificate with malicious OID
# (Simplified example - actual exploitation requires crafted DER encoding)
openssl req -new -x509 -keyout key.pem -out cert.pem \
  -subj "/CN=attacker" -days 365
# Connect to target with malicious certificate
openssl s_client -connect target.example.com:443 \
  -cert cert.pem -key key.pem

Ease of Execution: Low technical sophistication required. Automated tools could easily generate and deploy attacks at scale.

Business and Operational Impact

Service Availability Risks

The primary impact of CVE-2026-65634 is denial of service through resource exhaustion:

• Complete service outage: All TLS connections blocked during attack
• Cascading failures: Dependent services timeout waiting for responses
• Extended recovery time: Services may require manual intervention to restore
• Reputation damage: Customers experience unexpected unavailability

CPU Consumption Consequences

Each attack connection consumes:

• 13+ seconds of CPU time on a single core
• 100% CPU utilization during exploitation
• Memory pressure from large integer operations
• Scheduler starvation preventing other operations

Impact on Multi-Core Systems:

• 4-core system: 4 simultaneous attacks = complete CPU saturation
• 16-core system: 16 simultaneous attacks = complete CPU saturation
• Attacker can easily generate sufficient concurrent connections

Cascading Failure Potential

Services relying on Erlang/OTP may experience cascading failures:

1. Direct impact: TLS-dependent services become unresponsive
2. Secondary impact: Services depending on TLS services timeout
3. Tertiary impact: Load balancers mark services unhealthy
4. Quaternary impact: Failover mechanisms activate, potentially overloading remaining capacity

Example Cascade:

API Gateway (Erlang/OTP) ← TLS Attack
    ↓ (becomes unresponsive)
Microservices (timeout waiting for gateway)
    ↓ (queue requests, exhaust memory)
Message Queue (backs up)
    ↓ (becomes unavailable)
Dependent Applications (fail)

Industries and Use Cases Most Affected

High-Risk Sectors:

• Financial Services: Trading platforms, payment processors, banking APIs
• Healthcare: Patient data systems, medical device communication
• Telecommunications: Network infrastructure, VoIP systems
• Cloud Providers: Erlang-based infrastructure (e.g., RabbitMQ, ejabberd)
• Real-Time Systems: Messaging platforms, IoT backends, gaming servers

Specific Use Cases:

• RabbitMQ: Message broker using Erlang/OTP
• ejabberd: XMPP server for instant messaging
• Riak: Distributed database
• WhatsApp infrastructure: Built on Erlang/OTP
• Custom Erlang applications: Any service using ssl module

Detection and Monitoring

CPU Usage Pattern Analysis During TLS Handshakes

Implement monitoring to detect abnormal CPU patterns during TLS operations:

Detection Indicators:

1. Sudden CPU spikes during TLS handshake phase
2. Sustained high CPU (13+ seconds) on single connection
3. Multiple simultaneous spikes correlating with connection attempts
4. CPU usage not returning to baseline after connection timeout

Monitoring Implementation:

% Example: Monitor CPU usage during TLS operations
monitor_tls_cpu() ->
    InitialCPU = erlang:statistics(runtime),
    % TLS handshake occurs here
    {_, CPUTime} = erlang:statistics(runtime),
    case CPUTime > 13000 of  % 13 seconds in milliseconds
        true -> alert("Potential CVE-2026-65634 exploitation");
        false -> ok
    end.

Baseline Metrics:

• Normal TLS handshake: 50-500ms CPU time
• Legitimate complex certificates: <2 seconds CPU time
• Attack pattern: >13 seconds CPU time on single connection

Log Analysis for Suspicious OID Requests

Monitor Erlang/OTP logs for ASN.1 decoding anomalies:

Log Patterns to Watch:

% Erlang error logs indicating ASN.1 issues
=ERROR REPORT==== [timestamp] ===
asn1 decoding error: {error, {asn1, {invalid_oid, ...}}}
% Connection logs showing incomplete handshakes
=INFO REPORT==== [timestamp] ===
TLS connection from [IP] failed during certificate parsing
% Performance logs showing slow operations
=WARNING REPORT==== [timestamp] ===
Slow operation detected: asn1 decoding took 13000ms

Log Analysis Strategy:

1. Correlate TLS connection attempts with CPU spikes
2. Identify source IPs initiating connections before CPU spikes
3. Track failed handshakes from same source
4. Alert on repeated patterns from single IP

IDS/IPS Detection Strategies

Network-based detection can identify attack patterns:

IDS Signatures:

# Detect TLS ClientHello with suspicious certificate
alert tls any any -> any any (
    msg:"Potential CVE-2026-65634 exploitation attempt";
    tls.cert_subject contains "CN=";
    tls.cert_validity_notbefore < 2024-01-01;
    threshold: type both, track by_src, count 5, seconds 60;
    sid:1000001;
)
# Detect multiple failed TLS handshakes from same source
alert tcp any any -> any [443,8443] (
    msg:"Multiple TLS handshake failures - possible DoS";
    flow:established;
    content:"TLS";
    threshold: type both, track by_src, count 10, seconds 30;
    sid:1000002;
)

Detection Challenges:

• Legitimate certificates may have large OIDs
• Encrypted TLS traffic limits payload inspection
• Need baseline of normal certificate sizes for your environment

Baseline Metrics for Normal vs. Attack Behavior

Establish baseline metrics specific to your environment:

Remediation Strategy

Patch Versions and Upgrade Paths

Immediate Action: Upgrade to patched versions

Patched Versions:

• OTP 27.x: Upgrade to 27.3.4.18 or later
• OTP 28.x: Upgrade to 28.5.0.7 or later
• OTP 29.x: Upgrade to 29.1.1 or later
• OTP 26.x and earlier: Upgrade to OTP 27.3.4.18 minimum

Upgrade Path Recommendations:

Current Version → Recommended Target → Timeline
─────────────────────────────────────────────────
OTP 26.x        → OTP 27.3.4.18+    → Immediate
OTP 27.0-27.3.4.17 → OTP 27.3.4.18+ → Immediate
OTP 28.0-28.5.0.6  → OTP 28.5.0.7+  → Immediate
OTP 29.0-29.1.0    → OTP 29.1.1+    → Immediate
OTP 29.1.1+     → No action needed  → Monitor

Testing Patched Versions in Your Environment

Pre-Production Testing:

1. Set up test environment mirroring production configuration
2. Deploy patched OTP version
3. Run application test suite to verify compatibility
4. Perform load testing to ensure performance
5. Test TLS functionality with various certificate types
6. Validate dependent services still function correctly

Testing Checklist:

□ Application starts without errors
□ All TLS connections establish successfully
□ Certificate validation works correctly
□ Performance metrics within acceptable range
□ No memory leaks detected
□ Dependent services communicate correctly
□ Failover mechanisms function properly
□ Monitoring and alerting still operational

Rollout Timeline Recommendations

Recommended Rollout Schedule:

Accelerated Timeline (High-Risk Environments):

• Financial services, healthcare, critical infrastructure
• Complete rollout within 48-72 hours
• Accept higher risk of issues in exchange for faster patching

Compatibility Considerations

Potential Compatibility Issues:

1. Erlang/OTP version compatibility with existing code

• Review release notes for breaking changes
• Test with your specific application version

1. ASN.1 module updates may affect certificate handling

• Validate with your certificate types
• Test mutual TLS if applicable

1. Performance changes from patched decoder

• Monitor CPU usage post-upgrade
• Compare with baseline metrics

1. Distributed Erlang nodes with mixed versions

• Upgrade all nodes to same version
• Plan for brief service interruption during rolling upgrade

Compatibility Testing:

% Test certificate parsing with patched version
test_certificate_parsing() ->
    {ok, CertData} = file:read_file("test_cert.pem"),
    {ok, DecodedCert} = public_key:pem_decode(CertData),
    % Verify parsing completes quickly
    {Time, Result} = timer:tc(fun() -> 
        public_key:pkix_decode_cert(DecodedCert, otp)
    end),
    case Time > 1000000 of  % 1 second
        true -> {error, "Certificate parsing too slow"};
        false -> {ok, Result}
    end.

Interim Mitigation Measures

While preparing for patching, implement interim protections:

Rate Limiting on TLS Connections

Limit the rate of new TLS connections from single sources:

Implementation Options:

1. Firewall-level rate limiting:

# iptables example (Linux)
iptables -A INPUT -p tcp --dport 443 -m limit \
  --limit 10/minute --limit-burst 20 -j ACCEPT
iptables -A INPUT -p tcp --dport 443 -j DROP

1. Load balancer configuration:

# Example: HAProxy rate limiting
frontend tls_frontend
    bind *:443 ssl crt /path/to/cert.pem
    rate-limit sessions 100  # Max 100 concurrent sessions
    default_backend tls_backend

1. Erlang application-level:

% Rate limit new connections
-module(tls_rate_limiter).
init() ->
    ets:new(connection_tracker, [named_table, public]),
    ok.
check_rate_limit(ClientIP) ->
    Now = erlang:system_time(second),
    Key = {ClientIP, Now},
    case ets:lookup(connection_tracker, ClientIP) of
        [{_, Count, Timestamp}] when Now - Timestamp < 60 ->
            case Count > 10 of  % Max 10 connections per minute
                true -> {error, rate_limited};
                false -> 
                    ets:insert(connection_tracker, {ClientIP, Count+1, Timestamp}),
                    ok
            end;
        _ ->
            ets:insert(connection_tracker, {ClientIP, 1, Now}),
            ok
    end.

Effectiveness: Reduces attack impact by limiting concurrent connections, but doesn’t prevent exploitation entirely.

Connection Timeout Configuration

Reduce TLS handshake timeout to minimize impact:

Erlang SSL Configuration:

% Reduce handshake timeout from default 5 minutes to 30 seconds
SSLOptions = [
    {handshake_timeout, 30000},  % 30 seconds in milliseconds
    {versions, ['tlsv1.2', 'tlsv1.3']},
    {ciphers, ssl:cipher_suites(default, 'tlsv1.3')}
],
ssl:listen(443, SSLOptions).

Impact:

• Connections timeout after 30 seconds instead of 5 minutes
• Reduces total CPU consumption per attack
• May cause legitimate slow connections to fail

Network-Level Protections

Implement at network perimeter:

1. Connection state tracking:

• Monitor for incomplete TLS handshakes
• Alert on high rate of failed handshakes from single IP

1. Geo-blocking:

• Restrict TLS connections to expected geographic regions
• Reduces attack surface if applicable

1. DDoS mitigation:

• Enable DDoS protection on TLS ports
• Automatically rate-limit suspicious traffic patterns

1. WAF/IPS rules:

• Deploy rules detecting TLS handshake anomalies
• Block IPs with repeated failed connections

Temporary Workarounds Before Patching

Short-term mitigations:

1. Disable mutual TLS if not required

• Reduces attack surface by 50%
• Requires client certificate validation to be optional

1. Restrict TLS to known IPs if possible

• Whitelist legitimate client IPs
• Block all other TLS connections

1. Use reverse proxy with TLS termination

• Proxy handles TLS, forwards to Erlang backend
• Proxy can implement rate limiting and timeouts
• Example: nginx, HAProxy, AWS ALB

1. Implement circuit breaker for TLS connections

• Automatically reject new connections if CPU high
• Prevents cascading failures
• Allows legitimate traffic through

% Circuit breaker implementation
-module(tls_circuit_breaker).
check_cpu_threshold() ->
    {_, CPUUsage} = erlang:statistics(runtime),
    CPUPercent = (CPUUsage / erlang:system_info(cpu_quota)) * 100,
    case CPUPercent > 80 of
        true -> {error, circuit_open};  % Reject new connections
        false -> ok
    end.

Verification and Validation

How to Confirm Your Systems are Patched

Verification Steps:

1. Check OTP version:

erl -eval 'erlang:system_info(otp_release)' -s init stop

Expected output for patched systems:

• 27.3.4.18 or later
• 28.5.0.7 or later
• 29.1.1 or later

1. Check ASN.1 module version:

erl -eval 'application:load(asn1), application:get_key(asn1, vsn)' -s init stop

Expected output:

• 5.3.4.3 or later
• 5.4.3.1 or later
• 5.5.2 or later

1. Verify in running system:

% In Erlang shell
application:load(asn1),
application:get_key(asn1, vsn).

Testing for Vulnerability Presence

Vulnerability Test (Use with Caution):

% Test if system is vulnerable to CVE-2026-65634
% WARNING: This test may cause CPU spike on vulnerable systems
test_vulnerability() ->
    % Create a malicious OID with large subidentifier
    % This is a simplified test - actual exploitation requires proper DER encoding
    % Measure time to decode a large OID
    StartTime = erlang:system_time(millisecond),
    % Attempt to decode malicious OID
    % (Actual implementation requires crafted DER bytes)
    EndTime = erlang:system_time(millisecond),
    DecodeTime = EndTime - StartTime,
    case DecodeTime > 5000 of  % >5 seconds indicates vulnerability
        true -> {vulnerable, DecodeTime};
        false -> {patched, DecodeTime}
    end.

Safe Testing Approach:

1. Test in isolated environment only
2. Have rollback plan ready
3. Monitor system resources during test
4. Stop test immediately if CPU exceeds 90%

Post-Patch Validation Procedures

Validation Checklist:

Immediate Post-Patch (First Hour)
□ Application started successfully
□ No error messages in logs
□ TLS connections establishing normally
□ CPU usage within normal range
□ Memory usage stable
□ Dependent services responding
Short-Term Validation (First Day)
□ All TLS endpoints responding
□ Certificate validation working correctly
□ Performance metrics normal
□ No increase in error rates
□ Monitoring and alerting functional
□ Backup systems operational
Medium-Term Validation (First Week)
□ No performance degradation observed
□ No memory leaks detected
□ All features functioning normally
□ No unexpected errors in logs
□ Failover mechanisms tested
□ Disaster recovery procedures verified
Long-Term Validation (Ongoing)
□ Continued monitoring for anomalies
□ Regular security updates applied
□ Patch management process documented
□ Team trained on vulnerability
□ Incident response plan updated

Performance Validation:

% Compare performance before and after patch
validate_performance() ->
    % Measure TLS handshake time
    {Time, _Result} = timer:tc(fun() ->
        ssl:connect("example.com", 443, [])
    end),
    % Should be <500ms for normal certificates
    case Time > 500000 of  % 500ms in microseconds
        true -> {warning, "TLS handshake slower than expected"};
        false -> {ok, "Performance acceptable"}
    end.

Frequently Asked Questions

What is CVE-2026-65634 and how does it work?

CVE-2026-65634 is a denial-of-service vulnerability in Erlang/OTP’s ASN.1 OBJECT IDENTIFIER decoder. It exploits quadratic algorithmic complexity in the BER OID decoding process. When processing an OID with a large subidentifier (containing many continuation bytes), the decoder performs bit shift and addition operations on increasingly large integers, consuming exponential CPU time. An attacker can craft a malicious OID with approximately 262 KB of continuation bytes, causing the decoder to consume 13+ seconds of CPU time. This occurs during TLS handshake certificate parsing, before any authentication or trust verification, allowing unauthenticated remote exploitation.

Which Erlang/OTP versions are vulnerable?

The following versions are vulnerable:

• OTP 17.0 through 27.3.4.17
• OTP 28.0 through 28.5.0.6
• OTP 29.0 through 29.1.0

Patched versions are:

• OTP 27.3.4.18 or later
• OTP 28.5.0.7 or later
• OTP 29.1.1 or later

Check your version with: erl -eval 'erlang:system_info(otp_release)' -s init stop

Can this vulnerability be exploited without authentication?

Yes. This is one of the most dangerous aspects of CVE-2026-65634. The vulnerability occurs during TLS certificate parsing, which happens before any authentication or trust verification. An attacker can:

• Connect to any TLS port without credentials
• Send a malicious certificate in the TLS handshake
• Trigger the vulnerable decoder without completing the handshake
• Cause CPU exhaustion without any prior relationship with the target

No authentication, valid certificate, or trust chain is required.

What is the primary impact of this vulnerability?

The primary impact is denial of service through CPU exhaustion. A single attack connection can consume 13+ seconds of CPU time, making the service unresponsive to legitimate traffic. Multiple concurrent attacks can completely saturate server resources, causing:

• Complete service outage
• Cascading failures in dependent services
• Extended recovery time
• Reputation damage

The vulnerability affects availability, not confidentiality or integrity.

How do I know if my systems are affected?

1. Check OTP version: erl -eval 'erlang:system_info(otp_release)' -s init stop
2. Compare against patched versions (27.3.4.18+, 28.5