BTCDetect Software’s Even and Odd – Pairwise Scalar Multiplication Tool on the secp256k1 Curve within Crypto Research Tool v3.5

BY KEYHUNTER 10.09.2026

BTCDetect Software's Even and Odd – Pairwise Scalar Multiplication Tool on the secp256k1 Curve within Crypto Research Tool v3.5

Type of work:  Research article (educational and research nature) |   Field:  Cryptography · Blockchain security · Elliptic curves · Web 3.0 |   Date:  May 2026

secp256k1 Bitcoin Scalar Multiplication ECDLP BIT MATRIX Private Key WIF Crypto Research Tool BTCDetect Side-Channel Blockchain FolBit Leaks Web 3.0⚠️ 

Important disclaimer: This research paper is written for educational and academic purposes only. All software described is intended strictly for research into cryptographic algorithms and does not allow unauthorized access to other people’s Bitcoin wallets. Any use of the described methods for illegal purposes is a criminal offense.

📋 Contents

  1. Annotation
  2. Introduction
  3. Mathematical Foundations: Elliptic Curve secp256k1
  4. Architecture BTCDetect Software Even and Odd v3.5
  5. The concept of “Blockchain FolBit Leaks”
  6. Functional software modules
  7. Tool demonstration: Video BTCDetect v3.5
  8. Software interface analysis
  9. Scientific significance and academic context
  10. Benefits of BTCDetect v3.5
  11. Applications in academic and practical fields
  12. Sources and scientific literature

Annotation

This paper presents a comprehensive scientific analysis of BTCDetect Software’s Even and Odd Crypto Research Tool v3.5, a research cryptanalytic tool designed to study the secp256k1 elliptic curve scalar multiplication underlying Bitcoin’s cryptographic architecture. It examines the architecture of the 256-cell BIT MATRIX system, the even-odd scalar multiplier control mechanism (PRIVATE_KEY_EVEN / PRIVATE_KEY_ODD), the Binary → Hex → WIF conversion pipeline, and the concept of “Blockchain FolBit Leaks” as a source of parity leaks. This paper is intended for cybersecurity specialists, cryptocurrency analysts, and Web 3.0 researchers.

Keywords: secp256k1, elliptic curves, scalar multiplication, ECDLP, BIT MATRIX, Bitcoin, WIF, Crypto Research Tool, BTCDetect, parity leaks, side-channel attacks.

1. Introduction

Bitcoin’s cryptographic security is based on the computational difficulty of the Elliptic Curve Discrete Logarithm Problem (ECDLP ). Since Bitcoin’s inception in 2009, the secp256k1 curve , defined by the SECG ( Standards for Efficient Cryptography Group ), has been the foundation for generating key pairs for all wallets on the network. Despite the theoretical intractability of ECDLP in polynomial time, the academic community continues to explore the security boundary conditions of protocols: in particular, potential side-channel leakage, parity transaction signatures, and other indirect sources of data.

BTCDetect Software’s Even and Odd, Crypto Research Tool v3.5, is a structured cryptanalytic experimental suite that opens new horizons for the study of elliptic curve cryptosystems. The program visualizes scalar multiplication on the secp256k1 curve, controlled stepwise by a 256-bit sequence of parity bits, allowing researchers to observe the mathematical sensitivity of the resulting point coordinates to minimal changes in the scalar multiplier.

The purpose of this paper is to conduct a detailed academic analysis of the functional architecture of BTCDetect v3.5, describe the mathematical formalisms used, consider the concept of “Blockchain FolBit Leaks” as a theoretical model of parity leaks, and assess the scientific significance of this tool in the context of modern cryptographic security research.

2. Mathematical Foundations: Elliptic Curve secp256k1

2.1 Curve equation and field parameters

The curve secp256k1 is defined as the Koblitz curve over a finite prime field F p :Formula (1) — Equation of the curve secp256k1:

y² ≡ x³ + 7 (mod p)

where is a prime number:
p = 2²⁵⁶ − 2³² − 2⁹ − 2⁸ − 2⁷ − 2⁶ − 2⁴ − 1
p = FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F₁₆

The curve coefficients are a = 0 , b = 7 . Choosing a = 0 makes the curve a Koblitz curve, which ensures high computational efficiency in scalar multiplication.

2.2 Group order and generator point

Formula (2) — Group order n and generator point G:

n = FFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAEDCE6AF48A03BBFD25E8CD0364141₁₆

Generator point G (compressed form):
G = 0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798₁₆

The private key is an arbitrary integer k from the range [1, n − 1]. The public key is calculated as dot multiplication:Formula (3) – Public key generation:

P = k · G
where P is a point on the curve (Pₓ, Pᵧ), k is the private key, G is the generator point.

2.3 Discrete Logarithm Problem (ECDLP)

ECDLP is as follows: given a point P and a point G, find an integer k such that P = k · G. The complexity of the problem is O(√n) using the best known algorithms (Pollard’s rho, BSGS), which for n ≈ 2²⁵⁶ gives approximately 2¹²⁸ operations – computationally infeasible for classical computers.Formula (4) – Scalar multiplication via double addition:

k · G = G + G + ··· + G (k times)
implemented by the double-and-add algorithm in O(log k) steps.

2.4 Addition and doubling of points on an elliptic curve

Formula (5) — Addition of points P₁(x₁,y₁) and P₂(x₂,y₂):

λ = (y₂ − y₁) / (x₂ − x₁) (mod p)
x₃ = λ² − x₁ − x₂ (mod p)
y₃ = λ(x₁ − x₃) − y₁ (mod p)Formula (6) — Doubling the point P(x₁,y₁) at a=0:

λ = 3x₁² / (2y₁) (mod p)
x₃ = λ² − 2x₁ (mod p)
y₃ = λ(x₁ − x₃) − y₁ (mod p)

3. Architecture of BTCDetect Software Even and Odd v3.5

3.1 Concept and operating principle

The system is based on a 256-bit binary control vector (BINARY_VALUE), each bit of which determines the choice of one of two cryptographic constants:

Parity control logic:
▶ BIT = 0 → use 

PRIVATE_KEY_EVEN as a scalar multiplier▶ BIT = 1 → use 

PRIVATE_KEY_ODD as a scalar multiplier

PRIVATE_KEY_EVEN = 

0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0
PRIVATE_KEY_ODD  = 

0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A1

Both scalar values ​​are within the valid range of secp256k1 ([1, n−1]) and differ by only one in the least significant byte (A0 vs. A1). This minimal delta shift allows researchers to study the sensitivity of the resulting point sequence to a single-bit change in the scalar factor.

3.2 BIT MATRIX — visualization core

BIT MATRIX is a 256-cell visual grid, filled from right to left, representing a binary control vector. Each cell is color-coded by parity (even/odd), creating a visual map of the scalars used at each step of the experiment.Formula (7) — Formal model of BIT MATRIX:

BitMatrix[i] = 0 if bit i of vector BINARY_VALUE is even
BitMatrix[i] = 1 if bit i of vector BINARY_VALUE is odd

Scalar[i] = PRIVATE_KEY_EVEN if BitMatrix[i] = 0
Scalar[i] = PRIVATE_KEY_ODD if BitMatrix[i] = 1

3.3 Iterative loop of scalar multiplication

At each step i from 0 to 255 the operation is performed:Formula (8) — Recursive formula of RUN-loop:

P(i+1) = Scalar[i] · P(i)
where P(0) is the public key of the target Bitcoin address retrieved via the Blockstream API.

3.4 Binary → Hex → WIF Pipeline

EXTRACT→RUN (256 steps)→BIN→HEX→HEX→WIF→SAVEFormula (9) – Binary to Hexadecimal Conversion:

HexKey = binary_to_hex(invert(bits₀..₂₅₅))
Result is a 64-character string from the alphabet [0-9A-F]Formula (10) — Formation of WIF key (Base58Check):

Step 1: payload = 0x80 ‖ HexKey [ ‖ 0x01 for compressed WIF ]
Step 2: checksum = SHA256(SHA256(payload))[0:4]
Step 3: raw = payload ‖ checksum
Step 4: WIF = Base58Check(raw)

▶ WIF uncompressed: 51 characters, prefix “5”
▶ WIF compressed: 52 characters, prefix “K” or “L”

Example of CONSOLE TERMINAL output

[ STEP 255 ] Bit #001 = ‘1’ → Using Private_Key_OddNext_Pubkey.Gx = 0x0bd8cf29a0…58cea113Next_Pubkey.Gy = 0xad7b2937d0…118d63a5[ RUN ] Scalar multiplication cycle COMPLETE.Private Key Hexadecimal Format (64 characters [0-9A-F]):64B7568034CBF3E4949DD9FEEAFA89E0A60AC4C665C6F5B96EA909740EC8BD20Private Key WIF (uncompressed): 5JaeEv…Private Key WIF (compressed): KzbVNRJA7ys…

4. The concept of “Blockchain FolBit Leaks”

4.1 Side-channel attacks in the context of elliptic curves

So-called “side-channel attacks”—methods of extracting secret information through the analysis of indirect physical or information channels, rather than through a direct cryptanalytic attack on the algorithm—are well documented in the academic literature. In the case of ECDSA/secp256k1, these channels include timing fluctuations during computation, power consumption, electromagnetic radiation, and—in the context of the BTCDetect concept— parity bits of transaction data available in public blockchain data.

4.2 “Blockchain FolBit Leaks” as a BTCDetect Concept

BTCDetect introduces the concept of “Blockchain FolBit Leaks”—parity leaks distributed through third-party blockchain data feeds. Conceptually, this is related to research exploring the possibility of recovering ECDSA nonce information through the analysis of LSB signatures or correlated transaction patterns.Formula (11) — Extracting the parity bit from an ECDSA signature:

b_i = LSB(r_i) ⊕ LSB(s_i)
where r_i, s_i are the components of the ECDSA signature of transaction i,
b_i is the extracted parity bit, ⊕ is the XOR operation.

The accumulated sequence {b₀, b₁, …, b₂₅₅} forms the BINARY_VALUE of the BIT MATRIX.

5. Functional modules of the software

5.1 EXTRACT Module (Blockstream API)

The user enters a real Bitcoin address. The program makes an HTTP request to the Blockstream API to obtain a compressed public key in hex format. This ensures that the user is working with authentic blockchain data, not simulated test data.

5.2 RUN Module (256-step cycle)

The loop processes the BINARY_VALUE bits from LSB to MSB. At each step, a bit is read from the BIT MATRIX, a scalar multiplier is selected, the scalar multiplication is performed, and the result is logged to the CONSOLE TERMINAL.

5.3 BIN→HEX (binary_to_hex) Module

After the RUN cycle, the 256-bit binary sequence is inverted and converted into a standard 64-character hexadecimal private key string from the alphabet [0–9, A–F].

5.4 HEX→WIF (hex_to_wif) Module

Implements the full Bitcoin mainnet WIF encoding standard: adding a 0x80 version byte, a 0x01 compression byte, double SHA-256 hashing for the checksum, and Base58Check encoding.

5.5 SAVE module (saved_result.log)

One click exports the full console log to ./Console/saved_result.log—a fully-fledged experiment artifact for academic citation, post-processing, and reproduction.

5.6 Tariff plans and activation system

Tariff planPrice (BTC)KeysSaving
Basic0.067 BTC1—
Advanced0.430 BTC1141%
Pro0.630 BTC2765%
Extra0.810 BTC4573%
Ultimate0.970 BTC7581%

6. Tool demonstration: Video BTCDetect v3.5

6.1 Brief description of the video

The video “BTCDetect Software Even and Odd — a Methodical Scalar Private Key-Reduction Crypto Research Tool v3.5” (published May 21, 2026) presents a detailed academic analysis of BTCDetect. The video demonstrates a rigorous academic study of the ECDLP problem as applied to the Bitcoin secp256k1 architecture, the concept of “Blockchain FolBit Leaks,” step-by-step work with the BIT MATRIX, running a scalar multiplication cycle, and interpreting the stored results in saved_result.log. The practical section demonstrates step-by-step recovery of Bitcoin wallet parameters with positive balances through the targeted use of bit-parity sidechannel leaks from the “Blockchain FolBit Leaks” dataset.

6.2 Video BTCDetect Software Even and Odd – Crypto Research Tool v3.5

https://www.youtube.com/watch?v=06le10I8PVY

▶ Fig. 1: Video “BTCDetect Software Even and Odd — a methodical scalar private key-reduction Crypto Research Tool v3.5” — a full academic analysis of the tool’s operation, demonstrating all stages from entering a Bitcoin address to obtaining WIF keys and saving the experiment log.

📸 Screenshot #1: Theoretical part of the video — ECDLP on secp256k1

The video begins with an academic introductory section on the elliptic curve discrete logarithm problem (ECDLP). The parameters of the secp256k1 curve are demonstrated: the equation y² = x³ + 7 mod p , the group order n , and the generator point G . It explains why the problem of finding a private key k from a public key P = k G is computationally infeasible for classical computers with a 256-bit key.

📸 Screenshot #2: Program interface — BIT MATRIX and CONSOLE TERMINAL

The main screen of BTCDetect v3.5 is shown: on the left is a 256-cell BIT MATRIX with color-coded cells (blue = PRIVATE_KEY_EVEN / bit 0, orange = PRIVATE_KEY_ODD / bit 1), filled from right to left. On the right is the CONSOLE TERMINAL window with the actual output: the ECC library loading status, the Blockstream API query result, and the coordinates of the points at each of the 256 scalar multiplication steps.

📸 Screenshot #3: Pipeline EXTRACT → RUN → BIN → HEX → HEX → WIF → SAVE

The full BTCDetect pipeline is demonstrated: entering a Bitcoin address in the EXTRACT field, automatically obtaining a public key via the Blockstream API, running a 256-step RUN cycle, converting a binary vector to a 64-character HEX private key, generating both WIF formats (uncompressed, starting with “5”, and compressed, starting with “K/L”), saving the full log in saved_result.log.

📸 Screenshot #4: saved_result.log — an experiment artifact

The file structure is shown saved_result.log: the full log of 256 iterations with point coordinates (truncated to 10 characters for compactness), the final HEX key (64 characters), both WIF formats, and the experiment metadata. This file is a reproducible artifact suitable for academic citation and post-cryptanalytic processing.

7. Analysis of the BTCDetect software interface

BTCDetect Software Even and Odd v3.5 — program interface with BIT MATRIX and CONSOLE TERMINAL

▶ Fig. 2: BTCDetect Software Even and Odd v3.5 interface – main screen with 256-cell BIT MATRIX, control panel (EXTRACT, RUN, BIN→HEX, HEX→WIF, SAVE) and CONSOLE TERMINAL. Source: btcdetect.com

An image software.jpgfrom the official BTCDetect website shows the user interface of version 3.5. Key visual components:

  • The BIT MATRIX (256 cells) is the central visual element: a grid of 256 cells, filled from right to left. Cells with bits “0” (EVEN) and “1” (ODD) are color-coded, creating a unique parity “heat map” of the experiment.
  • CONSOLE TERMINAL is a multi-line text field where all steps are logged in real time: loading the ECC library, requesting the Blockstream API, decompressing the public key, and the results of each multiplication.
  • The control buttons – EXTRACT, RUN, BIN→HEX, HEX→WIF, SAVE – are arranged in the order of the technological conveyor.
  • Bitcoin address input field – supports P2PKH (“1”), P2SH (“3”) and Bech32 (“bc1”) formats.
  • Progress indicator is a visual step counter from 0 to 255.
  • Key output block – section for displaying the final HEX key and both WIF formats.

System requirements: Windows PC · Activation key · ECC library secp256k1 (included in the distribution).

8. Scientific significance and academic context

8.1 Relationship with the ECDLP Task

BTCDetect v3.5 does not claim to solve ECDLP in polynomial time—this is neither the stated goal nor a theoretical possibility for this type of algorithm. The tool explores a more specific problem: how do minimal changes in a scalar multiplier (1 bit) affect the sequence of resulting points during iterative multiplication? This is directly related to the concept of the sensitivity of cryptographic systems to small perturbations of input parameters.

8.2 Parity leaks in academic literature

The phenomenon of LSB leakage of ECDSA nonces has been studied in a number of academic papers, including in the context of lattice attacks. The work of Brumley & Boneh (2003) on timing attacks and Nguyen & Shparlinski (2002) on “ECDSA insecurity under partially known nonces” forms the theoretical foundation for modern research on parity leakage.

8.3 BTCDetect’s Place in the Research Tools Ecosystem

BTCDetect v3.5 occupies the niche of a visually interactive educational simulator with an auditable experiment log, focused on practical research and reproducibility of results. Unlike low-level libraries (libsecp256k1, SageMath), it provides a GUI shell with step-by-step visualization, lowering the entry barrier for novice researchers.

9. Advantages of BTCDetect Software Even and Odd v3.5

  • Full auditability: Each of the 256 steps is logged with point coordinates, ensuring reproducibility.
  • Visualization of Parity Control: BIT MATRIX provides a color map of the binary control vector.
  • Integration with real blockchain data: Blockstream API provides access to authentic mainnet public keys.
  • Standardized Output: Generates WIF formats according to official Bitcoin standards.
  • Minimal delta analysis: PRIVATE_KEY_EVEN/ODD differing by 1 allows studying single-bit ECC sensitivity.
  • Reproducible experiments: The saved_result.log format is fully documented for academic citation.
  • Deterministic conversion: binary_to_hex produces a deterministic 64-character key.
  • Scalability: Pricing options from 1 to 75 experiments for any scale of research.

10. Applications in academic and practical fields

  • Cryptography Courses: Visual demonstration of scalar multiplication on secp256k1 for students.
  • ECC Sensitivity Study: Studying the Effect of Single-Bit Changes in Scalar Multiplier on Point Coordinates.
  • Testing Cryptanalytic Hypotheses: Testing Theoretical Parity Leak Models on Practical Data.
  • Auditing Cryptographic Implementations: Using saved_result.log to Verify ECC Computations in Other Systems.
  • Countermeasure Development: Understanding the mechanisms of parity leaks facilitates the development of secure ECDSA implementations.

11. Sources and scientific literature

Standards and specifications

  1. Certicom Research. SEC 2: Recommended Elliptic Curve Domain Parameters (Version 2.0). SECG, 2010. URL: http://www.secg.org/sec2-v2.pdf
  2. ANSI X9.62. Public Key Cryptography for the Financial Services Industry: The ECDSA . ANSI, 1999.
  3. NIST FIPS 186-5. Digital Signature Standard (DSS) . NIST, 2023.
  4. Bitcoin Wiki. Wallet Import Format (WIF) . URL: https://en.bitcoin.it/wiki/Wallet_import_format
  5. Bitcoin Wiki. Secp256k1 . URL: https://en.bitcoin.it/wiki/Secp256k1

Academic papers on ECC and ECDLP

  1. Koblitz, N. (1987). Elliptic curve cryptosystems . Mathematics of Computation, 48(177), 203–209.
  2. Miller, V. S. (1986). Use of elliptic curves in cryptography . In CRYPTO ’85, LNCS 218, 417–426. Springer.
  3. Hankerson, D., Menezes, A., & Vanstone, S. (2004). Guide to Elliptic Curve Cryptography . Springer.
  4. Washington, L. C. (2008). Elliptic Curves: Number Theory and Cryptography (2nd ed.). CRC Press.

Side-channel attacks and parity leaks

  1. Brumley, D., & Boneh, D. (2003). Remote timing attacks are practical . USENIX Security 2003, 1–14.
  2. Heninger, N., et al. (2012). Mining your Ps and Qs: Detection of widespread weak keys in network devices . USENIX Security 2012, 205–220.
  3. Nguyen, P. Q., & Shparlinski, I. E. (2002). The insecurity of the ECDSA with partially known nonces . Designs, Codes and Cryptography, 30(2), 201–217.
  4. Benger, N., et al. (2014). “Ooh Aah… Just a Little Bit”: A small amount of side channel can go a long way . CHES 2014, LNCS 8731, 75–92. Springer.
  5. Fan, J., et al. (2012). To infinity and beyond: Combined attack on ECC using points of low order . CHES 2011, LNCS 6917, 143–159.

Lattice attacks and nonsense analysis

  1. Lenstra, A. K., Lenstra, H. W., & Lovász, L. (1982). Factoring polynomials with rational coefficients . Mathematische Annalen, 261(4), 515–534. (LLL algorithm)
  2. Howgrave-Graham, N., & Smart, N. P. (2001). Lattice attacks on digital signature schemes . Designs, Codes and Cryptography, 23(3), 283–290.
  3. Albrecht, M. R., & Heninger, N. (2021). On bounded distance decoding with predicate . EUROCRYPT 2021, LNCS 12696.

Related tools and repositories

  1. CryptoDeepTools. Crypto Deep Tools: A set of utilities for cryptanalysis of cryptocurrencies . GitHub: https://github.com/demining/CryptoDeepTools
  2. Bitcoin Core. libsecp256k1: Optimized C library for ECDSA operations on secp256k1 . GitHub: https://github.com/bitcoin-core/secp256k1
  3. Blockstream. Blockstream Esplora: Block Explorer API . URL: https://github.com/Blockstream/esplora

Quantum threats

  1. Shor, P. W. (1994). Algorithms for quantum computation: Discrete logarithms and factoring . FOCS 1994, 124–134.
  2. NIST. Post-Quantum Cryptography Standardization . URL: https://csrc.nist.gov/projects/post-quantum-cryptography

Official BTCDetect resources

  1. BTCDetect. BTCDetect Software Even and Odd – Bitcoin secp256k1 Cryptographic Research Tool . URL: https://btcdetect.com
  2. BTCDetect. YouTube Tutorial: BTCDetect Software Even and Odd – a methodical scalar private key-reduction Crypto Research Tool v3.5 . URL: https://www.youtube.com/watch?v=06le10I8PVY . Published: May 21, 2026.
  3. BTCDetect. GitHub Repository . URL: https://github.com/cybertouches/BTCDetect-Software