 Show Posts
|
|
Pages: [1]
|
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
Don't forget to make youre X,Y length to 32 or 256. while(X.length != 256) X = "0" + X; |
|
|
|
my GPU is small gtx 1050 just 1 millions is slow training
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. 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.
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
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. What are your detection rates for the 50m dataset (true positive/negative %, false positive/negative % etc.)? Selection error was 0.9916. But in tests it was 50%, shaking from 1000 to -1000 (good - bad). So still close to 50% |
|
|
|
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
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. |
|
|
|
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 2128.
NNs can capture very hard dependecies, depends on type and number of hidden layers. https://www.sciencedirect.com/science/article/pii/S0895717707000362 |
|
|
|
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 import random
import time
from bit import Key
import math
timestr = time.strftime("%Y%m%d-%H%M%S")
filename = "datasetNN_" + str(timestr) + ".csv"
print(time.strftime("%Y-%m-%d-%H:%M:%S"))
print(filename)
feature = ""
f = open(filename, "w")
j = 1
while j <= 256:
#print(j)
feature = feature + "f" + str(j) + ","
j += 1
header = feature+"Lebel"
#print(header)
f.write(header+"\n")
f.close()
i = 1
while i < 1000:
#while i < 1000000:
#label_output = '0'
label_output = 'even'
#print(i)
seed = random.randrange(2**119,2**120)
#seed = random.randrange(2**256)
key = Key.from_int(seed)
address = key.address
pubkey = key.public_key.hex()
x,y = key.public_point
if y % 2 == 0:
#label_output = 0 # even
#label_output = 'even' # even
label_output = 1 # even
else:
#label_output = 1 # odd
#label_output = 'odd' # odd
label_output = 2 # odd
y2_bin = bin(y)[2:]
bin2_split = list(y2_bin)
if len(bin2_split) == 256:
feature_binary = ""
for x in range(len(bin2_split)):
feature_binary = feature_binary + bin2_split[x] + ","
adddataline = feature_binary + str(label_output)
#print(addline)
f = open(filename, "a")
f.write(adddataline+"\n")
f.close()
i += 1
print(time.strftime("%Y-%m-%d-%H:%M:%S"))
test 2 datasetNN2.py import random
import time
from bit import Key
import math
timestr = time.strftime("%Y%m%d-%H%M%S")
filename = "datasetNN_" + str(timestr) + ".csv"
print(time.strftime("%Y-%m-%d-%H:%M:%S"))
print(filename)
feature = ""
f = open(filename, "w")
j = 1
#while j <= 256:
while j <= 64:
#print(j)
#feature = feature + "f" + str(j) + ","
feature = feature + "x" + str(j) + ","
j += 1
header = feature+"Lebel"
#print(header)
f.write(header+"\n")
f.close()
i = 1
while i < 1000:
#while i < 1000000:
#label_output = '0'
label_output = 'even'
#print(i)
seed = random.randrange(2**119,2**120)
#seed = random.randrange(2**256)
key = Key.from_int(seed)
address = key.address
pubkey = key.public_key.hex()
x,y = key.public_point
if y % 2 == 0:
#label_output = 0 # even
#label_output = 'even' # even
label_output = 1 # even
else:
#label_output = 1 # odd
#label_output = 'odd' # odd
label_output = 2 # odd
#y2_bin = bin(y)[2:]
#bin2_split = list(y2_bin)
bin2_split = list(pubkey[2:])
#if len(bin2_split) == 256:
#if len(pubkey) == 64:
feature_hex = ""
for x in range(len(bin2_split)):
#feature_hex = feature_hex + bin2_split[x] + ","
hex2_num = int(bin2_split[x], 16)
feature_hex = feature_hex + str(hex2_num) + ","
adddataline = feature_hex + str(label_output)
#print(addline)
f = open(filename, "a")
f.write(adddataline+"\n")
f.close()
i += 1
print(time.strftime("%Y-%m-%d-%H:%M:%S"))
Wrong, Key % 2 or key > n/2 not y % 2. |
|
|
|
There no know relationship between Y and -Y. Atleast for polynominal. Thats why im trying to use neural network to discover that,
Do you have sample dataset of Y and result ? Qhat input? , Qhat output? Ofc. I've tried bunch of them. X1;X2;X3;X4;X5;X6;X7;X8;X9;X10;X11;X12;X13;X14;X15;X16;X17;X18;X19;X20;X21;X22;X23;X24;X25;X26;X27;X28;X29;X30;X31;X32;Y1;Y2;Y3;Y4;Y5;Y6;Y7;Y8;Y9;Y10;Y11;Y12;Y13;Y14;Y15;Y16;Y17;Y18;Y19;Y20;Y21;Y22;Y23;Y24;Y25;Y26;Y27;Y28;Y29;Y30;Y31;Y32;target
233;18;54;13;167;132;41;227;170;248;134;37;7;113;94;20;171;72;185;202;195;2;247;229;78;165;85;239;238;206;187;41;122;192;153;227;188;238;59;122;136;199;95;24;167;130;100;146;89;92;190;97;65;161;50;95;94;31;78;35;162;106;231;205;1
233;18;54;13;167;132;41;227;170;248;134;37;7;113;94;20;171;72;185;202;195;2;247;229;78;165;85;239;238;206;187;41;181;59;102;28;66;17;196;133;119;56;160;231;88;125;155;109;166;163;65;158;190;94;205;160;161;224;177;220;93;149;24;50;0
Thats example of X,Y,is positive. ToByteArray.
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%.
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-tablesjust 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) or OpenNN. NeuralDesigner have friendly GUI, its easy to use. |
|
|
|
Y+(-Y) = FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F(MODULO)  Have any idea baout Y, -Y relationship? privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413B", publicKey="02FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556" X= FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556 Y= 51ED8885530449DF0C4169FE80BA3A9F217F0F09AE701B5FC378F3C84F8A0998 Y= AE12777AACFBB620F3BE96017F45C560DE80F0F6518FE4A03C870C36B075F297 privateKey="0000000000000000000000000000000000000000000000000000000000000006", publicKey="03FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556" X= FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556 Y= 51ED8885530449DF0C4169FE80BA3A9F217F0F09AE701B5FC378F3C84F8A0998 Y= AE12777AACFBB620F3BE96017F45C560DE80F0F6518FE4A03C870C36B075F297 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. privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413B", publicKey="02FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413C", publicKey="032F8BDE4D1A07209355B4A7250A5C5128E88B84BDDC619AB7CBA8D569B240EFE4"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413D", publicKey="03E493DBF1C10D80F3581E4904930B1404CC6C13900EE0758474FA94ABE8C4CD13"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413E", publicKey="03F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413F", publicKey="03C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140", publicKey="0379BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
privateKey="0000000000000000000000000000000000000000000000000000000000000001", publicKey="0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
privateKey="0000000000000000000000000000000000000000000000000000000000000002", publicKey="02C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5"
privateKey="0000000000000000000000000000000000000000000000000000000000000003", publicKey="02F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9"
privateKey="0000000000000000000000000000000000000000000000000000000000000004", publicKey="02E493DBF1C10D80F3581E4904930B1404CC6C13900EE0758474FA94ABE8C4CD13"
privateKey="0000000000000000000000000000000000000000000000000000000000000005", publicKey="022F8BDE4D1A07209355B4A7250A5C5128E88B84BDDC619AB7CBA8D569B240EFE4"
privateKey="0000000000000000000000000000000000000000000000000000000000000006", publicKey="03FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556" There no know relationship between Y and -Y. Atleast for polynominal. Thats why im trying to use neural network to discover that, Yes. but it cannot be usefull for deccision. |
|
|
|
Have any idea baout Y, -Y relationship? privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413B", publicKey="02FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556" X= FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556 Y= 51ED8885530449DF0C4169FE80BA3A9F217F0F09AE701B5FC378F3C84F8A0998 Y= AE12777AACFBB620F3BE96017F45C560DE80F0F6518FE4A03C870C36B075F297 privateKey="0000000000000000000000000000000000000000000000000000000000000006", publicKey="03FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556" X= FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556 Y= 51ED8885530449DF0C4169FE80BA3A9F217F0F09AE701B5FC378F3C84F8A0998 Y= AE12777AACFBB620F3BE96017F45C560DE80F0F6518FE4A03C870C36B075F297 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. privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413B", publicKey="02FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413C", publicKey="032F8BDE4D1A07209355B4A7250A5C5128E88B84BDDC619AB7CBA8D569B240EFE4"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413D", publicKey="03E493DBF1C10D80F3581E4904930B1404CC6C13900EE0758474FA94ABE8C4CD13"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413E", publicKey="03F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413F", publicKey="03C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140", publicKey="0379BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
privateKey="0000000000000000000000000000000000000000000000000000000000000001", publicKey="0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
privateKey="0000000000000000000000000000000000000000000000000000000000000002", publicKey="02C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5"
privateKey="0000000000000000000000000000000000000000000000000000000000000003", publicKey="02F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9"
privateKey="0000000000000000000000000000000000000000000000000000000000000004", publicKey="02E493DBF1C10D80F3581E4904930B1404CC6C13900EE0758474FA94ABE8C4CD13"
privateKey="0000000000000000000000000000000000000000000000000000000000000005", publicKey="022F8BDE4D1A07209355B4A7250A5C5128E88B84BDDC619AB7CBA8D569B240EFE4"
privateKey="0000000000000000000000000000000000000000000000000000000000000006", publicKey="03FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556" There no know relationship between Y and -Y. Atleast for polynominal. Thats why im trying to use neural network to discover that, |
|
|
|
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. privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413B", publicKey="02FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413C", publicKey="032F8BDE4D1A07209355B4A7250A5C5128E88B84BDDC619AB7CBA8D569B240EFE4"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413D", publicKey="03E493DBF1C10D80F3581E4904930B1404CC6C13900EE0758474FA94ABE8C4CD13"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413E", publicKey="03F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD036413F", publicKey="03C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5"
privateKey="FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140", publicKey="0379BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
privateKey="0000000000000000000000000000000000000000000000000000000000000001", publicKey="0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798"
privateKey="0000000000000000000000000000000000000000000000000000000000000002", publicKey="02C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5"
privateKey="0000000000000000000000000000000000000000000000000000000000000003", publicKey="02F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9"
privateKey="0000000000000000000000000000000000000000000000000000000000000004", publicKey="02E493DBF1C10D80F3581E4904930B1404CC6C13900EE0758474FA94ABE8C4CD13"
privateKey="0000000000000000000000000000000000000000000000000000000000000005", publicKey="022F8BDE4D1A07209355B4A7250A5C5128E88B84BDDC619AB7CBA8D569B240EFE4"
privateKey="0000000000000000000000000000000000000000000000000000000000000006", publicKey="03FFF97BD5755EEEA420453A14355235D382F6472F8568A18B2F057A1460297556" 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 |
|
|
|
Sorry for the stupid question.
But how can I import private key found by Pollard's kangaroo ECDLP solver? E.g. 0x60F4D11574F5DEEE49961D9609AC6
Electrum does not recognize it.
Make it size of 256 bits. 0000000000000000000000000000000000060F4D11574F5DEEE49961D9609AC6 and put it in wallet details as example on www.bitaddress.org |
|
|
|
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
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. 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
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). 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 dont know position of their privkeys, so its useless.
|
|
|
|
|
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.
|
|
|
|
|
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?
|
|
|
|
Trying to find patterns of pubkey => privkey or pubkey hashed to privkey. I've tried couple diffrent types of neural networks to solve that, but its requares massive data size, so its comparing to bruteforce, its not helpfull here. |
|
|
|
|
