GuessGame solver by rockosov

import hashlib
import itertools
import socket
import time
import re
import random
import string

def recv_timeout(the_socket,timeout=3):
    the_socket.setblocking(0)
    total_data=[];data='';begin=time.time()
    while 1:
        #if you got some data, then break after wait sec
        if total_data and time.time()-begin>timeout:
            break
        #if you got no data at all, wait a little longer
        elif time.time()-begin>timeout*2:
            break
        try:
            data=the_socket.recv(8192)
            if data:
                total_data.append(data)
                begin=time.time()
            else:
                time.sleep(0.1)
        except:
            pass
    return ''.join(total_data)

def create_suffix_generator(bytes_len):
    rounds = range(10000000)
    for round in rounds:
        yield str(round)


def found_suffix_for_prefix(prefix_in_hex):
    prefix = prefix_in_hex.decode('hex')
    found = False
    suffixes_generator = create_suffix_generator(3)
    for suffix in suffixes_generator:
        # suffix = ''.join(i for i in suffix)
        payload = prefix + suffix
        # print payload.encode('hex')
        hasH = hashlib.sha1(prefix + suffix).hexdigest()
        if hasH.startswith("000000"):
            found = True
            break

    if found:
        return suffix.encode('hex')
    else:
        return None

def inv(sk, a):
    print "Try to inv %s..." % a
    question_inv_format = "inv %s"
    inv_a = question_inv_format % a
    print "Request:", inv_a
    sk.send(inv_a + "\n")
    response = recv_timeout(sk).strip("\n")
    print "Response:", response
    answer = response.split(' ')[0]
    print "DONE! Answer is %s!" % answer
    return answer

def mix(sk, a, b):
    print "Try to mix %s %s..." % (a, b)
    question_mix_format = "mix %s %s"
    mix_a_b = question_mix_format % (a, b)
    print "Request:", mix_a_b
    sk.send(mix_a_b + "\n")
    response = recv_timeout(sk).strip("\n")
    print "Response:", response
    answer = response.split(' ')[0]
    print "DONE! Answer is %s!" % answer
    return answer

def build_left_direct_table(sk, g, m):
    print "Try to build left direct table..."
    direct_table = {}
    # g^1 mod p = g
    direct_table.update({g : 1})
    answer = g
    for i in range(2, m + 1):
        print "Round:", i
        answer = mix(sk, g, answer)
        # g^i mod p = answer
        direct_table.update({answer : i})
    last_element = answer
    print "DONE!"
    return direct_table, last_element

def build_left_inverse_table(sk, direct_table):
    print "Try to build left inverse table..."
    inverse_table = {}
    count = 1
    for key in direct_table.keys():
        print "Round:", count
        answer = inv(sk, key)
        # g^(-i) mod p = answer
        inverse_table.update({answer : (-1) * direct_table[key]})
        count += 1
    print "DONE!"
    return inverse_table

def build_right_direct_table(sk, a, last_element, m):
    print "Try to build right direct table..."
    direct_table = {}
    answer = inv(sk, a)
    for i in range(1, m + 1):
        print "Round:", i
        answer = mix(sk, answer, last_element)
        # a*g^i mod p = answer
        direct_table.update({answer : i})
    print "DONE!"
    return direct_table

def build_right_inverse_table(sk, direct_table):
    print "Try to build right inverse table..."
    inverse_table = {}
    count = 1
    for key in direct_table.keys():
        print "Round:", count
        answer = inv(sk, key)
        # g^(-i) mod p = answer
        inverse_table.update({answer : (-1) * direct_table[key]})
        count += 1
    print "DONE!"
    return inverse_table

def solve_dlog_problem(left_direct_table, left_inverse_table, right_direct_table, m):
    print "Try to solve dlog problem..."
    answer = 0
    for key in right_direct_table:
        if key in left_direct_table.keys():
            j = right_direct_table[key]
            i = left_direct_table[key]
            print "DONE! Key = %s, i = %s, j = %s, m = %s" % (key, i, j, m)
            answer = j * m - i
            break
        if key in left_inverse_table.keys():
            j = right_direct_table[key]
            i = (-1) * left_inverse_table[key]
            print "DONE! Key = %s, i = %s, j = %s, m = %s!" % (key, i, j, m)
            answer = j * m - i
            break
    if answer == 0:
        print "ERROR! Can't solve dlog problem!"
    return answer

LOC_HOST = '109.233.61.11'
LOC_PORT = 3126

sk = socket.socket()
sk.connect((LOC_HOST, LOC_PORT))
welcome = recv_timeout(sk)
print welcome

prefix_in_hex = re.findall("Prefix is \(hexed\) [\w]*", welcome)[0].split(' ')[3]
suffix = found_suffix_for_prefix(prefix_in_hex)
print suffix
sk.send(prefix_in_hex + suffix + "\n")
response = recv_timeout(sk)
print response
temp = re.findall("How many [\w\' ?]*", response)[0]
g = temp.split(' ')[2].strip('\'')
a = temp.split(' ')[6][:-1].strip('\'')
print "g =", g
print "a =", a
m = 125

left_direct_table, last_element = build_left_direct_table(sk, g, m)
left_inverse_table = build_left_inverse_table(sk, left_direct_table)
print "Left Direct table:", left_direct_table
print "Last element:", last_element
last_element = mix(sk, last_element, last_element)
print "Last_element ^ 2:", last_element
print "Left Inverse table:", left_inverse_table

right_direct_table = build_right_direct_table(sk, a, last_element, m)
# right_inverse_table = build_right_inverse_table(sk, right_direct_table)
print "Right Direct table:", right_direct_table
# print "Right Inverse table:", right_inverse_table

answer = solve_dlog_problem(left_direct_table, left_inverse_table, right_direct_table, m * 2)
print "Answer is", answer

sk.send("guess %s\n" % answer);
print recv_timeout(sk)

sk.close()