Topic: Neural Networks and Secp256k1 (Read 485 times)

It's on github, I posted a few years ago here, RNN converting training btc addresses to private keys, all the code is there to train, and of course if you know tensorflow its easy add layers and do as you wish

https://github.com/btc-room101/bitcoin-rnn

The reason I did this is to get a ballpark private-key estimate for input to kangaroo, where you need to be withon 2^40 to make it work, but certainly any relation can be found if you have enough data

This code is written in python, all the source is there

I'll tell you how the NSA does this backdoor, you use endomorphisms of sepc256k1 1 to infinity and train from simple cases to advanced

See the gtx1060 post I made today to reference endo's

It's best to start small use the sagemath to learn about secp256k1 on simple cases of [0,7], keep the 'p' small until you know what your doing, don't jump right into the 2^256 stuff; all the data comes from sage-math, then is processed in python,

Sagemath has all the glue for secp256k1 already installed, here is what follows is the sage to get you started, if you want to add NN then grab the github

from tinyec.ec import SubGroup, Curve
​
# Domain parameters for the `secp256k1` curve
# (as defined in http://www.secg.org/sec2-v2.pdf)
name = 'secp256k1'
p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f
n = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141
a = 0x0000000000000000000000000000000000000000000000000000000000000000
b = 0x0000000000000000000000000000000000000000000000000000000000000007
g = (0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798,
     0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8)
h = 1
curve = Curve(a, b, SubGroup(p, g, n, h), name)
print('curve:', curve)
​
privKey = int('0x51897b64e85c3f714bba707e867914295a1377a7463a9dae8ea6a8b914246319', 16)
print('privKey:', hex(privKey)[2:])
​
pubKey = curve.g * privKey
pubKeyCompressed = '0' + str(2 + pubKey.y % 2) + str(hex(pubKey.x)[2:])
print('pubKey:', pubKeyCompressed)

# endomorphism
lamN=pow(3,(n-1)/3,n)
betP=pow(2,(p-1)/3,p)

# G is 1/2 special point, n is order o E, G is sep256k1 generator
00000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63
c0c686408d517dfd67c2367651380d00d126e4229631fd03f8ff35eef1a61e3c
which is easily computable as ((n+1)/2)×G.
sage: h=(n+1)/2
sage: int(h)*G
(86918276961810349294276103416548851884759982251107 : 87194829221142880348582938487511785107150118762739500766654458540580527283772 : 1)
sage: hex(86918276961810349294276103416548851884759982251107)
'3b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63'

***

High-Value Key 123NW9MjzA1ruijnfVepMBRkAgHeNAeRDC
50.0 btc
sage: V=E.lift_x(100257432922100916568143421243988773726881105572982433208434735787631308087100)
sage: V
(100257432922100916568143421243988773726881105572982433208434735787631308087100 : 17976700734488631664679765453517918083636436394515771729223336359641082615751 : 1)

I'm no ML expert but I don't think adding more NN layers is going to improve the accuracy of this neural network. Remember that we basically have a hexadecimal number as input (trying to feed millions of hex numbers as input to the same neurons makes no sense because the numbers have no relationship with each other), and as such, they should be in bytes form instead of ASCII, and then we'd do something like assign each bit of the number to one or more input neurons, and then apply layers on it.

If you do want to use millions of numbers as input then you should use a ML classification algorithm and also give as input the polarity of these points for training. Neural networks are meant to work on one input only e.g. given a drawing of the number "2", identify which digit it is.

Don't forget to make youre X,Y length to 32 or 256.
while(X.length != 256)
X = "0" + X;

good or not if change 32 to max at 256


Layer (type)                 Output Shape             
=============================
input_1 (InputLayer)         [(None, 256)]           
_____________________________________
multi_category_encoding (Mul (None, 256)               
_____________________________________
dense (Dense)                (None, 32)               
_____________________________________
re_lu (ReLU)                 (None, 32)               
_____________________________________
dense_1 (Dense)              (None, 32)               
_____________________________________
re_lu_1 (ReLU)               (None, 32)               
_____________________________________
regression_head_1 (Dense)    (None, 1)                 
=============================



I will test add more 5 layer
activate I use ReLU


Layer (type)                 Output Shape             
=============================
input_1 (InputLayer)         [(None, 256)]           
_____________________________________
multi_category_encoding (Mul (None, 256)               
_____________________________________
dense (Dense)                (None, 256)               
_____________________________________
re_lu (ReLU)                 (None, 256)               
_____________________________________
dense_1 (Dense)              (None, 128)               
_____________________________________
re_lu_1 (ReLU)               (None, 128)               
_____________________________________
regression_head_1 (Dense)    (None, 1)                 
=============================



I try to use modify sample code for keras to use pubkey dataset
use keras predict titanic and keras predict California housing
just test may be wrong algorithm that should be use

on github have a ot of bitcoin trading bot use neural networks predict price easy than predict elliptic curve

A bit off-topic,

I try Neural Networks with colab

work with dataset of Secp256k1
generate pubkey and save to colab
Limited storage 100GB (system 40gp limited to use 60gb)

under 1 million dataset may be can work with colab
over 1 million is too much for colab

Google colab pro is good to can use Tesla V100 (limited on 24 hour)
Google colab design for work with neural networks
Google colab pro good value for $9.99 cost
name colab "LAB" is already tell for  testing and proof of concept not for production for real work because use time more 24 hour

Kaggle is good for find sample code (most way use github)
I like Google colab more than kaggle

Google colab free you need to finish job on 12 hour work only 1 gpu limited
Google colab pro ($9.99)  finish job on 24 hour
it good for testing job

colab you still need to coding (no GUI)
colab risk to loss you job if disconnect from server or session reset ( do new one again)
colab save file to ssd risk

colab need to use with google drive to use you file on drive is better (but make it work slow than on ssd on colab)

Real work with Neural Networks you should be use you own GPU is better only way
I run test pubkey small dataset with autokeras ()optimize code) use time over 48 hour on low end  gtx 1050 (slow work)

Neural Networks with Secp256k1 use very long time to train it. it use time a lot for try optimize code for get best result

some problem
use pubkey dataset 1000 to 10000 no problem on test
use pubkey dataset  1 million have a lot of error message between training

optimize code on small dataset is fine
but when try with large dataset 1 million

dataset
on test
use dataset by hex (split each)
use dataset by convert to decimal (split each)
use dataset by convert to binary  (binary 10101 not byte code) (split each)
my best result convert to binary 10101

I just on testing on small dataset

agree to try wok with over 1 billion dataset
try on large dataset and fix problem same time
I test on small and change to use large is difference like to try test new one on large dataset

test algorithm Neural Networks
try apply algorithm
use classification is give answer with percent
use predict number is give predict number with out percent

I think it using classification training is better because give result with percent of predict it useful for use decision

I think small neural networks  can not handle with Secp256k1 success problem curve with large number it make very complex
neural networks is small digit work with neurons
problem is still on large number

other idea is create some algorithm to predict will be small and easy than may be correct at 50% only can call success

You wish, but the reality says no.

In the paper they look at 14, 20, and 32 bit elliptic curves. The corresponding weights storage is 2¹³, 2^13.5, 2^14.2. Theoretically the storage would be in the order of 2⁷, 2¹⁰, and 2¹⁶. So all looks good, no breakthrough.

To even learn the secp256k1 weights you'd need at least 2¹²⁸ examples. Good luck executing that.

Google colab is very good you need to subscription $9.99 dollar per month to use colab pro available to use Tesla V100 it is very good deal

colab pro limited use 5 note same time and can use with 24 hour will be re-connect again require to open web browser can not close work page

you need to use with google drive to save you job subscriot more 100gp drive will be good

I just try to use colab pro

Selection error was 0.9916. But in tests it was 50%, shaking from 1000 to -1000 (good - bad). So still close to 50%

Colab has heavy limitations on the GPU in its free tier where they'll stop your whole notebook once you exceed a certain number of hours.


What are your detection rates for the 50m dataset (true positive/negative %, false positive/negative % etc.)?

A bit off-topic, but i've heard my friend they're using Google colab and Kaggle which give you access to high-end professional/data server GPU. I don't know the limitation, but it might worth to try.

great if can do with 1billion dataset

my GPU is small gtx 1050 just 1 millions is slow training
may be need to optimize model code

test at 1000 and 10000 is no problem but 100000 and 1000000 have a lot of error show on training

I can do only test and train
for use may be do by manual use

1m is nothing, i've tried 50m. I suppose there need tests for 1billion dataset
And for calculation need take small curves and increase numbers if success, to get formula and calculate how much data required for Secp256.

problem on ML.NET
dataset like a random no pattern

training with 1 million dataset result very low accuracy at 0.0001%
it not works
I will try on keras 5 layer and 256 NN
possible get result same

neural networks may be work only on dataset have pattern, NN can find pattern
but Secp256k1 or elliptic curve like a random

NNs can capture very hard dependecies, depends on type and number of hidden layers.

https://www.sciencedirect.com/science/article/pii/S0895717707000362

Using NN for cracking cryptographic functions is pointless. NN can capture only simple dependencies.

I expect the number of weights needed for capturing one bit with bigger than insignificant probability to be in the order of 2¹²⁸.

Wrong, Key % 2 or key > n/2  not y % 2.

sample python script create dataset for neural networks

this script just for testing (test on ml.net)
for use need to upgrade and fix

you need to modify to fit as you use

my test on ml.net use binary to 1 and 0 get result better than number (Dec)


test 1
datasetNN1.py


test 2
datasetNN2.py

Simple GUI try use ML.NET Model Builder GPU Support (Preview)

Download Visual Studio 2019 for Windows Community and install ML.NET Model Builder

but ML.NET Model Builder is not Neural Networks (NN use perceptron)

ML.NET Model Builder is use algorithm and try select best algorithm automatic for predict

(real Neural Networks should be use Keras no GUI or AutoKeras still need to coding)

ML.NET Model Builder try apply by use Text classification or Value prediction

Ofc. I've tried bunch of them.

Thats example of X,Y,is positive.
ToByteArray.



or OpenNN. NeuralDesigner have friendly GUI, its easy to use.

Do you have sample dataset  of Y and result ?
Qhat input? , Qhat output?

if do small one, neural networks

for who know about neural networks. you can do with you Nvidia CUDA GPU. you know already to do.
but still not yet have sample code on github for try and testing

but for who don't know must about neural networks

try AutoML Tables by google cloud
https://cloud.google.com/automl-tables

just upload dataset to server and training, that easy to use without no coding
 
(other service both Microsoft Azure AutoML and Amazon AWS SageMaker have Automatic neural networks service same)

Yes. but it cannot be usefull for deccision.

Y+(-Y) = FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F(MODULO)

There no know relationship between Y and -Y. Atleast for polynominal. Thats why im trying to use neural network to discover that,

Have any idea about Y, -Y relationship?
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413B",
publicKey="02FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
X= FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556
Y= 51ED8885530449DF0C4169FE80BA3A9F217F0F09AE701B5FC378F3C84F8A0998
Y= AE12777AACFBB620F3BE96017F45C560DE80F0F6518FE4A03C870C36B075F297

privateKey="0000000000000000000000000000000000000000000000000000000000000006", publicKey="03FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
X= FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556
Y= 51ED8885530449DF0C4169FE80BA3A9F217F0F09AE701B5FC378F3C84F8A0998
Y= AE12777AACFBB620F3BE96017F45C560DE80F0F6518FE4A03C870C36B075F297

Yes, its 50/50 ofc. each X have 2 Ys. The point is to get deccion by NN to get correct first half or second half. 02,03 its compressed, uncompressed form have 32 bytes too.
Or get dirrection when subtracting

X -Y sub 1 == X Y add 1

Again, we don't need large sophisticated neural networks, small ones will do. Though at this point you're making more of an empirical test of already used pubkeys since the Y polarity of the entire public key space converges to 50%.

As far as I know, it is exactly 50% of keys. For any public key you can negate it and switch it from 02 to 03 or from 03 to 02. It is totally symmetric, I cannot see a single example where it would be ambiguous or where more than a pair of keys could be produced in that way. You can see it simply by using G and -G and incrementing or decrementing points. You would see a pairs of private keys: (1;-1);(2;-2);(3;-3);... When dealing with private keys, you can simply subtract your private key from the maximum and get your negated private key. For public keys, you can switch between 02 and 03 prefix. That's all.

yes, use mathematical is smart way and no need to use powerful hardware
like ECC calculate fast

Did we need to create new algorithm to this this problem? or it is already have it?

use neural networks is require high power of hardware (and high power software too)

Large number:
Biginteger to byte array
or Biginteger to bit array
/ normalize.



Yes, dont need tons of GPU. I've alrady tried 50m dataset, but it dropped only to 0.9996 selection error, and thats still random. 512 , 256, 128,64. hidden neurons

Yes, we dont use private key, but we use its odd or even. Its not about Public key to Private key. Its about Public key to private key > n/2 or < n/2.

We don't need all that powerful hardware, because we're not trying to guess the range of the Y point, we are only trying to guess whether it is positive or negative.

For such an analysis you only need a few hundred thousand public keys and I wouldn't be surprised if you could run such a simulation on a single laptop.


We're not interested in private keys, we are trying to guess how often a public key has a positive Y coordinate (or negative Y).

Is it possible to know from the  Y  of the public key that private key is range > 0xfffffffffffffffffffffffffffffffe*********************
I Remember to read it in an article ...
this is a mathematical problem

How can use neural networks dataset?
do you have more detail ?
how to use classification?
how to deal with large number?

neural networks require to some large search support
it can not do alone one person or small team
I think we can not do it  (you only one alone or you team 2-5 person)

project neural networks risk to fail 100% no body to try it   (who do it fail not tell us to know)
nobody try one may be know result not easy possible

only keras 5 layer and perceptron 256 or 512 can not do this job
it can not normal neural networks to do this job must be very complex neural networks do this

easy you can try maximum layer keras can do

what is dataset to use
input?
output?

input
may be convert to binary and each column is one bit

neural networks not understand character must be convert to digit or only 1 and 0 (one-hot encode data)

problem Y point is 256 bit is very large number not easy to put to dataset
problem most AI. result have answer short is 1 and 0 or limited digit number of possibility

may be need to develop AI. 256 AI. for each  bit
may be need to use maximum neural networks layer
may be require minimum to level same or high more than OpenAI GPT-3

how many AI.? I guest over 256 AI. by one Ai. for one bit coalition
or may be 256*256 = 65,536 AI for do it

how many layer? I guess over 48 layer
may be (sample)
48-layer, 1600-hidden, 25-heads, 1558M parameters
24-layer, 2048-hidden, 16-heads, 1.3B parameters.
32-layer, 2560-hidden, 20-heads, 2.7B parameters.

BERT use 168M parameters
GPT-2 is with 1.5 billion parameters
full-sized GPT-3 has 175 billion parameters

so possible minimum require will be 175 billion parameters as research can do for now

some idea
using deep learning to train
use deep reinforcement learning (must be better than AlphaGo)
use NLP/MLM to translate (modify to special use)
modify BIRT to works
modify GPT-2 to works
use generative deep learning to train one ai generate and one verify

problem may be need to require training over a year

result possible to get very low accurate rate

if can do possible to get only just close up number on range not correct number
I believe some AI. search do some research about blockchain

not easy
project require large fund to support

what research want to do
blockchain is great project freedom without control need tp be upgrade to very stronger

research  need to be do first before some one do it and use at wrong way
I think may be natural networks possible can find found vulnerability need to fix it

layer reference see
https://huggingface.co/transformers/pretrained_models.html

DeepMind A.I. unit lost $649 million (so how many budget to use for this )

other, you need hardware like  Nvidia A100 over 1000 GPU
or NVIDIA DGX A100 x 100 (or NVIDIA DGX POD)
see hardware for training
https://en.wikipedia.org/wiki/AlphaGo

no body create project natural networks like this on GitHub
can not find sample project
try start project one and open to forked to extend update

found other project on this forum post
https://github.com/btc-room101/bitcoin-rnn

We dont know position of their privkeys, so its useless.

With taproot, that kind of analysis will be worthless, because all taproot public keys would be 256-bit and they would start with 02 prefix.

You'll probably want to scrape points directly from historic blockchain transactions such as ones from 2017 and 2018. I wouldn't simply randomly generate points if the purpose is to guess the polarity of Y in public keys that are used in real life, there's no use to that.

Given that each block averages a few thousand transactions, you'll want to train on transactions from a few hundred blocks, which'll result in about a few million or hundred thousand compressed points of training data. And that shouldn't take more than a few dozen MB if they are stored as text, one compressed address per line.

Remembering that an epoch is 2016 blocks long, you can either choose to target trends in Y polarity for a single epoch (given that most bitcoin "politics" occur right at the beginning and usually last for the epoch duration), or you can sample blocks from different epochs and try to get a general idea of Y polarity throughout history.

I'm not really sure how many hidden layers would be necessary for this kind of thing, but maybe one of the answers at https://stats.stackexchange.com/questions/181/how-to-choose-the-number-of-hidden-layers-and-nodes-in-a-feedforward-neural-netw will help.

Agreed, Y is splitted around 50%. Its same for signifcant bit and Y polarity what anwser is binary. The main question what size of dataset should be. Type of it. size of hidden layers.

I'm not aware of any research about trying to guess the polarity of the Y coordinate, which by the way will always have false positives if neural networks are used, but one caveat is that the distribution between odd-Y and even-Y points is sort of normal, there isn't a vast majority of points in the space that are either odd or even Y. So any deep learning classification is going to tend somewhere around ans == 0.5. It converges to that, anyway, given you have millions of random points in your dataset.

Did someone tried to disignate singificant bit, or polarity of Y cord on Secp256k1 by neural networks?

Any calculations about dataset size to get a liitle more percentege from random dessicion?
Should be used Y coordinate in dataset for learning for signifacnt bit.
Any possible checks except Key && Key+G && NN ans >0.5 && ans < 0.5?