A research paper based on L. Apeltsin’s preprint “A CryptoCubic Protocol for Hacker-Proof Off-Chain Bitcoin Transactions.” The paper analyzes the CryptoCubic protocol, proposed for secure off-chain Bitcoin transfers via 2-of-2 MultiSig, signature share encryption, self-destructive storage, and token-based authentication. We reconstruct three lines of argumentation from the preprint—regular MultiSig, “CryptoSquare,” and authentication—and examine the basis for the claimed “hacker-proof” security. The key conclusion is that the protocol’s security is conditional. It relies on an honest server, perfect variable isolation, an unproven “100% secure” self-destructive storage, and cryptographic primitives not specified in the preprint. A separate internal ambiguity was identified in the authentication section: the server stores a hash Sig_S, and the user compares it with the ciphertext hash Es; when read literally, the verification fails. This is especially important in a quantum context: if the protocol is instantiated using ECDSA/ECC, Shor’s algorithm compromises signatures and key exchange; symmetric primitives require 256-bit keys, taking Grover into account. We formulate testable hypotheses, criteria for their refutation, and a plan for a reproducible audit with formal verification and hybrid post-quantum migration.
Content
- Statement of the problem and research question
- Selected questions from the constructor
- Reconstructing CryptoCubic: Three Lines of Evidence
- Auditing the “hacker-proof” assertion
- Quantum analysis and post-quantum migration
- Testable hypotheses and refutation criteria
- Experimental design and reproducibility
- Connection of works and synthesis
- Limitations of the study
- Conclusion
- Sources
1. Statement of the problem and research question
Can an off-chain protocol that calls itself “hacker-proof” survive not only a classical attacker but also a quantum adversary? This is precisely the question that makes CryptoCubic’s preprint interesting for a modern research paper. The preprint itself is written within the paradigm of “fast and free” Bitcoin transfers: a coffee buyer doesn’t want to wait six confirmations and pay a fee comparable to the price of a coffee. Off-chain transfers solve this problem, but they reintroduce the question of trust: who holds the keys, who verifies ownership, and what prevents an intermediary or hacker from stealing funds?
CryptoCubic proposes an answer: instead of storing both signatures in one place, they are shared between the user and the server using 2-of-2 MultiSig and encryption. User A doesn’t know Sig_S, and the server doesn’t know Sig_U; both parties are required to control the address ADD . When funds are transferred to user B, the protocol “re-encrypts” the signature share so that B and the server jointly control the address, and A loses the ability to obtain both signatures alone. It’s a beautiful design, but its security depends on the details.
The central research question of the paper is: under what explicit cryptographic assumptions and access model does the CryptoCubic protocol preserve the invariant “no participant obtains both signatures to an address ADD without the cooperation of the other party”, and what verifiable experiments are needed to confirm or disprove this claim under classical and quantum threat models?
We do not claim that the protocol has already been hacked. We demonstrate that the preprint’s “hacker-proof” claim is a conditional design assertion , not a proven security theorem. The quantum threat reinforces the need for such verification: Shor’s algorithm threatens the discrete logarithm in elliptic curves, and therefore could affect Bitcoin’s ECDSA signatures and asymmetric encryption if it is built on ECC/RSA. Moreover, a quantum adversary does not “override” self-destructive storage and access control—they attack cryptographic primitives, not the physics of the server.
2. Selected questions from the constructor
From the “Questions for Quantum Technology Research” constructor, questions were selected that directly relate the CryptoCubic engineering protocol to the research problem being tested. Questions that were not applicable to this work were not included.
| No. | Designer’s question | Role in the article |
|---|---|---|
| 1 | What specific problem does the technology solve and for whom is it important? | Off-chain Bitcoin payments and trust in the intermediary. |
| 4 | How to formulate a testable hypothesis and what observation could disprove it? | Hypotheses H1–H5. |
| 5 | Where is the boundary of research? | Design analysis, not an experiment with real means. |
| 9 | What quantum effects are really necessary? | There are none in the protocol itself; quantum risk comes through cryptanalysis. |
| 10 | Is it possible to explain the mechanism using a minimal example? | 2-of-2 reconstruction of MultiSig and CryptoSquare. |
| 11 | What assumptions does the model use and when do they fail? | Honest server, isolation, self-destructive database. |
| 12 | What is measured in an experiment and how is the measurement related to the outcome? | Formal invariants, delay, message size, attack success. |
| 18 | How is the new work related to the previous ones? | Three lines inside the PDF: MultiSig → CryptoSquare → authentication. |
| 25 | How is a problem translated into a formal model? | State model and cryptographic games. |
| 31 | What error model is used? | Cryptographic failure vs. operational error. |
| 32 | What is called physical and what is called logical? | Keys/ciphertexts vs. protocol states. |
| 37 | To which classical method is the approach compared? | Coinbase-like intermediary, regular MultiSig, Lightning-like schemes. |
| 43 | What is the basis for the conclusion: evidence, simulation or experiment? | The PDF is a design proposal, not an experiment. |
| 46 | Is it possible to reproduce the key finding? | Code, configuration and a formal model are needed. |
| 49 | What cryptographic problem is being considered? | Signature forgery / key recovery via ECDLP. |
| 50 | Which quantum algorithm is applicable? | Shore for discrete logarithm; Grover for symmetric keys. |
| 51 | What are the resource estimates? | Not available in PDF; this is an open issue. |
| 52 | What data is available to the attacker? | Public keys, address, ciphertexts, hashes; not private keys. |
| 54 | QKD or post-quantum cryptography? | For signatures and multisig you need PQC, not just QKD. |
| 55 | For Bitcoin: What mechanism is being explored? | ECDSA signatures, multisig, public key disclosure. |
| 56 | What migration measures are being assessed? | Hybrid PQC schemes, FIPS 203/204/205. |
| 69 | What issues remain open? | Formal proof, implementation, PQC instantiation. |
| 70 | What further experiments will distinguish between the explanations? | ProVerif/Tamarin model + prototype + benchmarks. |
| 72 | How would the conclusions change under conservative assumptions? | Without an ideal database and without an honest server, security decreases. |
| 74 | What other article can this result be compared with? | With work on PQC migration of Bitcoin and off-chain protocols. |
| 75 | What new test question arises? | Is the invariant preserved under hybrid PQC instantiation? |
3. Reconstructing CryptoCubic: Three Lines of Evidence
The preprint is conveniently read as three sequential lines. The first shows why the standard off-chain MultiSig is insufficient. The second introduces encryption and “CryptoSquare.” The third adds authentication via tokens and hashes. It is the combination of these three lines that creates the claimed security.
3.1. Line 1: Regular 2-of-2 MultiSig off-chain
The server creates a signature pair Sig_U and Sig_S for address ADD. User A receives Sig_U and ADD, and the server stores it Sig_S in self-destructive storage. A tops up the address ADD with $10. When transferring to B, user A gives Sig_U and ADD. B can request Sig_S the server to retrieve the funds, after which he gains control of the funds.
The problem is obvious: A could have saved a copy Sig_U, published it, or been one of many previous recipients. B cannot be sure that it Sig_U is not known to anyone else. Therefore, this simple scheme does not provide security.
3.2. Line 2: Encrypted MultiSig and CryptoSquare
An asymmetric key pair A: is entered (Ka, Ka_Public). The server creates a symmetric key Ks and dynamically generates Sig_U, Sig_S, ADD. Then Sig_U is encrypted with A’s public key in Ea, and Sig_S is encrypted with the symmetric key Ks in Es. User A receives Es, ADD and their public key; Ea it is placed in self-destructive storage. The server stores Ks and Ka_Public. A “CryptoSquare” is created: neither A nor the server individually knows both signatures.
When transmitting B, user A sends Es and ADD. B creates a pair (Kb, Kb_Public) and sends it Kb_Public to the server. The server, with A’s permission, extracts Ea, receives Ka, decrypts Sig_U, encrypts it with key Kb_Public B Eb , and stores it Eb in self-destructive storage. Now B and the server jointly control ADD; A cannot obtain both signatures without B’s participation.
3.3 Line 3: Authentication
The server stores the hash, generates a random hash Token_A, encrypts it with A’s public key in Et_A, sends it to A, receives it back Token_A2 , and compares it with the original token. B is verified similarly. Additionally, the server transmits the value to B Hash, and B calculates the value Hash2 from Es and compares them to ensure that A transmitted the correct hash Es.
3.4. Summary table of stages
| Stage | What’s happening | What is being protected? | What remains is speculation |
|---|---|---|---|
| 1. Creating MultiSig | The server generates Sig_U, Sig_S, ADD; A receives Sig_U and address; Sig_S goes to self-destructive storage. | Splitting signatures between A and the server. | The server is honest; the storage is indeed self-destructive. |
| 2. Replenishment | A transfers $10 to ADD. | Funds are linked to a 2-of-2 address. | On-chain transaction is valid; Bitcoin network is available. |
| 3. Transfer B | A sends B Es and ADD; B creates Kb, Kb_Public. | B receives the encrypted share Sig_S. | A has not saved any extra copies; B trusts the server. |
| 4. Re-encryption | The server, with permission from A Ea, retrieves, receives Ka, decrypts Sig_U, and encrypts under Kb_Public in Eb. | A loses sole access; B gains share through the server. | The dynamic process is not accessible from the outside; Ka belongs to A. |
| 5. Authentication | Tokens Token_A/ Token_A2, Token_B/ Token_B2; hash comparison. | Confirmation of participants and authenticity Es. | There is an ambiguity in the PDF text: Hash(Sig_S) it is compared to Hash(Es). |
4. Audit of the “hacker-proof” statement
In Section 2 of the preprint, “hacker-proof” is defined through explicit assumptions. This is a strength of the paper: the author makes no secret of the fact that security is conditional. But these are precisely the conditions that need to be verified.
| PDF Assumption | What does it mean? | Investigation for audit |
|---|---|---|
| The server is friendly | The server does not try to deceive users. | The model does not protect against a malicious server; it is not a trustless system in the strict sense. |
| The server executes the protocol accurately | No unauthorized code changes. | A verifiable implementation and audit are needed. |
| There is a deviation detection system | When an invasion occurs, execution is terminated. | Formal specification and monitoring is required. |
| Dynamic process variables are not accessible from the outside | Secrets do not leak during execution. | Strong system assumption; verified by process isolation and TEE/HSM. |
| Self-destructive storage “100% safe” | Data is deleted after first access and cannot be recovered without Source X. | In PDF it is a conjecture , not a proven theorem. |
| Hacking = financial intent | Vandalism and data deletion are not considered hacking. | Protection against theft is not the same as protection against destruction. |
An important internal ambiguity. Section 5 of the PDF states that the server stores the SHA hash of Sig_S. The server later transmits this value Hash to user B, and B computes it Hash2 as the SHA hash of the ciphertext Es and verifies Hash == Hash2. If we take the text literally, then Hash = H(Sig_S), and Hash2 = H(Es). In general H(Sig_S) ≠ H(Enc_Ks(Sig_S)), . This means either there’s a typo in the specification, or the verification must compare the hash Es with the hash of Es, or B must first obtain Sig_S and compute the hash of . This isn’t “proof of tampering,” but it is a verifiable specification flaw that must be fixed before security claims can be made.
Furthermore, the PDF lacks a formal state model, cryptographic games, proof of security, implementation, benchmarks, latency, and cost analysis. Therefore, the correct scientific formulation is: “CryptoCubic is a design proposal with conditional security; it requires independent formal verification and implementation.” Calling it definitively “hacker-proof” without this is premature.
5. Quantum analysis and post-quantum migration
The CryptoCubic protocol itself doesn’t utilize quantum effects. Quantum threats enter it through cryptographic primitives: asymmetric encryption, Bitcoin signatures, key exchange, and hashes. Therefore, the constructor’s question, “What quantum effects are really necessary?” has a straightforward answer: for the protocol to function, none; for threat analysis, Shor’s and Grover’s algorithms.
5.1. Quantum Adversary Model
| Level | Enemy capabilities | What to check |
|---|---|---|
| Q0: classic | Interception, replay, forgery of messages, file theft. | Basic PDF model. |
| Q1: Quantum offline | Has public keys, address, ciphertexts, hashes; implements Shor’s algorithm for ECDLP. | Private key recovery and signature forgery in ECC/ECDSA. |
| Q2: Quantum + Server Leak | Accesses Ea/ Eb or accesses self-destructive storage. | Is the invariant “both signatures are not by the same person” preserved? |
| Q3: Quantum + Malicious Server | The server cooperates with the attacker. | The PDF model doesn’t cover this; a threshold scheme or public verification is needed. |
5.2. What exactly does Shor break?
Bitcoin uses ECDSA over secp256k1. Shor’s algorithm solves the elliptic curve discrete logarithm problem in polynomial time on a sufficiently large quantum computer. This means that if the public key is available to an attacker, they can, in principle, recover the private key. Bitcoin’s time-based disclosure model is important : the public key is often revealed when an output is spent or when an address is reused. In CryptoCubic, public keys Ka_Public are Kb_Public transmitted throughout the protocol; if asymmetric encryption is built on ECC/RSA, a quantum adversary can obtain the corresponding private keys and decrypt Ea/ Ebif they get their hands on the ciphertexts. Self-destructive storage is not “broken” by the quantum algorithm—it remains a system access control.
5.3 Symmetry and Hashes
Symmetric keys Ks and hash functions are less dramatic, but not free. Grover provides a quadratic speedup to brute-force attacks: a 256-bit symmetric key provides about 128 bits of quantum security in a perfect brute-force model. For SHA-256, preimage search with Grover also requires about 2^128 operations. This isn’t an argument against using SHA-256, but an argument against short keys and claims of “eternal” security.
5.4 Post-quantum primitives
In August 2024, NIST approved FIPS 203 (ML-KEM), FIPS 204 (ML-DSA), and FIPS 205 (SLH-DSA)—key establishment and digital signature standards designed to counter future quantum attacks. For CryptoCubic, this means: asymmetric encryption Kashould Kb be replaced with a hybrid scheme based on ML-KEM; Bitcoin signatures are the subject of a separate, complex migration; symmetries and hashes should remain 256-bit. QKD alone does not solve the signature and multisig problem: it requires an authenticated classical channel and does not replace PQC signatures.
| Primitive in CryptoCubic | Probable classical implementation | Quantum risk | Direction of migration |
|---|---|---|---|
Ka/ Ka_Public, Kb/Kb_Public | ECC/RSA (not specified in PDF) | Shor: Recovering a private key from a public key | Hybrid ML-KEM + classic design |
| 2-of-2 MultiSig Bitcoin | ECDSA/secp256k1 | Shor: Signature Forgery with a Disclosed Public Key | PQC signatures, but Bitcoin migration is complex and unspecified PDF |
Ks | Symmetrical key; length not specified | Grover: Half Bit Strength | 256-bit key and verified implementation |
| SHA hashes | SHA-256 (presumably) | Grover: Weakening the Search for the Archetype | 256-bit hashes; do not rely on short values |
| Self-destructive database | System access control | Doesn’t break with Shore directly | Formal specification, HSM/TEE, audit |
6. Testable hypotheses and refutation criteria
For an article to be scientific and not just promotional, statements must be translated into testable hypotheses. Below is the minimum set.
| Hypothesis | Formulation | Refutation criterion |
|---|---|---|
| H1 | Given the PDF assumptions (honest server, variable isolation, perfect self-destructive storage), CryptoSquare prevents either A or the server from obtaining both signatures on ADD. | Find an execution path in which one participant obtains Sig_U without Sig_S the cooperation of the other party. |
| H2 | There is an incompatibility in the PDF authentication section: Hash(Sig_S) not equal Hash(Es) with non-trivial encryption. | Show a correct implementation where the check converges without changing the meaning of Es; or prove that Es is identical to Sig_S, which contradicts the encryption. |
| H3 | When instantiated on ECC/ECDSA, a Q1-level quantum adversary with the public keys and ciphertexts can recover the corresponding private keys and violate confidentiality/authenticity. | Build an access model in which both signatures remain unreachable even under quantum Shor; or prove that public keys are not linked to critical secrets. |
| H4 | The “hacker-proof” claim cannot be accepted without independent implementation, formal verification, and audit. | Provide peer-reviewed formal proof and reproducible audit trail covering the PDF threat model. |
| H5 | Hybrid PQC migration preserves the functional consistency of CryptoSquare, but increases message sizes and latency. | Measure that under a hybrid scheme the protocol does not enforce functional invariants; or that the overhead is negligible with comparable security. |
The strongest verifiable result of this paper is H2. This isn’t a philosophical doubt, but a concrete inconsistency in the specification that can be demonstrated in pseudocode. It shows why even a “mathematically beautiful” protocol requires an executable specification and test vectors.
7. Experimental design and reproducibility
To transform CryptoCubic from a design proposal into a verifiable scientific paper, a minimum reproducible package is needed.
7.1 Formal Model
- Build a state model in TLA+ or Alloy: participants A, B, server S, storage D, messages
Ea,Eb,Es,Token_A,Token_B. - Check the invariants: “A does not know
Sig_S“, “B does not knowSig_Ubefore completion”, “S does not knowSig_Uafter completion”, “both participants agree onADD“. - Check for reuse
Token_Aand reinsertionEaafter self-destruction.
7.2 Cryptographic model
- Use ProVerif or Tamarin to analyze authentication and privacy.
- Model the quantum adversary not as “magic,” but as an oracle that solves ECDLP for selected public keys; a separate model without such an oracle.
- Check which properties depend on asymmetric encryption and which depend only on access control.
7.3. Prototype
- Implement a self-destructive storage simulator with an access log: reading deletes the write; re-writing is prohibited without the owner token.
- Implement three versions: (a) a token ECC instantiation; (b) a hybrid ML-KEM + ECC; (c) a fully PQC instantiation where possible without changing Bitcoin.
- For the Bitcoin portion, use regtest and 2-of-2 multisig; Bitcoin PQC signatures should not be considered ready without a separate compatibility analysis.
7.4. Metrics
| Metrics | For what | How to measure |
|---|---|---|
| Message size | PQC keys and signatures are larger than classic ones | Bytes per stage. |
| Delay | Impact on the “coffee” scenario | Median and 95th percentile per 1000 runs. |
| Success of attacks | H1–H3 Check | The proportion of traces where the invariant is violated. |
| Storage costs | Self-destructive database and audit | Size of logs, number of operations. |
| Reproducibility | Independent verification | Publishing code, versions and configuration. |
7.5 What is considered evidence
For this topic, simply “the code works” isn’t enough. We need formal invariants, test vectors, negative tests (attacks), comparison with a classical baseline, and a clear threat model. Only then can we talk about security in a scientific sense.
8. Connection of works and synthesis
Within the PDF, three “works” can be distinguished, which can be logically linked sequentially.
| PDF Line | What does it give? | What doesn’t work? | How is it related to the next one? |
|---|---|---|---|
| Regular MultiSig off-chain | Shows the idea of signature splitting and the role of the server. | Does not protect from the surviving Sig_U and from dishonest A. | Requires encryption of share A. |
| Encrypted MultiSig/CryptoSquare | Hides Sig_U from A and Sig_S from the server in one state. | Does not provide authentication of participants and does not formalize the storage. | Requires tokens and authentication Es. |
| Authentication | Adds A and B verification, tokens and hash. | Contains ambiguity Hash(Sig_S) vs Hash(Es). | Requires correction of the specification and formal model. |
Synthesis: CryptoCubic isn’t a single “magical” security solution, but a composition of three ideas. This composition is vulnerable to error at any level. Quantum analysis adds a fourth level: the choice of cryptographic primitives. If even one level—ECDSA/ECC—is replaced with a PQC hybrid, the remaining levels still need to be verified separately. Therefore, the correct research strategy is: first a formal specification, then a prototype, then PQC instantiation, then independent audit.
9. Limitations of the study
- We are analyzing the text of the preprint, not conducting an experiment with real bitcoins.
- The PDF does not specify specific encryption algorithms, key lengths, or parameters; therefore, quantum estimates are provisional.
- We’re not claiming that CryptoCubic has been hacked; we’re claiming that its “hacker-proof” is unproven and requires further verification.
- The self-destructive storage model in PDF is called a conjecture; its physical and systemic implementation is not considered.
- Post-quantum Bitcoin migration is a complex topic in its own right; this article presents it as a direction, not a complete solution.
- Internal ambiguity
Hash(Sig_S)/Hash(Es)may be a typo; but that’s why a specification must be executable and verifiable.
10. Conclusion
CryptoCubic is an interesting and useful composition for discussion: 2-of-2 MultiSig, signature share encryption, self-destructive storage, and token authentication. It’s better than a simple “trusted intermediary” in that it shares secrets and reduces the single point of compromise. However, the “hacker-proof” claim in the preprint is arbitrary. It relies on an honest server, perfect variable isolation, unprovable self-destructive storage, and unspecified cryptographic primitives.
The quantum issue makes this problem even more acute. If the protocol is instantiated using ECC/ECDSA, Shor’s algorithm threatens both Bitcoin signatures and asymmetric share encryption. Symmetric keys and hashes require 256-bit parameters, taking Grover’s constraint into account. Post-quantum migration must be hybrid and verifiable; QKD alone does not replace PQC signatures and multisig.
The main new question being tested is whether the “no one participant receives both signatures” invariant is preserved when replacing classical asymmetric primitives with hybrid PQC schemes and with a formally described self-destructive storage. The answer requires not a slogan, but a formal model, a prototype, and independent auditing.
11. Sources
- Apeltsin L. A. CryptoCubic Protocol for Hacker-Proof Off-Chain Bitcoin Transactions. arXiv:1408.2824v1. Analyzed preprint.
- National Quantum Initiative. Quantum Science Areas: Computing, Networks, and Sensors. quantum.gov .
- NIST. FIPS 203, 204, 205: Establishing Post-Quantum Key Establishment and Digital Signature Standards, August 13, 2024. csrc.nist.gov .
- NIST NCCoE. Migration to Post-Quantum Cryptography. nccoe.nist.gov .
- Shor PW Algorithms for Quantum Computation: Discrete Logarithms and Factoring. FOCS, 1994.
- Grover LK A Fast Quantum Mechanical Algorithm for Database Search. STOC, 1996.
- Research Question Builder “Quantum Technologies: 75 Questions for a Research Article” (used as a methodological framework).
