 Show Posts
|
|
Pages: « 1 [2] 3 4 »
|
hi please show us secret priv key for proof -> sha256(7*char) tihs example for you pubkey,
0416ec0022bff86ee7d386bd6fd989f8ddd00f182b5b2f25e3d8c4e4f0df71641a413fac31c27d683c61c86172d1a73b480bbde606fe3b858b2995d50590f5d626
r,s,z (191-bit nounce)
90f7e2f803adbd24d6ea3df979f26903bd3c1b01f8d87bfb797b58de0b7ce8c3,83b8cea8f2af4847e8929df6c14849d443d07612365622f481aa862a271b9e18,cf9dd6c3a8fb3cf04e1ec73ccb54e0ac8f0e4bfa2581ed21c8195dfd4cbe4fd4
18da216bb593920d262e6db6fab26b490150e9c905c0e50d07bf8d43d5ff3545,c768ca24c8edd15bd4f110bbc530dff68bda839a3e03383f154da1f725c77165,2be7f4cc000012e780f9b8dc79c1d40a4516833067c2bd81363a63226c71bbfc
481e83c088642f5c73816bd1d1885df42393d6d34c2ed8aa824577768549b838,e451deffa49f92e7582b869be25943658eaa454ded9bf8f92a7a4d232b4948e6,167ebdfbaae75cc603e153e4bafe54c71ccd8cb84f7c809c514dc46ce4744b30
cd5d51e4839a20000a7747f78975f91228a1611316def622427ed80622cdca1b,d088c010643055d3243264d27e60f95c4ab9ba3dadb9943d4fbde71cf10558d5,4725c27238aaa58196c37cc1d6010c5e18bdf1262b79f4f7b730e5d01ca06651 |
|
|
|
anyone want to take bets on the above 'precompiled binary' from the newbie account being malware?
We are not being optimistic anymore, I agree and increase the bet. |
|
|
|
I'm looking for a developer to write a script to generate all possible private keys and write them to an SQL database. Payment available
using AlienTechnologies.TimeTravel;
using Encoders;
public void Main()
{
var storage = TimeTravelToFuture();
var sql = new SqlDatabase(storage);
for (BigInteger i = 1; i < 115792089237316195423570985008687907852837564279074904382605163141518161494337; i++)
{
sql.Write(Base58Encoder.GetWif(i));
}
}
private Storage TimeTravelToFuture()
{
TimeMachine.Engine.TurnOn();
TimeMachine.Time.Set("2120-01-01-12-45-00");
TimeMachine.Travel();
return TimeMachine.RetreiveStorageDisk();
}
You're welcome. I'll be damned! to this answer  |
|
|
|
There are bitcoin-related programs written in C and the reason they are so fast is because they use their own hand-written functions, and this works because they know their application requirements so they only write the functionality that will actually be used, unlike a general-purpose library (such as Boost) which cannot make this assumption.
C has sse support. almost no one use it. say std::cout <<"\nCoinbase: "<< txScriptSig <<"\nPubkeyScript: "<< pubScriptSig <<"\nMerkle Hash: "<< merkleHash <<"\nByteswapped: "<< merkleHashSw <<"\nGenerating block...\n\n";
unsigned char block_hash1[32];
#ifdef _MSC_VER
_declspec(align(16)) unsigned char block_hashfp[32];
#else
__attribute__((aligned(16))) unsigned char block_hashfp[32];
#endif
unsigned int counter=0, start = time(NULL);
int drift = 4;
__m128i r, m, b, camp;
__m128i zero = _mm_setzero_si128();
unsigned short turt;
while(1) {
SHA256((unsigned char*)&block_header, 80, block_hash1);
SHA256(block_hash1, 32, block_hashfp);
r = _mm_load_si128((__m128i *)block_hashfp);
m = _mm_load_si128((__m128i *)(block_hashfp+16));
switch (drift)
{
case 0:
break;
case 1:
b = _mm_alignr_epi8(m, r, 31);
break;
case 2:
b = _mm_alignr_epi8(m, r, 30);
break;
case 3:
b = _mm_alignr_epi8(m, r, 29);
break;
case 4:
b = _mm_alignr_epi8(m, r, 28);
break;
case 5:
b = _mm_alignr_epi8(m, r, 27);
break;
case 6:
b = _mm_alignr_epi8(m, r, 26);
break;
case 7:
b = _mm_alignr_epi8(m, r, 25);
break;
case 8:
b = _mm_alignr_epi8(m, r, 24);
break;
case 9:
b = _mm_alignr_epi8(m, r, 23);
break;
case 10:
b = _mm_alignr_epi8(m, r, 22);
break;
case 11:
b = _mm_alignr_epi8(m, r, 21);
break;
case 12:
b = _mm_alignr_epi8(m, r, 20);
break;
case 13:
break;
default:
break;
}
/*now it turns out like:
* Hashes 6018c18fcd4bfabb523f2ee1f6c18880f38135f3eb0ff1aa76acbc2fa94eb8ce
* And
* b 0000000000000000 000000006018c18f
*/
camp = _mm_cmpeq_epi8(b ,zero);
turt = _mm_movemask_epi8(camp);
if (turt == 0xffff)
{
std::reverse(block_hashfp,block_hashfp +32);
std::cout << "\nBlock found!\nHash: " << bin2hex(block_hashfp, 32) <<"\nNonce: " << block_header.startNonce << "\nUnix time: "<< block_header.unixtime << std::endl;
break;
}
if(time(NULL) - start > 0) {
std::cout << counter <<" Hashes/s, Nonce "<< block_header.startNonce<<'\r';
start = time((time_t *)(counter = 0));
}
if( ++block_header.startNonce == 0 ) block_header.unixtime++ ; //trick is that to change pre-start time to find a block(really it's smth else) faster then nonce wraps
counter++;
}
48 stuff looks like some hex'ed ascii phase(readable) i will review Thanks alexeyneu |
|
|
|
Hi My question went like this I understand asserts in python. but I didn't understand the first '48' part. my aim is to separate the "signature" and separate it as in the link below, of course together with the PubKey Can you give me information about conditions (assert) that will help me? Thanks. information that helps me https://bitcoin.stackexchange.com/questions/58853/how-do-you-figure-out-the-r-and-s-out-of-a-signature-using-pythontype :pubkeyhash spending_signature_hex : 483045022100cbee7b355c737bccdaaaf566b52e07c6e560fa33861b3035d37feffad94f66e6022 053114a529ab13eba906f9e08288bcf02dd5142ae0ecb117f10d54f56868443af014104d720973d f5c090aa1dd17adefd9f575baa2f0547dd2913fb4982bf423f1cf82623b700e0d1b7f2b7b5dcfa9 301f8c197dd0b601204d00e02b544251c5d9ac45a information I want to parse r = 00cbee7b355c737bccdaaaf566b52e07c6e560fa33861b3035d37feffad94f66e6 s = 53114a529ab13eba906f9e08288bcf02dd5142ae0ecb117f10d54f56868443af PubKey= 04d720973df5c090aa1dd17adefd9f575baa2f0547dd2913fb4982bf423f1cf82623b700e0d1b7f 2b7b5dcfa9301f8c197dd0b601204d00e02b544251c5d9ac45a def parse_element(hex_str, offset, element_size):
"""
:param hex_str: string to parse the element from.
:type hex_str: hex str
:param offset: initial position of the object inside the hex_str.
:type offset: int
:param element_size: size of the element to extract.
:type element_size: int
:return: The extracted element from the provided string, and the updated offset after extracting it.
:rtype tuple(str, int)
"""
return hex_str[offset:offset+element_size], offset+element_size
def dissect_signature(hex_sig):
"""
Extracts the r, s and ht components from a Bitcoin ECDSA signature.
:param hex_sig: Signature in hex format.
:type hex_sig: hex str
:return: r, s, t as a tuple.
:rtype: tuple(str, str, str)
"""
offset = 0
# Check the sig contains at least the size and sequence marker
assert len(hex_sig) > 4, "Wrong signature format."
sequence, offset = parse_element(hex_sig, offset, 2)
# Check sequence marker is correct
assert sequence == '30', "Wrong sequence marker."
signature_length, offset = parse_element(hex_sig, offset, 2)
# Check the length of the remaining part matches the length of the signature + the length of the hashflag (1 byte)
assert len(hex_sig[offset:])/2 == int(signature_length, 16) + 1, "Wrong length."
# Get r
marker, offset = parse_element(hex_sig, offset, 2)
assert marker == '02', "Wrong r marker."
len_r, offset = parse_element(hex_sig, offset, 2)
len_r_int = int(len_r, 16) * 2 # Each byte represents 2 characters
r, offset = parse_element(hex_sig, offset, len_r_int)
# Get s
marker, offset = parse_element(hex_sig, offset, 2)
assert marker == '02', "Wrong s marker."
len_s, offset = parse_element(hex_sig, offset, 2)
len_s_int = int(len_s, 16) * 2 # Each byte represents 2 characters
s, offset = parse_element(hex_sig, offset, len_s_int)
# Get ht
ht, offset = parse_element(hex_sig, offset, 2)
assert offset == len(hex_sig), "Wrong parsing."
return r, s, ht
example_sig = None # insert_sig_here
r, s, ht = dissect_signature(example_sig)
print "r: %s\ns: %s\nht: %s\n" % (r, s, ht) |
|
|
|
Hi example :
141 bit pub key : 027765d6d5f593e63936d8200508040520927334e5facf0624bb577e1bf379c925
237 bit start : 204238422632563516529542231428170520420288375567849687937360593336821455
237 bit end : 204238422632563516529542231430958113570104703460541652721441638525069007 You can create a signature any way you want. can you solve it if possible? |
|
|
|
KEY[15]: 0x49dccfd96dc5df56487436f5a1b18c4f5d34f65ddb48cb5e2452dd26bc983cd5
Pub: 02b1985389d8ab680dedd67bba7ca781d1a9e6e5974aad2e70518125bad5783eb5
****************************
Found in 1 seconds
GPU#0 job finished
Working time 00:00:55s
FINDpubkey= (55b95bef84a6045a505d015ef15e136e0a31cc2aa00fa4bca62e5df215ee981b, 3b4d6bce33718dc6cf59f28b550648d7e8b2796ac36f25ff0c01f8bc42a16fd9)
GPU#0 Cnt:0000000000000000000000000000000000000000000000000000000000000001
GPU#0 Cnt:00000000000000000000000000000000000000000000000045ba000000000001 1110MKey/s x1073741824 2^30.12 x2^31=2^61.12
***********GPU#0************
KEY[16]: 0x49dccfd96dc5df56487436f5a1b18c4f5d34f65ddb48cb5e7ad38337c7f173c7
Pub: 0355b95bef84a6045a505d015ef15e136e0a31cc2aa00fa4bca62e5df215ee981b
****************************
Found in 4 seconds
GPU#0 job finished
Working time 00:00:59s
double giant step defeated. v1.7.1 released with maximum perfomance. Hi, Please , can you write a little tutorial on usage? |
|
|
|
|
Her kör satıcını kör bir alıcısı olacaktır.
|
|
|
|
|
Thanks for your attention COBRAS
The answer to my question is not your answer. I know how to translate hexdecimal numbers. but it became difficult for me to read it in c language and understand loop methods after a while.
For this reason, I wanted to understand with the example in my previous message.
|
|
|
|
|
Hello there
Can you explain with an example the algorithm used in Pollard's kangaroo ECDLP solver project?
I'm having trouble understanding because the numbers are hexdecimal.
for example
sage: randint(2**45,2**46)
47219499872892
sage: 47219499872892*G
(18692559038988851916170053003258633318507926584259629315624368898934485230811 : 9144672546996927057709444239997623041606234894764707963152906128604997321118 : 1)
sage: hex(18692559038988851916170053003258633318507926584259629315624368898934485230811),hex(9144672546996927057709444239997623041606234894764707963152906128604997321118)
('29539d0d985554a180fa729fdfcf57727e275619c4f7624923d489ba9ba324db', '1437b38492cc93a5e7188705806da639a9bdabb9591f3e265dc278c1afef819e')
2**45 bit
2**46 bit
pubkey = 0229539d0d985554a180fa729fdfcf57727e275619c4f7624923d489ba9ba324db
|
|
|
|
You should read BIP-143, all the information you seek is explained there. In other words, I'm trying to calculate the K point.
If by "K" you mean the corresponding point of the ephemeral key used in signing referred to "k" in some standards, then you can't do that. The whole security of ECDSA relies on the fact that this is impossible to compute. I'm not looking for the private k value I want to calculate the K point which is public. in pubkey and pubkeyhash type signatures N = 115792089237316195423570985008687907852837564279074904382605163141518161494337 type (X) = EllipticCurve Point on x ^ 3 + 7 for PrimeFileld type (G) = EllipticCurve Base Point on x ^ 3 + 7 for PrimeFileld type (R) = (max 256-bit) Integer type (S) = (max 256-bit) Integer type (Z) = (max 256-bit) Integer (How to calculate K on EllipticCurve): retrun EcPoint (R / S% N) * X + (Z / S% N) * G This gives us the point K on the Elliptic Curve If K.x == R signature is correct. Alice Signed. How does Bob understand this. Somehow it has to calculate the message (Z value) so that it can check the signature. My question is I'm trying to figure out how Bob calculates this on my Z value. Not calculating K. If I wanted to find the equivalent of point K in positive numbers, I would be interested in ECDLP. But our topic is not ECDLP. Thanks. |
|
|
|
|
Hello everyone
I am directly asking my question, I am trying to find the z value of a signature with signature type witness_v0_scripthash.
In other words, I'm trying to calculate the K point.
I learned how to calculate z value in signatures with signature types pubkey and pubkeyhash. I could not do it with the same method. Is this method correct? Can you help me? Thank you.
Example TX
Type : witness_v0_scripthash
Transaction
01000000000101842556e841ccf129e2077b3c9f700d6a458273a281ee230a8a1aa87b4ff6786b0 100000000ffffffff02852e23000000000017a91467f0f8cf7877cabf2b735af6ca101b7384314d c38767bf81000000000016001418a65824d303be627b3e4072fcb389d3dce26a120248304502210 087c189f6b0bc8b8d8bc7ebc8192d9f750e9b4f8150e87a928ba0176fa7329c85022056a33740a3 e01e72dbfa6a3b79d2e9a2c4a0e17dadb9a71e5a639cea8e24e94c0121036edf4b70e69f477684e 1947b34a695b7e0340253456794e71950129c1408c7cc00000000
tx
fd4db43eda3e1ecd205df6469526ccc67005596fa32a4ec13e132aaee6a6ad7b
signature
304502210087c189f6b0bc8b8d8bc7ebc8192d9f750e9b4f8150e87a928ba0176fa7329c85022056a33740a3e01e72dbfa6a3b79d2e9a2c4a0e17dadb9a71e5a639cea8e24e94c01,036edf4b70e69f477684e1947b34a695b7e0340253456794e71950129c1408c7cc
R
0087c189f6b0bc8b8d8bc7ebc8192d9f750e9b4f8150e87a928ba0176fa7329c85
S
56a33740a3e01e72dbfa6a3b79d2e9a2c4a0e17dadb9a71e5a639cea8e24e94c
Pubkey
036edf4b70e69f477684e1947b34a695b7e0340253456794e71950129c1408c7cc
|
|
|
|
Not one that I know of. The fastest secp256k1 library in existence, libsecp256k1 (Pieter Wuille's brainchild), currently works only on CPU. So, what someone would do from here is find somebody who can port this to CUDA. It's unlikely the actual operations themselves can be optimized further beyond placing them on blocks and threads, but the ideal way to create a super-fast secp256k1 CUDA implementation, or for any math library really, is to design it so that millions of these numbers can be operated on in parallel. Someone made a start for OpenCL but it's not as fast as it could be. Another ones this -> https://github.com/ilaychen/ECDSA-OpenCL |
|
|
|
Thanks NotATether for the reply For CUDA, the number library is important for fast transactions, especially in parallel transactions, the CGBN project started in 2019. I'm not sure how useful the CGBN number library would be compared to the large number use in Bitcrack and Kangaroo projects, but there is a table for the duration of mathematical operations. Project address: https://github.com/NVlabs/CGBNIs it the right way to make a new secp256K1 library with the CGBN number library on Cuda? |
|
|
|
Hi Is there secp25k1 for the cuda api on C ++? How can I create such a project in Visual Studio? Do you have a project ready? I will only use CUDA .. like https://github.com/brichard19/BitCrack and https://github.com/JeanLucPons/Kangaroohowever, I do not have enough knowledge of C ++ to understand the documents in these projects. I just want to increase the mathematical operations in parallel. So I am looking for a C ++ platform project that works in the CUDA API of secp256k1 library. Thank you.. |
|
|
|
|
WalletAddress = has160( sha256 ( sha256( PubKey ) ) )
şeklinde özetlendiği için adresten PubKey bulman mümkün değil.
senin söylediğin gibi bir transfer (out) olursa PubKey i görebilirsin.
|
|
|
|
Actually my question is about doing operation on the GPU, not about what I am trying to do. I just wrote an example that I want to experiment with. I generally experiment, read articles, but processing speed takes a lot of time. For example, I wanted to experiment by reading the last discussion here. https://math.stackexchange.com/questions/873843/cyclic-group-presentationOk. Well the code you are looking at/tweaking is full of GPU code, and the program works with multiple GPUs. That's why I asked. Are you trying to tweak and make your own Kangaroo program or something else?? sorry, I didn't understand what is not understood, just I want to make an Elliptic Curve Arithmetic GPU Based Library. I'm working on developing new algorithms like kangaroo thank you |
|
|
|
Actually my question is about doing operation on the GPU, not about what I am trying to do. I just wrote an example that I want to experiment with. I generally experiment, read articles, but processing speed takes a lot of time. For example, I wanted to experiment by reading the last discussion here. https://math.stackexchange.com/questions/873843/cyclic-group-presentation |
|
|
|
I am not familiar with the C programming language. Trying to understand just by reading the code I do, I installed CudaToolkit 10.2 and opened the project in Visual Studio. I have left some parameters from main.ccp. i don't know how and what to change I wrote my running main.ccp file here. https://bitcointalk.org/index.php?topic=5244940.msg56416339#msg56416339I added the ECmultipy method to the secp256K1.ccp file. He works on the project. With CPU only OpenCL or Cuda? I am currently using Nvidia Card. As far as I understand, OpenCL looks more advantageous. My goal is to reach the EllipticCurve Point Arithmetic library that works with more than one graphics card. Running Graphics Cards Rig line or Graphics card sharing system such as https://vast.aiFor now, I want to try it on my own computer. About 2 weeks ago I didn't know anything about C. I learn by researching and experimenting. Here's a simple control draft code for GPU . PrMod = 3618502788666131106986593281521497120414687020801267626233049500247285301313
ScalarNumber=0
while True :
ScalarNumbe = ScalarNumber +1
NewPoint = Point * i #for C -> Point NewPoint= secp256k1.ECMultiply(G, &ScalarNumber );
if NewPoint.x % PrMod == 85070591730234615865843651857942052871 :
SaveScalarFile(ScalarNumber)
I would really apreciate if you help. thank you for your interest. |
|
|
|
|
