import os
import shutil
import subprocess
from stem.control import Controller
import stem.process
from flask import Flask
from flask import request
import socket
from flask import jsonify
import base64
import hashlib
import binascii
from Crypto import Random
from Crypto.Cipher import AES


BS = 16
pad = lambda s: bytes(s + (BS - len(s) % BS) * chr(BS - len(s) % BS), 'utf-8')
unpad = lambda s : s[0:-s[-1]]


class AESCipher:

    def __init__( self, key ):
        self.key = key

    def encrypt( self, raw ):
        raw = pad(raw)
        iv = Random.new().read( AES.block_size )
        cipher = AES.new( self.key, AES.MODE_CBC, iv )
        return base64.b64encode( iv + cipher.encrypt( raw ) )

    def decrypt( self, enc ):
        enc = base64.b64decode(enc)
        iv = enc[:16]
        cipher = AES.new(self.key, AES.MODE_CBC, iv )
        return unpad(cipher.decrypt( enc[16:] ))

def encryptKey(key, password, username):
    encryptionkey = hashlib.pbkdf2_hmac('sha256', password.encode(), username.encode(), 1000000)
    aes = AESCipher(encryptionkey)
    print(key)
    return aes.encrypt(key)
def decryptKey(encryptedkey, password, username):
    encryptionkey = hashlib.pbkdf2_hmac('sha256', password.encode(), username.encode(), 1000000)
    aes = AESCipher(encryptionkey)
    return aes.decrypt(encryptedkey)






def get_free_tcp_port():
    tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    tcp.bind(('', 0))
    addr, port = tcp.getsockname()
    tcp.close()
    return port

def print_bootstrap_lines(line):
    if "Bootstrapped" in line:
        print(line)


class hiddenservice:
    def __init__(self, username, password, ports, CONTROL_PORT):
        self.username = username
        self.password = password
        self.ports = ports
        self.controller = Controller.from_port(port=CONTROL_PORT)
        self.controller.authenticate()
        if os.path.exists("%s/DataDirs/%s/key_content" % (directory, username)):
            try:
                with open("%s/DataDirs/%s/key_content" % (directory, username), "r") as file:
                    key = decryptKey(base64.b64decode(file.read()), password, username).decode()
            except Exception:
                #os.remove("%s/DataDirs/%s/key_content" % (directory, username))
                print("probably wrong password")
                pass
            try:
                self.onion = self.controller.create_ephemeral_hidden_service({80:5000}, key_type='RSA1024', key_content=key)
            except Exception:
                pass

        if not os.path.exists("%s/DataDirs/%s/key_content" % (directory, username)):
            self.onion = self.controller.create_ephemeral_hidden_service({80:5000})
            with open("%s/DataDirs/%s/key_content" % (directory, username), "w") as file:
                file.write(base64.b64encode(encryptKey(self.onion.private_key, password, username)).decode())

SOCKS_PORT=get_free_tcp_port()
CONTROL_PORT=get_free_tcp_port()
directory=os.path.dirname(os.path.realpath(__file__))


username="test"
password="pass"



tor_process = stem.process.launch_tor_with_config(tor_cmd='%s/Tor/tor.exe' % directory,config={
        'SocksPort': str(SOCKS_PORT),
        'ControlPort': str(CONTROL_PORT),
        'DataDirectory': '%s/DataDirs/%s' % (directory, username)
    },
    init_msg_handler=print_bootstrap_lines
    )


app = Flask(__name__)

@app.route('/')
def index():
    return "<h1>djkhashjgndashnjd</h1>"
@app.route('/message')
def message():
    print(request.args.get('content'))
    return jsonify(success=True)

hs = hiddenservice(username, password, {80:5000}, CONTROL_PORT)
print(hs.onion.service_id)
app.run()