AI Is Mass-Producing Hackers—The Barrier to Attack Is Falling

Key Takeaways
- AI makes vulnerability analysis and attack validation easier.
- Secure elements, PINs, and system design all shape hardware-wallet security.
- Third-party component flaws can become entry points for supply-chain attacks.
1. When Hackers Start Writing Code with AI
AI has swept into everyday work. When people need a small tool, they increasingly start by explaining what they want, asking AI for a first version, then running and revising it. A few rounds can be enough to get a working program.
AI is taking on many of the most laborious, experience-intensive parts of security analysis. Tracing call chains, mapping memory, locating faults, and repeatedly modifying test tools once demanded round after round of manual work. AI can now help move those tasks forward. People still set the direction and verify the results, while AI handles much of the analysis and trial and error needed to turn an idea into a testable approach.
The same capabilities can support attacks. One person asks AI to analyze project code and build features; another asks it to trace calls, read memory, and modify tools to find a way into a network or device. The work is similar. Its purpose depends on the person making the request.
This is how AI lowers the barrier to attack in practical terms. Many people used to get stuck on repetitive tasks that also required specialist experience. Someone with basic coding and hardware knowledge can now use AI's analysis to explore further. Even without a programming background, scammers may use AI to build convincing phishing sites.
We will use a study by the OneKey Anzen team to show what AI contributes to hardware attack analysis: assessing a wallet with three secure elements and examining how far an attacker can progress with AI assistance.
The case is instructive because it begins with a USB vulnerability, a class of implementation problem that can occur in other devices too. Hardware wallets have dedicated security designs to protect digital assets. Following the analysis step by step helps the industry examine trust boundaries and helps readers understand what AI-assisted attacks actually involve.
Scope and remediation: This article revisits a joint audit by OneKey Anzen and Keystone. The issue affected older Keystone 3 Pro firmware integrating the USB SDK and was fixed in v2.4.0, released on April 1, 2026. The official advisory lists several prerequisites: physical possession of the device, knowledge of the correct PIN, an unlocked device, approval of the USB connection, and connection to an attacker-controlled computer. At the time of the advisory, neither party had found evidence of exploitation against users. The analysis below does not mean current firmware remains affected or that charging alone enables an attack. Official research and security update
2. What Is a Hardware Wallet?
A little background on blockchains makes hardware wallets easier to understand.
Think of a blockchain as a ledger maintained jointly by thousands of computers—a distributed network of servers. Cryptocurrencies such as bitcoin are recorded in that ledger. Rather like a registered asset, ownership is represented in the records rather than by cash held in your hand.
How do you prove that an asset is yours? Your recovery phrase gives access to the keys that authorize its use. Think of those keys as an electronic seal: whoever can apply the seal can authorize transactions. Unlike a bank card, it cannot simply be reported lost and replaced. Someone who obtains the necessary recovery information may gain control of the corresponding assets.
A hardware wallet is designed to protect that seal. A main controller communicates with the computer and coordinates the components; secure elements (SEs) store secrets and check access conditions. For a transfer, the computer prepares a transaction and the device applies the seal internally by generating a signature. The computer receives the signed document, not the seal itself.
This principle is already used in online banking tokens, payment cards, and identity cards: dedicated hardware stores secrets and performs sensitive operations internally. Hardware wallets apply the same idea to digital assets. Banking tokens, payment and identity chips, identity-card chips



Physical examples | The OneKey device illustrates hardware-wallet construction. Photos: OneKey's official teardown, BugWorkShop's teardown, and kuhnmi's payment-card close-up (CC BY 2.0, resized).
That makes hardware wallets useful research subjects: weaknesses found in them may also exist in other security devices. Their potential role is also expanding beyond storing the electronic seal.
As AI begins to make payments, sign requests, and act on people's behalf, identity and permission management become more important. One approach is to consolidate authorization behind a single approval point, with people deciding which actions can pass. Hardware wallets may be one way to implement that approval point.
With that background, let us follow the analysis of a hardware wallet and see where AI helps at each stage.
3. How AI Assists Hardware-Wallet Analysis, Step by Step
1. Start with a Common Bug
This case arose from a joint audit with another wallet manufacturer. Our objective was to assess the device with AI assistance and examine how far an attacker could progress through a normal usage interface. The first question was where to begin.
The wallet is marketed as an air-gapped cold wallet: it has neither Bluetooth nor Wi-Fi, and transactions are exchanged through its camera, SD card, or USB connection.
It contains three secure elements. The material needed to recover the wallet is distributed across components, with the main controller relaying requests and responses. These basic details are public; beginners can also ask AI to help interpret the product documentation and open-source firmware.
We narrowed the entry points to USB and the SD card. This research path concerned normal device interfaces without opening the case, so probes, wiring modifications, fault injection, side channels, JTAG/SWD debug ports, and bootloader attacks were outside its scope. USB is a connection users may encounter when signing or charging.

The direction was now clear: investigate whether USB could affect the main controller, cause it to execute attacker-supplied code, and then reuse existing device workflows to request the necessary material. USB was also a promising place to look because protocol-stack implementations have a long history of memory-safety bugs.
This path applies to the affected older firmware and remains subject to the official prerequisites above. Unlocking the device and approving the USB connection are required; plugging in a cable or charging does not by itself open the attack channel.
A USB protocol stack implements the rules that let a computer and a device communicate. Chip vendors turn the USB standard into code and distribute it in a software development kit (SDK), which device manufacturers integrate into their products. The code receiving and handling USB messages is the USB stack.
A shared interface does not guarantee consistent implementation quality or maintenance. Some code remains in use for years without fresh scrutiny. Vulnerabilities often arise in those implementation details: a single flaw may allow an attacker to trigger a problem using a host-controlled message field.
The stack has many layers—descriptors, control requests, class commands, and data endpoints. There are numerous entry points, so the search needs a narrower focus.
We focused on length fields. They can be controlled externally and determine how many bytes the device reads or writes. The device uses them to decide where to store incoming data and how much memory to access.
Trusting a computer-supplied length can lead to out-of-bounds access. Suppose a buffer holds only 8 bytes, but a request asks the program to write 1,000. If the program proceeds, the excess data overwrites adjacent memory and may create an opening for injected code. The key question is whether every length is checked against the available capacity before the actual access.
Lengths are passed around so routinely that each layer may assume an earlier layer has checked them. One such assumption can let data pass through the entire chain without a valid boundary check.
Most paths do have effective checks. The hard part is finding the exception. Traditionally, researchers trace a length from its entry point through each function and file, recording its origin, transformations, eventual use, and any validation along the way.
A single function may simply receive the length and pass it on. The full chain can be much longer: a value may change hands a dozen times, cross several files, be truncated, receive an offset, or be stored in a structure and retrieved later.
By the third file, a reader may have lost track of where the original value came from. Many fields need this complete treatment. The task demands both experience and stamina: experience guides the investigation, while sustained attention keeps the details accurate.
AI can help organize this material. Given the relevant source, it can trace a length through the call graph, map the path from input to memory access, and help screen suspicious locations. Researchers then verify whether the checks work and whether a suspected problem can be reproduced.

The issue we found was an out-of-bounds write. The device had an 8-byte buffer but did not adequately constrain the externally supplied length, allowing excess data to reach adjacent memory. The flaw was in a third-party USB package integrated into the wallet.
Why can an access continue beyond those 8 bytes? They occupy just a small part of memory, with other data next to them. The processor does not automatically know the size of an array declared in source code.
A buffer is a memory region defined by a starting address and a length. Once an access crosses its boundary, it may continue if the neighboring memory is accessible. An out-of-bounds read can expose adjacent data; an out-of-bounds write can change it. An ordinary length field can therefore become a way to affect the device's internal state.
Crossing the boundary is only the first step. We still need to determine which data maintains communication, which affects execution, and what each modification would do. Entering a room does not tell you how all its internal mechanisms work.
2. What Can the Vulnerability Actually Do?
We began testing the vulnerability's effects. Our first write immediately dropped the USB connection.
That interrupted further testing, but it also provided a clue: the buffer probably sat near state needed to keep USB working, and the overwrite had damaged it.
Program data sits in adjacent memory locations, with its exact layout determined by compilation. An 8-byte buffer[8] may be followed by a connection state such as usb_state, a receive length such as rx_len, or a callback pointer.
Imagine a row of lockers. Developers assign the labels, but the processor accesses addresses. If asked to write 1,000 bytes continuously, it will not automatically stop at each variable's boundary. Data needed for normal operation may be overwritten too.
Keeping USB stable means preserving critical state: modify regions that do not disrupt normal behavior, or retain important values while writing through the surrounding memory.
Precise changes require mapping the source code to the actual memory layout. Source code describes variables and structures; a memory dump usually provides addresses and values. Their correspondence must be checked field by field.
This is one of the most experience-intensive and time-consuming parts of the process. Researchers infer positions from field types, lengths, and alignment, then compare them with the real device. One incorrect offset can shift everything that follows. Beginners may struggle even to interpret the structure layout.
AI can assist with these repeated comparisons. Source code is text, and memory can be represented as hexadecimal data, so both can be analyzed together. AI can also help modify test tools while the researcher uses experimental results to decide what comes next. An agent can connect repeated analysis and tool calls to refine the memory map incrementally.
After several experiments, we found a write pattern that changed the target region while preserving the data needed for normal operation, keeping the device connected.
The next step was to redirect execution toward injected code. A natural target is a function pointer: it identifies which function will run next, rather like an entry in a program of events. Changing that pointer may change the execution path.
Devices normally defend against this. Memory-protection mechanisms can mark a region as writable but non-executable, with a hardware unit enforcing the permissions.
When that protection works, the processor refuses to execute injected code even if a function pointer targets it. The device in this study had a configuration error in its memory protection unit (MPU), leaving an opening at this stage.
If the pointer can be changed and the injected code can execute, the attacker gains code execution on the main controller. Firmware signatures check the authenticity of firmware loaded at boot. Memory changes made during execution also require effective runtime protections.
Whether control of the main controller leads to wallet-recovery secrets depends on the authorization boundaries of the entire security design.
3. Why Does Controlling the MCU Not Immediately Reveal the Recovery Phrase?
An obvious next step is to read memory and look for the recovery phrase.
Hardware wallets store recovery material in encrypted form, decrypting it temporarily for operations such as signing or export and clearing it afterward. Reading memory does not automatically reveal plaintext. We first need to locate the encrypted data.
The open-source firmware supplies the clues. AI-assisted code analysis identifies the encrypted seed material in a secure element's storage pages: the first 16 bytes of Page 0 hold the IV, while Page 1 holds the ciphertext.
The next task is to match fields in the code with data from the device: which address corresponds to each field, which bytes are the IV, and which are the ciphertext.
AI again helps with this time-consuming matching process, allowing us to locate the relevant data.
Once we have the ciphertext, two approaches remain: break the encryption, or reuse the device's own decryption process.
Approach One: Break the Encryption Directly
First, consider what encryption does. It works like a keyed lock: locking and unlocking are easy with the key. Without it, the ciphertext alone should be of little help.
Let E be the original data, C the ciphertext, and K the encryption key.
Their relationship is:
Encrypting E with K produces C; decrypting with the same key recovers E. The attack considered here would recover the original data without K. Secure algorithms are designed to make that computationally impractical.
How can that security be measured? Cryptography provides a precise way to frame the question.
Suppose you choose two plaintexts, E₀ and E₁. A computer randomly picks one, encrypts it with K, and shows you C. Can you tell which plaintext was selected?
For secure encryption, the following condition should hold:
Pr[correct guess] is the probability of guessing correctly; ½ is the success rate of a random guess. The vertical bars take the absolute difference between the probabilities. This captures the idea behind semantic security.
You choose two plaintexts, receive the encryption of one, and still cannot do meaningfully better than guessing. Even radically different plaintexts—such as 00000000 and 11111111—should not leave a useful distinguishing clue in the ciphertext. That is the central idea: encryption should not reveal which answer is right.
Two choices make the basic idea easy to explain, with a random-guess baseline of ½. With four candidates the baseline is one quarter, and with more candidates it is lower still. The essential point is that ciphertext should not give an attacker a significant advantage over guessing.
If an algorithm offers no useful mathematical shortcut, an attacker must try candidate keys. An n-bit binary key has 2ⁿ possible values. On average, finding the right one takes about half the search space, or 2^(n−1) attempts. At r trials per second:
Take n = 256, the key size of AES-256, and r = 10¹⁵: a hypothetical million machines each testing a billion keys per second. Even at that enormous assumed rate, t is approximately 2×10⁵⁴ years.
The universe is about 1.4×10¹⁰ years old—a difference of roughly 10⁴⁴ times. An idealized quantum search using Grover's algorithm reduces the search complexity to its square root, roughly the equivalent of a 128-bit search. Under the same simplified rate assumption, that still takes more than 10¹⁵ years. This is an illustration, not a forecast of real quantum-hardware performance.
Those costs make direct key search impractical. Established encryption algorithms undergo years of cryptographic scrutiny; an effective break would be a major result. We therefore returned to the device's implementation.
The question became which code, credentials, and materials the device uses for decryption, and whether a compromised main controller could reuse that path.
Approach Two: Reuse the Device's Decryption Workflow
If the device needs to decrypt data to sign, its firmware must contain a path that obtains the necessary key. The code that reconstructs the key becomes the real target.
With AI helping us trace the decryption code, we found this relationship:
After credential verification, chip A performs two KDF stages internally and three SHA-256 operations to produce a 32-byte A share. Chip B XORs a protected storage page with a digest derived from the passcode, producing a 32-byte B share. The two shares form 64 bytes, which pass through salted hashing and SHA-512; the first 32 bytes are used as key material. That material is finally combined with the 32-byte AES key programmed into OTP to obtain the actual decryption key. The third secure element mainly handles authentication such as fingerprints and does not play the same role in this derivation.
Think of a safe with three locks: all three keys are needed to open it. They represent the material from secure element A, secure element B, and OTP.
Here, passcode means the device PIN. The salt and AES key are separate, per-device random values programmed into one-time programmable (OTP) memory during manufacturing. They cannot be changed after programming, but may still be readable. The main controller's function f ultimately uses these materials. If the controller is compromised and the required material can be obtained, an attacker can attempt the same recovery process.
How could those materials be obtained?
Start with the salt and AES key in OTP. On this device, the MPU controls read permissions for that memory, and the main controller can reconfigure the MPU. Control of the MCU therefore creates an opportunity to change those permissions and read the material.
The PIN is another required input alongside the OTP material.
4. What Happens to PIN Attempt Limits?
This section explains why offline verification no longer depends on the device's failure counter once verification material is readable under the experimental conditions. It does not remove this case's initial unlock and USB-approval requirements: the official advisory requires knowledge of the correct PIN.
Even when access already requires authorization, a security review should examine whether a compromised MCU can export verification data and whether the device's attempt limit remains effective afterward.
The PIN has six digits, and the device is configured to erase itself after five incorrect attempts. How should that limit be assessed?
We asked AI to help locate the PIN-verification workflow and determine exactly how the device checks an input.
A device generally stores a verifier rather than the plaintext PIN: v = F(p, s). Here p is the PIN, s is device-specific material, and F is the firmware's computation. In this case the computation runs on the main controller. Even if p is unknown, v, F, and s can be read under the experimental conditions.
That makes it possible to reproduce verification outside the device. Calculations that never pass through the wallet cannot increment its failure counter. PIN guesses can be checked entirely on a computer.
The design assumes the main controller remains trustworthy. Chip B applies different access conditions to different data: the verifier is readable before verification, while the B-share material used for decryption receives stronger protection. In normal operation, the controller counts failures and triggers erasure at the five-attempt threshold.
Once verification is possible offline, the 10⁶ combinations of a six-digit PIN form a finite search space outside the device's attempt limit. One experiment found the PIN after 1.831 seconds. The further-reading section explains what this timing does and does not say about the cost of an individual check.
With the PIN available, the remaining input is in place. Following the firmware's algorithms produces the credentials needed for the subsequent workflow.
When all the required material is available, the recovery phrase can be reconstructed, potentially giving an attacker control over the corresponding accounts.
5. What Does the Risk Look Like to a User?
So far, we have followed the researcher's analysis. Now consider the situation from the wallet owner's perspective.
Scenario One: Older Firmware and an Approved USB Connection
The first questions are whether the device runs affected older firmware and whether all the advisory's prerequisites hold. Malware on a computer alone does not establish that a locked wallet can be compromised directly.
This USB path requires an unlocked device, an approved USB connection, and an attacker-controlled computer. Simply connecting a charging cable does not satisfy those conditions.
Only after those conditions hold can the malicious host reach the vulnerable USB request-handling path.
The research demonstrates that conditional path: the host sends a crafted request, affects the MCU, and then follows the device's existing workflows to obtain the required material.
If all material needed to reconstruct the recovery phrase can be collected, the corresponding assets may be at risk. This result cannot be generalized to every firmware version, usage mode, or hardware wallet.
Scenario Two: Physical Possession of the Device
Physical access also opens other research directions. The following describes general principles of physical attacks; it does not claim that these techniques were demonstrated in this case or that possession alone bypasses the PIN.
Opening a device, probing it, or applying fault injection can help investigate the MCU's protection boundaries. Processors depend on power and clock signals to execute instructions. On certain devices and under specific experimental conditions, briefly disturbing those signals may affect a security check. Success depends on the chip, its configuration, and its defenses.

Even after MCU control is obtained, access to further material still depends on credentials, secure-element authorization, and other independent protections.
The case is a reminder that dedicated security features need to be assessed as an integrated system. By connecting several implementation flaws with AI assistance, an attacker may gradually cross boundaries the design intended to enforce.
4. What Did AI Contribute?
Putting the stages together gives the following chain:
In this research, AI mainly assisted vulnerability analysis, test-tool changes, code navigation, and data matching. Researchers set the approach and direction; AI took on much of the painstaking work that depends on experience, helping analysis and validation keep moving.
For newcomers to embedded systems, understanding source code and debugging behavior is often the main obstacle. AI can explain code, organize clues, and help check hypotheses, making it possible to progress past stages that previously stalled an investigation.
Building websites offers a familiar comparison. People without programming experience once needed a substantial investment of time; today, natural-language requests can produce usable pages. Scammers can use the same capability to imitate banks and other services, making phishing pages easier to create and harder to distinguish.
AI's role is extending into further parts of the workflow.
Cloud-based AI tools generally impose safety restrictions. Tools without comparable limits may be used for a wider range of attack tasks. Combined with laboratory power supplies, probes, and fault-injection equipment, AI can also help write control software and organize measurements.
Raelize published a concrete example in May 2026. Researchers assembled the hardware, supplied wiring information and reference material, and used Claude Code to write control programs for fault-injection equipment and a laboratory power supply. The experiment helped reproduce a known secure-boot bypass on an early ESP32. Raelize's experiment report
Secure boot checks firmware authenticity before it runs. The verification code assumes that the processor executes its instructions correctly. Real chips depend on physical conditions such as supply voltage and clock timing. Fault injection briefly disturbs those conditions—for example with a voltage glitch—to induce an incorrect operation that may bypass a check.
From reading code to running experiments, AI can connect scattered information and reduce the burden of processing it. That capability supports both attack analysis and defensive work.
Hardware and software security therefore remain central issues in the AI era. NVIDIA's work on hardware-isolated execution and permission boundaries in AI infrastructure shares a broad principle with isolating sensitive operations in a hardware wallet. NVIDIA Sentry overview, agent-safety architecture, DSX POD announcement. As AI reduces the cost of analysis and automation, network and hardware defenses require continuing investment.
5. Supply-Chain Security Matters Too
The research highlights an often overlooked component: the vulnerable USB code came from a chip vendor's SDK. A security review must therefore cover wallet application logic, low-level drivers, communication stacks, and the configuration and interaction of those components within the complete device.
Banking tokens, security tokens, and payment terminals have comparable divisions of responsibility. Device software processes outside requests and passes work to components that store secrets and perform protected operations. The assets differ, but the underlying mechanisms have common features. PCI payment-terminal security standards
Low-level components are often shared across products. A chip vendor supplies one SDK, and several device manufacturers build on it. A flaw in shared code can therefore spread its impact through the supply chain.
Manufacturers cannot limit their reviews to application code they wrote themselves. Users buy a complete device, regardless of who authored a vulnerable component. Even sound wallet logic can be undermined by a driver. The device manufacturer remains responsible for assessing the security of the complete system.
Remediation also requires coordination: the chip vendor fixes its SDK, device manufacturers identify affected products and adapt and test firmware, and users install the updates. This case was fixed in v2.4.0; users on affected older versions should update through official channels. Connecting each risk to its affected versions prevents historical research from being mistaken for the current state of a product.
Security work in the AI era needs to span the product lifecycle, from hardware and software design to packaging authenticity, communications, operations, and after-sales repairs. Each stage needs appropriate awareness and verification.
The OneKey Anzen team also incorporates lessons from this research into its own designs. AI can organize clues for attackers, and it can help us review code and test assumptions too.
Visual Appendix: How Random Data Becomes a 24-Word Recovery Phrase
A recovery phrase acts as a way to restore a wallet. Here is how a sequence of random bits becomes twenty-four words.
In BIP39's 24-word format, the starting data has 256 bits. Each is either 0 or 1, giving 2²⁵⁶ possible combinations. Eight checksum bits are computed from that data and appended, producing 264 bits.
The result is split into groups of 11 bits. Each group represents one of 2¹¹ = 2048 indices, matching the entries in a 2048-word list. Since 264 ÷ 11 = 24, the result is twenty-four words.
256 + 8 = 264 = 24 × 11.
The final 8 bits are derived from the original data. They add no randomness and do not make guessing harder. Their purpose is to detect some transcription errors; they are not encryption. The word list simply maps indices to words and can be public.
The mnemonic and an optional independent passphrase generate a seed, from which account keys are derived under rules such as BIP32. The same phrase and passphrase, used with the same derivation rules, restore the same account. BIP39 specification, BIP32 specification
Further Reading
1. Secret Sharing and Independent Authorization
Splitting a secret does not automatically give each share independent access control. If the same compromised party can still request all the shares, splitting alone does not provide an additional computational barrier to that party.
Consider a simple two-share XOR scheme. Let the secret be , and choose mask uniformly from , independently of . Define two shares:
Here denotes bitwise XOR.
First, a single share reveals no information about . For any fixed secret value and share value ,
The right-hand side does not depend on , so the conditional distribution of does not depend on . Observing therefore changes no beliefs about . Likewise, and is independent of , so also reveals nothing about . These statements require a uniform, independent mask that is not reused across secrets.
Next, the two shares reconstruct the secret because XOR cancels itself:
The scheme is thus correct: either share alone gives no information about the secret, while both shares together recover it deterministically.
This separates two security assumptions. Secret sharing addresses the loss of one share; it does not automatically address a hijacked request path. If a compromised controller remains an authorized requester and the other chips return their shares, the attacker can collect the material through the normal protocol without cryptanalyzing the ciphertext. The design question is whether each share has authorization conditions independent of the MCU. Compromising the MCU should not automatically authorize every other component.
2. Offline PIN-Search Timing and the Role of Salt
A six-digit decimal PIN has candidates. If every verification must run on the device, failure counting, delays, and erasure thresholds can make exhaustive search impractical. Once the verification material can be exported and the computation reproduced on a host, the device no longer controls the attempt count. In this simplified model, search cost depends on candidate count and per-check time .
Assume the PIN is uniformly distributed and the search tries candidates without repetition. The correct PIN is equally likely to occupy any position from , so the expected number of trials is
The corresponding expected time is .
The reported seconds cannot simply be divided by . The search stops when it finds the PIN, so that time covers the first checked candidates, not necessarily the whole space. If the correct PIN's position is , the time per check is
Only when does seconds follow. For any , is strictly larger. Thus is a lower bound on the per-check time. The time to exhaust the full space, , is likewise at least seconds.
For example, if sequential search starts at and the PIN is , then and . Checking all candidates takes approximately seconds, with an expected search time of about seconds. The numbers vary with , but the qualitative point remains: under these experimental conditions, offline verification without an attempt limit makes the -candidate space feasible to exhaust on ordinary hardware.
Finally, salt makes the same passcode map to different verifiers on different devices, preventing a precomputed table from being reused across them. It changes the amortized cost across targets rather than enlarging one device's candidate space. Once the relevant material is available for a given device, the space remains and the per-check cost remains .
Conclusion
AI is taking on much of the most exhausting, experience-intensive analysis and trial and error. Tracing code, matching memory, finding faults, and modifying tools can now move forward through faster iterations. Researchers still judge the direction and validate the outcome, while AI reduces the time and effort needed to implement an idea. This is where the barrier to attack is falling in concrete terms.
The same capabilities support defense: reviewing code, validating vulnerabilities, and examining the supply chain more efficiently. Understanding how AI takes on this work helps us assess risk more accurately and improve protections where they matter.
FAQ's
AI can help read firmware, trace parameters through call chains, map source structures to memory, organize experimental results, and modify testing tools. Researchers still define the goals, constraints, and validation methods and determine whether the results are reliable.
The path discussed here exploits implementation and authorization weaknesses to obtain the material needed for decryption; it does not break algorithms such as AES. AI primarily assists code and data analysis. This research does not demonstrate a break of modern encryption.
Chip count alone is not enough. Splitting secrets must be paired with independent authorization. If several chips unconditionally trust the same compromised MCU, splitting the material does not stop that MCU from collecting it through existing workflows.
The device can count and restrict checks only when they pass through it. If verification material can be exported and the calculation reproduced elsewhere, those attempts no longer reach the device. The risk depends on export permissions, the verification method, and the authorization design.
Hardware wallets often depend on chip vendors' drivers and communication stacks. A shared component flaw may affect several products, so manufacturers need to assess the integrated system and coordinate upstream fixes, firmware adaptation, testing, and user updates.






