st98 の日記帳

# uncompyle6 version 2.11.3
# Python bytecode 3.5 (3350)
# Decompiled from: Python 2.7.9 (default, Mar  1 2015, 12:57:24) 
# [GCC 4.9.2]
# Embedded file name: /chat.py
# Compiled at: 2017-08-03 08:00:51
# Size of source mod 2**32: 3227 bytes
import asyncio
import threading
import sys
import zlib
import base64
import itertools
PORT = 9999
VERSIONS = ('v1', 'v2')
CURRENT_VERSION = sys.argv[2] if len(sys.argv) == 3 and sys.argv[2] in VERSIONS else VERSIONS[0]

class Message:

    def __init__(self, message):
        self.text = message

    def encode(self):
        if CURRENT_VERSION == VERSIONS[0]:
            return self.text.encode()
        return base64.b64encode(bytearray([a ^ b for a, b in zip(zlib.compress(self.text.encode()), itertools.cycle('wtfkey'))]))

    @staticmethod
    def decode(data):
        if CURRENT_VERSION == VERSIONS[0]:
            return Message(data.decode())
        return zlib.decompress(bytearray([a ^ b for a, b in zip(base64.b64decode(data), itertools.cycle('wtfkey'))])).decode()

    def __str__(self):
        return self.text


class Console:

    @staticmethod
    def write(message):
        print('\r< {}\n> '.format(message), end='')

    @staticmethod
    def read():
        return Message(input('\r> '))


class ChatProtocol:

    def __init__(self, message, loop):
        self.message = message
        self.loop = loop
        self.transport = None

    def connection_made(self, transport):
        self.transport = transport
        if self.message:
            self.transport.sendto(self.message.encode())

    def datagram_received(self, data, addr):
        Console.write(Message.decode(data))

    def error_received(self, exc):
        pass

    def connection_lost(self, exc):
        pass


class Sender(threading.Thread):

    def __init__(self, ip, port, loop):
        super().__init__(daemon=True)
        self.ip = ip
        self.port = port
        self.loop = loop

    def run(self):
        while True:
            message = Console.read()
            protocol = lambda : ChatProtocol(message, self.loop)
            connection = self.loop.create_datagram_endpoint(protocol, remote_addr=(self.ip, self.port))
            asyncio.run_coroutine_threadsafe(connection, self.loop)


class Receiver:

    def __init__(self, ip, port, loop):
        self.ip = ip
        self.port = port
        self.loop = loop

    def start(self):
        protocol = lambda : ChatProtocol(None, self.loop)
        coro = self.loop.create_datagram_endpoint(protocol, local_addr=(self.ip, self.port))
        self.task = self.loop.create_task(coro)


def main():
    if len(sys.argv) not in (2, 3):
        print('Usage: {} <user_ip> <version>'.format(sys.argv[0]))
        print('Available versions: {}'.format(', '.join(VERSIONS)))
        exit(1)
    print('Your are using chat {}'.format(CURRENT_VERSION))
    loop = asyncio.get_event_loop()
    Receiver('0.0.0.0', PORT, loop).start()
    Sender(sys.argv[1], PORT, loop).start()
    try:
        try:
            loop.run_forever()
        except:
            pass

    finally:
        loop.close()


if __name__ == '__main__':
    main()
# okay decompiling chat.pyc

import zlib
from pwn import *
s = '442b68744a617578754c73585a5254536555545358314f78524b4652516c637657554e584a4b744a7538657978564652326e466d6f365a7a67413d3d'
print zlib.decompress(xor(s.decode('hex').decode('base64'), 'wtfkey'))

import re
from pwn import *

def interpret(s, prog):
  l = len(s)
  h, q = l // 2, l // 4
  for c in prog:
    c = int(c, 16)
    if c == 0:
      s = s[::-1]
    elif c == 1:
      s = s[h:] + s[:h]
    elif 2 <= c <= 3:
      i = c - 2
      m = re.findall(r'.{' + str(h) + '}', s)
      m[i] = m[i][::-1]
      s = ''.join(m)
    elif 4 <= c <= 7:
      i = c - 4
      m = re.findall(r'.{' + str(q) + '}', s)
      m[i] = m[i][::-1]
      s = ''.join(m)
    elif 8 <= c <= 0xb:
      i = c - 8
      m = re.findall(r'.{' + str(q) + '}', s)
      m[i] = m[i][1:] + m[i][:1]
      s = ''.join(m)
    elif 0xc <= c <= 0xf:
      i = c - 0xc
      m = re.findall(r'.{' + str(q) + '}', s)
      m[i] = m[i][-1:] + m[i][:-1]
      s = ''.join(m)
  return s

s = remote('nc.task.school-ctf.org', 41447)
s.recvuntil('> ')
s.sendline('start')

for _ in range(100):
  log.info(s.recvuntil("program '"))
  prog = s.recvuntil("'")[:-1]
  s.recvuntil("sequence '")
  seq = s.recvuntil("'")[:-1]
  log.info('program : %r' % prog)
  log.info('sequence : %r' % seq)

  s.recvuntil('> ')
  res = interpret(seq, prog)
  log.info('result : %r' % res)
  s.sendline(res)
  log.info(s.recvline())

s.interactive()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import sys
import random
import string
from functools import wraps
from base64 import b32decode as b32


FLAG = "XXX"


def emojified(f):
    @wraps(f)
    def decorated_function(arg, *args, **kwargs):
        arg = arg.replace('{', '👉🏼')
        arg = arg.replace('}', '👈🏼')
        arg = arg.replace('School', '🎓')
        arg = arg.replace('CTF', '🏴')
        return f(arg, *args, **kwargs)
    return decorated_function


def reversed(f):
    @wraps(f)
    def decorated_function(arg, *args, **kwargs):
        arg = arg[:-1]
        return f(arg, *args, **kwargs)
    return decorated_function


def splitted(sep='_'):
    def real_decorator(f):
        @wraps(f)
        def decorated_function(arg, *args, **kwargs):
            arg = arg.split(sep)
            return f(arg, *args, **kwargs)
        return decorated_function
    return real_decorator


def mixed(seed=0):
    def real_decorator(f):
        @wraps(f)
        def decorated_function(arg, *args, **kwargs):
            random.seed(seed)
            random.shuffle(arg)
            return f(arg, *args, **kwargs)
        return decorated_function
    return real_decorator


def joined(sep='_'):
    def real_decorator(f):
        @wraps(f)
        def decorated_function(arg, *args, **kwargs):
            arg = sep.join(arg)
            return f(arg, *args, **kwargs)
        return decorated_function
    return real_decorator


def verbosed(f):
    @wraps(f)
    def decorated_function(arg, *args, **kwargs):
        num2words = {1: 'One', 2: 'Two', 3: 'Three', 4: 'Four', 5: 'Five',
                     6: 'Six', 7: 'Seven', 8: 'Eight', 9: 'Nine', 10: 'Ten'}
        for k, v in num2words.items():
            arg = arg.replace(str(k), v.upper())
        return f(arg, *args, **kwargs)
    return decorated_function


def caesared(key):
    def real_decorator(f):
        @wraps(f)
        def decorated_function(arg, *args, **kwargs):
            arg = ''.join(
                chr((ord(c) - 0x61 + key) % len(string.ascii_lowercase) + 0x61)
                if c in string.ascii_lowercase else c for c in arg
            )
            return f(arg, *args, **kwargs)
        return decorated_function
    return real_decorator


def shuffled(from_, to):
    def real_decorator(f):
        @splitted(from_)
        @mixed(len(from_))
        @joined(to)
        @wraps(f)
        def decorated_function(arg, *args, **kwargs):
            return f(arg, *args, **kwargs)
        return decorated_function
    return real_decorator


def kittyfied(mew):
    def real_decorator(f):
        @wraps(f)
        def decorated_function(arg, *args, **kwargs):
            arg=arg.replace(mew, '^_MeW_^')
            return f(arg, *args, **kwargs)
        return decorated_function
    return real_decorator


@emojified
@splitted()
@mixed(int.from_bytes(mixed.__name__.encode(), 'big'))
@joined()
@verbosed
@caesared(random.randint(10,100))
@shuffled((297515763796).to_bytes(5, 'little').decode(), 'to')
@kittyfied(b32(b'N52G6===').decode())
@splitted('_^_')
@mixed(sys.version_info[0])
@joined('\\')
def print_flag(flag):
    print(flag)


if __name__ == "__main__":
    print_flag(FLAG)

# coding; utf-8
import random

def deshuffle(s, seed=0):
  random.seed(seed)
  t = list(range(len(s)))
  random.shuffle(t)
  res = []
  for x in range(len(s)):
    res.append(s[t.index(x)])
  return res

def caesar(s, n):
  return ''.join(chr((ord(c) - 0x61 + n) % 26 + 0x61) if 'a' <= c <= 'z' else c for c in s)

num2words = {1: 'One', 2: 'Two', 3: 'Three', 4: 'Four', 5: 'Five',
             6: 'Six', 7: 'Seven', 8: 'Eight', 9: 'Nine', 10: 'Ten'}

s = 'MeW_^sto?👈🏼_v0r_qexq/ONEpto\MeW_^op\iiv_🎓🏴👉🏼@^_MeW_^qefkh'
s = s.split('\\')
s = deshuffle(s, 3)
s = '_^_'.join(s)
s = s.replace('^_MeW_^', 'oto')
s = s.split('to')
s = 'THREE'.join(deshuffle(s, len('THREE')))
s = caesar(s, 3)
for k, v in num2words.items():
  s = s.replace(v.upper(), str(k))
s = s.split('_')
s = deshuffle(s, 469920933220)
s = '_'.join(s)
s = s.replace('👉🏼', '{')
s = s.replace('👈🏼', '}')
s = s.replace('🎓', 'School')
s = s.replace('🏴', 'CTF')

print(s)

from PIL import Image
im = Image.open('tetris_1c50d9c8075e0467079dd7c079b7742f46241d8a.png')
w, h = im.size
res = ''
for y in range(65, 1560, 65):
  t = ''
  for x in range(130, 585, 65):
    t += '1' if im.getpixel((x, y)) == (0, 0, 0, 255) else '0'
  res += chr(int(t, 2))
print res