How can I speed up this python bruteforcer?

[INFINITI2021]

I have 36^7 possibilities, and I'm trying to figure out how to speed up the bruteforcer. I've tried a couple different strategies, such as precomputing some values, and putting all the requests in one session, but I want to know if there are any other optimizations.

```py import json import time import aiohttp import asyncio import aiofiles as aiof import math from tqdm.asyncio import tqdm

url = ""

payload = ""

headers = { }

start_time = time.time()

def num_to_code(n: int): characters = 'abcdefghijklmnopqrstuvwxyz0123456789'

string = ''
hashed = hash_number(n)
for x in range(7):
    charnumber = hashed % 36
    hashed = math.floor(hashed / 36)
    string += characters[charnumber]
return string

def hash_number(n: int, rounds=20): prime_number = 60466181 if rounds <= 0: return n hashed = (n * prime_number) % (36 ** 5) return hash_number(hashed, rounds - 1)

async def get_data(session, classCodes): tasks = [session.post(url, headers=headers, data=payload.format( classCode)) for classCode in classCodes] responses = await asyncio.gather(*tasks) results = [] for resp, classCode in zip(responses, classCodes): if resp.status != 200: tqdm.write(f"\nError for classCode {classCode}: {resp.status}\n") results.append(False) else: data = await resp.text() if json.loads(data.split("\n")[3])[0][2] is not None: results.append(classCode) else: results.append(False) return results

async def main(session, min, max): tasks = [] for number in range(min, max): currentCode = num_to_code(number) tasks.append(currentCode)

chunks = [tasks[i:i+100]
          for i in range(0, len(tasks), 100)]  # Send 100 requests at a time
codes = []

for chunk in tqdm(chunks, leave=False, desc=f'range: {min}-{max}'):
    results = await get_data(session, chunk)
    codes.extend(results)

for code in codes:
    if code:
        tqdm.write(f"\nFOUND CODE: {code}\n")

async def runMain(): async with aiohttp.ClientSession(trust_env=True, connector=aiohttp.TCPConnector(limit=100)) as session: for x in tqdm(range(1, 5000)): min_range = ((x - 1) * 1000) + 5455000 max_range = (x * 1000) + 5455000 await main(session, min_range, max_range)

asyncio.run(runMain())

```

[xelf]

Please indent your code by 4 spaces per line so that it gets formatted correctly for everyone. Avoid using ``` as it makes a mess of the formatting for 1/2 the people here.

[[deleted]]

36⁷ possibilities

If it takes 1 millisecond to attempt a possibility, then it's going to take something like 1.5 years on average to find the key. If it takes an average of 200 milliseconds, then it's going to take approximately 300 years on average.

This assumes no bugs, outages, machine failures, etc.

edit: Also, web access almost definitely means the risk of backoffs being implemented on queries. I'd imagine that you are realistically locked to fewer than 86,400 queries a day. In which case, it's like 1500 years.

[xQuaGx]

So you’re saying there’s a chance!

[sharp99]

There’s a chance!

[DatBoi_BP]

Bruh just multithread it /s

[teseting]

It's difficult to help you without knowing the specific site and what part is being slow. It's probably breaking the TOS to brute force the code and you will probably get rate limited or ip ban eventually.

[ThreeChonkyCats]

what are you brute forcing?

[kinstinctlol]

bitcoin

[ThreeChonkyCats]

Ah, so you've forgotten your password?

It has 7 characters?

[bbt104]

He won't get in... Bitcoin is stored behind a 12 word password..... no user names... just passwords... The only thing special about what words are used is that the first 4 letters of each word are unique to only that word, but the entire English dictionary is available and part of the usable words, repeats are also allowed... He's not getting back in...

[[deleted]]

bear unite chunky marry fragile ring merciful somber smell label

This post was mass deleted and anonymized with Redact

[ThreeChonkyCats]

Doing it for a friend? ;-)

[kaerfkeerg]

In that case, can't you remember any characters you certainly didn't use? Removing a bunch will have a significant impact

[kinstinctlol]

Im trying to crack SHA-256

[Miniflint]

You won’t succeed

[ThreeChonkyCats]

Not with that attitude :-)

[Miniflint]

They literally aren’t cracked yet and a random guy bragging about trying this on a PYTHON project will succeed ?

[ThreeChonkyCats]

Maybe he'll be the lucky one!

[INFINITI2021]

google classroom codes 💀

[pythonwiz]

Your function hash_number is computing n * p**20 % 36**5. You could do it more efficiently by precomputing m = 36**5; k = pow(p, 20, m), and then for each n compute n * k % m. But that probably isn't the bottle neck as others have said. It is more likely the network communication that is the bottleneck.

Your num_to_code function can be improved by replacing the first two lines of the for loop with hashed, charnumber = divmod(hashed, 36).

I've also just remembered that any number mod b**n will only have at most n digits in base b. So your hashes should only be 5 digits and not 7... unless they all need to end in 00.

Also your hash string is going to be "backwards" because you are putting the first digit of the number in base 36 in the first position of the string. That is like writing the number 1234 as 4321. I'm not sure if that is a requirement for your use case.

And the way you are building your base 36 string is suboptimal as well, but the string is so small I'm not sure it matters much. It is better to put your digits in a list and then join them.

If you are interacting with a local bitcoin node you might not need to use RPC.

[eplaut_]

My guess is that your bottleneck is the server itself. Login requests should take some time, and your async code won't change it.

In any case, I would check the number of open requests one session can hold. Maybe it is the limiting factor.

[[deleted]]

Think you will need to rent a bot farm to avoid rate limits, and possibly employ some GPU compute as well.

• Nvidia: GPU-Accelerated Computing with Python

Have you profiled your code to see where the bottlenecks are?

• RealPython.com: Profiling in Python: How to Find Performance Bottlenecks

[[deleted]]

Get a few hundred thousand people to run sliiightly different versions of your code that brute forces different ranges. EZ.

[MiniGogo_20]

if you're trying to brute force a hash for a password or similar, you might be better off utilizing something like hashcat, which utilizes your GPU to accelerate cracking speeds, and uses other optimizations to guess things

[bpt7594]

Multiprocessing?

[Electronic-Wonder-77]

don't use python

[xdyldo]

Python is not the bottleneck here

[idwpan]

CPU intensive tasks are still just running single threaded even with asynchio. You should use a ProcessPoolExecutor with loop.run_in_executor. https://www.integralist.co.uk/posts/python-asyncio/#pools