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.
}
$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 AttacksDetection 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
# 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

