he downloaded program from the site does not work.Could not compile correctly.Someone compile under Windows 7 64bit.You can upload or send by mail [email protected] /I want to join the project too, thanks.
Topic: Pollard's kangaroo ECDLP solver - page 108. (Read 58630 times)
I let my system run on dp 26 with 2^22 kangaroos
Does your export strip any information out of original DP files or are you extracting everything, minus the headers?
Only exports DP, headers can be "extracted" with -winfoIn SaveFile/HashTable, DPs are grouped by 18bits (from 0x00000 to 0x3ffff). And inside every group are stored distance and x-coord.
Distance: (1bit sign + 1bit type tame/wild + 126bits distance)
X-Coord: 128 bits
With 18bits of group + 128bits of x-coord, we have 146bits; and we "lost" 110bits (left N bits are zeroed as DP, -d option)
Example:
Code:
Distance: 0000000000000000f862dc916dfc4479
X-Coord: 000002af00818a0d3e8923d211901f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46
00000 2af00818a0d3e8923d2119 01f7f e7bfd3dc4c604b3e708c2fb4bdd2ed46
|__DP |__Lost bits (110-DP) | |___128 bits
|__18bits (first 2bits from first hex-char lost)
X-Coord: 000002af00818a0d3e8923d211901f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46
00000 2af00818a0d3e8923d2119 01f7f e7bfd3dc4c604b3e708c2fb4bdd2ed46
|__DP |__Lost bits (110-DP) | |___128 bits
|__18bits (first 2bits from first hex-char lost)
Running a test at DP 25 for puzzle #115 with 2^27 kangaroos; 16 hours, running strong. RAM at constant 49%. RAM = 8GB
Does your export strip any information out of original DP files or are you extracting everything, minus the headers?
Only exports DP, headers can be "extracted" with -winfoIn SaveFile/HashTable, DPs are grouped by 18bits (from 0x00000 to 0x3ffff). And inside every group are stored distance and x-coord.
Distance: (1bit sign + 1bit type tame/wild + 126bits distance)
X-Coord: 128 bits
With 18bits of group + 128bits of x-coord, we have 146bits; and we "lost" 110bits (left N bits are zeroed as DP, -d option)
Example:
Code:
Distance: 0000000000000000f862dc916dfc4479
X-Coord: 000002af00818a0d3e8923d211901f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46
00000 2af00818a0d3e8923d2119 01f7f e7bfd3dc4c604b3e708c2fb4bdd2ed46
|__DP |__Lost bits (110-DP) | |___128 bits
|__18bits (first 2bits from first hex-char lost)
X-Coord: 000002af00818a0d3e8923d211901f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46
00000 2af00818a0d3e8923d2119 01f7f e7bfd3dc4c604b3e708c2fb4bdd2ed46
|__DP |__Lost bits (110-DP) | |___128 bits
|__18bits (first 2bits from first hex-char lost)
Where on that page do you go, and what do you enter exactly?
Put tame "distance" in Secret Exponent, and select compressed to view only X coord in Pubkey (after 02/03)
Code:
0000000000000000f862dc916dfc4479 -> 02:000002af00818a0d3e8923d211901f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46
I see there is a match in the LSBs:
Code:
01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46
So I take it this was a solved key?Code:
TAME: 01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000f862dc916dfc4479
WILD: 01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000502a2b5c6849dc12
SECRET_PRIV_KEY = TAME_DIST - WILD_DIST + START
0xf862dc916dfc4479 - 0x502a2b5c6849dc12 + 2**64 = 0x1a838b13505b26867
WILD: 01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000502a2b5c6849dc12
SECRET_PRIV_KEY = TAME_DIST - WILD_DIST + START
0xf862dc916dfc4479 - 0x502a2b5c6849dc12 + 2**64 = 0x1a838b13505b26867
Where on that page do you go, and what do you enter exactly?
Put tame "distance" in Secret Exponent, and select compressed to view only X coord in Pubkey (after 02/03)
Code:
0000000000000000f862dc916dfc4479 -> 02:000002af00818a0d3e8923d211901f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46
I see there is a match in the LSBs:
Code:
01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46
So I take it this was a solved key?Code:
TAME: 01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000f862dc916dfc4479
WILD: 01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000502a2b5c6849dc12
SECRET_PRIV_KEY = TAME_DIST - WILD_DIST + START
0xf862dc916dfc4479 - 0x502a2b5c6849dc12 + 2**64 = 0x1a838b13505b26867
WILD: 01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000502a2b5c6849dc12
SECRET_PRIV_KEY = TAME_DIST - WILD_DIST + START
0xf862dc916dfc4479 - 0x502a2b5c6849dc12 + 2**64 = 0x1a838b13505b26867
Any how, I was able to calculate, correctly, the formula you two have provided.
How do you calculate when you have to add say a 2^115? Or do you have/know of a calculator that autocalculates everything once you enter Tt - Tw + 2^x ?
Where on that page do you go, and what do you enter exactly?
Put tame "distance" in Secret Exponent, and select compressed to view only X coord in Pubkey (after 02/03)
Code:
0000000000000000f862dc916dfc4479 -> 02:000002af00818a0d3e8923d211901f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46
I see there is a match in the LSBs:
Code:
01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46
So I take it this was a solved key?Code:
TAME: 01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000f862dc916dfc4479
WILD: 01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000502a2b5c6849dc12
SECRET_PRIV_KEY = TAME_DIST - WILD_DIST + START
0xf862dc916dfc4479 - 0x502a2b5c6849dc12 + 2**64 = 0x1a838b13505b26867
WILD: 01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000502a2b5c6849dc12
SECRET_PRIV_KEY = TAME_DIST - WILD_DIST + START
0xf862dc916dfc4479 - 0x502a2b5c6849dc12 + 2**64 = 0x1a838b13505b26867
@WanderingPhilospher
Let G = secp256k1_generator_point
Edit:
Let LSB = 128 lower bits of the x-coordinate
(0x0000000024a2b6bb0000000026dd90e3)*G = 0x1bfbfb9e55b617f03ad44aabe7545c1aad8ac86776cf2b3ba9bc5d0eb1002f99
Doesn’t match the LSB of the x-coordinate from your tame line data, maybe try a few more random points from the file. I was able to validate 10,000 points from my file without any errors.
Yes, you should be able to solve the key when there is a match from the files. But you will also need the beginning range that was used to solve for the original key. We only need to find out if there’s a match of the LSB of the x-coordinates from both types of kangaroos, then we can use the distances and the beginning range to calculate the private key.
So, if you have matching LSBs, then you may have a solution? In your estimate, how many times can LSBs match up but do not solve the key, guesstimate.Let G = secp256k1_generator_point
Edit:
Let LSB = 128 lower bits of the x-coordinate
(0x0000000024a2b6bb0000000026dd90e3)*G = 0x1bfbfb9e55b617f03ad44aabe7545c1aad8ac86776cf2b3ba9bc5d0eb1002f99
Doesn’t match the LSB of the x-coordinate from your tame line data, maybe try a few more random points from the file. I was able to validate 10,000 points from my file without any errors.
Yes, you should be able to solve the key when there is a match from the files. But you will also need the beginning range that was used to solve for the original key. We only need to find out if there’s a match of the LSB of the x-coordinates from both types of kangaroos, then we can use the distances and the beginning range to calculate the private key.
If you have 128-bit matching LSB, then with very high probability that you will find a solution. The probability for not finding a solution with 128-bit matching LSB is very small:
[number of entries in your hash table] divided by [2^128]
Some examples from 65bits address.
You can use https://brainwalletx.github.io/ to check G**p tame points.
Where on that page do you go, and what do you enter exactly?You can use https://brainwalletx.github.io/ to check G**p tame points.
Code:
TAME
01f57df72a208ecb0dff27e1836f190850728 0000000000000000c6b916f827ecc764
01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000f862dc916dfc4479
01f84404e1bbaf74e5e86ddf86fa2e96f165a 0000000000000000d190f29c6c0596f6
34f64327b6e6129a2af1cc6a106f2cec5fcf0 00000000000000001f9e0d582f7942fd
f6889b8abd66be32f13ebe2cf24d5ab6b62 00000000000000009b0984d32bf64396
34f6fdd77d4d6a532866be4fdfa5923a09ead 0000000000000000bc3de9e206c157db
--
WILD
34f44f024c8997abff6b5f1ee364c414c3016 0000000000000000344f3351ce019232
34f6889b8abd66be32f13ebe2cf24d5ab6b62 -00000000000000000d2f2c61d9bc24d1
34f738fed0a483f198a7a44d04e073c45b962 -0000000000000000602f88bbfaa6b336
01f7a2ae1656a659818a81f9a87204c29f1e8 -000000000000000048ea5f42dfb5bcc4
01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000502a2b5c6849dc12
01f8143c41d86963bf9df718f9d0ba2e80cd7 00000000000000000a350d95bb55cb79
01f57df72a208ecb0dff27e1836f190850728 0000000000000000c6b916f827ecc764
01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000f862dc916dfc4479
01f84404e1bbaf74e5e86ddf86fa2e96f165a 0000000000000000d190f29c6c0596f6
34f64327b6e6129a2af1cc6a106f2cec5fcf0 00000000000000001f9e0d582f7942fd
f6889b8abd66be32f13ebe2cf24d5ab6b62 00000000000000009b0984d32bf64396
34f6fdd77d4d6a532866be4fdfa5923a09ead 0000000000000000bc3de9e206c157db
--
WILD
34f44f024c8997abff6b5f1ee364c414c3016 0000000000000000344f3351ce019232
34f6889b8abd66be32f13ebe2cf24d5ab6b62 -00000000000000000d2f2c61d9bc24d1
34f738fed0a483f198a7a44d04e073c45b962 -0000000000000000602f88bbfaa6b336
01f7a2ae1656a659818a81f9a87204c29f1e8 -000000000000000048ea5f42dfb5bcc4
01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000502a2b5c6849dc12
01f8143c41d86963bf9df718f9d0ba2e80cd7 00000000000000000a350d95bb55cb79
I see there is a match in the LSBs:
Code:
01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46
So I take it this was a solved key? @WanderingPhilospher
Let G = secp256k1_generator_point
Edit:
Let LSB = 128 lower bits of the x-coordinate
(0x0000000024a2b6bb0000000026dd90e3)*G = 0x1bfbfb9e55b617f03ad44aabe7545c1aad8ac86776cf2b3ba9bc5d0eb1002f99
Doesn’t match the LSB of the x-coordinate from your tame line data, maybe try a few more random points from the file. I was able to validate 10,000 points from my file without any errors.
Yes, you should be able to solve the key when there is a match from the files. But you will also need the beginning range that was used to solve for the original key. We only need to find out if there’s a match of the LSB of the x-coordinates from both types of kangaroos, then we can use the distances and the beginning range to calculate the private key.
So, if you have matching LSBs, then you may have a solution? In your estimate, how many times can LSBs match up but do not solve the key, guesstimate. Let G = secp256k1_generator_point
Edit:
Let LSB = 128 lower bits of the x-coordinate
(0x0000000024a2b6bb0000000026dd90e3)*G = 0x1bfbfb9e55b617f03ad44aabe7545c1aad8ac86776cf2b3ba9bc5d0eb1002f99
Doesn’t match the LSB of the x-coordinate from your tame line data, maybe try a few more random points from the file. I was able to validate 10,000 points from my file without any errors.
Yes, you should be able to solve the key when there is a match from the files. But you will also need the beginning range that was used to solve for the original key. We only need to find out if there’s a match of the LSB of the x-coordinates from both types of kangaroos, then we can use the distances and the beginning range to calculate the private key.
Some examples from 65bits address.
You can use https://brainwalletx.github.io/ to check G**p tame points.
You can use https://brainwalletx.github.io/ to check G**p tame points.
Code:
TAME
01f57df72a208ecb0dff27e1836f190850728 0000000000000000c6b916f827ecc764
01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000f862dc916dfc4479
01f84404e1bbaf74e5e86ddf86fa2e96f165a 0000000000000000d190f29c6c0596f6
34f64327b6e6129a2af1cc6a106f2cec5fcf0 00000000000000001f9e0d582f7942fd
34f6889b8abd66be32f13ebe2cf24d5ab6b62 00000000000000009b0984d32bf64396
34f6fdd77d4d6a532866be4fdfa5923a09ead 0000000000000000bc3de9e206c157db
--
WILD
34f44f024c8997abff6b5f1ee364c414c3016 0000000000000000344f3351ce019232
34f6889b8abd66be32f13ebe2cf24d5ab6b62 -00000000000000000d2f2c61d9bc24d1
34f738fed0a483f198a7a44d04e073c45b962 -0000000000000000602f88bbfaa6b336
01f7a2ae1656a659818a81f9a87204c29f1e8 -000000000000000048ea5f42dfb5bcc4
01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000502a2b5c6849dc12
01f8143c41d86963bf9df718f9d0ba2e80cd7 00000000000000000a350d95bb55cb79
01f57df72a208ecb0dff27e1836f190850728 0000000000000000c6b916f827ecc764
01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000f862dc916dfc4479
01f84404e1bbaf74e5e86ddf86fa2e96f165a 0000000000000000d190f29c6c0596f6
34f64327b6e6129a2af1cc6a106f2cec5fcf0 00000000000000001f9e0d582f7942fd
34f6889b8abd66be32f13ebe2cf24d5ab6b62 00000000000000009b0984d32bf64396
34f6fdd77d4d6a532866be4fdfa5923a09ead 0000000000000000bc3de9e206c157db
--
WILD
34f44f024c8997abff6b5f1ee364c414c3016 0000000000000000344f3351ce019232
34f6889b8abd66be32f13ebe2cf24d5ab6b62 -00000000000000000d2f2c61d9bc24d1
34f738fed0a483f198a7a44d04e073c45b962 -0000000000000000602f88bbfaa6b336
01f7a2ae1656a659818a81f9a87204c29f1e8 -000000000000000048ea5f42dfb5bcc4
01f7fe7bfd3dc4c604b3e708c2fb4bdd2ed46 0000000000000000502a2b5c6849dc12
01f8143c41d86963bf9df718f9d0ba2e80cd7 00000000000000000a350d95bb55cb79
@WanderingPhilospher
Let G = secp256k1_generator_point
Edit:
Let LSB = 128 lower bits of the x-coordinate
(0x0000000024a2b6bb0000000026dd90e3)*G = 0x1bfbfb9e55b617f03ad44aabe7545c1aad8ac86776cf2b3ba9bc5d0eb1002f99
Doesn’t match the LSB of the x-coordinate from your tame line data, maybe try a few more random points from the file. I was able to validate 10,000 points from my file without any errors.
Yes, you should be able to solve the key when there is a match from the files. But you will also need the beginning range that was used to solve for the original key. We only need to find out if there’s a match of the LSB of the x-coordinates from both types of kangaroos, then we can use the distances and the beginning range to calculate the private key.
Let G = secp256k1_generator_point
Edit:
Let LSB = 128 lower bits of the x-coordinate
(0x0000000024a2b6bb0000000026dd90e3)*G = 0x1bfbfb9e55b617f03ad44aabe7545c1aad8ac86776cf2b3ba9bc5d0eb1002f99
Doesn’t match the LSB of the x-coordinate from your tame line data, maybe try a few more random points from the file. I was able to validate 10,000 points from my file without any errors.
Yes, you should be able to solve the key when there is a match from the files. But you will also need the beginning range that was used to solve for the original key. We only need to find out if there’s a match of the LSB of the x-coordinates from both types of kangaroos, then we can use the distances and the beginning range to calculate the private key.
Those are from Tame and Wild files. What exactly does the program look for in those 2 lines above to result in solved key? Can anyone break it down by line and what the line/characters represent? Thanks.
Without knowing how the data is encoded/decoded, the lines by themselves are not very useful. A link to the source code would be very useful in this case.Quote
The X-coord is 128+18 bits and distance 126bits. The X-coordinate could be re-generated from the distance if necessary.
source code:
Code:
// Read DP
for(uint32_t h = 0; h < HASH_SIZE; h++) {
fread(&items,sizeof(uint32_t),1,f1);
fread(&maxItems,sizeof(uint32_t),1,f1);
for(uint32_t i = 0; i < items; i++) {
fread(&x,16,1,f1);
fread(&d,16,1,f1);
sign = (d.i64[1] & 0x8000000000000000);
htype = (d.i64[1] & 0x4000000000000000);
if(htype==0) {
::fprintf(ft,"%05x%016lx%016lx ", h & 0x3ffff, (uint64_t) (x.i64[1]), (uint64_t) (x.i64[0]));
::fprintf(ft,"%016lx%016lx\n", (uint64_t) (d.i64[1] & 0x3fffffffffffffff), (uint64_t) (d.i64[0]));
numTame++;
} else {
::fprintf(fw,"%05x%016lx%016lx ", h & 0x3ffff, (uint64_t) (x.i64[1]), (uint64_t) (x.i64[0]));
if(sign)
::fprintf(fw,"-");
::fprintf(fw,"%016lx%016lx\n", (uint64_t) (d.i64[1] & 0x3fffffffffffffff), (uint64_t) (d.i64[0]));
numWild++;
ft = tame; fw= wild.
I found and compiled the above source code and my exported data validates while yours do not.
The first column is the least significant bits (LSB) of the x-coordinate, and the second column is the traveled_distance to multiply secp256k1_generator_point with.
Tame:
[distinguished_point] = (tame_traveled_distance)*(secp256k1_generator_point)
Wild:
[working_public_key] = [(original_public_key) - (beginning_range)*(secp256k1_generator_point)].
[distinguished_point] = [(+-wild_traveled_distance)*(secp256k1_generator_point)] + [working_public key]
[private_key] = (beginning_range) + (tame_traveled_distance) +- (wild_traveled_distance)
When you say your export data validates while mine did not, what do you mean? I just copied and pasted the first two lines from each file that were generated from the export option.
For the private key; can it be solved via the data you get from the export source code I listed above? Sounds like it's missing a piece of data?
So, in order for the server to solve the private key, all it needs is x coord and distance?
Code:
// Send DP to server
for(int g = 0; g < CPU_GRP_SIZE; g++) {
if(IsDP(ph->px[g].bits64[3])) {
ITEM it;
it.x.Set(&ph->px[g]);
it.d.Set(&ph->distance[g]);
it.kIdx = g;
dps.push_back(it);
Those are from Tame and Wild files. What exactly does the program look for in those 2 lines above to result in solved key? Can anyone break it down by line and what the line/characters represent? Thanks.
Without knowing how the data is encoded/decoded, the lines by themselves are not very useful. A link to the source code would be very useful in this case.Quote
The X-coord is 128+18 bits and distance 126bits. The X-coordinate could be re-generated from the distance if necessary.
source code:
Code:
// Read DP
for(uint32_t h = 0; h < HASH_SIZE; h++) {
fread(&items,sizeof(uint32_t),1,f1);
fread(&maxItems,sizeof(uint32_t),1,f1);
for(uint32_t i = 0; i < items; i++) {
fread(&x,16,1,f1);
fread(&d,16,1,f1);
sign = (d.i64[1] & 0x8000000000000000);
htype = (d.i64[1] & 0x4000000000000000);
if(htype==0) {
::fprintf(ft,"%05x%016lx%016lx ", h & 0x3ffff, (uint64_t) (x.i64[1]), (uint64_t) (x.i64[0]));
::fprintf(ft,"%016lx%016lx\n", (uint64_t) (d.i64[1] & 0x3fffffffffffffff), (uint64_t) (d.i64[0]));
numTame++;
} else {
::fprintf(fw,"%05x%016lx%016lx ", h & 0x3ffff, (uint64_t) (x.i64[1]), (uint64_t) (x.i64[0]));
if(sign)
::fprintf(fw,"-");
::fprintf(fw,"%016lx%016lx\n", (uint64_t) (d.i64[1] & 0x3fffffffffffffff), (uint64_t) (d.i64[0]));
numWild++;
ft = tame; fw= wild.
I found and compiled the above source code and my exported data validates while yours do not.
The first column is the least significant bits (LSB) of the x-coordinate, and the second column is the traveled_distance to multiply secp256k1_generator_point with.
Tame:
[distinguished_point] = (tame_traveled_distance)*(secp256k1_generator_point)
Wild:
[working_public_key] = [(original_public_key) - (beginning_range)*(secp256k1_generator_point)].
[distinguished_point] = [(+-wild_traveled_distance)*(secp256k1_generator_point)] + [working_public key]
[private_key] = (beginning_range) + (tame_traveled_distance) +- (wild_traveled_distance)
When you say your export data validates while mine did not, what do you mean? I just copied and pasted the first two lines from each file that were generated from the export option.
For the private key; can it be solved via the data you get from the export source code I listed above? Sounds like it's missing a piece of data?
Those are from Tame and Wild files. What exactly does the program look for in those 2 lines above to result in solved key? Can anyone break it down by line and what the line/characters represent? Thanks.
Without knowing how the data is encoded/decoded, the lines by themselves are not very useful. A link to the source code would be very useful in this case.Quote
The X-coord is 128+18 bits and distance 126bits. The X-coordinate could be re-generated from the distance if necessary.
source code:
Code:
// Read DP
for(uint32_t h = 0; h < HASH_SIZE; h++) {
fread(&items,sizeof(uint32_t),1,f1);
fread(&maxItems,sizeof(uint32_t),1,f1);
for(uint32_t i = 0; i < items; i++) {
fread(&x,16,1,f1);
fread(&d,16,1,f1);
sign = (d.i64[1] & 0x8000000000000000);
htype = (d.i64[1] & 0x4000000000000000);
if(htype==0) {
::fprintf(ft,"%05x%016lx%016lx ", h & 0x3ffff, (uint64_t) (x.i64[1]), (uint64_t) (x.i64[0]));
::fprintf(ft,"%016lx%016lx\n", (uint64_t) (d.i64[1] & 0x3fffffffffffffff), (uint64_t) (d.i64[0]));
numTame++;
} else {
::fprintf(fw,"%05x%016lx%016lx ", h & 0x3ffff, (uint64_t) (x.i64[1]), (uint64_t) (x.i64[0]));
if(sign)
::fprintf(fw,"-");
::fprintf(fw,"%016lx%016lx\n", (uint64_t) (d.i64[1] & 0x3fffffffffffffff), (uint64_t) (d.i64[0]));
numWild++;
ft = tame; fw= wild.
I found and compiled the above source code and my exported data validates while yours do not.
The first column is the least significant bits (LSB) of the x-coordinate, and the second column is the traveled_distance to multiply secp256k1_generator_point with.
Tame:
[distinguished_point] = (tame_traveled_distance)*(secp256k1_generator_point)
Wild:
[working_public_key] = [(original_public_key) - (beginning_range)*(secp256k1_generator_point)].
[distinguished_point] = [(+-wild_traveled_distance)*(secp256k1_generator_point)] + [working_public key]
[private_key] = (beginning_range) + (tame_traveled_distance) +- (wild_traveled_distance)
Those are from Tame and Wild files. What exactly does the program look for in those 2 lines above to result in solved key? Can anyone break it down by line and what the line/characters represent? Thanks.
Without knowing how the data is encoded/decoded, the lines by themselves are not very useful. A link to the source code would be very useful in this case.Quote
The X-coord is 128+18 bits and distance 126bits. The X-coordinate could be re-generated from the distance if necessary.
source code:
Code:
// Read DP
for(uint32_t h = 0; h < HASH_SIZE; h++) {
fread(&items,sizeof(uint32_t),1,f1);
fread(&maxItems,sizeof(uint32_t),1,f1);
for(uint32_t i = 0; i < items; i++) {
fread(&x,16,1,f1);
fread(&d,16,1,f1);
sign = (d.i64[1] & 0x8000000000000000);
htype = (d.i64[1] & 0x4000000000000000);
if(htype==0) {
::fprintf(ft,"%05x%016lx%016lx ", h & 0x3ffff, (uint64_t) (x.i64[1]), (uint64_t) (x.i64[0]));
::fprintf(ft,"%016lx%016lx\n", (uint64_t) (d.i64[1] & 0x3fffffffffffffff), (uint64_t) (d.i64[0]));
numTame++;
} else {
::fprintf(fw,"%05x%016lx%016lx ", h & 0x3ffff, (uint64_t) (x.i64[1]), (uint64_t) (x.i64[0]));
if(sign)
::fprintf(fw,"-");
::fprintf(fw,"%016lx%016lx\n", (uint64_t) (d.i64[1] & 0x3fffffffffffffff), (uint64_t) (d.i64[0]));
numWild++;
ft = tame; fw= wild.
Those are from Tame and Wild files. What exactly does the program look for in those 2 lines above to result in solved key? Can anyone break it down by line and what the line/characters represent? Thanks.
Without knowing how the data is encoded/decoded, the lines by themselves are not very useful. A link to the source code would be very useful in this case.
I'm sorry but I can't help you as I'm not the author of this mods.
What does program compare to result in a solved key/solution?
(Tame,Wild) = Collision
k = k1 + Tame.dist - Wild.dist
Tame File:
Wild File:
Those are from Tame and Wild files. What exactly does the program look for in those 2 lines above to result in solved key? Can anyone break it down by line and what the line/characters represent? Thanks.
Anyone?(Tame,Wild) = Collision
k = k1 + Tame.dist - Wild.dist
Tame File:
Code:
000000000000054e3f71000000000a250208a 0000000024a2b6bb0000000026dd90e3
Wild File:
Code:
00003000000007666967d0000000093b5394a 000000008dc1e960000000002be62262
Those are from Tame and Wild files. What exactly does the program look for in those 2 lines above to result in solved key? Can anyone break it down by line and what the line/characters represent? Thanks.
Each dp have 2 128bit word distance and x-coordinate.
There will be collision if x-coordinate of tame and wild Dp the same.
to chech what type of Dp need test 126 bit of distance if it zero then it is tame dp, if it is one then dp is wild.
The above tame and wild files, were from some random search I did. These tame and wild were exported from a workfile using this program.
So for the above tame and wild, the first part of each line needs to match; the x coord? The second part is the distance and it just tells us what kind of kangaroo it is?
Jump to: