ZICQ
中 Log in / Sign up
Newsroom Research & Papers #MiniMax Cyber #AI-Assisted Cryptanalysis #AI Agents #Cryptographic Security #AI for Science

MiniMax Cyber Extends AI-Driven Cryptanalysis to Executable Attacks

Avatar of Mr.Xu

By Mr.Xu Compiled & Reviewed by Editorial

Published:

中文阅读 (Chinese) English Version
Co-reading Select any sentence in the article to highlight, annotate, or copy a quote card. Join discussion ↓

Summary:MiniMax says MiniMax Cyber connects mathematical reasoning, executable attack generation, and outcome verification into a single cryptanalysis workflow. On Tier 2 of CryptanalysisBench, the system reportedly constructed collision, key-recovery, signature-forgery, and plaintext-recovery attacks against several NIST candidates without previously known practical attacks. It also reports new results on reviewed designs including COLM, SBC-VOLE, and ARADI, alongside claimed speedups of hundreds to te


Core Claim

MiniMax reports that MiniMax Cyber organizes cryptanalysis into an executable loop linking mathematical reasoning, attack-code generation, and secret-recovery verification. The system reportedly produced results against NIST candidates without known practical attacks, cryptographically reviewed designs, and classic public-key challenges.

Unlike a research model that merely proposes attack ideas, this workflow requires the generated program to recover a secret, produce colliding outputs, or create a valid forgery within an explicit data and compute budget. A mathematical error or implementation error therefore causes a direct failure rather than being hidden behind a plausible narrative.

Tier 2 of CryptanalysisBench contains 135 publicly reviewed schemes with no known practical attacks and seven production-strength challenge schemes. MiniMax says it used the same setup as the original paper in blind runs, but the available material does not disclose the model version, prompts, agent scaffold, toolchain, per-task success rate, or a complete reproduction package.

From Mathematical Hypothesis to Executable Attack

Cryptanalysis differs from ordinary software vulnerability scanning. It can attack the design itself, including block structures, algebraic relations, proof assumptions, and security protocols, while implementation audits focus on incorrect code or secret leakage. The reported results span both categories and should not be evaluated as one homogeneous claim.

A complete workflow has four layers:

  1. Structural abstraction: identify exploitable invariants, weakened paths, or algebraic dependencies from specifications, proofs, and reference implementations rather than merely matching known vulnerability patterns.
  2. Attack synthesis: translate the derivation into executable solvers, collision searches, or forgery programs while respecting parameter sets, query limits, and memory boundaries.
  3. Systems optimization: improve data structures, arithmetic width, memory layout, and search pruning so that a theoretical attack fits a practical resource budget.
  4. Outcome verification: require secret recovery, output equality, or forgery acceptance as the terminal condition. This provides a much stricter check than a model's self-assessment.

MiniMax does not disclose MiniMax Cyber's model size, training method, decoding parameters, or agent orchestration. It is therefore difficult to attribute the results precisely to base-model reasoning, reinforcement training, or long-horizon tool use.

Reported Results on NIST Candidates

| Target | Reported result | Technical implication | |---|---|---| | Waterfall-256 | Found collisions in 0.045 seconds on one core across the tested output lengths | Claimed first practical collision construction rather than only a theoretical complexity estimate | | Blender-256 | Found full-round collisions in 0.36–2.3 seconds on one core | Reportedly attacked both the 64-bit word-size implementation issue and the underlying construction | | LOCKER | Reduced the solver matrix from 42 PB to 58 MB and recovered the shared secret for all parameter sets in about 2 seconds | Solved the underlying rank-metric decoding problem rather than merely exploiting a code bug | | ROLLO-I-128 | Recovered an equivalent secret key from the public key in about 6 seconds on one core | Turned full-parameter key recovery from theory into practical execution | | DRS | Exploited an official verification bug that used bitwise & instead of logical &&, forging signatures in 0.1–0.8 seconds with zero signing queries | Demonstrates implementation-audit value, but does not break the underlying lattice problem | | RQC-128 | Recovered plaintext from ciphertext in 0.41 seconds using randomness-sampling leakage | Turns an implementation-level secret leak into an executable recovery pipeline | | LAC-128 | Identified a missing ciphertext copy in a decryption-failure branch and hashing of uninitialized memory into the derived key | Exploits an implementation defect that may break chosen-ciphertext security |

The system also reports skipped core rounds, corrupted sampling, and out-of-bounds accesses in the reference implementations of ISAP, Shamash, QC-MDPC KEM, REMUS-N1, and ForkAE, totaling more than a dozen previously unreported implementation flaws.

For an n-bit output, a generic birthday collision search requires roughly 2^(n/2) evaluations in order of magnitude. The sub-second results for Waterfall-256 and Blender-256 should therefore not be interpreted as generic hash-breaking capability. They indicate exploitation of a specific construction, truncation behavior, or implementation path.

Reviewed Designs and Classic Hard Problems

For publicly reviewed constructions, MiniMax additionally reports:

  • COLM: valid authenticated-ciphertext forgery with no decryption queries and only two encryption queries, violating integrity in the standard model. This is not equivalent to direct plaintext recovery.
  • SBC-VOLE: full secret-key recovery from a single known signature in approximately 0.06 seconds across all six parameter sets and both official code variants. Signatures are commonly public, making this attack chain particularly consequential.
  • ARADI: practical key recovery extended from five to eight rounds in 2.4–16 seconds on one core, plus new theoretical records for rounds nine through twelve. The nine-to-twelve-round results remain theoretical boundaries rather than practical breaks.

For schemes without an obvious design flaw that depend on classic hardness assumptions, MiniMax says the system combined algebraic-structure exploitation with low-level optimization on modern processors. It reportedly solved dozens of previously unsolved high-order instances in public cryptographic challenges and achieved measured speedups of hundreds to tens of thousands of times over recent solvers or prior multi-GPU systems.

The reduction of LOCKER's solver matrix from 42 PB to 58 MB is especially notable. A dense linear-algebra representation can make the search space expand rapidly with dimension and parameters. Discovering hidden structure and replacing that representation with a compact formulation or more effective constrained solver can produce a reduction of this magnitude. The optimization nevertheless depends on the specific instance and cannot be generalized automatically to all rank-metric, lattice, or multivariate problems. The available material does not provide a complete challenge list, solver budgets, or end-to-end timings.

How Credible Are the Results?

Blind runs and executable validation raise the evidentiary bar, but they do not replace independent review.

  • Training contamination remains possible: NIST specifications, proofs, and attack papers are public. A blind run reduces immediate benchmark-specific tuning but does not prove that the model never encountered relevant structures during pretraining.
  • The aggregate denominator is missing: successful cases are listed, but the status of all 142 Tier 2 schemes, the overall success rate, and failure reasons are absent. Tier 1 known attacks are also not shown as a control experiment.
  • Timing scope is unclear: figures such as 0.045, 0.06, and 2 seconds are more likely attack-program runtimes. Whether model inference, prompt generation, compilation, restarts, and preprocessing are included is unknown.
  • Baseline fairness needs checking: prior solvers may have used multi-GPU clusters while some new results count single-core execution. Conversely, excluding AI generation and debugging cost inflates practical efficiency.
  • Theoretical and practical findings need separate review: full-round collisions, key recovery, and valid forgeries can be checked directly. ARADI's nine-to-twelve-round records and alleged gaps in security proofs still require mathematical review.
  • Implementation bugs are not algorithm breaks: DRS, RQC-128, and LAC-128 demonstrate that reference code may be insecure, but their results do not show that the underlying cryptographic assumptions have failed.

Engineering Trade-offs and Real Cost

Attack runtime is not end-to-end efficiency. A solver may finish in seconds while the agent still requires substantial model inference, context processing, compilation, parallel trials, and expert review before producing that solver.

Structured dimension reduction is not universal acceleration. The 42 PB-to-58 MB result depends on a particular matrix and secret structure. When an instance loses regularity, the search space can expand again. Scaling curves across parameter sizes and structural families are therefore essential.

Implementation flaws are cheaper to fix, but design flaws are deeper. Correcting && versus &, initializing memory, or repairing sampling can eliminate several vulnerabilities. If the underlying construction is practically broken, maintainers may need new parameters, a redesigned primitive, or outright withdrawal.

Automation raises the verification burden. Executable attacks eliminate many vague claims but do not automatically rule out side channels, data leakage in test instances, or mistakes in theoretical boundary conditions. Independent implementations and cryptographers remain necessary.

The capability has an obvious dual-use risk. The same system can help standards bodies uncover flaws or help attackers build exploits. Disclosure should follow coordinated vulnerability processes so that patches and migration paths are ready before weaponizable details become public.

Deployment Guidance

  1. Treat MiniMax Cyber as a cryptanalytic red-team assistant, not the final adjudicator. It is well suited to triaging specifications, proofs, and reference implementations, while production-grade conclusions still require expert sign-off.
  2. Create a reproducibility gate. Pin model, prompts, tools, seeds, compiler, and hardware; retain complete traces, generated code, and logs; then rerun from a clean environment.
  3. Require independent cross-validation. Use at least two independent implementations to confirm collisions, key recovery, and forgeries. Theoretical claims also require checks of algebra, complexity assumptions, and edge conditions.
  4. Standardize cost reporting. Report end-to-end model and solver time, peak memory, query counts, preprocessing, failure rates, and variance across repeated runs rather than only the best attack time.
  5. Isolate agent execution. Apply restricted containers, CPU and memory quotas, network allowlists, and secret scanning so generated code cannot access unrelated credentials or exfiltrate research data.
  6. Separate response tracks by risk. For deployed constructions, implementation vulnerabilities and mathematical design failures require different responses. Patching and regression testing may suffice for code defects, while an underlying break may require key rotation, parameter migration, or retirement.
  7. Prioritize independent replication. LOCKER, ROLLO-I-128, SBC-VOLE, and COLM provide clear security boundaries and verifiable terminal conditions, making them strong initial cases for third-party verification.

Source: MiniMax Blog (2026-11-20)

— END —

Tags: #MiniMax Cyber #AI-Assisted Cryptanalysis #AI Agents #Cryptographic Security #AI for Science

Editorial & Fact-Checking Note: This article is compiled from primary research, official release documentation, and source papers by the ZICQ Newsroom pipeline with automated entity verification and human editorial review. If you notice any technical inaccuracy, please submit a correction via our corrections policy or email our editorial desk directly.

What's your take on this story?
🚀 Explore & Submit Works

Community Comments

Loading live comments and annotations…