Skip to main content
Vulnerability Database/CVE-2026-103651

CVE-2026-103651: MISP HOTP Auth Bypass Vulnerability

CVE-2026-103651 is an authentication bypass flaw in MISP that allows replay of consumed HOTP tokens and counter rewinding. This post explains its impact, affected versions, and mitigation steps.

Published:

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

CVE-2026-103651 Overview

CVE-2026-103651 is an authentication flaw in MISP, the open-source threat intelligence platform, affecting the one-time password (OTP) verification flow. The HOTP (HMAC-based One-Time Password) paper token logic compares submitted tokens against a counter cached in the user session rather than the authoritative counter persisted in the database. An attacker who already holds a session with a completed password step can replay a previously consumed HOTP token to pass the second factor and rewind the server-side counter state. The flaw maps to [CWE-287: Improper Authentication] and affects MISP versions prior to 2.5.48.

Critical Impact

Attackers who possess any valid HOTP paper token value and a password-authenticated session can bypass second-factor authentication and corrupt the HOTP counter, enabling repeated replays and invalidating subsequent legitimate tokens.

Affected Products

  • MISP (Malware Information Sharing Platform) versions prior to 2.5.48
  • Deployments using HOTP paper tokens as the second authentication factor
  • MISP user accounts with hotp_counter configured

Discovery Timeline

  • 2026-10-01 - CVE-2026-103651 published to the National Vulnerability Database
  • 2026-10-01 - Last updated in NVD database

Technical Details for CVE-2026-103651

Vulnerability Analysis

MISP implements two OTP mechanisms for second-factor authentication: time-based OTP (TOTP) and HMAC-based OTP (HOTP) delivered via paper token lists. HOTP tokens are stateful — each consumed token increments a server-side counter so the same token cannot be reused.

The vulnerable UsersController logic reads the hotp_counter from the user record cached in the session at password-submission time. When the user later submits an OTP, verification runs against that cached counter value. After a successful HOTP consumption, the counter is incremented in the database, but the session-cached user array keeps the stale value. This allows a second verification using the same token to succeed against the unchanged cached counter.

Root Cause

The root cause is a stale-state read in a stateful authentication primitive. The HOTP verification uses $user['hotp_counter'] sourced from Session-cached data rather than reloading the authoritative counter from the database before each verification attempt. The verifier also does not re-check that the token being accepted has not already been burned.

Attack Vector

Exploitation requires an attacker who (1) controls a MISP user session that has completed the password step but not the OTP step, and (2) possesses at least one HOTP token value (for example, a photograph of a paper token list). The attacker submits the already-consumed token, and the server validates it against the stale cached counter. Each replay succeeds without advancing the database counter beyond its first increment, enabling repeated authentication and desynchronizing the counter from legitimate tokens the user still holds.

php
            }
            $secret = $user['totp'];
            $totp = \OTPHP\TOTP::create($secret);
-            $hotp = \OTPHP\HOTP::create($secret);
            if ($totp->verify(trim($this->request->data['User']['otp']))) {
                // OTP is correct, we login the user with CakePHP
+                $this->Session->delete('otp_user');
                $this->Auth->login($user);
                $this->_postlogin();
-            } elseif (isset($user['hotp_counter']) && $hotp->verify(trim($this->request->data['User']['otp']), $user['hotp_counter'])) {
-                // HOTP is correct, update the counter and login
-                $this->User->id = $user['id'];
-                $this->User->saveField('hotp_counter', $user['hotp_counter']+1);
+            } elseif (isset($user['hotp_counter']) && $this->__consumeHotp($user['id'], trim($this->request->data['User']['otp']))) {
+                $this->Session->delete('otp_user');
                $this->Auth->login($user);
                $this->_postlogin();
            } else {

Source: MISP commit f34aee2c7. The patch replaces the inline HOTP verification against the session-cached counter with a __consumeHotp() helper that reads the authoritative counter from the database and burns the token atomically. The pending OTP session (otp_user) is also deleted on success to prevent reuse of the password-authenticated session.

Detect Identity Attacks the Moment Authentication Fails

Singularity™ Identity surfaces credential misuse, lateral movement, and privilege escalation in real time, so you can contain the breach before it spreads.

Stop Identity Attacks

Detection Methods for CVE-2026-103651

Indicators of Compromise

  • Multiple successful authentications for the same user account within a short window using identical OTP token values
  • MISP audit log entries showing repeated login success events without corresponding hotp_counter database increments
  • User reports of previously valid paper tokens being rejected as the counter desynchronizes
  • Login sessions where the OTP submission phase occurs more than once from the same session identifier

Detection Strategies

  • Compare MISP application logs for consecutive _postlogin() events per user and correlate with database state changes on the users.hotp_counter column
  • Alert on any case where the delta between the submitted OTP acceptance count and the stored counter increments is greater than one
  • Monitor for authentication events where the OTP step completes multiple times against the same Session identifier

Monitoring Recommendations

  • Enable MISP's full audit logging and forward authentication events to a centralized SIEM for correlation
  • Baseline the normal rate of HOTP counter increments per user and alert on anomalies
  • Review web server access logs for repeated POST requests to the login OTP endpoint from the same session cookie

How to Mitigate CVE-2026-103651

Immediate Actions Required

  • Upgrade MISP to version 2.5.48 or later, which replaces the vulnerable verification path with the __consumeHotp() helper that reads the authoritative counter from the database
  • Audit recent authentication logs for any user with HOTP enabled to identify potential replay activity
  • Rotate HOTP paper token lists for any user whose counter state appears desynchronized or where replay is suspected

Patch Information

The fix is published in MISP commit f34aee2c7 and included in release 2.5.48. The patch introduces a __consumeHotp() method that performs HOTP verification against the stored counter and atomically burns the token. It also clears the pending otp_user session entry on successful authentication so the password-authenticated pre-OTP session cannot be replayed.

Workarounds

  • Temporarily disable HOTP paper-token second-factor authentication and require TOTP (authenticator app) for all users until the upgrade is applied
  • Shorten MISP session lifetimes to reduce the window in which a password-authenticated, OTP-pending session can be abused
  • Enforce network-level access controls (VPN or IP allowlisting) in front of the MISP login interface to limit attacker reach
bash
# Upgrade MISP to the fixed release
cd /var/www/MISP
sudo -u www-data git fetch origin
sudo -u www-data git checkout v2.5.48
sudo -u www-data git submodule update --init --recursive
sudo systemctl restart apache2

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

Experience the Most Advanced Cybersecurity Platform

See how the world’s most intelligent, autonomous cybersecurity platform can protect your organization today and into the future.