Go红队开发—web网络编程

立山  论坛元老 | 2025-3-12 12:34:41 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 2011|帖子 2011|积分 6033

目录

web网络编程

tips：这一章的铺垫比较重要，这章过后就是一些安全工具如何编写以及一些poc、exp的工具编写。
Req

简朴的请求

  • 客户端创建
  • 请求设置
  1. func reqHttp() {
  3.     client := req.C()       //客户端创建
  5.     res, err := client.R(). //请求设置，这个点的意思链式调用，后续在控制请求中会讲
  7.                 Get("https://httpbin.org/uuid")
  9.     if err != nil {
  11.         log.Println("请求失败：", err)
  13.     }
  15.     fmt.Println(res)
  17. }
复制代码
快速请求


  • MustGet
    测试使用可以，正式开发不发起使用，可控性差
  1. // 快速使用，一般用在test的时候
  3. func testHttp() {
  5.   
  7.     resp := req.MustGet("https://httpbin.org/uuid") //这里就是发起了一次请求
  9.     fmt.Println(resp.String())                      //第一种打印*req.Response类型的响应体
  11.     fmt.Println(string(resp.Bytes()))               //第二种打印*req.Response类型的响应体
  13. }
复制代码
调试

DevMode

DevMode是直接开启全局调试，自动打印出来
  1. // 调试模式
  3. func devModeReq() {
  5.     //使用req进行请求，所以req的调试模式也是在req启动
  7.     req.DevMode()                                   //开启调试模式，就会打印出来请求的过程以及响应内容
  9.     req.SetCommonBasicAuth("username", "password"). //设置用户名和密码
  11.                             SetTimeout(5 * time.Second). //设置超时时间
  13.                             SetUserAgent("my-ua")
  15.     resp := req.MustGet("https://httpbin.org/uuid")
  17.     //没有开启调试模式但是想打印的话就正常打印
  19.     fmt.Println(resp.String())        //第一种打印*req.Response类型的响应体
  21.     fmt.Println(string(resp.Bytes())) //第二种打印*req.Response类型的响应体
  23. }
复制代码
DebugLog

DebugLog 是跟踪请求的过程

他可以看到你整个请求的过程，重定向的信息等等
  1. // 查看请求的过程发生了什么
  3. func deLog() {
  5.     client := req.C().
  7.         EnableDebugLog() //开启DebugLog
  9.     client.R().Get("http://baidu.com/s?wd=req")
  11. }
复制代码
TraceInfo瓶颈分析

trace跟踪信息
  1. func traceReq() {
  3.     // Enable trace at request level
  5.     client := req.C()
  7.     resp, err := client.R().
  9.         EnableTrace(). //开启瓶颈分析
  11.         Get("https://api.github.com/users/imroc")
  13.     if err != nil {
  15.         log.Fatal(err)
  17.     }
  19.     trace := resp.TraceInfo()  //trace跟踪信息
  21.     fmt.Println(trace.Blame()) //分析总结(请求减慢的原因归咎)
  23.   
  25.     fmt.Println(trace) // 打印内容
  27. }
复制代码
控制请求与响应

控制请求的字段内容

这里做一个了解，反面会详细说一下作用范围，这里就过一遍即可，知道哪些字段可控(其实都可控)
  1. func controlReq() {
  3.   
  5.     client := req.C().
  7.         SetUserAgent("my-ua"). //设置ua头，在client中设置，在下面的R()中设置不了
  9.         //EnableDumpAllToFile("log.txt") //将请求的信息写到该文件中
  11.         //捕获请求和响应,
  13.         // 想要看的更加详细就可以开启dump所有内容，
  14.         // 就能够看到我们是不是真的改变了请求内容
  16.         EnableDumpAll()
  18.   
  20.     parms := map[string]string{
  22.         "a": "123",
  24.         "b": "hello",
  26.     }
  28.   
  30.     resp, err := client.R(). //拿到请求体
  32.                     SetPathParam("usernamae", "imroc"). //设置请求路径，用username作为占位符
  34.                     SetPathParam("xxx", "test").        //再次设置，用xxx作为占位符
  36.                     SetQueryParam("a", "12").           //设置请求参数，a=12
  38.                     SetQueryParams(parms).              //用map来作为请求参数，用于多个参数的时候
  40.                     SetHeader("mycookie", "test").      //设置请求头
  42.                     SetHeader("mysession", "test2").    //设置请求头
  44.                     SetBody("body=world").              //设置请求体
  46.                     Get("https://httpbin.org/uuid")
  48.   
  50.     //以上设置暂时在初期阶段够用了。
  52.     if err != nil {
  54.         log.Println("请求出错：", err)
  56.     }
  58.     fmt.Println(resp)
  60. }
复制代码
控制调试打印的内容


  • SetCommonDumpOptions：控制输出的内容
  • EnableDumpAllToFile：dump到文件中
输出的log2.txt文件内容如下
  1. // 控制调试打印的内容
  3. // 全局应用
  5. func controlDevOptions() {
  7.     client := req.C()
  9.     opt := &req.DumpOptions{
  10.         Output:         os.Stdout, //标准输出
  11.         RequestHeader:  false,     //不输出请求头
  12.         RequestBody:    false,     //不输出请求体
  13.         ResponseHeader: true,      //输出响应头
  14.         ResponseBody:   true,      //输出响应体
  15.         Async:          false,     //不进行异步输出
  17.     }
  18.     client.SetCommonDumpOptions(opt).
  19.         EnableDumpAllToFile("log2.txt")
  20.     client.R().Get("https://httpbin.org/uuid")
  22. }
复制代码
分开dump请求与响应部分


  • var bufReq, bufResp bytes.Buffer：需要用变量来吸收请求与响应不同部分
  • SetDumpOptions：控制dump导出部分
  1. // 分别打印请求与响应部分
  3. // 在R中控制调试打印的内容，只作用与本次R请求，与上面的client直接全局设置的不同
  5. func controlReqRespOutPut() {
  7.     client := req.C()
  9.     var bufReq, bufResp bytes.Buffer
  11.     client.R().
  13.         // 不开启的话就会导致无法转储出去单独打印请求体响应体
  15.         EnableDump(). //EnableDump启用转储，包括请求和响应的所有内容。
  17.         SetDumpOptions(&req.DumpOptions{
  19.             RequestOutput:  &bufReq,  //将请求体输出到这里
  21.             ResponseOutput: &bufResp, //将响应体输出到这里
  23.             RequestHeader:  true,
  25.             RequestBody:    true,
  27.             ResponseHeader: true,
  29.             ResponseBody:   true,
  31.         }).
  33.         SetBody("body=hello+world!").
  35.         Get("https://httpbin.org/uuid")
  37.   
  39.     fmt.Println("请求体")
  41.     fmt.Println(bufReq.String())
  43.     fmt.Println("响应体")
  45.     fmt.Println(bufResp.String())
  47. }
复制代码
请求体设置

SetBody 可以接受恣意类型
PS: EnableDumpAllWithoutResponse由于开启了调试模式，所以会打印许多东西，但是可以忽略响应打印出来结果，所以这函数就是忽略响应结果，只看请求。

在编写一些poc/exp的时间可能需要在body部分，需要加入一些结构体或者map数据，他会根据你设置的content-type来判定剖析成json还是xml格式，如果都不设置的话他会默认将这些类型剖析为json数据body。

添加上content-type类型后就自动转了，比较方便(反面另有更方便的)


  • SetBodyXXX
    不用设置content-type也能直接转想要的格式了

以下是代码：
  1. // 设置请求体中的一些骚姿势
  3. func setbodyHttp() {
  5.     type test struct {
  7.         Name string
  9.         Age  int
  11.     }
  13.     t := test{
  15.         Name: "zhangsan",
  17.         Age:  123,
  19.     }
  21.     client := req.C().DevMode().EnableDumpAllWithoutResponse()
  23.     client.R().
  25.         SetBody(t).
  27.         SetContentType("application/xml").
  29.         Get("https://httpbin.org/uuid")
  31.   
  33.     client2 := req.C().DevMode().EnableDumpAllWithoutResponse()
  35.     client2.R().
  37.         SetBodyXmlMarshal(t).
  39.         Get("https://httpbin.org/uuid")
  41.   
  43. }
复制代码
作用范围级别

在设置请求参数的时间，有分两种作用范围设置，一种全局(客户端级别)，另一种就是只作用与这一个client的对象(请求级别)。
以下就只管快速过为妙，上面学的时间已经有许多函数都用过了，没须要花太多时间，知道即可，下面作为一个知识字典，以后方便查阅。
请记住：

  • 用req.C().R()来设置的请求级别
  • 用req.C()来设置的是全局级别(也即客户端级别client)
设置参数查询

请求级别：

  • SetQueryParam：SetQueryParam("test", "123") 即 httpxxx?test=123
    设置多个的时间仅仅对末了一个设置的生效
  • SetQueryParams：SetQueryParams吸收map类型设置多个变量，由于map的键唯一，所以多个同名的话也只会作用一个。
  • SetQueryString：直接给查询参数即可，SetQueryString("test1=123&test2=456")
    这个不会产生什么重复覆盖题目，字符串给啥他就拼接到你url中去
  • AddQueryParam：AddQueryParam("key", "value1") 如果该参数已存在，它不会覆盖原有的值，这个一般用在你暂时需要添加什么查询参数的时间可以用，而且不会覆盖原有的同名键值
全局级别：

  • SetCommonQueryParam
  • SetCommonQueryParams
  • SetCommonQueryString
  • AddCommonQueryParam
URL 路径参数

请求级别：

  • SetPathParam：SetPathParam("username", "zhangsan")
  • SetPathParams：吸收map类型
全局级别：

  • SetCommonPathParam
  • SetCommonPathParams
表单请求设置

请求级别：

  • SetFormData：吸收map类型，但是同一个键只能有一个
  • SetFormDataFromValues:：
    代码如下所示，但是注意的是url.Values是net/url包，所以要注意这个url不是我定义的，拿来就用即可。
  1. client3 := req.C().DevMode().EnableDumpAllWithoutResponse()
  3. v := url.Values{
  4.         "p": []string{"hello", "world", "!"},
  5. }
  6. client3.R().
  7.         SetFormDataFromValues(v).
  8.         Post("https://httpbin.org/post")
复制代码


  • multipart ⽅式提交表单：EnableForceMultipart
  1. client3 := req.C().DevMode().EnableDumpAllWithoutResponse()
  2. v := url.Values{
  3.         "p": []string{"hello", "world", "!"},
  4. }
  5. client3.R().
  6.         EnableForceMultipart().
  7.         SetFormDataFromValues(v).
  8.         Post("https://httpbin.org/post")
复制代码

全局级别：

  • SetCommonFormData
  • SetCommonFormDataFromValues
请求头设置

请求级别：

  • SetHeader：自动将你传进的header键的首字母大写
  • SetHeaders：吸收map类型，自动将你传进的header键的首字母大写
  • SetHeaderNonCanonical：你给什么样就输出什么样，不会自动给你首字母大写
  • SetHeadersNonCanonical：你给什么样就输出什么样，不会自动给你首字母大写
  • SetHeaderOrder：控制header的顺序，由于有的服务端可能会对header的顺序判定是否允许请求，设置了SetHeaderOrder，他就会按照你给定的顺序进行排序请求过去。
  1. request.SetHeaderOrder(
  2.         "cookie",
  3.         "ssession",
  4.         "test",
  5.         "ua",
  6. )
复制代码
全局级别

  • SetCommonHeaderNonCanonical
  • SetCommonHeadersNonCanonical
判定响应状态码

没啥好说的，都到这了这些应该对于各位师傅来说都是一眼就学会的基操了。

  • resp.IsSuccessState
  • resp.IsErrorState
  • resp.StatusCode
  1. // 判断响应状态码
  3. func judgeStatusCode() {
  5.     client := req.C()
  7.     resp, err := client.R().Get("http://www.baidu.com")
  9.     if err != nil {
  11.         log.Println("请求失败：", err)
  13.     }
  15.     if resp.IsSuccessState() {
  17.         fmt.Println("ok")
  19.     }
  21.     if resp.IsErrorState() {
  23.         fmt.Println("error")
  25.     }
  27.   
  29.     //可以通过响应对应的代码判断
  31.     if resp.StatusCode != http.StatusOK { //http有一个const变量，里面有很多对应的响应码，自行查看即可(文件：http\status.go)
  33.         fmt.Println("error")
  35.     }
  37.   
  39.     //打印响应体
  41.     fmt.Println(resp.Bytes())  //bytes打印
  43.     fmt.Println(resp.String()) //string打印
  45. }
复制代码
剖析数据

SetSuccessResult


  • SetSuccessResult：SetSuccessResult会⾃动剖析你给的结构体或map
  • SetErrorResult
    这里一同把SetErrorResult也讲了，可以自定义错误剖析到你自己定义的错误中去，没啥好说感觉也时，定义好了就直接给到SetErrorResult即可(详细见代码处)
运行结果如下图所示：
  1.   
  3. // 接收响应回来的json数据
  5. type user struct {
  7.     Login string `json:login`
  9.     Id    int    `json:id`
  11.     Name  string `json:name`
  13. }
  15.   
  17. // 接收错误响应
  19. type errorResp struct {
  21.     Mess string `json:message`
  23. }
  25.   
  27. // 解析响应的json数据
  29. // SetSuccessResult⾃动解析结构体或map
  31. func getHttpJson() {
  33.     client := req.C()
  35.     var respUser user
  37.     var respError errorResp
  39.     res, err := client.R().
  41.         SetSuccessResult(&respUser). //接收响应回来的json数据，同时也可以解析map
  43.         SetErrorResult(&respError).  //若请求错误将错误信息存储到该结构体中
  45.         Get("https://api.github.com/users/whoisdhan")
  47.     if err != nil {
  49.         log.Println("代码请求出错：", err)
  51.         return
  53.     }
  55.     if res.IsSuccessState() {
  57.         fmt.Println("请求成功")
  59.         fmt.Println(respUser.Login)
  61.         fmt.Println(respUser.Id)
  63.         fmt.Println(respUser.Name)
  65.     } else if res.IsErrorState() {
  67.         fmt.Println("网络请求出错：", respError.Mess)
  69.     } else {
  71.         fmt.Println("未知错误：", res.StatusCode)
  73.     }
  75.   
  77. }
复制代码
gjson


  • 字段名、.：表示读取该字段，字段名.0表示读取该键名下的数据的第一个字段，字段名.1读取第二个
  • *、?：gjson支持通配符：像在linux下令行中使用的通配符那样用就行，a*a收尾为a的都匹配
  • #：表示该字段全部元素。

    • 在结尾：字段名1.字段名2.# 表示返回字段名2的数组长度
    • 在中间，即#反面另有内容：字段名1.#.字段名2 表示返回字段名2全部元素
    • 缘故原由：这也是为啥我叫他#的意思是表示该字段全部元素，在结尾就是返回长度，不在就是返回整个数组列表

gjson剖析json数据可提取指定字段，不用定义结构体
gjson非常得当提取几个字段出来之类的，方便的一笔。
  1. // 由于我们的http请求回来的数据能方便的转为string所以也能用gjson
  3. // 模拟数据
  5. const httpjson = `
  7. {
  9.   "name":{"first":"Tom", "last": "Anderson"},
  11.   "age": 37,
  13.   "children": ["Sara", "Alex", "Jack"],
  15.   "fav.movie": "Dear Hunter",
  17.   "friends": [
  19.     {"first": "Dale", "last":"Murphy", "age": 44, "nets": ["ig", "fb", "tw"]},
  21.     {"first": "Roger", "last": "Craig", "age": 68, "nets": ["fb", "tw"]},
  23.     {"first": "Jane", "last": "Murphy", "age": 47, "nets": ["ig", "tw"]}
  25.   ]
  27. }`
  29.   
  31. func gjsonHttp() {
  33.     //先简单用正常的httpjson数据尝试一下
  35.     client := req.C()
  37.     resp, _ := client.R().
  39.         Get("https://api.github.com/users/whoisdhan")
  41.   
  43.     login := gjson.Get(resp.String(), "login")
  45.     id := gjson.Get(resp.String(), "id")
  47.     name := gjson.Get(resp.String(), "name")
  49.     fmt.Println(login, id, name)
  51.   
  53.     //用httpjson测试数据
  55.     fmt.Println(gjson.Get(httpjson, "name.first"))
  57.     fmt.Println(gjson.Get(httpjson, "friends.#.first"))
  59.     fmt.Println(gjson.Get(httpjson, "friends.#.nets"))
  61.     fmt.Println(gjson.Get(httpjson, "fav\\.movie")) //字段存在符号的话用\\转义
  63. }
复制代码
响应数据剖析练习

这里的剖析可能有点主观了，可以按照自己的想法，只管不要被我带偏，我的不肯定是最佳的
  1. // 练习
  2. // 1. 获取⽤户信息 https://api.github.com/users/{username}
  3. // 2. 获取仓库列表信息 https://api.github.com/users/{username}/repos
  4. // 3. 用户与仓库列表信息：普通读取json、Unmarshal转结构体⽅式解析、gjson读取
  5. // 4. 用户与仓库列表信息：格式化输出到控制台
  6. // 5. 仓库列表信息保存到本地 JSON ⽂件中。
  7. //这里就固定拿仓库列表信息如下信息：
  8. // (也可以随便获取你想要的字段)
  9. //  用户信息{login、id、url、name、email}
  10. //  仓库列表信息{name、owner.login、description}
复制代码

  • myMarshalIndent：为了方便格式化，我自己写了一个格式化函数方便不同方式保存的时间进行格式化
    格式化都需要先转到map中存储才能够格式化正常的json数据出来，格式化好了就恣意你想干啥就干啥了
  • 需要注意的细节：
    有的json他是列表包裹着[]，所以转的时间要注意判定用map[string]interface{}还是[]map[string]interface{}
  • json.MarshalIndent：他可以对map列表进行格式化的，由于那样也时一个正常的json数据，只不外你需要用[]map[string]interface{}列表类型进行存储(这里是一个很重要的细节，开发过程中如果不注意很容易导致崩溃)
我用了三个函数完成这个练习：

  • normalGetJson：平凡读取，就是剖析出来后整个data就直接write到文件中
  • UnmarshalToStruct：Unmarshal转结构体⽅式剖析，这里使用了上面学到的SetSuccessResult，给到结构体后进行剖析，如许也很方便
  • gjsonOutput：这里就是使用gjson了，gjson很方便，但是面对比较多字段提取的时间还是比较繁琐。
    这里复习了一个细节：map想要后续不断地赋值的话就需要进行make空间出来才行，如果是[]map的话需要给定一个空间范围，0也行，你要说明这是一个切片。如果你只是单单定义一个map变量或者map切片变量，后续是无法使用的。
    另有一个细节就是：make出来的空间是固定的，如果你要make出来的空间作为一个暂时变量赋值给其他变量的时间要注意了，用了一个空间就不要继承用了，由于你将一个空间给了多个变量的话，那么那些变量都指向你这一个空间，那么他们的值其实都一样。
运行结果：这里就放几个保存出来的文件截图

  • normalGetJson：

  • UnmarshalToStruct

  • gjsonOutput

示例代码：
  1. // 用户信息{login、id、url、name、email}
  3. // 仓库列表信息{name、owner.login、description}
  5. func gjsonOutput(username string) {
  7.     //gjson就十分简单了，只需要拿到响应json数据即可取出来看
  9.     mapUserData := make(map[string]interface{}) //用户信息存储
  11.     //仓库信息存储，
  13.     // 由于仓库是数组列表所以要给一个初始长度
  15.     // 因为可能仓库为空的，所以就初始化为0即可
  17.     mapReposData := make([]map[string]interface{}, 0)
  19.     fmt.Println("-------------------用户信息-------------------")
  21.     client := req.C()
  23.     resp, err := client.R().
  25.         SetPathParam("username", username).
  27.         Get("https://api.github.com/users/{username}")
  29.     if err != nil {
  31.         log.Println("代码请求失败：", err)
  33.     }
  35.     //gjson想要写入文件就只能转储到struct或者map中
  37.     mapUserData["login"] = gjson.Get(resp.String(), "login").String()
  39.     mapUserData["id"] = gjson.Get(resp.String(), "id").String()
  41.     mapUserData["url"] = gjson.Get(resp.String(), "url").String()
  43.     mapUserData["name"] = gjson.Get(resp.String(), "name").String()
  45.     mapUserData["email"] = gjson.Get(resp.String(), "email").String()
  47.     data, err := json.MarshalIndent(mapUserData, "", "\t")
  49.     if err != nil {
  51.         log.Println("格式化失败：", err)
  53.     }
  55.     fmt.Println(string(data))
  57.     // test := gjson.Get(resp.String(), "login")
  59.     // fmt.Println(test)
  61.   
  63.     fmt.Println("---------------------------------------------")
  65.   
  67.     fmt.Println("-------------------仓库信息-------------------")
  69.     client = req.C()
  71.     resp, err = client.R().
  73.         SetPathParam("username", username).
  75.         Get("https://api.github.com/users/{username}/repos")
  77.     if err != nil {
  79.         log.Println("代码请求失败：", err)
  81.     }
  83.     // 仓库列表信息{name、owner.login、description}
  85.     arr := gjson.Get(resp.String(), "#.name")
  87.     for i, j := range arr.Array() {
  89.         //一定要放到这里来，因为make指向同一个空间，
  91.         // 如果你在for外面定义mapTmpRepos造成取到的值会全部变成最后一个值，
  93.         // 因为同一个空间他会同步改变你map切片append里面所有的内容，
  95.         // 因为同一个空间嘛
  97.         mapTmpRepos := make(map[string]interface{})
  99.         mapTmpRepos["name"] = j.String()
  101.         mapTmpRepos["login"] = gjson.Get(resp.String(), (strconv.Itoa(i) + ".owner.login")).String()
  103.         mapTmpRepos["description"] = gjson.Get(resp.String(), (strconv.Itoa(i) + ".description")).String()
  105.         mapReposData = append(mapReposData, mapTmpRepos)
  107.     }
  109.     data, err = json.MarshalIndent(mapReposData, "", "\t")
  111.     if err != nil {
  113.         fmt.Println("格式化失败：", err)
  115.     }
  117.     fmt.Println(string(data)) //格式化的内容打印到终端
  119.   
  121.     file, err := os.OpenFile("gjson.json", os.O_CREATE|os.O_RDWR|os.O_RDWR, 0666)
  123.     if err != nil {
  125.         log.Println("打开文件失败：", err)
  127.     }
  129.     _, err = file.Write(data)
  131.     if err != nil {
  133.         log.Println("导出json失败：", err)
  135.     }
  137. }
复制代码
Cookie

请求级别：

  • SetCookies
  1. SetCookies(&http.Cookie{
  2.         Name:  "hacker",
  3.         Value: "aaa",
  4. })
复制代码
全局级别：

  • SetCommonCookies
  1. SetCommonCookies(&http.Cookie{
  2.         Name:  "Global",
  3.         Value: "dddd",
  4. })
复制代码
默认行为

就是当你请求的服务端响应了set-cookie回来后，当你再次请求的时间就会携带上这个set-cookie回来的cookie键值去请求。
禁⽤Cookie


  • SetCookieJar(nil)
存储Cookie

安装
  1. go get -u github.com/juju/persistent-cookiejar
复制代码
使用
  1. func saveCookies() {
  2.     jar, err := cookiejar.New(&cookiejar.Options{
  3.         Filename: "cookies.json",
  4.     })
  6.     if err != nil {
  7.         log.Println("保存失败")
  8.     }
  10.     defer jar.Save()
  11.     client := req.C().SetCookieJar(jar).DevMode()
  12.     client.R().Get("http://www.baidu.com")
  14. }
复制代码
证书校验

无视风险

针对一些不安全的网站请求可能会请求失败，所以需要忽略证书的校验
两种方式可以忽略：
  1. client := req.C().DevMode().EnableDumpAllWithoutResponse()
  2. //忽略证书风险
  3. //第一种
  4. //client.SetTLSClientConfig(&tls.Config{InsecureSkipVerify: true})
  5. //第二种
  6. client.TLSClientConfig.InsecureSkipVerify = true
  7. _, err := client.R().
  8.         Get("https://self-signed.badssl.com/")
  9. if err != nil {
  10.         fmt.Println("代码请求失败：", err)
  11. }
复制代码
配置证书

配置好风险站点的证书即可访问风险站点
证书需要访问网站的时间在欣赏器的小锁中下载即可（具体不演示了，自行百度网站证书如何下载）

  • 证书文件配置
  1. client := req.C().DevMode().EnableDumpAllWithoutResponse()
  2. //可以同时配置多个网站的证书
  3. client.SetRootCertsFromFile("cert1.crt","cert2.crt","cert3.crt")
复制代码

  • 证书内容配置
    在下载了证书之后，可以编辑证书将里面的内容配置进来也行
  1. client := req.C().DevMode().EnableDumpAllWithoutResponse()
  2. client.SetRootCertFromString("-----BEGIN CERTIFICATE-----")
复制代码
Auth身份认证


  • SetBasicAuth
  • SetDigestAuth
    区别：
    一个Basic认证，一个Digest认证
    Digest认证比较安全，请求被拦截了攻击者无法直接获取密码
    但是Basic的请求被拦截了就是直接获取到密码
    服务端支持哪一个？
    检查WWW-Authenticate响应头，返回Basic 还是 Digest就知道支持哪一个。
  1. func authHttp() {
  2.     client := req.C().DevMode().EnableDumpAllWithoutResponse()
  3.     client.R().
  4.         SetBasicAuth("username", "password").
  5.         Get("https://httpbin.org/uuid")
  6.        
  7.     client2 := req.C().DevMode().EnableDumpAllWithoutResponse()
  8.     client2.R().
  9.         SetDigestAuth("username2", "password2").
  11.         Get("https://httpbin.org/uuid")
  13. }
复制代码
文件上传下载

上传文件


  • SetFile
  • SetFiles：吸收map类型，上传多个文件
  • SetUploadCallback：表现上传进度
  1. func uploadFileHttp() {
  2.     //简单上传
  3.     client := req.C().DevMode().EnableDumpAllWithoutResponse()
  5.     callback := func(info req.UploadInfo) { //显示上传进度
  7.         fmt.Printf("\n文件名：%q\n已上传：%.2f%%\n",
  8.             info.FileName,
  9.             float64(info.UploadedSize)/float64(info.FileSize)*100.0)
  10.     }
  11.    
  12.     client.R().
  13.         //SetFile("filename", "cookies.json").
  14.         SetFiles(map[string]string{
  16.             "test":  "test.txt",
  18.             "test2": "test2.txt",
  20.             "test3": "test3.txt",
  22.         }).
  23.         SetUploadCallback(callback). //使用该函数：显示上传进度
  24.         Post("https://httpbin.org/post")
  26. }
复制代码
下载文件


  • SetOutputFile：这里是指定下载的文件路径
  • SetOutputDirectory：设置下载的默认路径，即SetOutputFile可以只给文件名，自动存在该路径下
  • SetDownloadCallback：表现下载进度
  1. func downloadFileHttp() {
  3.     client := req.C() //.DevMode().EnableDumpAllWithoutResponse()
  5.     callback := func(info req.DownloadInfo) {
  7.         if info.Response.Response != nil { //响应不为空
  9.             fmt.Printf("\n已下载：%.2f%%\n",
  11.                 float64(info.DownloadedSize)/float64(info.Response.ContentLength)*100.0)
  13.         }
  15.     }  
  17.     client.R().
  19.         //这里是指定文件路径
  21.         SetOutputFile("./baidu.html").Get("http://127.0.0.1/xxx.txt")
  23.     client2 := req.C().
  25.         //这里可以设置默认下载目录，后面直接download的时候就不用指定路径了，给文件名即可
  27.         SetOutputDirectory("./").
  29.         DevMode().
  31.         EnableDumpAllWithoutResponse()
  33.     client2.R().
  35.         SetOutputFile("baidu2.html").
  37.         SetDownloadCallback(callback).
  39.         Get("http://127.0.0.1/xxx.txt")
  41. }
复制代码
多线程下载练习


  • NewParallelDownload：创建一个多线程下载客户端
  • 其他函数在解释中标明了。
  1. func threatDownload() {
  3.     client := req.C()
  5.     err := client.NewParallelDownload("http://xxxxx.xxxx.xxx/xxx.iso").
  7.         SetConcurrency(5).               //设置 5 个线程 并行下载
  9.         SetFileMode(0777).               //设置 文件权限（可读可写可执行）。
  11.         SetOutputFile("xxx.iso").        //设定最终 存储文件名
  13.         SetSegmentSize(1024 * 1024 * 5). //每个线程下载 5MB 的数据块
  15.         SetTempRootDir("./tmp").         //这个是下载的时候指定的临时存储目录
  17.         Do()
  19.     if err != nil {
  21.         log.Println("下载失败：", err)
  23.         return
  25.     }
  27. }
复制代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

立山

论坛元老
这个人很懒什么都没写!

楼主热帖

标签云

渠道 国产数据库 集成商 AI 运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表