This is a webserver for generating query strings with low hashes, and redirect to http://aHashPlace.herokuapp.com. goCap.py takes an x y image and scale and makes requests to cap.go. runner.py spins up 2 instances of cap.go and 2 instances of goCap.py the second instance will proceed backwards through the pixels in reverse.

cap.go

package main
import(
	"bytes"
	"fmt"
	"crypto/sha256"
	"math/rand"
	"time"
    "net/http"
	"strings"
	"net/url"
	"log"
	"encoding/hex"
	"os"
)

func randChr(i int)(string){
	i = i + 65
	if i>90 {
		i = i - 43
	}
	return string(i)
}

func randStr(random *rand.Rand, length int, previous string)(string){
	result := ""
	for len(previous)-1+len(result)<length{
		result = result + randChr(random.Intn(36))
	}
	if len(previous)>1 {
		return previous[1:]+result
	}
	return result
}

func HashPass(data []byte, thresh [32]byte) (bool,[32]byte){
	hash := sha256.Sum256(data)
	pass := false
	if bytes.Compare(hash[:],thresh[:]) == -1 {
		pass = true
	}
	return pass,hash
}

type seedAndText struct{
	seed int64
	text string
	count int64
	hash [32]byte
	thresh [32]byte
}

func getAPassingHash(queryString string,thresh [32]byte, seed int64,halter chan int,ch chan seedAndText){
	randSource := rand.NewSource(seed)
    random := rand.New(randSource)
	passes := false
	var hash [32]byte
	s := ""
	count := int64(0)
	halted := false
	salt := randStr(random,24,"")
	for !passes && !halted {
		select {
			case _, ok := <- halter:
				if ok{
					halter <- 0
					halted = true
				} else {
					halted = true
				}
			default:
				count += 1
				salt = randStr(random,24,salt)
				s=queryString + "&salt=" + salt
				passes,hash =  HashPass([]byte(s),thresh)
		}
	}
	if passes{
		select {
			case ch <- seedAndText{seed,s,count,hash,thresh}:
				// ok
			default:
				// nothing
		}
	}
}

func main() {
    http.HandleFunc("/", Salter)
    http.ListenAndServe(":"+os.Args[1], nil)
}

func makeThresh() [32]byte{
	var thresh [32]byte
	for idx := range thresh {
		if idx < 4{
			thresh[idx] = byte(0)
		}else{
			thresh[idx] = byte(255)
		}
	}
	return thresh
}

func Salter(w http.ResponseWriter, r *http.Request) {
	fmt.Println(r.RequestURI)
	q, err := url.ParseQuery(strings.Split(r.RequestURI,"?")[1])
	halter := make(chan int)
	ch := make(chan seedAndText)
	if err != nil {
		log.Fatal(err)
	}
	threshSlice, err := hex.DecodeString(q.Get("threshold"))
	var thresh [32]byte
	if err != nil {
		thresh = makeThresh()
		//q.Del("threshold")
	} else {
		thresh = *(*[32]byte)(threshSlice)
	}
	for i:=0;i<7;i++{
		time.Sleep(5)
		go getAPassingHash(q.Encode(),thresh,time.Now().UnixNano(),halter,ch)
	}
	passing := <-ch
	close(halter)
	http.Redirect(w, r, "http://ahashplace.herokuapp.com/?"+passing.text, http.StatusSeeOther)
    //fmt.Fprintf(w,passing.text)
}

goCap.py

from urllib import parse
import requests
from bs4 import BeautifulSoup
import hashlib
import sys
from PIL import Image
import shutil
import requests
import asyncio
import json
import random

port = sys.argv[5]

async def cap(args):
    #q = parse.urlencode(args, quote_via=parse.quote_plus)
    print(f"?x={args['x']}&y={args['y']}")
    response = requests.get(f"http://ahashplace.herokuapp.com/?x={args['x']}&y={args['y']}",allow_redirects=True)
    soup = BeautifulSoup(response.text,"html.parser")
    thresh = soup.find(id="hash").text
    print(thresh)
    color = soup.find(id="color").text
    if color != args['color']:
        thresh = soup.find(id="hash").text
        q = parse.urlencode({**args,"threshold":thresh}, quote_via=parse.quote_plus)
        response = requests.get(f"http://localhost:{port}/?"+q,allow_redirects=True)
    return response

async def worker(argsQueue,outQueue):
    await outQueue.put(await cap(await argsQueue.get()))
    argsQueue.task_done()

def paddedHex(n):
    h = hex(n).split("x")[1]
    return ("0"+h) if len(h) == 0 else h

def tupleToHex(t):
	return "#"+paddedHex(t[0])+paddedHex(t[1])+paddedHex(t[2])

def snapShot():
    image_url = "https://ahashplace.herokuapp.com/data.json"
    r = requests.get(image_url, stream = True)
    filename = "aHashPlace.json"
    # Check if the image was retrieved successfully
    if r.status_code == 200:
        r.raw.decode_content = True
        with open(filename,'wb') as f:
            shutil.copyfileobj(r.raw, f)            
        print('Image sucessfully Downloaded: ',filename)
    else:
        print('Image Couldn\'t be retreived')
    with open(filename,"r") as f:
        data = json.loads(f.read())
    return(data)


def hashCheck(hash,threshold):
    return int(hash,16) < int(threshold,16)   


async def main():
    #try:
    xPos = int(sys.argv[1])
    yPos = int(sys.argv[2])
    source = sys.argv[3]
    scale = float(sys.argv[4])
    #port = sys.argv[5]
    i = Image.open(source)
    """
    except:
        xPos = 0
        yPos = 0
        grabOg()
        source = "aHashPlaceBase.png"
        scale = 1
    """
    i = Image.open(source)
        
    resized = i.resize((int(i.width*scale),int(i.height*scale)))
    data = resized.getdata()
    width = resized.width
    #cap({"x":42,"y":69,"color":"tomato","title":"title","text":"text","href":"https://ahashplace.herokuapp.com","image":"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"})
    #input("press any key to continue...")
    argsQueue = asyncio.Queue()
    outQueue = asyncio.Queue()
    count = 0
    argsList = []
    screen = snapShot()
    hardList = []
    for n,pix in enumerate(data):
        y = int(n/width)
        x = int(n-width*y)
        if x+xPos > 420 or y+yPos > 420:
            continue
        if pix == (0,0,0,0):
            continue
        if dict(parse.parse_qsl(screen[x+xPos][y+yPos]))["color"]!=tupleToHex(pix):
            if hashCheck(hashlib.sha256(screen[x+xPos][y+yPos].encode()).hexdigest(),"0000000f5fb0f8c4ad5866d64ebbfd57a6ac2106648dcd9a29dc7edf5cbe3a30"):
                hardList.append({"x":x+xPos,"y":y+yPos,"color":tupleToHex(pix),"title":"...","href":"https://ahashplace.herokuapp.com"})
            else:
                argsList.append({"x":x+xPos,"y":y+yPos,"color":tupleToHex(pix),"title":"...","href":"https://ahashplace.herokuapp.com"})
            count += 1
    try:
        order = sys.argv[6]
        if order == "shuffle":
            random.shuffle(argsList)
            random.shuffle(hardList)
        if order == "reverse":
            argsList.reverse()
            hardList.reverse()
        else:
            pass
    except:
        pass
    argsList += hardList
    for args in argsList:
        await argsQueue.put(args)
        
    tasks = []
    for n in range(count):
        t = asyncio.create_task(worker(argsQueue,outQueue))
        tasks.append(t)
        #if n >= 8:
        await outQueue.get()
        outQueue.task_done()
    #for k in range(8):
    #    await outQueue.get()
    #    outQueue.task_done()
    await outQueue.join()
    await argsQueue.join()
    
    for task in tasks:
        task.cancel()
    # Wait until all worker tasks are cancelled.
    await asyncio.gather(*tasks, return_exceptions=True)
    
asyncio.run(main())

runner.py

import os
import sys

# python runner.py 0 0 yourimage.png 1

x = sys.argv[1]
y = sys.argv[2]
img = sys.argv[3]
scale = sys.argv[4]

try:
	port1 = sys.argv[5]
except:
	port1 = 5065
try:
	port2 = sys.argv[6]
except:
	port2 = 5066

os.system(f"""start "serving: {port1}" go run cap.go {port1}""")
os.system(f"""start "serving: {port2}" go run cap.go {port2}""")

input("Paused for mining servers... Press anykey to continue.")

os.system(f"""start "forward port:{port1}" python goCap.py {x} {y} {img} {scale} {port1}""")
os.system(f"""start "reverse port:{port2}" python goCap.py {x} {y} {img} {scale} {port2} reverse""")

print("Processes started".ljust(64))