betaFeedback

WorksComputer Science

Hello Again: Exploiting Replay Protected Monotonic Counters to Brute-Force Windows Hello PINs

Abstract

Windows Hello is the primary authentication mechanism on over one billion Windows 11 devices, supporting PINs as short as four digits. Such low-entropy PINs are viable only because the TPM's anti-hammering protection mitigates brute-force attacks. Most modern x86 platforms rely on firmware TPMs (fTPMs) that persist their non-volatile (NV) state, including the lockout state, to SPI flash. On newer platforms, rollback prevention of this state is delegated to the flash chip via Replay Protected Monotonic Counters (RPMCs), a JEDEC-standardized mechanism operating over a physically accessible bus. We present the first practical security analysis of RPMC in shipping x86 systems. Using low-cost interposer hardware, we identify multiple implementation flaws, two of which fundamentally undermine RPMC's security model: First, Winbond SPI flash - the leading NOR flash vendor with over 25% market share - leaks its HMAC key under voltage glitching, enabling arbitrary counter forgery. Second, AMD's NV controller does not verify RPMC increments, so an interposer can suppress them unnoticed. Moreover, AMD platforms without RPMC flash appear to lack NV rollback protection altogether: on two AMD desktops, reflashing an old image resets the fTPM's lockout counters. Both flaws enable rollbacks of the fTPM's NV state (AMD, Intel, or Pluton), including its lockout counters. We demonstrate this end-to-end on locked, encrypted hardware: our setup finds a 4-digit Windows Hello PIN in 40 hours instead of 69 days. A compromised PIN also grants access to device-bound keys and Hello-based enterprise SSO. The same primitive defeats BitLocker's TPM+PIN pre-boot protector, reducing the worst-case time for a default-length 6-digit PIN from 19 years to 20 days.

CCS Concepts

• Security and privacy → Hardware attacks and countermeasures; Authentication.

ACM Reference Format:

Christian Werling, Matti Finder, Hans Niklas Jacob, Julian Prein, Niclas Kühnapfel, and Jean-Pierre Seifert. 2026. Hello Again: Exploiting Replay Protected Monotonic Counters to Brute-Force Windows Hello PINs. In Proceedings of the 2026 ACM SIGSAC Conference on Computer and Communications Security (CCS ’26), November 15–19, 2026, The Hague, Netherlands. ACM, New York, NY, USA, 16 pages. https://doi.org/10.1145/3830454.3846631

This work is licensed under a Creative Commons Attribution 4.0 International License. CCS ’26, The Hague, Netherlands

© 2026 Copyright held by the owner/author(s).

ACM ISBN 979-8-4007-2871-6/2026/11

https://doi.org/10.1145/3830454.3846631

Introduction

While user authentication on PCs traditionally revolved around passwords, smartphones have commoditized biometrics and short numeric PINs to authenticate a variety of operations, from unlocking the screen to auto-filling passwords to issuing payments. In order to protect low-entropy PINs from the brute-force attacks of the earlier smartphone generations [1, 7, 9], Apple, Google, and Samsung have built dedicated hardware and multi-layered software systems around PIN authentication [4, 17, 27, 48]. They all employ escalating timeouts after failed verification attempts, some even allowing permanent lockouts after a number of incorrect PINs, and the option to wipe sensitive data altogether. Despite such measures, previous research has shown that even standardized hardware-based implementations are not immune to protocol or hardware vulnerabilities [8, 12, 13].

Windows Hello aims to close this security and usability gap on PCs and offers PINs as short as 4 numeric digits as the primary authentication method or as a fallback for biometrics. Along with Windows Hello for Business, Hello is advertised as the central authentication method, beyond unlocking the laptop, that also authenticates the use of other device-bound credentials and serves as a Single Sign-On (SSO) provider for enterprises. Microsoft needs to secure these PINs equally, but across a much broader set of hardware than smartphone vendors do. Hello documentation claims that the (in Windows 11 mandated) TPM 2.0 makes Windows Hello PINs “anti-hammering” protected and hardware-bound, thwarting brute-force and phishing attacks, respectively [33]. Previous research on Hello has already shown that its protection without a TPM is inadequate [2, 15, 18, 26]. Therefore, Hello relies on PIN-authorized TPM sealing to protect the user’s private key material used for the above-listed authentication features. TPM 2.0’s “Dictionary Attack Protection” [51 16.8] is the critical technology to, by default, employ a 32 try limit across reboots that re-enables one try every 10 minutes [36].2

While premium laptops have traditionally opted for dTPMs in the past, possibly due to better on-paper security or regulatory requirements [43], dTPMs suffer from an exposed bus allowing passive attackers to sniff sensitive data [3, 44] and active attackers to mount reset attacks [25, 54]. A more popular type of TPM implementation now is firmware TPMs (fTPMs). These run in Trusted Execution Environments (TEEs), either on the CPU’s security coprocessors (AMD PSP, Intel CSME), or in an isolated execution layer of the main core (Qualcomm QTEE/QSEE on TrustZone), making their communication with the x86 client application much harder for attackers to inspect. In 2024, Microsoft adopted this trend and collaborated with SoC vendors to integrate a custom coprocessor, Microsoft Pluton, that is envisioned to act as a key storage provider for Windows, but can also act as an fTPM [40]. Microsoft requires it on all Copilot+-certified laptops [29, 35]. However, in July 2026, Microsoft’s documentation silently added a phase-out notice to Pluton’s fTPM functionality on AMD and Qualcomm [45], falling back to the vendor’s firmware TPM (as was already the case on Intel) or a discrete TPM. Previous work has shown that fTPMs may be compromised via side channels [41] or through a compromise of their host security processor [22]. However, we identified another threat vector: To persist their state across reboots, fTPMs store it along with other non-volatile (NV) data on SPI flash. This data is encrypted and integrity protected via device-unique keys used by AMD’s and Intel’s NV controllers [21, 22]. While the data, therefore, cannot be inspected or altered by an attacker with access to SPI flash under normal circumstances, they could still save the ciphertexts and replay them. Microsoft seems well aware that platform vendors like AMD and Intel must secure their NV controllers from such rollback attacks by explicitly requiring rollback protection in both their Windows 10 and Windows 11 hardware compatibility programs [30, 31]. Nonetheless, we have not found any practical research on the security of these.

Replay Protected Monotonic Counters. SPI flash has evolved over the years to deliver NOR flash content at ever-increasing speeds. NV controllers loading firmware code and data usually employ code-signing mechanisms to provide secure boot: loading and executing only trusted software. “Replay Protected Monotonic Counter” (RPMC) is an additional JEDEC specification that extends SPI flash with security counters. Our research shows that systems with RPMC use it to secure fTPM and other non-volatile storage of AMD’s, Intel’s, and Microsoft’s own fTPM.

Contributions

This paper presents the first public security analysis of both RPMC controllers and flash chips deployed in shipping x86 systems. Assuming physical access, we evaluate attacks on the SPI bus used

for RPMC communication, both towards the SPI flash and the SPI controller.

  • First security evaluation of three RPMC flash vendors: Winbond, Macronix, GigaDevice (Section 3):

    • Integer Overflow: On Winbond, Macronix, and GigaDevice, an increment to the maximum integer value leads to overflows of the counters, contradicting RPMC’s monotonicity (minor impact).

    • Counter Corruption: On GigaDevice flash, voltage glitching allows manipulation of returned RPMC counter values (minor impact).

    • HMAC Key Leak: On Winbond flash, voltage glitching leaks valid RPMC signatures and, more critically, the authentication keys (major impact, see below).

  • First security evaluation of the dominant x86 vendors’ NV controllers (Intel, AMD) with and without RPMC (Section 4):

    • Naive Rollback: All tested Intel NV controllers and all RPMC-backed AMD NV controllers withstand naive rollbacks of the flash contents (including fTPM state); two AMD systems (Zen 2 and Zen 5) without RPMC-capable flash do not (major impact).

    • HMAC Key Reuse: Intel’s RPMC-based NV controllers reuse the same Key Data across all counters and sessions, weakening counter authentication (minor impact).

    • Unverified Increment: AMD’s RPMC-based NV controllers do not verify increment success (major impact, see below).

  • NV-state rollback, rendering fTPM Dictionary Attack Protection ineffective, confirmed end-to-end against live targets via two independent attack paths using a custom, low-cost SPI hardware interposer (Section 4.5): AMD’s Unverified Increment on an HP OmniBook 3 and Winbond’s HMAC Key Leak on a Framework Laptop 13.

  • End-to-end attack against Windows Hello: PIN brute-forcing demonstrated on an AMD laptop at around 4.14 tries/minute, resulting in a worst-case time of 40 hours for a 4-digit numerical PIN (Section 5.2).

  • End-to-end attack against BitLocker: PIN brute-forcing demonstrated on an Intel laptop via the Winbond HMAC Key Leak rollback path at around 34.1 tries/minute, resulting in a worst-case time of 20 days for a default-length 6-digit PIN (Section 5.3).

Note: The two attack paths above are independent of the target application; we pair them with Windows Hello and BitLocker purely as two illustrative end-to-end proofs of concept.

Disclosure. We informed all directly and indirectly affected parties of these issues, i.e., Winbond, Macronix, GigaDevice, JEDEC, Intel, AMD, and Microsoft. Unfortunately, none of them has committed to fixing the root-cause vulnerabilities; only Microsoft announced a mitigating policy change, raising the recommended minimum Hello PIN length to 6 digits. Their detailed statements and remediation status are discussed in Section 6.

Background

Trusted Platform Modules

Trusted Platform Modules, as defined by the TPM 2.0 Library Specification, are a standard for cryptographic modules providing a variety of security features [50]. We will shortly cover its three most important features for this research:

2.1.1 Sealed Storage. TPM sealed storage allows the TPM to encrypt and integrity-protect an arbitrary data blob. This data can only be unsealed by the same TPM that created it and only when a set of release conditions is satisfied [51].

2.1.2 Policy Sessions. Policies are a TPM authorization mechanism that implements, e.g., the release conditions for TPM sealed storage. Each policy is represented by a cryptographic digest computed offline as the cumulative hash of a sequence of policy assertions. Software interfacing with the TPM always does so in the context of a policy session also represented by one or more policy digests. If one of these digests matches the policy digest of, e.g., a sealed storage, it serves as a valid authorization to unseal said storage. Policy digests in a policy session can be constructed by, e.g., entering a passphrase or measuring system state, or combined out of other policy digests. This allows policies to implement arbitrarily complex, cryptographically bound authorization policies [51].

2.1.3 Dictionary Attack Protection. The TPM enforces a hardware-level dictionary attack (DA) protection mechanism to limit exhaustive searches against authorization values (passphrases or PINs) stored on the device [51]. The lockout logic is governed by four 32-bit NV-persistent variables counting failed authorization attempts [51]. These can be configured in parameters such as their maxTries and recoveryTime, which determine after how many failed authorization attempts a Lockout Mode is entered and after what time a failed attempt is forgotten [51]. Setting the recoveryTime to a large value, e.g. 232−12^{32} - 1 seconds, allows entering an effectively permanent lockout.

2.1.4 Firmware TPMs. While it used to be common that TPMs were realized in dedicated chips connected to the SoC via an LPC or SPI bus (discrete TPMs or dTPMs), the industry now has largely shifted towards potentially more cost-effective firmware TPMs (fTPMs) running in security coprocessors. Moreover, despite AMD and Intel offering fTPMs by default in their SoCs, Microsoft started collaborating with SoC vendors to integrate a Microsoft-designed security core named Microsoft Pluton [35]. dTPMs suffer from a central vulnerability: their exposed bus towards the SoC. In that regard, fTPMs do not trivially expose their communication to the outside as their communication happens inside the SoC. However, in contrast to dTPMs, AMD’s, Intel’s, and Microsoft Pluton’s fTPMs do not have dedicated on-chip memory securely storing their non-volatile state. Instead, they rely on the SoC to provide them with non-volatile (NV) storage. Previous work on the AMD PSP and Intel CSME analyzed internals of how NV storage is implemented in these security coprocessors [22, 49]. On both platforms, the NV storage (including fTPM state) stores its data alongside the UEFI firmware on the SPI flash. To protect it from manipulation by an attacker with SPI access, its contents get encrypted and integrity protected using device-unique keys. Additionally, when the NV controller boots up, it must ensure that the NV state read from flash is the most recent one. Otherwise, features such as the fTPM Dictionary Attack Protection, which heavily rely on consistent state progression across reboots, are vulnerable to rollback attacks.

Replay Protected Monotonic Counters

RPMC is a specification of JEDEC for SPI flash devices that builds on top of the SPI bus protocol [24]. RPMC serves as an additional building block in securing the contents of said devices. Devices supporting this standard are extended with commands enabling the usage of multiple monotonic counters [24]. It is closely related to one part of another JEDEC specification: the Replay Protected Memory Block (RPMB) of eMMC [23].

Integration of RPMC has been an ongoing effort. The groundwork was a document by Intel in 2013 [20]; this document was later copied in 2021 to form the official JESD260 specification [24], making it the de facto standard way to extend flash chips with security counters. In recent times, support for these counters has been added to major open source projects like Coreboot3, but Tesla’s fork4 of it contained artifacts hinting at its usage for even longer. By now, RPMC is used in commercial off-the-shelf laptops to secure the NV state of TPMs and protect sensitive EFI variables (e.g., Secure Boot enabled) against rollback attacks. In combination with traditional code signing techniques, RPMC can also be used to prevent firmware rollback, but we were unable to find real-world examples as of now.

RPMC consists of five main commands; the regular command flow can be seen in Figure 1. To prove their authenticity, commands are appended with a Message Authentication Code, also called a signature within the specification, generated using HMAC with SHA256 as the underlying hash function [24]. RPMC uses two types of keys: the Root Key serves as the persistent pre-shared secret that authenticates users of a counter, and the HMAC Key serves as a temporary session key for an already authenticated party. Each counter’s Root Key can only be initialized once.5 After Root Key initialization, these counters start in the “HMAC key register uninitialized” state [24].

Figure 1. Per Counter RPMC Command Flow

Write Root Key Register. This command is used to initialize the Root Key of a specific counter. If successful, the selected counter is set to 0, and the Root Key is stored in the Root Key register of that counter [24].

Update HMAC Key Register. This command only works if the root-key register for the specific counter was populated. It is used to transmit 4 bytes of Key Data, which form the HMAC Key (HMAC of the Key Data using the Root Key), for the current session [24]. This HMAC Key is used by the controller to authenticate any further RPMC commands (Increment Monotonic Counter, Request Monotonic Counter, and also the Update HMAC Key Register itself) and by the chip itself to sign the data returned by Read Extended Status [24].

Increment Monotonic Counter. A successful execution of this command increments the selected counter by 1 [24]. A valid request requires including the current value of the selected counter to ensure that the request, and consequently, the signature, is always different on subsequent calls of this command.

Request Monotonic Counter. This command is used to prepare the retrieval of a selected counter value [24]. Each request includes a randomization Tag to prevent replay attacks. The Tag can be populated with any 12 bytes of data and will be echoed during the retrieval with Read Extended Status.

Read Extended Status. This command can be issued after previous commands to retrieve progress information or the requested counter value. The response signals the execution state of any previous RPMC command, indicating whether the chip is still busy, has successfully completed the command, or if an error (e.g., signature mismatch) occurred. When Request Monotonic Counter was issued beforehand, and the response indicates a success, the response includes three additional fields: Tag, Counter Value, and Signature.

Attacks & Threat Model

In the specification, JEDEC mentions, “The current definition of the Serial Flash does not offer any protection against HW attacks” [24]. JESD260 itself echoes this by requiring that increment operations be performed in a power glitch aware manner [24], a requirement Winbond’s datasheets reproduce almost verbatim [55]. As RPMC is introduced to fix this gap, the main threat model for these chips are attackers that already have physical access to a device containing such a chip.

Previous security research exists that targets a similar use of counters for RPMB, highlighting protocol weaknesses [8], exploitation with Chip-off techniques [13], and glitching possibilities using EMFI [12].

Windows Security

Disk Encryption

Full disk encryption is a well-established method to protect data at rest using industry-grade encryption; however, its security mainly depends on the encryption key used. Microsoft BitLocker is Windows’ built-in disk encryption software, allowing a transparent encryption of the main volume. An interplay of firmware-based Secure Boot (UEFI Secure Boot) and a TPM enables automatic decryption when firmware and the Windows bootloader are in known-good states, providing data security without additional friction for the user [34].

TPM+PIN. For higher security needs, BitLocker offers a TPM+PIN protector: in addition to the verification of the known-good states, the Windows Boot Manager prompts for a PIN that authorizes the TPM to Unseal the volume master key. This PIN is subject to the same Dictionary Attack Protection counters as Windows Hello (Section 2.1.3), but, unlike Hello, without any additional Windows-imposed try or timeout limit layered on top. On our test systems, the startup PIN had to be at least 6 digits; however, an administrator can lower this to a 4-digit floor by explicitly enabling and configuring the Configure minimum PIN length for startup policy [39].

Windows Hello

Once Windows has booted up, its lockscreen protects the – now unencrypted – Windows environment. Windows Hello is a more recent security feature by Microsoft introduced in Windows 10 and the only login type for online accounts on Windows 11 [5]. It manages the user’s access to “their identity provider, applications, and services” [32], including the use as a FIDO2 security key. In contrast to using a password to unlock the system and authenticate sensitive operations, Hello allows users to use a fingerprint or face recognition service for authentication [32]. Windows Hello for Business (WHFB) extends Windows Hello, which is local to the machine, with external identity providers [6]. It “provides enterprise-grade security and management capabilities, including device attestation, certificate-based authentication, and conditional access policies”. Notably, WHFB “is considered two-factor authentication” by Microsoft, signaling that no additional factors are needed [33].

With or without biometrics, Hello asks users to set up a numeric or alphanumeric PIN at least 4 digits long. While such a PIN may have much lower entropy than a traditional password, Microsoft claims that Windows Hello prevents brute-force attacks through the use of a TPM and by employing escalating timeouts [36]. In fact, “anti-hammering protection”, as Microsoft calls it, is active on two levels: The Windows lockscreen also employs a 5-try per boot limit before asking the user to reboot the system. Then, the device enters a lockout state that escalates with each subsequent failure cycle [37]. Microsoft claims that the Hello PIN entry is additionally protected by the TPM’s Dictionary Attack Protection (Section 2.1.3). This configures the TPM to lock after 32 authorization failures and to forget one authorization failure every 10 minutes [36]. According to our research, Microsoft does not allow permanent lockouts after a defined number of tries, neither for Windows Hello nor WHFB. However, businesses can adapt their PIN policies to require stronger PINs than the default 4-digit numeric PIN Microsoft allows [38].

Previous research on Windows Hello has shown that on devices without a TPM, Windows Hello’s authentication data is not properly protected [2, 18, 26]. While some research on WHFB sheds light on the inner workings of the authentication, others have developed specialized tools to assess PIN security over the network [15]. A qualitative study on Windows Hello in a small business found that while participants perceived it as more usable and responsive than traditional Windows authentication, they tended to prefer PINs over biometrics due to limited hardware support or being out of reach of the laptop [10].

Hardware Requirements. Windows 11 famously made the presence of a TPM mandatory [31]. However, TPMs were already the object of Windows 10’s Hardware Compatibility Program (HCP) [30]. It leaves open whether a discrete or firmware TPM must be available. However, some relevant changes to the document have happened to its underlying security assumptions since the oldest available version from 2015: While the first two versions (1511, 1607) do not require RPMC, version 1703 made RPMC for rollback prevention mandatory:

RPMC for non-discrete TPMs (consumer 16 MB parts) is a requirement for 2019. RPMC for UEFI (commercial 32 MB parts) is a requirement for 2020.

Versions 1709, 1803, and 1809 kept this phrasing until version 1903 (i.e., the version of March 2019) generalized this requirement shortly before it became effective:

Effective October 1, 2020 This requirement is Mandatory for platforms that support specific hardware capabilities for replay protection. Confidential & replay-protected storage: If a TPM uses external memory for non-volatile storage of TPM state (including seeds, proof values, & dictionary attack variables), movement of the TPM state to and from the NV memory should include protections of that data to ensure confidentiality and integrity of the data and to mitigate against rollback attacks. This is generally accomplished by encrypting the data, applying a Message Authentication Code, and storing the resulting record in replay-protected storage such as Replay Protected Memory Block (RPMB) or Replay Protected Monotonic Counter (RPMC).

While Windows 11’s HCP also leaves open which rollback prevention method is used, it makes it mandatory for specific platforms only [31]:

  1. Intel platforms with Intel PTT firmware version 600.* or higher.

  2. AMD platforms with Zen 2 (4000 series) or newer.

  3. Qualcomm platforms with RPMB-capable storage.

Regarding Microsoft’s own fTPM, Microsoft Pluton, the document specifies that certain AMD platforms must support a TPM 2.0 device, and that the supported TPM 2.0 devices are discrete TPM 2.0 and Pluton-based firmware TPM 2.0. Notably, the corresponding Intel System Guard section instead lists “discrete TPM 2.0 or integrated TPM 2.0 (Intel PTT)” – Pluton is not called out on the Intel side. Note that in July 2026, Microsoft added a phase-out notice for Pluton’s fTPM functionality on AMD and Qualcomm platforms, falling back to the vendor’s firmware TPM or a discrete TPM [45].

Flash Attacks

In this section, we will present our security findings when targeting SPI flash chips with RPMC support in isolation. Later sections test the RPMC controller and flash in integration. We analyzed flash chips across different operating voltages from three major manufacturers: Winbond, GigaDevice, and Macronix. The chips tested are listed in Table 1.

ManufacturerSeriesPackage IdentifierSupply VoltageInteger OverflowHMAC Key LeakCounter Corruption
WinbondW25R128JVSIQ3 V✓✓×
WinbondW25R128JWPIQ1.8 V✓✓×
MacronixMX77L12850FM2I403 V✓××
MacronixMX77U12851FM2I421.8 V✓××
GigaDeviceGD25LR256FYIGE1.8 V✓×✓

Table 1. Overview of Tested Memory Chips with RPMC Support

Attacker Capabilities. Since RPMC was designed to offer protection against hardware attacks [24], we assume an attacker with the following capabilities:

  • Ability to attach a controller, e.g., flash programmer, to the chip and send arbitrary commands as well as read their responses

  • Ability to influence the chip’s supply voltage, allowing for the insertion of voltage glitches

  • Ability to interact with the flash chip for a prolonged amount of time

Attack Setup. We started testing with a breadboard setup, shown in Figure 2. The setup revolves around a Raspberry Pi Pico 2W microcontroller acting as the SPI controller, the SPI flash chip (the device under test), an IRF8736 power MOSFET, and an appropriate gate driver to optionally meddle with the SPI flash’s supply voltage. The Pico is running with the flag PICO_USE_FAST_SUPPORTED_CLOCKPICO\_USE\_FAST\_SUPPORTED\_CLOCK set to run at 150 MHz (as of April 2026); changing this flag affects the parameters we highlight later.

Figure 2. Schematic Diagram of the Attack Setup

The setup forms a crowbar circuit on the flash chip’s VCCV_{\mathrm{CC}}, enabling it to quickly and precisely pull its supply voltage below the operating range. The firmware for the setup, as well as the scripts used for the final attacks, are available in the artifacts (§ 8).

Integer Overflow

Without causing any glitches, we found that Macronix, Winbond, and GigaDevice chips are susceptible to integer overflows. The counter value appears to be stored internally as a 32-bit unsigned integer. If a counter with a value of 4294967295 (the maximum value of a 32-bit unsigned integer) is incremented once more, it returns to 0. This enables attackers to issue authentic Increment Monotonic Counter commands to set it to lower values, contradicting the implicit assumption that the counter should be “monotonic”.

Duration. In our testing, it took about 4 weeks to overflow the Winbond counter and about 6 weeks for the Macronix or GigaDevice chip. Theoretically, the average time for an increment request is 80µs in Winbond’s [55] and GigaDevice’s [16] case or 45 µs in Macronix’s case [28]. This means a full overflow cycle could be as fast as 4 or 2.5 days, respectively. This theoretical estimate, however, does not account for the time required to transmit the necessary messages or the possibility of transactions failing, which occurred sporadically during our testing. Nonetheless, significant speedups could be achieved by precomputing signatures on more powerful hardware.

Mitigations. Despite allocating 4 bytes, i.e., 32 bits, for the counter value, the RPMC specification fails to specify the expected behavior of increments to the maximum integer [24]. This contrasts with the specification of RPMB within eMMC, where it is directly stated that a counter should reject all increments once it reaches its maximal value [23]. JEDEC could resolve this by either deciding on a single behavior and documenting it, or by using one of the reserved bits in the Write Root Key Register command to make this behavior configurable for the end user. We contacted JEDEC with this proposal in April 2025, but they have not updated the specification since then.

Impact. We believe this fault is not caused by a single manufacturer’s implementation but rather by ambiguity in the RPMC specification. It forces manufacturers to make a choice, and leaves end users in the dark about exactly how their chip behaves and whether it meets their security requirements. For the use case of NV state rollback protection, the ability to overflow a counter and arrive at a lower value than before is only of marginal use: It could allow one-time reuse of stale NV state, but would require another overflow to reuse it. The impact would be much higher, however, if RPMC is used as a ratcheting mechanism to protect a device’s firmware against rollback attacks, using a pair of software and hardware version numbers. Once the counter overflows, all previous firmware versions become valid again. This breaks ratcheting’s security goal to prevent firmware rollbacks.

Counter Corruption

We found the GigaDevice flash to be susceptible to voltage glitching during the Request Monotonic Counter process. With the right timing, we were able to get the chip to return faulty counter values. The returned values are indistinguishable from valid responses, as the tag matches the one requested by the controller and a valid signature signs the whole message (covering the faulty counter value). During glitching, we additionally observed the chip sometimes returning a different tag or a faulty signature. This is not a direct vulnerability, as any well-implemented controller should easily catch and reject these.

Parameters. With a well-configured setup, we were able to trigger the glitch with a success chance of around 10%. The best working MOSFET open time was closing it with no delay of 0 or 140 ns while glitching 10500 (roughly 200µs) to 14300 (roughly 240 µs) decrements after driving the chip select of the Request Monotonic Counter request high again. The later we glitched, the higher the wrong counter value would be, but the glitched value would still stay below the real counter’s value.

Mitigations. As we have observed this behavior only on GigaDevice flash chips, we believe the best defense against this attack is a hardware revision of those chips that better protects the loading process of the counter against fault injection. Another approach would be to insert standard fault-injection countermeasures to detect voltages outside normal operating conditions and subsequently reset or stall the chip’s operation to prevent abnormal behavior.

Impact. The real-world impact of this vulnerability is low for the use cases we observed. Since the returned counter values still exhibit some randomness, one would need to build a payload that specifically matches one of them. Since this would probably require multiple glitch attempts, the attacker needs to keep the application waiting by returning a busy status. But even then, for every Increment Monotonic Counter validated with Request Monotonic Counter, this process would need to be repeated until you glitch a value exactly one higher. This was impractical for the real-world attack targets we found, but could still impact other use cases we have not seen so far.

HMAC Key Leak

We found the Winbond flash chips to be susceptible to voltage glitching at two critical points: After issuing an Increment Monotonic Counter command, we applied a crowbar glitch during what we think is the chip’s signature verification operation. When we issued a subsequent Read Extended Status, it would occasionally return a valid signature for our initially sent Increment Monotonic Counter, even when the initial request lacked a valid signature. More critically, when we encountered a similar glitch after an Update HMAC Key Register command, the chip returned the calculated HMAC key in a subsequent Read Extended Status, regardless of whether our initial Update HMAC Key Register was signed correctly. Winbond seems to reuse the register read by Read Extended Status to store the chip’s HMAC engine output. A well-timed voltage glitch then appears to stop the process that would normally clear this register again, allowing its output to leak. We have also tested both chips from Winbond’s 3.3V and 1.8V lines and even performed this attack against the flash chip in a commercially available laptop. All attacks were successful, leading us to conclude that this is a design flaw in Winbond’s RPMC engine.

Parameters. Using the best parameters we found, we can leak the HMAC key within roughly 1 second, enabling even on-demand glitching with a purpose-built interposer. We found a MOSFET open delay of 0 to 5 (roughly 140 ns–160 ns) to work best, and a glitch with a delay of around 7300–7350, roughly 340 µs after the initial chip select low of the request.

Mitigations. Winbond’s datasheet even reproduces JEDEC’s own requirement almost verbatim: “The increment counter implementation should make sure that the counter increment operation is performed in a power glitch aware manner.” [24, 55]. We believe the only way to remedy the fault described in this section is through a hardware revision to Winbond’s RPMC engine. This hardware revision should address register reuse and ensure that no secret data is ever written to a register that can be read.

Impact. This vulnerability severely impacts any application that relies on Winbond flash chips and is almost equivalent to leaking the Root Key from such a chip. With the HMAC key, an attacker can use an interposer to sign their own responses to Request Monotonic Counter and fill them with arbitrary counter values that benefit them. This fully nullifies any security within RPMC. Since the glitch is also very fast, glitching can be performed on demand once the Key Data for the current session is known. There is no practical way to detect this, as the attacker could return a busy status from the chip until the glitch succeeds. Glitching that causes a timeout is unlikely, and in all the real-world use cases we saw, timeouts were not an issue. But even if it occurs, the attacker could extend the time they have by performing the attack during the period from the Update HMAC Key Register to the first Request Monotonic Counter, as this is the first request that actually requires a signed status.

Interposer Attacks

In § 4, we evaluated attacks against isolated RPMC-enabled SPI flash chips. Especially the HMAC Key Leak (§ 4.3) should allow an attacker to circumvent RPMC-backed security mechanisms such as NV state rollback prevention (see Section 2.1.4). However, implementing such an attack requires non-trivial technical effort, including overcoming electronic limitations, operating at high SPI clock speeds, and performing manufacturer-specific reverse engineering. In this section, we present our solution to these challenges: our custom-made interposer PCB (§ 5.2).

Furthermore, when investigating AMD’s and Intel’s NV state rollback protection in detail, we discovered security issues with Intel’s (§ 5.4.1) and AMD’s (§ 5.4.2) use of RPMC-enabled SPI flash chips. While Intel’s weakness will ease the counter forgery enabled by Winbond’s HMAC Key Leak (§ 4.3), AMD’s flaw will allow us to attack systems regardless of whether the SPI flash contains vulnerabilities or not.

Figure 3. Attack Setup with the Interposer Board

Attacker Capabilities

To attack a system using a vulnerable RPMC chip, an attacker can leverage their physical access and manipulate, e.g., the chip’s response to a Read Extended Status command. More concretely, an active attacker needs the following capabilities:

  • Eavesdrop on the RPMC communication between the controller and SPI flash chip to keep track of the state of the controller and chip, and to trigger manipulations at the appropriate times.

  • Manipulate the RPMC traffic between the controller and SPI flash chip, specifically:

    • Filter RPMC commands sent from the controller towards the SPI flash chip.

    • Respond to these commands with attacker-chosen responses signed with a leaked HMAC key.

  • Glitch the SPI flash chip to leak the necessary HMAC keys (optional due to 4.4.1).

These capabilities align with the assumed threat model specified in the RPMC standard [24].

Attack Setup

Manipulating selected SPI transactions on a high-speed SPI connection is technically challenging. To facilitate this manipulation, we desolder the target’s SPI flash chip and place our interposer PCB between the controller and the SPI flash chip. This setup must minimize interference with the SPI bus, as QSPI traffic can reach clock speeds up to 100 MHz. It must also listen in on the SPI traffic and trigger manipulations of this traffic with a latency of only dozens of nanoseconds.

Hardware. At the core of this PCB lies a QSPI-capable MUX IC [52], which – for most SPI traffic – enables a nearly-direct connection between the target platform and the de-soldered SPI flash chip. When an SPI command should be manipulated, the MUX is configured to connect the target’s SPI bus not to the SPI flash chip, but to a Raspberry Pi (RPi) Pico 2W’s SPI “slave” interface [46]. The RPi Pico 2W will respond to the controller’s SPI commands instead of the SPI flash chip. Additionally, the RPi Pico 2’s other SPI interface is permanently connected to the SPI flash chip’s SPI bus to monitor SPI traffic and take over the controller role during manipulation phases.

Due to varying target SPI bus voltage requirements, a Logic Level Shifter (LLS) IC [42] translates the 3.3V3.3\mathrm{V} signals of the RPi Pico 2 to the corresponding target voltage (most often 1.8V1.8\mathrm{V}). We also connect a logic analyzer to observe and debug the interposer logic. A MOSFET on the SPI flash chip’s voltage rail enables in-circuit voltage-fault injection attacks on the SPI flash chip.

To insert the interpose PCB between a target and its SPI flash chip, we desolder the SPI flash chip and attach a 1.27 mm pin header instead. The interposer can then be connected directly to this header, and the SPI flash chip mounted in a socket fitting its package. See Figure 4 for an exemplary hardware setup.

Photo of the attack setup against the Framework Laptop 13’s mainboard

Figure 4. Photo of the Attack Setup against the Framework Laptop 13’s mainboard

Firmware. The RPi Pico 2W was chosen for its low price – around 5$ – and its RP2350 chipset, which includes Programmable Input Output (PIO) blocks [47]. These allow us to implement time-critical attack logic as low-latency state machines, without the need for an (expensive) FPGA.

We implemented a PIO state machine to listen to the target’s SPI traffic and trigger on the first bytes of an SPI command, which identifies its type. This is then used to trigger other parts of the attack logic, such as functionality to record and process the current SPI command with the RPi Pico 2W’s firmware. Once the firmware determines that future RPMC commands should be manipulated, it can also configure this state machine to instead switch the MUX over to the RPi Pico 2W’s SPI “slave” interface after such a trigger. The PIO state machine enables such a manipulation decision within only a few dozen nanoseconds. Additionally, another state machine on the same PIO hardware can be used to output a firmware-determined bit sequence on the SPI bus’ MISO line, enabling the firmware to respond to the controller’s RPMC commands.

Board Revision. The board described above (v1) suffered from signal-integrity and timing issues on the interposed QSPI bus at the Framework Laptop 13’s operating SPI clock speed, preventing reliable command manipulation against that target. Since the Winbond/Intel attack path (Section 4.5.2) only needs to replay an HMAC key already leaked once via voltage glitching (Section 3.3) – rather than glitch on demand – we built a second, replay-only board revision (v2) to address this. Compared to v1, v2 (a) configures the RPi Pico 2’s GPIO bank for native 1.8V I/O from the start, removing the Logic Level Shifter entirely; (b) omits the glitching MOSFET, since no fresh key extraction is needed; and (c) uses a faster MUX IC [19]. Removing the LLS and glitching circuitry simplified the signal path, which, combined with the faster MUX, resolved the timing and signal-integrity issues that had prevented reliable command manipulation against the Framework Laptop 13. We used v2 only for the Intel/Framework result (Section 4.5.2); the AMD/OmniBook result (Section 4.5.1) stands as originally demonstrated on v1.

Naive Rollback Attempts

To understand the vulnerabilities and attacks that follow, we will now revisit a critical detail when working with security applications that require non-volatile storage, such as fTPMs. An fTPM usually stores its NV state alongside the firmware on the SPI flash chip and protects its integrity and confidentiality using well-known cryptographic methods. However, to reliably implement anti-hammering mechanisms (Section 2.1.3), it must also prevent rollback attacks against the NV state.

Of the nine systems we examined during our research (see Table 2), four support RPMC (including Winbond’s functionally identical Authentication Flash) and five do not. On AMD-based systems, the NV state (including the fTPM state) is contained in a file of the PSP file system [22]. On Intel-based systems, the NV state is part of the ME File System inside the CSME Region of the UEFI volume [49].

DeviceYearPlatformCPUFlashuses RPMCMicrosoft branding
Intel NUC Desktop Board NUC6i3SYK2015IntelCore i3-6100UWinbond W25Q64FVSIGNo–
ASUS TUF Gaming B450-Plus2019AMDRyzen 5 3600 (Zen 2)Winbond W25Q256JWEQNo–
Lenovo IdeaPad 5 Pro 16ACH162021AMDRyzen 5600H (Zen 3)Winbond 74M12JWSIQYes1–
Lenovo ThinkPad T15 Gen 22021IntelCore i7-1165G7Winbond W25R256JVENYesSecured-core PC
MSI PRO B760M-P DDR42024IntelCore i5-14400Winbond W25Q256JWEQNo–
MSI PRO B850-P WIFI2024AMDRyzen 5 9600X (Zen 5)Macronix MX25U25671GNo–
Framework Laptop 132024IntelCore Ultra 5 125HWinbond 25R256JWYes–
HP OmniBook 3 15-fn0523ng2025AMDRyzen AI 5 330GigaDevice 25LR256FYIGeYesCopilot+
Acer Aspire 14 AI OLED2025IntelCore Ultra 5 226VMacronix MX25U25672GNoCopilot+

Table 2. Evaluated Target Systems. Integration patterns of RPMC are unclear to us.

We conducted our test on systems with the fTPM enabled in the UEFI and a TPM-protected secret under dictionary attack protection, i.e., either a Windows Hello PIN and BitLocker on Windows 11 or a TPM object created with tpm2-tools on Linux. The test comprised these steps:

  1. Attach an SPI programmer, dump the SPI flash, and detach.

  2. Boot up the system, change the fTPM state, e.g., by increasing the TPM’s lockout counter through a failed authentication attempt, and shut down cleanly.

  3. Attach the SPI programmer, write the dumped SPI flash image, and detach.

  4. Boot up the system and check whether the fTPM state was rolled back.

We distinguished successful from unsuccessful rollbacks on either operating system. On Windows, a BitLocker recovery screen on boot indicates a reset fTPM, and the Get-Tpm PowerShell command reports the exact LockoutCount. On Linux, tpm2_getcap properties-variable reports the lockout counter, and loading a previously created TPM object fails if the fTPM was reset.

On seven of the nine systems, the fTPM detected the rollback. On Windows, instead of booting directly, we were asked to enter the BitLocker recovery key; after Windows booted, an error message said the Windows Hello PIN was unavailable, forcing us to set up Windows Hello again. On Linux, loading our TPM object failed its integrity check. Both symptoms indicate that the fTPM no longer had access to its previous objects. These seven platforms (with or without RPMC support) must have detected the stale NV state through their mismatches between a counter in the (encrypted and integrity-protected) NV data and an expected value saved elsewhere. They therefore rejected using it for the boot and, instead, reset its contents to allow the system to boot with a fresh fTPM.

Both AMD desktops (Zen 2 and Zen 5), whose flash lacks RPMC, did not detect the rollback. On these systems, reprogramming an old NV state onto the SPI flash with an SPI programmer alone reliably returned the fTPM’s lockout counter to its value at the time of the flash dump.

It is important to note that the Intel-based “pre-RPMC” systems have defended this naive attack. While the CSME whitepaper mentions a Protected Real-Time Clock (PRTC) that could enable the rollback protection [21], independent research indicates that the counter values of the ME File System’s metadata must match a so-called Anti-Replay table (AR) [49]. Regarding the rollback protection of this table, Sklyarov states: “RPMC is an optional feature of the SPI Flash chip helpful for Anti-Replay Protection implementation. If this feature is not available, ME implements its own timer-based counter.” [49] Our naive rollback tests on the Intel systems without RPMC flash – the NUC from 2015, the MSI desktop, and the Acer Aspire from 2024 and 2025 – support this claim. For AMD, our results indicate the opposite: The Lenovo IdeaPad, which we initially classified as pre-RPMC, relies on Winbond’s Authentication Flash, and both AMD systems without such flash accepted naive rollbacks. While these observations may not be representative of all AMD systems, we conclude that AMD SoCs likely do not feature standalone rollback protection for their NV state.

Controller Vulnerabilities

In order to better understand how AMD and Intel protect their NV state on the four systems with RPMC support (Table 2), we collected traces6 of the SPI bus during early boot and during runtime, namely a failed Windows Hello PIN entry, whose anti-hammering protection is backed by the fTPM (see § 3.0.2).

Our key observations from the traces were these (highlighted in bold are the ones critical for the upcoming controller vulnerabilities): during early boot, AMD and Intel both initialize the first four RPMC counters via Update HMAC Key Register, and Intel calls Update HMAC Key Register with the same Key Data value of 0x1 across all boots; AMD additionally calls Update HMAC Key Register on counter 0 a second time; and while AMD only ever uses counter 0 afterwards, Intel uses both counter 0 and counter 1. After every Increment Monotonic Counter, AMD does not verify the counter via an Request Monotonic Counter, which in turn Intel does.

HMAC Key Reuse

The Key Data field should be used to generate a unique HMAC key each time the Update HMAC Key Register command is issued [24]. The finding that Intel-based systems use the constant Key Data value 0x1 across reboots is a security weakness that is not exploitable in isolation, as it only slightly reduces the replay-attack resilience of the RPMC specification.7

However, this finding significantly reduces the attack efforts necessary to turn Winbond’s HMAC Key Leak (§ 4.3) into an NV state rollback attack: Instead of performing the voltage fault injection attack each time an Update HMAC Key Register command is issued, the constant Key Data value allows us to perform the voltage fault injection only once. The leaked HMAC key for the constant Key Data value of 0x1 can then be used to forge all Request Monotonic Counter replies across all boots. The obvious mitigation for this issue is to choose Key Data securely randomly for each Update HMAC Key Register command.

Unverified Increment

Our RPMC traces surfaced another, more critical security issue on AMD-based systems. Recall that the only response from an RPMC-enabled SPI flash chip that is cryptographically signed is the Request Monotonic Counter response [24]. On AMD, Increment Monotonic Counter is the only RPMC command triggered by the fTPM-backed Hello PIN entry. This means that the AMD SPI controller does not receive any confirmation about the increment success. An attacker can simply filter out this Increment Monotonic Counter request so that the increment operation is never performed on the SPI flash chip, and send a malicious response that appears to confirm a successful increment without the ability to sign responses. This allows an attacker to roll back the NV state on RPMC-backed systems, as outlined in Section 4.5.1.

We view this attack vector as particularly impactful, as it works with every RPMC-enabled SPI flash chip, regardless of whether the chip is vulnerable to our voltage-fault attack.

On a positive note, AMD should be able to fix this vulnerability through firmware updates: To protect against this attack, RPMC controllers must verify any allegedly successful increment operations by re-reading the counter value, as Intel’s RPMC usage already does by calling Request Monotonic Counter after each Increment Monotonic Counter.

RPMC-based NV State Rollback Attack

Utilizing the vulnerabilities discussed in § 4.3, § 5.4.1, and § 5.4.2, and our custom interposer (4.2), we implemented two attack paths against AMD’s and Intel’s RPMC-backed NV state rollback protection mechanisms.

4.5.1 Suppressing Increments. We attacked the AMD-based HP OmniBook 3 15-fn0523ng system (see Table 2) by attaching our interposer PCB between the system’s motherboard and the desoldered SPI flash chip. This allowed us to program the RPi Pico 2W to intercept any Increment Monotonic Counter commands and prevent them from reaching the SPI flash chip. We use a PIO state machine to detect any Increment Monotonic Counter commands and disconnect the controller from the SPI flash chip during said command (see Figure 5). Since only the command byte is transmitted, the command appears as an invalid command to the SPI flash chip, so no actual increment is performed. After detecting a Increment Monotonic Counter command, the RPi Pico 2W will respond to any Read Extended Status commands with a success response, causing the AMD system to assume the increment was successful. Finally, we stop intercepting SPI traffic so the flash chip can continue to respond to the controller’s requests.

Figure 5. Selective suppression of an Increment Monotonic Counter (0x9B 0x02) command

4.5.2 Using Leaked Key. The Intel system (Framework Laptop 13 in Table 2) with a vulnerable Winbond 25R256JW chip was also modified by adding our interposer PCB (v2, § 5.2) between the motherboard and the SPI flash chip. For the attack, the interposer PCB must track all RPMC commands and issue manipulated responses to Request Monotonic Counter and Increment Monotonic Counter. These manipulated responses aim to reflect the state of an RPMC-enabled SPI flash chip, but with attacker-chosen counter values.

Due to Intel’s constant Key Data value (4.4.1), we did not need to re-extract the HMAC session keys after every Update HMAC Key Register, but could hard-code them for each counter after a one-time voltage fault injection attack (3.3). The interposer PCB’s firmware then uses a PIO state-machine to detect Request Monotonic Counter commands. For each, it waits for the following Read Extended Status command – while letting through any other, non-RPMC SPI commands – and uses that time to fabricate a response containing a chosen counter value, and sign it with the leaked HMAC key. As soon as the interposer detects a Read Extended Status command, it disconnects the flash chip from the target and returns its own forged response. Afterward, the interposer reconnects the target and SPI flash chip to ensure reliable (non-RPMC) SPI communication.

The interposer’s firmware also listens for Increment Monotonic Counter commands to keep track of the spoofed counter values.

Additionally, it also interposes all immediately following Read Extended Status commands as described above, because otherwise the flash chip would indicate the counter value mismatch in the status, since the current expected value is included in the Increment command (§ 2.2).

4.5.3 Results. Both attack paths reliably trick their respective target into accepting an expired NV state during boot, thereby circumventing the RPMC-backed rollback prevention: the AMD suppression path (Section 4.5.1) on the OmniBook, and the Winbond leaked-key path (Section 4.5.2) on the Framework Laptop 13 using the v2 interposer board (§ 5.2). We build on the AMD path for the end-to-end Windows Hello attack (§ 6) and on the Winbond path for the end-to-end BitLocker attack (§ 6.3); note that this pairing is arbitrary, since the underlying NV-state rollback primitive is independent of the target application – either attack path could equally be paired with either application. Furthermore, we expect the suppression-based attack path to work the same way when Microsoft’s Pluton TPM is enabled, as we observed the same RPMC usage with unverified SPI bus traffic increments (§ 5.4).

Windows Hello and BitLocker PIN Brute-Forcing

In § 5, we presented our custom interposer boards that we can use to modify RPMC transactions using different vulnerabilities to rollback the NV state. We will now describe how we used these boards in two end-to-end attacks. First, we brute-forced the Windows 11 Hello PIN on locked and encrypted Copilot+ hardware, specifically the HP Omnibook (see Table 2), using the AMD Unverified Increment rollback path. The same rollback primitive is not specific to Hello: § 6.3 describes our second end-to-end attack, live BitLocker PIN brute-forcing on the Framework Laptop 13 using the Winbond HMAC Key Leak rollback path, which defeats BitLocker’s TPM+PIN pre-boot protector even more effectively.

Attacks Overview. Assuming a physical attacker with no knowledge of a user’s PIN, this section outlines three different brute-force attacks against Windows Hello. The first, theoretical, attack describes a naive brute-force attack on Hello PINs, limited by lockout delays imposed by both Windows and the TPM. It serves as the baseline for estimating the impact of the two following attacks.

The second attack assumes that the attacker is able to conduct an NV State rollback between reboots (as outlined in Section 4.5.1 and Section 4.5.2). As experimentally verified by us, it demonstrates brute-forcing without any lockout durations enforced by Windows or the TPM. However, it is still limited to 5 tries per boot.

Lastly, we evaluate a theoretical third attack where an attacker obtains access to the sealed TPM object that Windows sends to the TPM for decryption. While this attack scenario requires at least temporary file system access, we argue that it can serve as a privilege-escalation technique. Fundamentally, it would allow an attacker to increase their tries per boot from 5 (Windows-enforced) to 32 (TPM-enforced).

Lockout Configurations. We noticed that lockout configurations differ from Microsoft’s documentation and among our tested devices (Table 2). The Windows Hello for Business FAQs claim that Hello provides four PIN entries per reboot (with a “A1B2C3” captcha after the third try) [37], while our target systems (with regular Hello set up) allowed one more try before the captcha; so a total of five tries. It further describes increasing lockout durations of “1 minute after the first reboot, 2 minutes after the fourth reboot, and 10 minutes after the fifth reboot” [37]. While we confirmed that the HP OmniBook employs this style of lockout duration after reboots, we did not see it on the Acer Aspire.

Running Get-TPM in PowerShell reveals the TPM’s actual lockout counters. To our understanding, the lockout counters need to reach 32 so an actual TPM-enforced lockout would apply. On the OmniBook, the firmware’s factory-provisioned LockoutHealTime is 10 minutes, as documented by Microsoft as the default; however, once Windows 11’s Hello PIN setup completes, this changes to 2 hours, matching what we observed on the Acer Aspire and the Framework Laptop but contradicting Microsoft documentation [36].

Naive Brute-Forcing

We first assume an attacker who does not have access to the TPM object used during the login process because the hard drive is BitLocker-encrypted (see § 3.0.1). Thus, instead of verifying their attempts directly with the TPM, they need to interact with the Windows login screen and check the PINs there.

Results. We calculated the worst-case brute-force times for the naive brute-forcing in Table 3, once for the 10-minute recoveryTime that Microsoft documents as the default, and once for the 2-hour recoveryTime we observed on the Acer Aspire and the Framework Laptop (§ 6). Notably, with the 10-minute setting, a four-digit PIN can be recovered after 69 days; with the 2-hour setting, the same worst case grows to 833 days, a 12× increase proportional to the recoveryTime ratio. We think that this security level (69 days worst-case brute-force for a TPM-backed 4-digit PIN) can already be inadequate for certain users.

DigitsNaive (with lockout)with NV Rollback
2 h10 minHelloBitLocker
4833 days69 days40 hours5 hours8
6228 years19 years168 days20 days
822831 years1903 years46 years6 years

Table 3. Worst-Case Numeric PIN Retrieval Time, Naive Brute-Force vs. Our Measured NV Rollback Attack: for Windows Hello, 69 days collapse to 40 hours; for BitLocker’s TPM+PIN Protector, 19 years collapse to 20 days. NV Rollback bypasses recoveryTime entirely and is therefore unaffected by it.

Mitigations. While enterprises may use Microsoft’s WHFB policy settings to increase the minimum PIN length or require letters [38], they do not allow changing the 10-minute recovery delay after 32

failed attempts. We believe Windows should prevent naive brute-forcing as just described by making the 32 try limit a permanent limit and use this policy by default: It is highly unlikely that users who already entered their PIN incorrectly 32 times will recall their correct PIN on the 33rd attempt (enabled after the TPM-configured recoveryTime (2.1.3)). After all, Microsoft provides a flow to reset the PIN using the user’s Microsoft account and an internet connection. Enforcing a permanent lockout would match the behavior of, e.g., iPhones [4].

Brute-Forcing with NV Rollbacks

In the second attack, we assume an attacker again without access to the TPM object, who is therefore limited to interacting with the Windows login screen, as in the previous scenario. However, this time they can also rollback the NV state during rebooting using our interposer board (4.5).

NV State Rollback. Assume the NV state rollback primitive from § 5.5. We mounted the same attack on our OmniBook, but before booting, started an interposing logic appropriate for the attack. For AMD, this means the interposer suppresses all Increment Monotonic Counter commands (4.5.1). Additionally, the interposer has access to an initial dump of the PSP NV state. During reboot, it issues an SPI write to the flash chip, overwriting any current NV state with the dumped state.

KVM Automation. To brute-force the Hello PIN via the Windows login screen, we have to connect, in addition to our interposer board, a KVM to the target system (see Figure 6). It allows us to read the video output and trigger keyboard input. The KVM is further controlled by an attacker platform that uses OCR to determine the state of the login screen. It then sends keystrokes through the KVM to the target to input a PIN or trigger a reboot once Windows mandates it (i.e., after 5 tries, see § 3.0.2). During the reboot, our board reprograms the NV state to its previous state.

Figure 6. Brute-force Setup with the Interposer Board and a KVM

In detail, the automation flow is this:

  1. Boot and wait for the lock screen

  2. Enter PIN (4x)

  3. Enter Captcha (“A1B2C3”)

  4. Enter one more PIN

  5. Restart (using keystrokes)

  6. Reprogram flash chip

  7. Repeat

Once the correct PIN is found, the Windows desktop appears, and our KVM logic halts.

Results. After reboot, we observed that the system accepted the next 5 PIN entries right away, rendering two distinct lockout mechanisms ineffective: a Windows-induced 1, 2, or 5-minute timeout, as well as a TPM-induced timeout (2 hours on this device once Hello PIN setup completes),6 too. To show that our attack works, we recorded a demo video of an unoptimized end-to-end attack against the AMD-based OmniBook with a TPM-protected Windows Hello PIN. The video shows our attacker hardware automatically trying all PINs starting from 1000 until it reaches 1235 (the correct PIN), which unlocks the system. While the attack ran from 18:27–19:46 (visible on a clock in the timelapse), 19:13–19:35 was spent unsticking our rudimentary brute-forcing script; net time to find the correct PIN was 57 minutes across 236 tried PINs, i.e. ~41 PINs per 10 minutes (4.14 tries/minute) – compared to the TPM lockout’s 1 try per 10 minutes.9 However, the performance of our rudimentary

setup – shared by both attacks – has large room for optimization, e.g., by restoring the target’s original SPI clock speed or writing NV state to flash faster. Table 3 calculates worst-case brute-force times directly from this measured rate. Compared to Microsoft’s theoretical 10-minute timeouts per try, this yields a ~41x speedup. Compared to the actual timeout of 2 hours, the speedup is a factor of ~497.

Generalizing to BitLocker’s TPM+PIN Protector

The rollback primitive from § 5.5 is not specific to Windows Hello: it affects any TPM-sealed secret gated by the Dictionary Attack Protection counters, including BitLocker’s TPM+PIN protector (2.3.1). Unlike Hello, BitLocker’s pre-boot PIN prompt imposes no additional Windows-side try or timeout limit on top of the TPM’s own 32-try budget, so a rollback between boots grants the full 32 tries every cycle. Using the Winbond leaked-key rollback path (Section 4.5.2) on the Framework Laptop 13, we demonstrated this live: our interposer rolls back the NV state between reboots, granting the full 32-try TPM budget every boot cycle, and our automation enters PIN attempts at the pre-boot prompt until the correct PIN is found. Our demo video10 shows our attacker hardware trying all PINs from 123222 to 123457 (the correct PIN) in 8 minutes 40 seconds across 236 tries. After a simple optimization of the KVM’s attack loop, the same 236-try campaign took 6 minutes 55 seconds, i.e. ~341 tries per 10 minutes (34.1 tries/minute) – compared to the TPM lockout’s 1 try per 10 minutes – yielding a worst-case time of 20 days for a default-length 6-digit PIN, as shown alongside Hello’s numbers in Table 3. Compared to Microsoft’s theoretical 10-minute timeout per try, this yields a ~341x speedup; compared to the 2-hour timeout we actually observed on this same Framework Laptop (Section 5), the speedup is a factor of ~4092.

Brute-Forcing with NV Rollbacks and TPM Object

Finally, we would like to highlight one more attack scenario that deserves attention that we have not, however, experimentally verified at the time of writing: Recall that at the core, Windows Hello protects a private user key by sealing it with the TPM under a PIN-protected auth policy (2.3.2, 2.1). Windows stores the TPM object (i.e., the TPM-encrypted user private key) on a disk that, by default, is encrypted on Windows 11. If, however, an attacker obtains access to that TPM object, for example, because the attacker has temporary access to the unlocked device, including access to Windows system files, or the device does not employ disk encryption, brute-force times are even lower. The attacker may now boot the target device into an attacker-controlled operating system. By then issuing the same TPM commands (e.g., using tpm2-tools11) as Windows does, including the entry of a candidate PIN and a subsequent call to Unseal, an attacker gets the ability to check 32 PINs before needing to reboot and rollback the NV state. This should elevate the attack speed against Windows Hello roughly to the BitLocker’s attack speed. In addition, it could reen able a Windows Hello migration attack as introduced in [26].

Discussion

Our two end-to-end attacks against Windows Hello and BitLocker (Section 5) were made possible by two independent attack paths our RPMC research surfaced for rolling back the NV state (including the fTPM state) between reboots, both confirmed end-to-end against a live target:

  1. Systems relying on Winbond flash chips for RPMC face the risk of an attacker extracting HMAC keys through voltage glitching (3.3) and interposing SPI traffic to forge counter requests (4.5.2).

  2. AMD-based systems relying on RPMC can be targeted by an interposer without knowledge of the HMAC or Root keys: Targeted suppression of the Increment Monotonic Counter command suffices (4.5.1).

On AMD systems without RPMC flash, neither is needed: reprogramming an old flash image with an SPI programmer suffices (Section 4.3).

Mitigations. While the former issue requires changes to Winbond hardware to fix it at the root (3.3), the latter issue can, as far as our assessment goes, be addressed by AMD through firmware updates (4.4.2).

Affected Systems. To our knowledge, all RPMC-based systems using Winbond flash are vulnerable to interposer attacks using a leaked key (4.5.2). Furthermore, unless AMD provides firmware fixes12, all RPMC-based systems with AMD SoCs should be vulnerable to the interposer attacks suppressing increments during NV state operations (4.5.1). Moreover, AMD-based systems without RPMC flash appear to lack NV rollback protection altogether: on both such systems we tested, reprogramming the SPI flash with an old image sufficed to roll back the fTPM state (Section 4.3).

On AMD systems, software can identify whether RPMC is in use: Since Linux 5.19, the ccp driver exports the PSP’s security attributes via sysfs, including whether an RPMC-capable SPI flash is present (rpmc_spirom_available) and whether RPMC has been enabled (rpmc_production_enabled) [53].13 The firmware update daemon fwupd summarizes both in its AMD SPI Replay protections attribute, displayed by fwupdmgr security [14]. These reports match our results: the Lenovo IdeaPad, whose Authentication Flash supports RPMC commands, reports both attributes as 1 and detected naive rollbacks, whereas the Zen 2 desktop reports both as 0 and accepted them. Thus, on AMD, either outcome exposes the system to one of the rollback paths above: the Unverified Increment with RPMC, or a naive rollback without it. For Intel systems, we are not aware of a comparable interface; whether they rely on RPMC can, to our knowledge, only be identified through inspection of the mainboard and SPI bus traffic: If the mainboard hosts an RPMC-capable flash chip (e.g., Winbond’s “W25R” series), the system likely relies on RPMC. To confirm this, SPI traffic during boot can be analyzed using a logic analyzer.

When picking a system, it is hard to know beforehand which flash the OEM uses or whether RPMC is used, unless it is openly documented, as in the Framework laptop [11]. In our research, we have not conducted tests on non-x86 laptops, such as ARM-based laptops. For Qualcomm-based platforms with RPMB-capable storage – a related concept to RPMC specified in JEDEC’s eMMC specification [23] – Windows 11’s Hardware Compatibility Program dictates rollback protection, too (2.3.2).

Responsible Disclosures. We initially informed Winbond about the susceptibility of their chips to glitching in January 2025; Winbond acknowledged the report but did not follow up. In April 2026, we sent a second report detailing that voltage glitching also leaks the HMAC key itself, together with the resulting impact on Windows Hello and BitLocker, and sent a further reminder in September 2026. Winbond has since responded that their engineering team is actively evaluating the issue, possibly including a silicon revision, but has not committed to a concrete fix or timeline.

We informed AMD about the increment suppression attack and how to fix it in February 2026 and have followed up, demonstrating the end-to-end attack against Windows Hello in April 2026 and proposing two concrete firmware-fix options together with the BitLocker impact in September 2026. AMD acknowledged the report and forwarded it for internal review, but has not yet given a technical assessment or committed to a fix. In November 2026, we informed AMD that naive rollbacks succeed on its platforms without RPMC flash (Section 4.3).

Additionally, we reported our end-to-end attack and the enabling vulnerabilities by both AMD and Winbond to Microsoft in April 2026. Despite running Microsoft-authored code from a dedicated core, Microsoft Pluton’s fTPM is similarly affected by AMD’s Unverified Increment (4.4.2) as AMD’s own fTPM is (4.5.3). We also demonstrated our end-to-end attack against Windows Hello to them. Microsoft closed this case as “moderate severity”, defense-in-depth, below the bar for immediate servicing – issuing no CVE or bounty, but committing to raise the recommended minimum Hello PIN length to 6 digits. In September 2026, we further disclosed that the same rollback also defeats BitLocker’s TPM+PIN protector, which is brute-forceable even faster than Windows Hello (5.3); at Microsoft’s request, we filed this as a separate report, since it is handled by a different product team and falls outside the scope of their in-progress Hello fix, which predates our BitLocker disclosure. Microsoft ultimately permitted us to publish the specific Hello mitigation language proposed below (see Interim Mitigations), but declined to provide any further written statement for this paper; they expect to issue their own communications once their fix ships, alongside our publication on November 15.

Regarding our minor findings, Intel initially closed our report on the HMAC Key Reuse as “Informative/Rejected”, stating that the responsible business unit does not consider the issue independently exploitable. In September 2026, Intel reopened the case; Intel PSIRT considers the finding a security weakness rather than a vulnerability, as it only reduces the attacker’s effort once a Winbond HMAC Key Leak has occurred. We agree with this classification and adopt it in this version. Nonetheless, the weakness still upgrades a one-time Winbond HMAC Key Leak into a permanent compromise, and Intel could mitigate it by falling back to its pre-RPMC rollback protection on systems with Winbond flash.

JEDEC has responded to the Integer Overflow, saying that our suggestions would be forwarded to the formulating committee.

We disclosed the Integer Overflow finding to Macronix in April 2025; they confirmed the counter wraparound but, calculating approximately 680 years to reach it at the minimum update interval, closed the case as impractical to exploit.

We disclosed our findings on Counter Corruption under glitching to GigaDevice in April 2026. GigaDevice has engaged constructively, requesting and receiving our fault-injection parameters in September 2026 to attempt reproduction; a fix or formal statement is still pending.

Interim Mitigations. Since none of the major firmware (AMD) or hardware (Winbond) vulnerabilities have been fixed at the time of writing, Microsoft could still meaningfully raise the bar for our attacks purely through policy, without waiting on vendor firmware or hardware fixes. Raising the default minimum PIN length by just two digits – from 4 to 6 for Windows Hello, and from 6 to 8 for BitLocker’s TPM+PIN protector – substantially narrows our NV Rollback attack’s window of practicality (Table 3): the worst-case retrieval time increases from 40 hours to 168 days for Hello, and from 20 days to 6 years for BitLocker. This would not eliminate the underlying rollback primitive, but it substantially narrows the window in which our attack remains practical.

RPMC Integration. Regarding the overall integration trends for RPMC, we are not aware of whether OEMs (e.g., Lenovo) or SoC vendors (e.g., Intel) decide on the rollback prevention method (RPMC or non-RPMC methods). Microsoft, for its part, does not mandate the method either – at least not anymore (2.3.2). Our anecdotal evidence on the presence or absence of RPMC in laptops, shown in Table 2, indicates that both AMD and Intel integrated RPMC(-like) flash into systems as early as 2021 and that AMD has at least one Copilot+ certified laptop with RPMC. Intel builds one without RPMC, even though Intel was the initial driver behind the extensions (2.2).

RPMC Security. We will now debate the overall benefit of RPMC integration compared to pre-RPMC rollback prevention of the platform NV state. It can be argued that RPMC logically places the rollback counters where the protected NV state data itself lives: SPI flash. However, this comes at several disadvantages: First and foremost, it reintroduces an external bus that fTPMs were meant to eliminate, exposing security operations to it again. This requires cryptographic legwork: The SoC and flash chip must generate and exchange the shared Root Key in a trusted OEM environment. Then, based on random data, this key must be rotated to allow signature creation and verification on both ends. While coprocessors like the AMD PSP and Intel CSME clearly already have the capabilities for the Root Key storage as well as the cryptographic operations, although not openly documented nor accessible to 3rd parties, our research shows that flash vendors fail to implement these mechanisms securely on their end. The fault injection attacks used in this research do not exhaust the full toolset of hardware attacks; other methods, such as electromagnetic or laser fault injection, as well as side-channel analysis, come to mind. Regarding the integrity of the data that the SPI NOR flash delivers, unreliable reads can be detected by parity or signature checks, as widely employed in the industry. With its additional RPMC responsibilities, the SPI flash suddenly becomes the Achilles heel of NV state integrity and, as a consequence, the fTPM’s integrity. On Windows Hello for Business, this ends up protecting enterprise SSO (2.3.2).

Compare this to pre-RPMC rollback protection of NV state: Our experiments indicated a functional, self-contained rollback protection implemented by Intel that we were unable to circumvent naively, presumably the ME’s timer-based counter (§ 5.3).14 It might still exist and be ready to activate even on systems shipped with an RPMC configuration. Based on our current understanding, we believe that Intel should switch back from RPMC-backed to pre-RPMC rollback prevention through firmware updates to reinstantiate fTPM security even on systems with insecure RPMC flash. For AMD, the situation is reversed: our experiments indicate no such fallback (§ 5.3), so RPMC is currently AMD’s only means of NV rollback protection. On AMD platforms without RPMC flash, an SPI programmer suffices to roll back the fTPM state, which arguably falls short of the rollback protection that Microsoft’s hardware compatibility programs require [[30, 31]]. Rather than abandoning RPMC, AMD should verify its increments (§ 5.4) and provide rollback protection for platforms without RPMC flash.

RPMC Repairability. Beyond these security concerns, RPMC integration also affects repairability. Anecdotally, during our research, the Framework’s RPMC flash failed due to a faulty supply voltage. Normally, we would have been able to desolder the defective flash and replace it with a new one. However, the Root Key of the broken chip is unknown to us, and the Intel SoC is in a post-provisioning state that does not accept other Root Keys. As a result, our system is effectively bricked. When we contacted Framework, a company known for its high repairability standards, about this, they said that the repair process for this board only allows a full board replacement. We cannot say whether this is due to missing micro soldering capabilities at the repair centers or to a missing RPMC reprovisioning flow in Framework’s or Intel’s firmware. Nonetheless, this part pairing would not exist without RPMC.

Conclusion

The shift from discrete to firmware TPMs brought a meaningful security benefit: by running TPM logic inside the SoC’s security coprocessor, the exposed SPI bus – previously exploitable for passive and active attacks – is no longer on the critical path for TPM communication. RPMC-backed rollback protection partially undoes that progress by re-externalizing a security-critical part of the fTPM state – its anti-hammering counters – to the very bus that fTPMs had incidentally rendered inaccessible.

Our first security evaluation of RPMC deployments in shipping x86 systems reveals multiple independent implementation flaws that compromise this protection. Winbond – the world’s leading NOR flash vendor – leaks its HMAC authentication key under voltage glitching, enabling arbitrary counter forgery in under a second. Notably, Winbond’s own datasheet reproduces JEDEC’s power-glitch-aware requirement almost verbatim, yet our results show a simple crowbar glitch defeats it. Intel’s NV controller amplifies this by reusing a constant session key across all boots, reducing full key-extraction attack to a single, one-time glitch. AMD’s NV controller, independently of any flash vulnerability, never verifies that an issued increment was actually applied, allowing a low-cost interposer to silently suppress all counter increments and thus permit unlimited NV state rollbacks.

We demonstrated the real-world consequences of both flaws with end-to-end brute-force attacks: AMD’s Unverified Increment against the Windows Hello PIN, and Winbond’s HMAC Key Leak against BitLocker’s TPM+PIN protector, both on locked, encrypted hardware; the former even Copilot+-certified. By combining fTPM state rollbacks with automated PIN entry, we achieve approximately 41 times the attempt rate of the default TPM lockout regime, reducing the expected time to crack a 4-digit numeric PIN on a locked device from 69 days to 40 hours. The impact is not limited to lockscreen bypass: a brute-forced Hello PIN can unlock device-bound keys, enable Hello-based enterprise SSO, and, in some configurations, allow an attacker to satisfy an otherwise multi-factor-protected authentication. Lastly, the same rollback primitive generalizes beyond Hello: we also demonstrate it live against BitLocker’s own TPM+PIN pre-boot protector, which grants the full 32-try TPM budget on every boot without any Windows-imposed throttling, reducing the expected time to crack a default-length 6-digit PIN on a locked device from 19 years (with the laxer 10-minute TPM lockout) to 20 days – a ~341 times speedup. On AMD systems without RPMC-capable flash, an attacker may not even need either flaw: on Zen 2 and Zen 5 desktops, naive rollbacks of the NV state with an SPI programmer succeeded.

Our results show that the current RPMC ecosystem – spanning specification gaps, flash vendor implementations, and SoC controller design – is not up to its task. We recommend that AMD deploys a firmware fix to verify increment success and that Winbond addresses the key-leak vulnerability in hardware, or, alternatively, that Intel considers reverting to pre-RPMC rollback protection on affected systems as a short-term measure. We have responsibly disclosed all findings to Winbond, Macronix, GigaDevice, Intel, AMD, JEDEC, and Microsoft, and we make our tools and interposer design publicly available to facilitate further research and vendor remediation.

Acknowledgments

This research was funded by the German Federal Ministry of Research, Technology and Space within the DI-SIGN-HEP Project Grant 16KIS2074.

Open Science

The artifacts of our paper are published as a Git repository15 that contains the interposer firmware (both board revisions), our interposer PCB designs, scripts used to mount the KVM attack, build and run descriptions, the leaked HMAC keys of our test system’s Winbond flash chip, and an excerpt of the traces we used in finding our attack – per platform, one boot trace and a trace showing the behavior when entering an incorrect Windows Hello PIN.

We also provide two short timelapse PoC videos on YouTube where we brute-forced 236 PINs: one of the Windows Hello attack16 on the AMD laptop taking a net 57 minutes and one of the BitLocker attack17 on the Intel laptop taking 8 minutes 40 seconds (6 minutes 55 seconds after optimizing our KVM’s attack loop, see § 6.3).

Changes from the CCS ’26 Version

This version differs from the paper published at ACM CCS ’26 as follows:

  • AMD rollback protection without RPMC. In the CCS version, we classified the Lenovo IdeaPad 5 Pro 16ACH6 as a system without RPMC. After the final deadline, we found that its Winbond W74M flash is a so-called Authentication Flash, which is functionally identical to RPMC flash and uses the same commands; SPI traces show that the system uses them during boot. Furthermore, we evaluated three additional desktop systems without RPMC flash. On the two AMD-based ones (Zen 2 and Zen 5), naive rollbacks of the NV state succeeded and reset the fTPM’s dictionary attack counters. Contrary to our original assumption, AMD SoCs therefore likely do not feature standalone rollback protection for their NV state. The Intel-based one (Core i5-14400) detected the rollback, consistent with the ME’s timer-based anti-replay counter described by Sklyarov [49]. We updated the abstract, Table 2, the contributions in § 1, § 5.3, the RPMC Integration and RPMC Security paragraphs in § 7, and § 8 accordingly, and we limited our recommendation to fall back to pre-RPMC rollback protection to Intel. In Affected Systems (§ 7), we added that AMD systems without RPMC are affected as well and described how Linux and fwupd report whether an AMD system relies on RPMC.

  • BitLocker brute-force speed. An optimization of our KVM’s attack loop reduced the duration of the 236-try BitLocker campaign from 8 minutes 40 seconds to 6 minutes 55 seconds (34.1 instead of 27.2 tries/minute). The worst-case time for a default-length 6-digit BitLocker PIN thus drops from 26 to 20 days. We updated the abstract, § 1, Table 3, § 6.3, § 7, and § 8 accordingly.

  • Disclosure updates. We added that we informed AMD about the naive rollbacks, and, following Intel PSIRT’s assessment, we now classify the HMAC Key Reuse as a security weakness rather than a vulnerability (§ 5.4.1, § 7).

  • Shortened abstract. We shortened the abstract to fit arXiv’s length limit; the findings it summarizes are unchanged.

References

References

  1. [1]Admin. 2023. Apple iOS Hardware Assisted Screenlock Bruteforce. https://www.mdsec.co.uk/2015/03/apple-ios-hardware-assisted-screenlock-bruteforce/
  2. [2]Oleg Afonin. 2022. Windows Hello: No TPM No Security | ElcomSoft Blog. https://blog.elcomsoft.com/2022/08/windows-hello-no-tpm-no-security/
  3. [3]Denis Andzakovic. 2019. Extracting BitLocker Keys from a TPM. https://pulsesecurity.co.nz/articles/TPM-sniffing.html
  4. [4]Apple. 2026. Apple Platform Security. https://help.apple.com/pdf/security/en-US/apple-platform-security-guide.pdfDOI
  5. [5]baanaanghwagen. 2021. WINHELLO2hashcat. https://hashcat.net/forum/thread-10461.html
  6. [6]BSI. n. d. Windows Hello for Business - Project "Windows Dissected".
  7. [7]Thomas Cannon. 2012. Into The Droid - Gaining Access to Android User Data. https://defcon.org/images/defcon-20/dc-20-presentations/Cannon/DEFCON-20-Cannon-Into-The-Droid.pdf
  8. [8]Western Digital. 2020. Replay Protected Memory Block (RPMB) Protocol Vulnerabilities. https://documents.westerndigital.com/content/dam/doc-library/en_us/assets/public/western-digital/collateral/white-paper/white-paper-replay-protected-memory-block-protocol-vulnerabilities.pdf
  9. [9]Elcomsoft. 2020. Elcomsoft iOS Forensic Toolkit 6.40: iPhone 5 and 5c Passcode Unlock | Elcomsoft Co.Ltd. https://www.elcomsoft.com/news/761.html
  10. [10]Florian M. Farke, Leona Lassak, Jannis Pinter, and Markus Dürmuth. 2022. Exploring User Authentication with Windows Hello in a Small Business Environment. In Eighteenth Symposium on Usable Privacy and Security (SOUPS 2022). 523–540. https://www.usenix.org/conference/soups2022/presentation/farke
  11. [11]Framework. 2025. Framework Intel Core Ultra Series 1 Mainboard Schematic. https://github.com/FrameworkComputer/Framework-Laptop-13/blob/8503dff62b25b27/Mainboard/Mainboard_Interfaces_Schematic_Intel_Core_Ultra_Series_1.pdf
  12. [12]Aya Fukami and Richard Buurke. 2024. Keyless Entry: Breaking and Entering eMMC RPMB with EMFI. In Proceedings of the 17th ACM Conference on Security and Privacy in Wireless and Mobile Networks. ACM, Seoul Republic of Korea, 145–155. doi:10.1145/3643833.3656114DOI
  13. [13]Aya Fukami, Richard Buurke, and Zeno Geradts. 2024. Exploiting RPMB Authentication in a Closed Source TEE Implementation. Forensic Science International: Digital Investigation 48 (March 2024), 301682. doi:10.1016/j.fsidi.2023.301682DOI
  14. [14]fwupd Project. n. d. fwupdPlugin: Host Security ID Specification. https://fwupd.github.io/libfwupdplugin/hsi.html
  15. [15]Georgios Gerontakis, Panayiotis Yannakopoulos, and Ioannis Voytiazis. 2025. From Vulnerability to Verification: Building a Tool to Remotely Test Windows Hello PIN Security on Systems without TPM. In Proceedings of the 28th Pan-Hellenic Conference on Progress in Computing and Informatics (PCI ’24). Association for Computing Machinery, New York, NY, USA, 100–106. doi:10.1145/3716554.3716569DOI
  16. [16]GigaDevice. 2024. GD25LR256E Datasheet. https://download.gigadevice.com/Datasheet/DS-00573-GD25LR256E-Rev1.6.pdf
  17. [17]Google. 2022. Gatekeeper. https://source.android.com/docs/security/features/authentication/gatekeeper
  18. [18]Joseph Haddad, Nikolaos Pitropakis, Christos Chrysoulas, Mouad Lemouden, and William J. Buchanan. 2023. Attacking Windows Hello for Business: Is It What We Were Promised? Cryptography 7, 1 (March 2023), 9. doi:10.3390/cryptography7010009
  19. [19]Texas Instruments Incorporated. 2019. TMUX1574 Datasheet. https://www.ti.com/lit/ds/symlink/tmux1574.pdf
  20. [20]Intel. 2013. Serial Flash Hardening Product - External Architecture Specification. https://www.intel.com/content/www/us/en/content-details/841356/serial-flash-hardening-product-external-architecture-specification.html
  21. [21]Intel. 2022. Intel® Converged Security and Management Engine (Intel® CSME) Security Technical White Paper. (Oct. 2022). https://www.intel.com/content/dam/www/public/us/en/security-advisory/documents/intel-csme-security-white-paper.pdf
  22. [22]Hans Niklas Jacob, Christian Werling, Robert Buhren, and Jean-Pierre Seifert. 2023. faultTPM: Exposing AMD fTPM’s Deepest Secrets. In 2023 IEEE 8th European Symposium on Security and Privacy (EuroS&P). IEEE, Delft, Netherlands, 1128–1142. doi:10.1109/EuroSP57164.2023.00069
  23. [23]JEDEC. 2015. Embedded Multi-Media Card (eMMC) Electrical Standard (5.1). https://www.jedec.org/standards-documents/docs/jesd84-b51
  24. [24]JEDEC. 2021. Replay Protected Monotonic Counter (RPM C) for Serial Flash Devices. https://www.jedec.org/standards-docs/jesd260
  25. [25]Bernhard Kauer. 2007. {OSLO}: Improving the Security of Trusted Computing. In 16th USENIX Security Symposium (USENIX Security 07). https://www.usenix.org/conference/16th-usenix-security-symposium/oslo-improving-security-trusted-computing
  26. [26]Ejin Kim and Houng-Kee Choi. 2021. Security Analysis and Bypass User Authentication Bound to Device of Windows Hello in the Wild. Security and Communication Networks 2021, 1 (2021), 6245306. doi:10.1155/2021/6245306
  27. [27]Dave Kleidermacher, Jesse Seed, Brandon Barbello, Stephan Somogyi, Android, Pixel, and Tensor security teams. 2021. Pixel 6: Setting a New Standard for Mobile Security. https://security.googleblog.com/2021/10/pixel-6-setting-new-standard-for-mobile.html
  28. [28]Macronix. 2023. MX7L12850F Datasheet. https://www.macronix.com/Lists/Datasheet/Attachments/9023/MX7L12850F%20V3%20128Mb%2%90v1.3.pdf
  29. [29]Yusuf Mehdi. 2024. Introducing Copilot+ PCs. https://blogs.microsoft.com/blog/2024/05/20/introducing-copilot-pcs/
  30. [30]Microsoft. 2020. Windows Hardware Compatibility Program - Windows 10 - Systems. https://learn.microsoft.com/en-us/windows-hardware/design/compatibility/whcp-specifications-policies
  31. [31]Microsoft. 2021. Windows Hardware Compatibility Specifications for Windows 11 - Systems. https://learn.microsoft.com/en-us/windows-hardware/design/compatibility/whcp-specifications-policies
  32. [32]Microsoft. 2022. Windows Hello Enhanced Sign-in Security. https://learn.microsoft.com/en-us/windows-hardware/design/device-experiences/windows-hello-enhanced-sign-in-security
  33. [33]Microsoft. 2022. Windows Hello for Business Overview. https://learn.microsoft.com/en-us/windows/security/identity-protection/hello-for-business/
  34. [34]Microsoft. 2023. BitLocker Countermeasures. https://learn.microsoft.com/en-us/windows/security/hardware-security/data-protection/bitlocker/countermeasures
  35. [35]Microsoft. 2023. Microsoft Pluton Security Processor. https://learn.microsoft.com/en-us/windows/security/hardware-security/pluton/microsoft-pluton-security-processor
  36. [36]Microsoft. 2023. Trusted Platform Module (TPM) Fundamentals. https://learn.microsoft.com/en-us/windows/security/hardware-security/tpm/tpm-fundamentals
  37. [37]Microsoft. 2024. Windows Hello for Business Frequently Asked Questions (FAQ). https://learn.microsoft.com/en-us/windows/security/identity-protection/hello-for-business/faq
  38. [38]Microsoft. 2024. Windows Hello for Business Policy Settings. https://learn.microsoft.com/en-us/windows/security/identity-protection/hello-for-business/policy-settings
  39. [39]Microsoft. 2026. BitLocker FAQ. https://learn.microsoft.com/en-us/windows/security/operating-system-security/data-protection/bitlocker/faq
  40. [40]Microsoft and Nazmus Sakib. 2025. Understanding the Microsoft Pluton Security Processor - Windows IT Pro Blog. https://techcommunity.microsoft.com/blog/windows-itpro-blog/understanding-the-microsoft-pluton-security-processor/4370413
  41. [41]Daniel Moghimi, Berk Sunar, Thomas Eisenbarth, and Nadia Heninger. 2020. Firmware TPM Meets Timing and Lattice Attacks. In 29th USENIX Security Symposium (USENIX Security 20). 2057–2073. https://www.usenix.org/conference/usenixsecurity20/presentation/moghimi-tpmarxiv.org/abs/1911.05673
  42. [42]Nexperia B.V. 2024. 74LVC16245A-Q100: 16-Bit Bus Transceiver with Direction Pin; 5 V Tolerant; 3-State. https://assets.nexperia.com/documents/data-sheet/74LVC_LVCH16245A_Q100.pdf
  43. [43]NSA. 2024. Trusted Platform Module (TPM) Use Cases. https://media.defense.gov/2024/Nov/06/2003579882/-1/-1/0/CSI-TPM-USE-CASES.PDF
  44. [44]Henri Nurmi. 2020. Sniff, There Leaks My BitLocker Key. https://pulsesecurity.co.nz/articles/TPM-sniffing
  45. [45]officedocspro. n. d. Microsoft Pluton as Trusted Platform Module (TPM 2.0). https://learn.microsoft.com/en-us/windows/security/hardware-security/pluton/pluton-as-tpm
  46. [46]Raspberry Pi Ltd. 2024. Raspberry Pi Pico 2 W Datasheet: An RP2350-Based Microcontroller Board with Wireless. (Nov. 2024). https://pip.raspberrypi.com/documents/RP-008304-DS-1-pico-2-w-datasheet.pdf
  47. [47]Raspberry Pi Ltd. 2024. RP2350 Datasheet. https://pip.raspberrypi.com/documents/RP-008373-DS-2-rp2350-datasheet.pdf
  48. [48]Samsung. 2025. Samsung Knox Mobile Security White Paper. https://docs.samsungknox.com/admin/fundamentals/whitepaper/samsung-knox-mobile-security/assets/Knox-security-white-paper-r1.pdf
  49. [49]Dmitry Sklyarov. 2017. Intel ME: Flash File System Explained. https://blackhat.com/docs/eu-17/materials/eu-17-Sklyarov-Intel-ME-Flash-File-System-Explained-wp.pdf
  50. [50]TCG. 2026. Trusted Platform Module 2.0 Library Part 0: Introduction. (March 2026). https://trustedcomputinggroup.org/wp-content/uploads/Trusted-Platform-Module-2.0-Library-Part-0-Introduction_Version-185_pub.pdf
  51. [51]TCG. 2026. Trusted Platform Module 2.0 Library Part 1: Architecture. (March 2026). https://trustedcomputinggroup.org/wp-content/uploads/Trusted-Platform-Module-2.0-Library-Part-1-Architecture_Version-185_pub.pdf
  52. [52]Texas Instruments Incorporated. 2009. TS3A27518E Datasheet. https://www.ti.com/lit/ds/symlink/ts3a27518e.pdf
  53. [53]The Linux Kernel Developers. 2022. ABI Documentation: sysfs-driver-ccp. https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-driver-ccp
  54. [54]Christian Werling, Tahmid Hanh, and Jean-Pierre Seifert. 2025. Not Discrete Enough: On the Inherent Insecurity of dTPMs for Measured Boot. In 2025 Annual Computer Security Applications Conference Workshops (ACSAC Workshops). 546–550. doi:10.1109/ACSACW69556.2025.00063DOI
  55. [55]Winbond. 2018. W25R128JV Datasheet. https://www.winbond.com/resource-files/w25r128jv%20rev%2009032018.pdf
  56. [56]Winbond. 2018. W74M12JW Datasheet. https://www.winbond.com/resource-files/W74M12JW%20RevA.pdf

Paper details

vlnc:W_mdsr6mwx
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents