HackThisSite - Application Mission 17

; enc_and_check(char* username /*rdi->[rbp-0x488]*/, char* key /*rsi->[rbp-0x490]*/)
14bc  mov    rax,[rbp-0x490]        ; key
14c6  call   strlen
14cb  cmp    rax,0x3
154a  mov    DWORD PTR [rbp-0x440],0x120
1554  mov    DWORD PTR [rbp-0x43c],0x150
155e  mov    DWORD PTR [rbp-0x438],0x14c
1568  mov    DWORD PTR [rbp-0x434],0xb4
15b7  movzx  eax,BYTE PTR [rax]      ; key[i]
15ba  movsx  eax,al
15bd  lea    edx,[rax*4+0x0]         ; key[i] * 4
15d2  cmp    edx,eax                 ; == 表里的常量？

16bb  mov    rax,[rbp-0x488]        ; username
16c5  call   strlen
16ca  lea    rbx,[rax+rax*1]        ; rbx = 2 * strlen(username)
16d5  call   strlen                 ; strlen(hex buffer)
16dd  cmp    rbx,rax
16e0  je     ok
16e2  mov    eax,0x1                ; 长度不符 -> 失败

171e  movzx  eax,BYTE PTR [buf+idx]  ; 取两个 hex 字符
174e  call   sscanf("%02X")          ; -> hexval  ([rbp-0x474])
1773  mov    eax,[rbp-0x470]         ; acc（上一字节算出的值，初值 0）
1779  mov    [rbp-0x46c],eax         ; t = acc
177f  cmp    DWORD PTR [rbp-0x46c],0x1f
1786  jle    1791
1788  sub    DWORD PTR [rbp-0x46c],0x1f   ; while (t > 31) t -= 31;  -> t = acc mod 31
178f  jmp    177f
1791  mov    rdx,[rbp-0x488]         ; username
17a2  movzx  eax,BYTE PTR [rdx+j]
17a5  movsx  eax,al                  ; u = (signed char)username[j]
17a8  sub    eax,[rbp-0x470]         ; u - acc
17ae  sar    eax,1                   ; (u - acc) >> 1   （算术右移）
17b0  mov    esi,eax
17c3  movzx  eax,BYTE PTR [rdx+j]
17c6  movsx  edx,al                  ; u
17cf  mov    ecx,eax(=t)             ; cl = t
17d1  shl    edx,cl                  ; u << (t & 31)
17d5  not    eax                     ; ~(u << t)
17d7  and    eax,esi
17d9  mov    [rbp-0x464],eax         ; result

t      = acc mod 31                # acc<=31 时不减，等价 acc % 31
result = ((signed_char)username[j] - acc) >> 1
result &= ~(username[j] << (t & 31))

#!/usr/bin/env python3
"""HackThisSite Application Challenge 17 keygen.

Reconstructed from _Z13enc_and_checkPcS_ in app17unix (objdump -d -Mintel).

The binary checks a key of the form  HTS-XXXX-XXXX-...  where the number of
hex digits equals 2 * len(username).  For each username byte u and the running
state `acc` (starts at 0), it recomputes

    result = ((u - acc) >> 1) & ~(u << (acc mod 31))        # 32-bit, signed

and demands that the two hex digits for that position equal `result`; the next
state becomes `result`.  `>>` is an arithmetic shift (x86 `sar`) and the shift
count is taken modulo 32 (x86 `shl cl`).  Every intermediate is 32-bit two's
complement, but only values 0..0xFF can be written as two hex digits, so a
username is solvable only when every step lands in 0..255.
"""

MASK = 0xFFFFFFFF

36 collapsed lines

def s32(x):
    """Wrap to 32-bit signed."""
    x &= MASK
    return x - 0x100000000 if x & 0x80000000 else x


def reduce31(acc):
    """Faithful port of the binary's `while (t > 31) t -= 31` for signed int."""
    if acc <= 31:            # negative acc never enters the loop
        return acc
    return acc % 31          # for acc > 31 the loop yields acc in [0, 31]


def key_bytes(username):
    """Return the list of per-character bytes the key has to encode."""
    acc = 0
    out = []
    for ch in username.encode('latin-1'):
        u = ch - 256 if ch >= 128 else ch          # movsx (signed char)
        t = reduce31(acc)
        res = s32(u - acc) >> 1                    # sar eax, 1
        shifted = s32(u << (t & 31))               # shl edx, cl
        res = s32(res & s32(~shifted))             # not / and
        out.append(res)
        acc = res
    return out


def keygen(username):
    payload = key_bytes(username)
    if any(b < 0 or b > 0xFF for b in payload):
        raise ValueError(
            'username %r is not representable in the 2-hex-digit format: %r'
            % (username, payload))
    hexs = ''.join('%02X' % b for b in payload)
    return 'HTS-' + '-'.join(hexs[i:i + 4] for i in range(0, len(hexs), 4))


if __name__ == '__main__':
    import sys
    usernames = sys.argv[1:] or ['demo']
    for name in usernames:
        print('%-14s -> %s' % (name, keygen(name)))

#!/usr/bin/env python3
"""Feed keygen_final outputs to the real app17unix binary and report verdict."""
import os
import pty
import select
import sys
import time

HERE = os.path.dirname(os.path.abspath(__file__))
BIN = os.path.join(HERE, 'unix', 'app17unix')
sys.path.insert(0, HERE)
from keygen_final import keygen


def run(username, key, timeout=6.0):
    pid, fd = pty.fork()
    if pid == 0:
        os.execv(BIN, [BIN])
    out = b''
    sent_user = sent_key = sent_extra = False
31 collapsed lines
    deadline = time.time() + timeout
    while time.time() < deadline:
        r, _, _ = select.select([fd], [], [], 0.2)
        if r:
            try:
                data = os.read(fd, 4096)
            except OSError:
                break
            if not data:
                break
            out += data
        if not sent_user and b'Username:' in out:
            os.write(fd, username.encode() + b'\n')
            sent_user = True
        elif sent_user and not sent_key and b'Password:' in out:
            os.write(fd, key.encode() + b'\n')
            sent_key = True
        elif sent_key and not sent_extra and b'Congratulations' in out:
            os.write(fd, b'\n')
            sent_extra = True
            break
    try:
        os.close(fd)
    except OSError:
        pass
    try:
        os.waitpid(pid, 0)
    except OSError:
        pass
    return out


if __name__ == '__main__':
    for name in (sys.argv[1:] or ['demo']):
        key = keygen(name)
        out = run(name, key)
        ok = b'Congratulations' in out
        print('username=%-12s key=%-28s -> %s'
              % (name, key, 'ACCEPTED' if ok else 'rejected'))