Blockchain Architecture Assessment - Added days - Soqucoin

1. Introduction

Soqucoin engaged Halborn to perform a security assessment of the Soqucoin blockchain's post-quantum cryptographic subsystem, specifically the Binius64 finite field arithmetic and LatticeFold+ batch verification implementation, from March 30th, 2026 to April 1st, 2026. The assessment scope covered approximately 600 lines of core cryptographic C++ code on branch soqucoin-genesis at commit 8c8840fae.

2. Assessment summary

Halborn was allocated 3 days for this engagement and assigned 1 full-time security engineer to conduct a comprehensive review of the assets within scope. The engineer is an expert in blockchain and smart contract security, with advanced skills in cryptographic protocol analysis, low-level C++ review, and fuzz testing, as well as extensive knowledge of post-quantum cryptographic schemes.

The objectives of this assessment are to:

• Verify the correctness of the Binius64 binary field arithmetic used as the algebraic foundation for proof verification.

• Assess the security of the LatticeFold+ verifier and its integration into the consensus layer.

• Identify vulnerabilities that could lead to proof forgery, consensus divergence, or undefined behavior at the node level.

In summary, Halborn identified several areas for improvement to minimize both the likelihood and potential impact of security risks, which were successfully addressed by the Soqucoin team. The primary issues include:

• Replace the reducible reduction polynomial x^128 + x^7 + 1 with an irreducible one to construct a proper finite field and eliminate zero divisors that enable proof forgery.

• Correct the x86 GFNI-accelerated multiplication path to use the appropriate intrinsic, ensuring field products are computed correctly on all x86 nodes.

• Bind LatticeFold+ proofs to the committed UTXO data by incorporating the external commitment into the verification check, preventing trivial proof forgery.

• Add the missing second reduction pass in the portable multiplication fallback to produce correct field products across all platforms.

• Include the final squaring step in the field inverse computation to ensure all inverse-dependent verification operations produce correct results.

• Remove the const_cast in batch_inverse and accept the input array by mutable reference to eliminate undefined behavior under the C++ standard.

3. Test approach and methodology

Halborn conducted a combination of manual code review, mathematical analysis, and targeted fuzz testing to balance efficiency, timeliness, practicality, and accuracy within the scope of this assessment. While manual review is crucial for identifying flaws in cryptographic logic and protocol design, automated testing enhances coverage of the codebase and quickly surfaces deviations from mathematical invariants.

The following phases and associated techniques were employed throughout the term of the assessment:

• Reviewed approximately 600 lines of core cryptographic C++ code across the Binius64 field implementation (field.h, field.cpp), the LatticeFold+ verifier (verifier.cpp, verifier.h), and the consensus integration points in the script interpreter.

• Performed polynomial factorization analysis using SageMath and SymPy to verify the irreducibility claim of the reduction polynomial, confirming it factors into three irreducible components over GF(2).

• Constructed concrete proof-of-concept exploits demonstrating zero divisor pairs in the ring, incorrect multiplication outputs on both x86 and portable code paths, and trivial proof forgery against the LatticeFold+ verifier.

• Developed and executed targeted fuzz harnesses against field arithmetic operations to surface invariant violations and edge cases.

• Cross-validated the x86 GFNI+AVX2 accelerated path against the portable bit-serial fallback to identify divergence between platform-specific implementations.

• Traced the end-to-end consensus integration path from the OP_LATTICEFOLD opcode through the script interpreter to the verifier entry point, analyzing how field-level bugs propagate to consensus-level impact.