import requests
import typing as T
import re
import multiprocessing as mp
import threading
import queue
import os

if not os.path.isdir('results'):
    os.mkdir('results')

class Config(T.TypedDict):
    name: str
    file: str
    match: T.Pattern

class Check:

    __regex_configs: T.List[Config] = [
        {
            'file': 'aws.txt',
            'name': 'AWS Key',
            'match': r'AKIA[0-9A-Z]{16}'
        },
        {
            'file': 'twilio.txt',
            'name': 'Twilio',
            'match': r'AC[a-z0-9]{32}'
        },
        {
            'file': 'sendgrid.txt',
            'name': 'Sendgrid SMTP',
            'match': r'smtp\.sendgrid\.net'
        },
        {
            'file': 'nexmo.txt',
            'name': 'Nexmo',
            'match': r'NEXMO_|nexmo_|VONAGE_|vonage_'
        },
        {
            'file': 'office365.txt',
            'name': 'Office365 SMTP',
            'match': r'smtp\.office365\.com'
        },
        {
            'file': 'aws_smtp.txt',
            'name': 'AWS SMTP',
            'match': r'email-smtp\.'
        }
    ]

    def __init__(self) -> None:
        pass

    def validate(self, url: str, body: str) -> T.List[str]:
        found: T.List[str] = []
        for config in self.__regex_configs:
            if re.search(config.get('match'), body):
                found.append(
                    config.get('name')
                )
                with open('results/' + config.get('file'), mode='a') as file:
                    file.write(url + '\n')
        return found


class Scanner:

    def __init__(self) -> None:
        self.__urls: T.List[str] = []
        self.__check = Check()
        self.__paths: T.List[str] = None
        self.__queue = queue.Queue()
        self.__thread: int = mp.cpu_count()
        self.__threads: T.List[threading.Thread] = []

    def set_urls(self, urls: T.List[str]):
        not_valid_urls = 0
        for url in urls:
            if '://' not in url:
                url = 'http://' + url
            if url.endswith('/'):
                url = url[:-1]
            if not '.' in url:
                not_valid_urls += 1
            else:
                self.__urls.append(
                    url
                )
        if not_valid_urls:
            print(f'Removed {not_valid_urls} not valid url')
        print(f'Found {len(self.__urls)} valid url')

    def set_paths(self, paths: T.List[str]):
        self.__paths = paths

    def create_tasks(self):
        for url in self.__urls:
            for path in self.__paths:
                self.__queue.put(
                    f'{url}{path}'
                )
        print(f'Created {self.__queue.qsize()} tasks')

    def start(self):
        print('Starting scan')
        for i in range(self.__thread):
            th = threading.Thread(target=self.scan)
            self.__threads.append(
                th
            )
        for i in self.__threads:
            i.start()
        for i in self.__threads:
            i.join()
        print('Done scanning :)')

    def check(self, target: str):
        try:
            resp = requests.get(
                url=target,
                headers={'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.2454.85 Safari/537.36'},
                allow_redirects=False,
                verify=False,
                timeout=10
            )
            check = self.__check.validate(target, resp.text)
            if check:
                for found in check:
                    print(f'{target} > Found {found}')
            else:
                print(f'{target} > Can\'t found anything')
        except Exception as err:
            print(f'{target} > {err}')

    def scan(self):
        while not self.__queue.empty():
            url = self.__queue.get()
            self.check(url)
            self.__queue.task_done()


class GeneratePaths:

    __paths: T.List[str] = [
        '/', '/config/'
    ]

    __files: T.List[str] = [
        'config', 'dev', 'test',
        'development', 'staging', 'aws',
        's3', 'env', 'default',
        'prod', 'credentials', 'settings',
        'configuration'
    ]

    __extensions: T.List[str] = [
        '.ts', '.js', '.json',
        '.yaml', '.yml'
    ]

    __additionals: T.List[str] = [
        '/.env', '/.aws/credentials'
    ]

    def __init__(self) -> None:
        self.__generated: T.List[str] = []

    def merge_paths(self):
        for path in self.__paths:
            for file in self.__files:
                for extension in self.__extensions:
                    self.__generated.append(
                        f'{path}{file}{extension}'
                    )
        for additional in self.__additionals:
            self.__generated.append(
                additional
            )

    def get_paths(self) -> T.List[str]:
        return self.__generated


def main():
    try:
        paths = GeneratePaths()
        paths.merge_paths()
        scan = Scanner()
        scan.set_paths(paths=paths.get_paths())
        urls = open(input('List Urls ? '), mode='r').read().splitlines()
        scan.set_urls(urls=urls)
        scan.create_tasks()
        scan.start()
    except FileNotFoundError as err:
        print(err)


if __name__ == '__main__':
    main()