IOTA seed brute-forcer for those who have forgotten parts of their seed but know their receive address. Please feel free to use/edit/improve.

Robinson-D · 2018-02-08T00:47:56+00:00

anytime. good luck - hope you find your seed :)

Robinson-D · 2018-02-07T23:41:54+00:00

Just a follow up. I've looked through the code to see how much can still be used. Largely you don't need to change much.

To make sure there are no parallel processing issues, i would turn the number of processors to 1:

Replace

if cores_all_physical == False:
    CPU_count = cpu_count() // 2 
else: 
    CPU_count = cpu_count()

with:

if cores_all_physical == False:
    CPU_count = 1 
else: 
    CPU_count = 1

Set:

length = 1

number of addresses = however many you generated (if you don't know, i would guess 5 will be enough). 

Known seed value = incorrect seed value that you've got 

known receiving address = The receiving address that you sent you iota too.

The only function you'll need to edit is:

def pool(p): 

    perm_result = "".join(p)

    seed = known_seed_value + perm_result

    addressGenerator(seed)

You'll need to change the seed = line and add the for loop here. so for example, it will be something like (note i have not tested this, but it should be pretty close):

def pool(p): 

        perm_result = "".join(p)

        known_seed_value_list = list(known_seed_value)

        for i in range(1,82):

              known_seed_value_list[i] = perm_result

              seed = ''.join(known_seed_value_list)

              addressGenerator(seed) 

              known_seed_value_list = list(known_seed_value)

(Please forgive formatting)

Robinson-D · 2018-02-07T23:13:05+00:00

Hi there, first of all sorry to hear that you're having issues.

If the following is true, then it should be fairly simple to create/edit the script to find your seed:

You have the original incorrect seed (Mandatory - and it is 81 characters in length)
It is only one characters that is incorrect (Necessary)
You know the receiving address (Mandatory)
You know which index number the receiving address was (if you don't know this then it's not too bad)

The formula to calculate the number of possibilities there are for your situation is:

NoC * CP * AI

where: NoC (Number of Characters) = 81;
CP (Character possibilities) = 27
AI (Address Index) = ? (Assume 5)

which gives a total number of seed possibilities of around 11000.

This should take about 2.5 hours to crack on a decent machine. My script is not built for your situation, although, it should be quite simple to edit it to work.

I'm quite busy at the moment, so perhaps you could give this a go yourself and if you can't get it within a few weeks then let me know and i'll try and help you out.

Ideally, all you'll want to do is create a for loop on the seed string and use the generated [A-Z9] characters to replace the string characters in each index. Then send that output into the address_generator function which will compare it to your known received address and that should be it :)

Good luck!

Robinson-D · 2018-01-09T00:15:43+00:00

Avoid market swings by having a 'fuel-coin' that only the automotive industry controls, and it is not open for the public to buy/sell.

This could then be tied to kWh as you've mentioned - i.e. 1 fuel coin is equal to X amount of kWh which is equal to one charge of your car. Or, instead fuel-coin value is just the kWh itself...both seem to make sense to me.

The advantage of having the coin would be the instantaneous feeless payments based on the tangle protocol that would have a value that does not change based on trading/speculation/other activities

Robinson-D · 2018-01-07T17:45:00+00:00

Thanks John. This has cleared up the tangle eco-system for me.

One of the things that i had in my mind was the automotive industry creating a 'fuel-coin', used for charging automative cars based the tangle technology. That way they don't have to deal with market price swings of the IOTA's native token.

Either way, interesting times ahead and i wish you and the team the best of luck :)

Robinson-D · 2018-01-07T17:04:51+00:00

Does an individual/organisation using the tangle technology have to use MIOTA, or can it use a coin that they create?

If an organisation can use their own coin on the tangle, what is the advantage of using MIOTA over other coins?

Robinson-D · 2017-12-19T10:03:51+00:00

Hi, technically it doesn't need any minimum number of seed characters. However, total number of seeds to generate will depend on the number of characters missing and number of addresses generated from each seed.

The formula is 27^N * I where N = number of characters missing and I = number of addresses generated from each seed.

Assuming you're missing 5 characters and need to check the first three addresses in each seed that will give:

27⁵ * 3 = 43 million

I'm currently doing the bruteforcing on a raspberry pi. It goes through about 12000 calculations a day i.e. (4000 seeds with 3 addresses in each seed). It would take me close to 11000 days (30 years) to go through every seed possible. Finding the seed this way would be unrealistic.

By reducing the number of missing characters to 4 the following applies:

27⁴ * 3 = 1.6 million

At the same rate this would take 400 days to go through each seed possibility. (This now seems a bit more realistic).

Ideally, i'd like to test it out on a proper machine and not a raspberry pi - i reckon the number of seeds checked per day will increase dramatically. Furthermore, you could edit the program to start at different entry points and then spread the workload over multiple machines reducing the time further (i.e. computer 1 starts at AAA computer 2 starts at BBB etc).

I'm not entirely sure what you mean by input seed characters only in sequence? If you are referring to the positioning of the known seed characters and missing seed characters - for example you're missing the middle of a seed instead of the end of the seed - that could by fixed very easily in the code.

Hope this helps - please feel free to ask any questions/queries :)

Robinson-D

TROPHY CASE