pendora-box/pendora-box.py

#!/usr/bin/env python3

import argparse
import json
from pathlib import Path
import hashlib
import requests
import sys
from os import geteuid, chdir
import subprocess
from io import BytesIO
import zipfile
import rpmfile
import gzip
from bs4 import BeautifulSoup
import re


def compute_file_hash(filepath):
    with open(filepath, 'rb') as file_for_hash:
        data = file_for_hash.read()
    filesize = len(data)
    # Github sha value is computed as such:
    return hashlib.sha1(b"blob " + bytes(str(filesize), 'utf-8') + b"\0" + data).hexdigest()


def get_master_info(repo, filepath, credz):
    url = f"https://api.github.com/repos/{repo}/contents/{filepath}"
    r = requests.get(url, auth=credz)
    sha = r.json()['sha']
    dlurl = r.json()['download_url']
    return sha, dlurl


def get_last_release_info(repo, credz):
    url = f"https://api.github.com/repos/{repo}/releases"
    r = requests.get(url, auth=credz)
    for release in r.json():
        if not release['draft'] and not release['prerelease']:
            return release['tag_name']


def extract_bin(archtype, binpath, destpath, content):
    ioobj = BytesIO(content)  # Get a File object from bytes ;)

    if archtype == 'zip':
        with zipfile.ZipFile(ioobj, "r") as zf:
            filenames = zf.namelist()
            for fn in filenames:
                if binpath in fn:
                    with open(destpath, 'wb') as f:
                        f.write(zf.read(fn))
                    break
    elif archtype == 'rpm':
        with rpmfile.RPMFile(fileobj=ioobj) as rpm:
            # Extract a fileobject from the archive
            fd = rpm.extractfile(binpath)

        with open(destpath, 'wb') as f:
            f.write(fd.read())
    elif archtype == 'gz':
        with open(destpath, 'wb') as f:
            f.write(gzip.decompress(content))
    ioobj.close()


def githubmastersync(reponame, filepaths, credz):
    for filepath in filepaths:
        localfile = Path('files').joinpath(Path(filepath).name)
        print(f"  * {localfile} ", end='')
        lastsha, dlurl = get_master_info(reponame, filepath, credz)

        if not localfile.exists():
            r = requests.get(dlurl)
            with open(localfile, 'wb') as f:
                f.write(r.content)
            print('-> Installed! ;)')

        else:
            sha = compute_file_hash(localfile)

            if sha == lastsha:
                print('-> Up-to-date.')
            else:
                r = requests.get(dlurl)
                with open(localfile, 'wb') as f:
                    f.write(r.content)
                print('-> Updated!')


def githubreleasesync(reponame, repoinfo, credz):
    local_version = repoinfo['local_version']
    last_version = get_last_release_info(reponame, credz)
    short_version = last_version.replace('v', '')

    filenames = repoinfo['files']

    for filename in filenames:
        if isinstance(filename, dict):
            inpath = filename['inpath']
            outpath = filename['outpath']
            filename = filename['filename']
            filename = filename.replace('{last_version}', last_version).replace('{short_version}', short_version)
            localfile = Path('files').joinpath(outpath)
            print(f"  * {localfile} ", end='')

        else:
            filename = filename.replace('{last_version}', last_version).replace('{short_version}', short_version)
            localfile = Path('files').joinpath(Path(filename).name)
            print(f"  * {localfile} ", end='')

        if filename.endswith('.gz'):
            is_gz, is_zip = True, False
        elif filename.endswith('.zip'):
            is_gz, is_zip = False, True
        else:
            is_gz, is_zip = False, False

        urldl = f'https://github.com/{reponame}/releases/download/{last_version}/{filename}'

        if not localfile.exists():
            content = requests.get(urldl, auth=credz).content
            if is_gz:
                extract_bin('gz', inpath, localfile, content)
            elif is_zip:
                extract_bin('zip', inpath, localfile, content)
            else:
                with open(localfile, 'wb') as f:
                    f.write(content)

            print('-> Installed! ;)')
        else:
            if local_version == last_version:
                print('-> Up-to-date.')

            else:
                content = requests.get(urldl, auth=credz).content
                if is_gz:
                    extract_bin('gz', inpath, localfile, content)
                elif is_zip:
                    extract_bin('zip', inpath, localfile, content)
                else:
                    with open(localfile, 'wb') as f:
                        f.write(content)
                print('-> Updated!')

    with open("config.json", "r") as jsonfile:
        data = json.load(jsonfile)

    data['githubreleasesync'][reponame]['local_version'] = last_version

    with open("config.json", "w") as jsonfile:
        json.dump(data, jsonfile, indent=4)


def ncatsync(conf):
    r = requests.get('https://nmap.org/dist/')
    last_version = r.text.split('The latest Nmap release is version ')[1].split('.\n')[0]
    local_version = conf['local_version']

    for filename in conf['files']:
        localfile = Path('files').joinpath(Path(filename).name)
        print(f"  * {localfile} ", end='')

        if filename == "ncat.exe":
            archtype = 'zip'
            binpath = 'ncat.exe'
            destpath = 'files/ncat.exe'
            urldl = f'https://nmap.org/dist/nmap-{last_version}-win32.zip'

        elif filename == "ncat":
            archtype = 'rpm'
            binpath = './usr/bin/ncat'
            destpath = 'files/ncat'
            urldl = f'https://nmap.org/dist/ncat-{last_version}-1.x86_64.rpm'

        if not localfile.exists():
            content = requests.get(urldl).content
            extract_bin(archtype, binpath, destpath, content)

            print('-> Installed! ;)')
        else:
            if local_version == last_version:
                print('-> Up-to-date.')

            else:
                content = requests.get(urldl).content
                extract_bin(archtype, binpath, destpath, content)

                with open("config.json", "r") as jsonfile:
                    data = json.load(jsonfile)

                data['ncat']['local_version'] = last_version

                with open("config.json", "w") as jsonfile:
                    json.dump(data, jsonfile, indent=4)
                print('-> Updated!')

    with open("config.json", "r") as jsonfile:
        data = json.load(jsonfile)

    data['ncat']['local_version'] = last_version

    with open("config.json", "w") as jsonfile:
        json.dump(data, jsonfile, indent=4)


def netcatsync(conf):
    # https://eternallybored.org/misc/netcat/ seems to be the most stable from all tested. (04/2022)
    r = requests.get('https://eternallybored.org/misc/netcat/')
    soup = BeautifulSoup(r.content, 'lxml')
    versions = []
    for link in soup.find_all('a', {'href': re.compile('netcat.+win.+')}):
        version = link['href'].split('-')[-1].split('.zip')[0]
        versions.append(version)

    last_version = max(versions)
    local_version = conf['local_version']

    for filename in conf['files']:
        # nc64.exe is also available in the archive feel free to add it.
        localfile = Path('files').joinpath(Path(filename).name)
        print(f"  * {localfile} ", end='')

        archtype = 'zip'
        binpath = filename
        destpath = f'files/{filename}'
        urldl = f'https://eternallybored.org/misc/netcat/netcat-win32-{last_version}.zip'

        if not localfile.exists():
            content = requests.get(urldl).content
            extract_bin(archtype, binpath, destpath, content)

            print('-> Installed! ;)')
        else:
            if local_version == last_version:
                print('-> Up-to-date.')

            else:
                content = requests.get(urldl).content
                extract_bin(archtype, binpath, destpath, content)

                with open("config.json", "r") as jsonfile:
                    data = json.load(jsonfile)

                data['netcat']['local_version'] = last_version

                with open("config.json", "w") as jsonfile:
                    json.dump(data, jsonfile, indent=4)
                print('-> Updated!')

    with open("config.json", "r") as jsonfile:
        data = json.load(jsonfile)

    data['netcat']['local_version'] = last_version

    with open("config.json", "w") as jsonfile:
        json.dump(data, jsonfile, indent=4)


def plinksync(conf):
    r = requests.get('https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html')
    last_version = r.text.split('PuTTY.\nCurrently this is ')[1].split(', ')[0]
    local_version = conf['local_version']

    for filename in conf['files']:
        localfile = Path('files').joinpath(Path(filename).name)
        print(f"  * {localfile} ", end='')

        urldl = 'https://the.earth.li/~sgtatham/putty/latest/w32/plink.exe'

        if not localfile.exists():
            content = requests.get(urldl).content
            with open(localfile, 'wb') as f:
                f.write(content)

            print('-> Installed! ;)')
        else:
            if local_version == last_version:
                print('-> Up-to-date.')

            else:
                content = requests.get(urldl).content
                with open(localfile, 'wb') as f:
                    f.write(content)

                with open("config.json", "r") as jsonfile:
                    data = json.load(jsonfile)

                data['plink']['local_version'] = last_version

                with open("config.json", "w") as jsonfile:
                    json.dump(data, jsonfile, indent=4)
                print('-> Updated!')

    with open("config.json", "r") as jsonfile:
        data = json.load(jsonfile)

    data['plink']['local_version'] = last_version

    with open("config.json", "w") as jsonfile:
        json.dump(data, jsonfile, indent=4)


def update(config):
    print("Updating...")
    with open("credz.json", "r") as jsonfile:
        credz = json.load(jsonfile)
    credz = (credz['username'], credz['token'])

    for reponame, filepaths in config['githubmastersync'].items():
        githubmastersync(reponame, filepaths, credz)

    for reponame, repoinfo in config['githubreleasesync'].items():
        githubreleasesync(reponame, repoinfo, credz)

    # ncatsync(config['ncat'])
    netcatsync(config['netcat'])
    plinksync(config['plink'])
    make_executable()


def make_executable():
    path = Path('files')
    for fpath in path.glob("*"):
        if fpath.name != '.gitkeep':
            fpath.chmod(0o777)


def yes_or_no(question, default="yes"):
    """Ask a yes/no question via input() and return their answer.

    "question" is a string that is presented to the user.
    "default" is the presumed answer if the user just hits <Enter>.
            It must be "yes" (the default), "no" or None (meaning
            an answer is required of the user).

    The "answer" return value is True for "yes" or False for "no".
    """
    valid = {"yes": True, "y": True, "ye": True, "no": False, "n": False}
    if default is None:
        prompt = " [y/n] "
    elif default == "yes":
        prompt = " [Y/n] "
    elif default == "no":
        prompt = " [y/N] "
    else:
        raise ValueError("invalid default answer: '%s'" % default)

    while True:
        print(question + prompt)
        choice = input().lower()
        if default is not None and choice == "":
            return valid[default]
        elif choice in valid:
            return valid[choice]
        else:
            print("Please respond with 'yes' or 'no' " "(or 'y' or 'n').\n")


def rmtree(root):
    for p in root.iterdir():
        if p.is_dir():
            rmtree(p)
        else:
            p.unlink()
    root.rmdir()


def print_menu(menu_options):
    for key in menu_options.keys():
        print(key, '->', menu_options[key])


def is_sudo():
    return True if geteuid() == 0 else False


def ask_port(default_port):
    while True:
        try:
            choice = input(f'What port would you like to listen on ? [{default_port}]: ')
            if choice == '':
                port = default_port
            else:
                port = int(choice)
            break
        except ValueError:
            print('Wrong input. Please enter a number ...')
    return port


def listen_http(files_dir):
    port = ask_port(80)
    ips = get_ips()

    print('The HTTP server is about to start.\nA good start ;) :')
    for iname in ips:
        if port == 80:
            print(f'  -> {iname}: http://{ips[iname]}/linpeas.sh')
        else:
            print(f'  -> {iname}: http://{ips[iname]}:{port}/linpeas.sh')

        cmd = ['python', '-m', 'http.server', '-d', files_dir, str(port)]

    if port < 1024 and not is_sudo():
        print('Listening on any port under 1024 requires root permissions.')
        cmd.insert(0, 'sudo')
    subprocess.call(cmd)


def listen_smb(files_dir, version):
    port = ask_port(445)
    ips = get_ips()

    print('The HTTP server is about to start.\nA good start ;) :')
    for iname in ips:
        if port == 445:
            print(f'  -> {iname}: \\\\{ips[iname]}\\share\\winPEASany.exe')
        else:
            print(f'  -> {iname}: \\\\{ips[iname]}:{port}\\share\\winPEASany.exe  # This syntax (:port) is not supported on Windows ?')

    if version == 1:
        cmd = ['smbserver.py', '-port', str(port), 'share', files_dir]
    elif version == 2:
        cmd = ['smbserver.py', '-smb2support', '-port', str(port), 'share', files_dir]
    else:
        sys.exit('Wrong SMB version')

    if port < 1024 and not is_sudo():
        print('Listening on any port under 1024 requires root permissions.')
        cmd.insert(0, 'sudo')
    subprocess.call(cmd)


def get_public_ip():
    return requests.get('https://api.ipify.org').text


def get_ips():
    ips = dict()
    try:
        ips['public'] = get_public_ip()
    except requests.exceptions.ConnectionError:
        pass

    cmd = ['ip', 'a']
    out = subprocess.run(cmd, capture_output=True).stdout.decode('utf-8')
    lines = out.split('\n')

    while("" in lines):
        lines.remove("")

    for line in lines:
        if line[0].isdigit():
            iname = line.split(' ')[1].split(':')[0]
        if 'inet ' in line:
            ip = line.split(' ')[5].split('/')[0]
            if ip != '127.0.0.1':
                ips[iname] = ip
    return ips


def menu_choice(menu_options):
    while(True):
        print_menu(menu_options)
        option = ''
        try:
            option = int(input('Enter your choice: '))
        except ValueError:
            print('Wrong input. Please enter a number ...')

        files_dir = Path.cwd().joinpath('files')

        if option == 1:
            listen_http(files_dir)
        elif option == 2:
            listen_smb(files_dir, 1)
        elif option == 3:
            listen_smb(files_dir, 2)
        elif option == 0:
            print('Quitting')
            sys.exit()
        else:
            print('Invalid option. Please enter a valid number.')


if __name__ == '__main__':

    chdir(Path(__file__).resolve().parent)  # Change current dir to source location

    parser = argparse.ArgumentParser(description='Sync your files and starts a listener on HTTP, SMB or SMB2.')
    parser.add_argument('-u', '--update', action='store_true', help='update your files (described in config.json)')
    args = parser.parse_args()

    with open("config.json", "r") as jsonfile:
        config = json.load(jsonfile)

    if args.update:
        update(config)
    tmp = Path('files/tmp')
    is_empty = not any(tmp.iterdir())
    if not is_empty:
        if yes_or_no("The folder 'files/tmp' is not empty. Would you like to remove the content ?", default="no"):
            for p in tmp.iterdir():
                if p.is_dir():
                    rmtree(p)
                else:
                    p.unlink()

    print('Choose a service to start a listener:')
    menu_options = {
        1: 'HTTP',
        2: 'SMB1',
        3: 'SMB2',
        0: 'Exit',
    }
    menu_choice(menu_options)