Golang安全开发HTTP客户端与远程交互

Get(url string)(resp *Response,err error)POST(url string, bodyTYpe string, body io.Reader)(resp *Response,err error)Head(url string)(resp *Respones,err error)

r1, err := http.Get("<https://www.baidu.com/robots.txt>")  //读取响应正文  defer r1.Body.Close()  r2, err := http.Head("<https://www.baidu.com/robots.txt>")  defer r2.Body.Close()
  form := url.Values{}  form.Add("foo", "bar")  r3, err = http.Post(    "<https://www.baidu.com/robots.txt>",    "application/x-www-form-urlencoded",    strings.NewReader(form.Encode()),  )  defer r3.Body.Close

func PostForm(url string, data url.Values) (resp *Response, err error) {  return DefaultClient.PostForm(url, data)}form := url.Values{}  form.Add("foo", "bar")  //r3, err = http.Post(  //  "<https://www.baidu.com/robots.txt>",  //  "application/x-www-form-urlencoded",  //  strings.NewReader(form.Encode()),  //)  r3,err :=http.PostForm("<https://www.baidu.com/robots.txt>",form)  defer r3.Body.Close

func NewRequest(method, url string, body io.Reader) (*Request, error) {  return NewRequestWithContext(context.Background(), method, url, body)}

req,err :=http.NewRequest("DELETE","<https://www.baidu.com/robots.txt>",nil)  var client http.Client  resp,err :=client.Do(req)

form := url.Values{}  form.Add("foo", "bar")  var client http.Client  req, err := http.NewRequest(    "PUT",    "<https://www.baidu.com/robots.txt>",    strings.NewReader(form.Encode()))  resp,err :=client.Do(req)

r1, err := http.Get("<https://www.baidu.com/robots.txt>")  if err != nil {    log.Panicln(err)  }  fmt.Println(r1.Status)  //读取并显示响应正文  body,err :=ioutil.ReadAll(r1.Body)  if err != nil {    log.Panicln(err)  }    //读取响应正文  fmt.Println(string(body))    defer r1.Body.Close()

import (  "encoding/json"  "log"  "net/http")
type Status struct {  Message string  Status  string}
func main() {  res, err := http.Post("<https://www.baidu.com/ping>",    "application/json", nil)  if err != nil {    log.Println(err)  }  var status Status  if err := json.NewDecoder(res.Body).Decode(&status); err != nil {    log.Fatalln(err)  }  defer res.Body.Close()  log.Printf("%s ->%s\\n", status.Status, status.Message)
}

package main
import (  "fmt"  "io/ioutil"  "log"  "net/http"  "net/url"  "strings")
func main() {  resp, err := http.Get("<https://www.baidu.com/robots.txt>")  if err != nil {    log.Panicln(err)  }  //打印http响应  fmt.Println(resp.Status)  body, err := ioutil.ReadAll(resp.Body)  if err != nil {    log.Panicln(err)  }  fmt.Println(string(body))  resp.Body.Close()
  resp, err = http.Head("<https://www.baidu.com/robots.txt>")  if err != nil {    log.Panicln(err)  }  resp.Body.Close()  fmt.Println(resp.Status)  form := url.Values{}  form.Add("foo", "bar")  resp, err = http.Post(    "<https://www.baidu.com/robots.txt>",    "application/x-www-form-urlencoded",    strings.NewReader(form.Encode()))  if err != nil {    log.Panicln(err)  }  resp.Body.Close()  fmt.Println(resp.Status)
  req, err := http.NewRequest("DELETE", "<https://www.baidu.com/robots.txt>", nil)  if err != nil {    log.Println(err)  }  var client http.Client  resp, err = client.Do(req)  resp.Body.Close()  fmt.Println(resp.Status)  req, err = http.NewRequest("PUT", "<https://www.baidu.com/robots.txt>", strings.NewReader(form.Encode()))  resp, err = client.Do(req)  if err != nil {    log.Panicln(err)  }  resp.Body.Close()  fmt.Println(resp.Status)}

----cmd    -----shodan        ----main.go----shodan    ----api.go    ----host.go    ----shodan.go

<https://api.shodan.io/shodan/host/{ip}?key=>func APIInfo(token,url string){}func HostSearch(token,url string){}

package shodan
// 定义一个常量BaseURLconst BaseURL = "<https://api.shodan.io>"
// 定义一个Client结构体用于定义apikey的type Client struct {  apiKey string}
/**Client 表示该函数的返回类型是指向 Client 类型的指针，而不是 Client 类型本身。这是因为在Go语言中，结构体是值类型，因此，如果在函数中修改结构体的字段，则不会对原始结构体产生影响，而需要返回指向修改后结构体的指针。
return &Client{apiKey: apiKey} 的作用是创建一个新的 Client 结构体，并将其中的 apiKey 字段初始化为传递给函数的 apiKey 参数。然后，使用 & 运算符返回指向新创建的 Client 结构体的指针。
因此，func New(apiKey string) *Client 的作用是创建并返回一个指向新创建的 Client 结构体的指针，该结构体包含了用于进行 Shodan API 请求的 API 密钥。*/// 创建一个New函数 参数包含apikey字符串，func New(apiKey string) *Client { //会创建一个新的Client结构体  return &Client{apiKey: apiKey} //指针指向Client，返回apikey}

func (s *Client) APIInfo(){}func (s *Client)HostSearch(){}

https://api.shodan.io/api-info?key=xxxxxxxxxxxxxxxxxx

{"scan_credits": 100, "usage_limits": {"scan_credits": 100, "query_credits": 100, "monitored_ips": 16}, "plan": "dev", "https": false, "unlocked": true, "query_credits": 100, "monitored_ips": null, "unlocked_left": 100, "telnet": false}

package shodan
type ApiInfo struct {  QueryCredits int `json:"query_credits"`  ScanCredits int `json:"scan_credits"`  Telnet bool `json:"telnet"`  Plan string `json:"plan"`  HTTPS bool `json:"https"`  Unlocked bool `json:"unlocked"`}

/*这段代码是 Client 类型的 ApiInfo() 方法的实现。该方法通过 HTTP GET 请求向 Shodan API 发送 api-info 请求，并将客户端提供的 API 密钥作为参数发送。
当 API 请求成功时，该方法将返回一个 ApiInfo 结构体类型的指针和一个 error 类型的值。ApiInfo 结构体类型包含了有关当前用户的 Shodan API 使用情况的信息，例如剩余查询次数、API 计划等。error 类型的值用于指示操作是否成功。
在实现方法时，代码通过调用 http.Get() 函数向 Shodan API 发送请求，并将其响应存储在名为 res 的变量中。如果在发送请求时发生错误，则方法将立即返回该错误。否则，代码使用 defer 语句确保在方法返回之前关闭响应主体。
接下来，代码通过调用 json.NewDecoder().Decode() 函数，将响应体解析为 ApiInfo 结构体类型。如果解码过程中发生错误，则方法将立即返回该错误。否则，方法将返回指向解析后的 ApiInfo 结构体的指针*/func (c *Client) ApiInfo() (*ApiInfo, error) {  res, err := http.Get(fmt.Sprintf("%s/api-info?key=%s", BaseURL, c.apiKey))  if err != nil {    return nil, err  }  defer res.Body.Close()  var ret ApiInfo  if err := json.NewDecoder(res.Body).Decode(&ret); err != nil {    return nil, err  }  return &ret, err}

https://api.shodan.io/shodan/host/search?key=xxxxxxxxxx&query={query}&facets={facets}

package shodan
/*这段代码定义了一个名为 HostLocation 的结构体类型，该类型包含了与 Shodan 主机位置信息相关的字段。每个字段都包含了该位置信息的不同属性，如城市、区域代码、经纬度等。字段的含义如下：City：主机所在城市的名称。RegionCode：主机所在地区的代码。AreaCode：主机所在地区的区域代码。Longitude：主机所在位置的经度。CountryCode3：主机所在国家的三字母代码。CountryName：主机所在国家的名称。PostalCode：主机所在位置的邮政编码。DMACode：主机所在地区的 DMA（Designated Market Area）代码。CountryCode：主机所在国家的两字母代码。Latitude：主机所在位置的纬度。这些字段的类型不同，包括字符串类型、整型和浮点型。此外，字段标记了不同的 JSON 标记，以便在使用 JSON 解码器时能够正确地将 JSON 数据映射到结构体字段。因此，可以将该结构体用于解析 Shodan API 返回的主机位置信息的 JSON 数据。*/type HostLocation struct {  City         string  `json:"city"`  RegionCode   string  `json:"regionCode"`  AreaCode     int     `json:"area_code"`  Longitude    float32 `json:"longitude"`  CountryCode3 string  `json:"country_code3"`  CountryName  string  `json:"country_name"`  PostalCode   string  `json:"postal_code"`  DMACode      int     `json:"dma_code"`  CountryCode  string  `json:"country_code"`  Latitude     float32 `json:"latitude"`}
/*这段代码定义了一个名为 Host 的结构体类型，该类型包含了与 Shodan 主机信息相关的字段。每个字段都包含了不同的主机信息属性，如操作系统、时间戳、ISP（Internet Service Provider，互联网服务提供商）、ASN（Autonomous System Number，自治系统编号）等。字段的含义如下：OS：主机操作系统名称。Timestamp：主机信息记录的时间戳。ISP：主机所使用的互联网服务提供商。ASN：主机所在自治系统的编号。Hostnames：主机的主机名列表。Location：主机所在的位置信息，类型为 HostLocation。IP：主机的 IP 地址，类型为 int64。Domains：主机的域名列表。Org：主机所属的组织。Data：主机信息的原始数据。Port：Shodan 扫描到的端口号。IPstring：主机的 IP 地址，以字符串形式表示。这些字段的类型不同，包括字符串类型、整型、整型切片、字符串切片和自定义类型（HostLocation）。此外，字段标记了不同的 JSON 标记，以便在使用 JSON 解码器时能够正确地将 JSON 数据映射到结构体字段。因此，可以将该结构体用于解析 Shodan API 返回的主机信息的 JSON 数据。*/type Host struct {  OS        string       `json:"os"`  Timestamp string       `json:"timestamp"`  ISP       string       `json:"isp"`  ASN       string       `json:"asn"`  Hostnames []string     `json:"hostnames"`  Location  HostLocation `json:"location"` //Location：主机所在的位置信息，类型为 HostLocation,这些字段的类型不同，包括字符串类型、整型、整型切片、字符串切片和自定义类型（HostLocation）。此外，字段标记了不同的 JSON 标记，以便在使用 JSON 解码器时能够正确地将 JSON 数据映射到结构体字段。因此，可以将该结构体用于解析 Shodan API 返回的主机信息的 JSON 数据。  IP        int64        `json:"ip"`  Domains   []string     `json:"domains"`  Org       string       `json:"org"`  Data      string       `json:"data"`  Port      int          `json:"port"`  IPstring  string       `json:"ip_str"`}type HostSearch struct {  Metches []Host `json:"metches"`}

func (c *Client) HostSearch(q string) (*HostSearch, error) {  res, err := http.Get(fmt.Sprintf("%s/shodan/host/search?key=%s&query=%s",BaseURL,c.apiKey,q))  if err != nil {    return nil, err  }  defer res.Body.Close()  var ret HostSearch  if err :=json.NewDecoder(res.Body).Decode(&ret);err!=nil {    return nil, err  }  return &ret, err  }

package main
import (  "GoStudy/Go-Hacking/HTTP/shodan/shodan"  "fmt"  "log"  "os")
func main() {  if len(os.Args) != 2 {    log.Fatalln("Usage: shodan searchterm")  }  apiKey := os.Getenv("SHODAN_API_KEY")  s := shodan.New(apiKey)  info, err := s.ApiInfo()  if err != nil {    log.Panicln(err)  }  fmt.Printf("Query Credits:%d\\nScan Credits: %d\\n\\n", info.QueryCredits, info.ScanCredits)  hostSearch, err := s.HostSearch(os.Args[1])  if err != nil {    log.Panicln(err)  }  for _, host := range hostSearch.Matches {    fmt.Printf("%18s%8d\\n", host.IPString, host.Port)  }}

msf6 > load msgrpc pass=root123 ServerHost=192.168.148.129[*] MSGRPC Service:  192.168.148.129:55552 [*] MSGRPC Username: msf[*] MSGRPC Password: BqlW09ND[*] Successfully loaded plugin: msgrpc

export MSFHOST= xxxxx:55552export MSFPASS=s3cr3t

go get gopkg.in/vmihailenco/msgpack.v2

Metasploit ---client   ---main.go ---rpc  ---msf.go

["session.list","token"]

{"1" => {  'type' => "shell",  "tunnel_local" => "192.168.35.149:44444",  "tunnel_peer" => "192.168.35.149:43886",  "via_exploit" => "exploit/multi/handler",  "via_payload" => "payload/windows/shell_reverse_tcp",  "desc" => "Command shell",  "info" => "",  "workspace" => "Project1",  "target_host" => "",  "username" => "root",  "uuid" => "hjahs9kw",  "exploit_uuid" => "gcprpj2a",  "routes" => [ ]  }}

 package rpc
// Metasploit绘画列表类型定义type SessionListReq struct {  _msgpack struct{} `msgpack:"asArray"`  Method   string  Token    string}type SessionListRes struct {  ID          uint32 `msgpack:"omitempty"`  Type        string `msgpack:"type"`  TunnelLocal string `msgpack:"tunnel_local"`  TunnelPeer  string `msgpack:"tunnel_peer"`  ViaExploit  string `msgpack:"via_exploit"`  ViaPayload  string `msgpack:"via_payload"`  Description string `msgpack:"desc"`  Info        string `msgpack:"info"`  Workspace   string `msgpack:"workspace"`  SessionHost string `msgpack:"session_host"`  SessionPort int    `msgpack:"session_port"`  Username    string `msgpack:"username"`  UUID        string `msgpack:"uuid"`  ExploitUUID string `msgpack:"exploit_uuid"`}

[ "auth.login", "MyUserName", "MyPassword"]

{ "result" => "success", "token" => "a1a1a1a1a1a…" }

{"error" => true,"error_class" => "Msf::RPC::Exception","error_message" => "Invalid User ID or Password"}

[ "auth.logout", "<token>", "<LogoutToken>"]

{ "result" => "success" }

// 登录和登出type loginReq struct {  _msgpack struct{} `msgpack:",asArray"`  Method   string  Username string  Password string}type loginRes struct {  Result       string `msgpack:"result"`  Token        string `msgpack:"token"`  Error        bool   `msgpack:"error"`  ErrorClass   string `msgpack:"error_class"`  ErrorMessage string `msgpack:"error_message"`}type logoutReq struct {  _msgpack    struct{} `msgpack:",asArray"`  Method      string  Token       string  logoutToken string}type logoutRes struct {  Result string `msgpack:"result"`}

// Metasploit客户端定义type Metasploit struct {  host  string  user  string  pass  string  token string}
func New(host, user, pass string) *Metasploit {  msf := &Metasploit{    host: host,    user: user,    pass: pass,  }  return msf}

// 可重复的序列化和反序列化的通用send方法func (msf *Metasploit) send(req, res any) error {  buf := new(bytes.Buffer)  msgpack.NewEncoder(buf).Encode(req)  dest := fmt.Sprintf("http://%s/api", msf.host)  r, err := http.Post(dest, "binary/message-pack", buf)  if err != nil {    return err  }  defer r.Body.Close()  if err := msgpack.NewDecoder(r.Body).Decode(&res); err != nil {    return err  }  return nil}

func (msf *Metasploit) Login() error {  ctx := &loginReq{Method: "auth.login", Username: msf.user, Password: msf.pass}  var res loginRes  if err := msf.send(ctx, &res); err != nil {    return err  }  msf.token = res.Token  return nil}func (msf *Metasploit) Logout() error {  ctx := &logoutReq{    Method:      "auth.logout",    Token:       msf.token,    logoutToken: msf.token,  }  var res logoutRes  if err := msf.send(ctx, &res); err != nil {    return err  }  msf.token = ""  return nil}func (msf *Metasploit) SessionList() (map[uint32]SessionListRes, error) {  req := &SessionListReq{Method: "session.list", Token: msf.token}  res := make(map[uint32]SessionListRes)  if err := msf.send(req, &res); err != nil {    return nil, err  }  for id, session := range res {    session.ID = id    res[id] = session  }  return res, nil}

func New(host, user, pass string) (*Metasploit, error) {  msf := &Metasploit{    host: host,    user: user,    pass: pass,  }  //嵌入Metasploit登录初始化  if err := msf.Login(); err != nil {    return nil, err  }  return msf, nil}

import (  "GoStudy/Go-Hacking/HTTP/Metasploit/rpc"  "fmt"  "log"  "os")
func main() {host :=os.Getenv("MSFHOST")pass :=os.Getenv("MSFPASS")user:="msf"  if host ==""||pass =="" {    log.Fatalln("Missing required environment variable MSFHOST or MSFPASS")  }  msf,err :=rpc.New(host,user,pass)  if err != nil {    log.Panicln(err)  }  defer msf.Logout()    session,err :=msf.SessionList()  if err != nil {    log.Panicln(err)  }  fmt.Println("Sessions:")  for _,session:=range session{    fmt.Printf("%5d %s\\n",session.ID,session.Info)  }
}

package rpc
import (  "bytes"  "fmt"  "gopkg.in/vmihailenco/msgpack.v2"  "net/http")
type SessionListReq struct {  _msgpack struct{} `msgpack:",asArray"`  Method   string  Token    string}type SessionListRes struct {  ID          uint32 `msgpack:",omitempty"`  Type        string `msgpack:"type"`  TunnelLocal string `msgpack:"tunnel_local"`  TunnelPeer  string `msgpack:"tunnel_peer"`  ViaExploit  string `msgpack:"via_exploit"`  ViaPayload  string `msgpack:"via_payload"`  Description string `msgpack:"desc"`  Info        string `msgpack:"info"`  Workspace   string `msgpack:"workspace"`  SessionHost string `msgpack:"session_host"`  SessionPort int    `msgpack:"session_port"`  Username    string `msgpack:"username"`  UUID        string `msgpack:"uuid"`  ExploitUUID string `msgpack:"exploit_uuid"`}
// 登录和登出type loginReq struct {  _msgpack struct{} `msgpack:",asArray"`  Method   string  Username string  Password string}type loginRes struct {  Result       string `msgpack:"result"`  Token        string `msgpack:"token"`  Error        bool   `msgpack:"error"`  ErrorClass   string `msgpack:"error_class"`  ErrorMessage string `msgpack:"error_message"`}type logoutReq struct {  _msgpack    struct{} `msgpack:",asArray"`  Method      string  Token       string  logoutToken string}type logoutRes struct {  Result string `msgpack:"result"`}
// Metasploit客户端定义type Metasploit struct {  host  string  user  string  pass  string  token string}
func New(host, user, pass string) (*Metasploit, error) {  msf := &Metasploit{    host: host,    user: user,    pass: pass,  }  //嵌入Metasploit登录初始化  if err := msf.Login(); err != nil {    return nil, err  }  return msf, nil}
// 可重复的序列化和反序列化的通用send方法func (msf *Metasploit) send(req, res any) error {  buf := new(bytes.Buffer)  msgpack.NewEncoder(buf).Encode(req)  dest := fmt.Sprintf("http://%s/api", msf.host)  r, err := http.Post(dest, "binary/message-pack", buf)  if err != nil {    return err  }  defer r.Body.Close()  if err := msgpack.NewDecoder(r.Body).Decode(&res); err != nil {    return err  }  return nil}
func (msf *Metasploit) Login() error {  ctx := &loginReq{Method: "auth.login", Username: msf.user, Password: msf.pass}  var res loginRes  if err := msf.send(ctx, &res); err != nil {    return err  }  msf.token = res.Token  return nil}func (msf *Metasploit) Logout() error {  ctx := &logoutReq{    Method:      "auth.logout",    Token:       msf.token,    logoutToken: msf.token,  }  var res logoutRes  if err := msf.send(ctx, &res); err != nil {    return err  }  msf.token = ""  return nil}func (msf *Metasploit) SessionList() (map[uint32]SessionListRes, error) {  req := &SessionListReq{Method: "session.list", Token: msf.token}  res := make(map[uint32]SessionListRes)  if err := msf.send(req, &res); err != nil {    return nil, err  }  for id, session := range res {    session.ID = id    res[id] = session  }  return res, nil}

go get github.com/PuerkitoBio/goquery

<cp:coreProperties xmlns:cp="<http://schemas.openxmlformats.org/package/2006/metadata/core-properties>" xmlns:dc="<http://purl.org/dc/elements/1.1/>" xmlns:dcterms="<http://purl.org/dc/terms/>" xmlns:dcmitype="<http://purl.org/dc/dcmitype/>" xmlns:xsi="<http://www.w3.org/2001/XMLSchema-instance>"><dc:title>附件14:</dc:title><dc:creator>微软用户</dc:creator><cp:lastModifiedBy>zhangqq</cp:lastModifiedBy><cp:revision>26</cp:revision><cp:lastPrinted>2020-11-05T03:48:00Z</cp:lastPrinted><dcterms:created xsi:type="dcterms:W3CDTF">2020-09-11T08:08:00Z</dcterms:created><dcterms:modified xsi:type="dcterms:W3CDTF">2021-10-28T09:55:00Z</dcterms:modified></cp:coreProperties>

<Properties xmlns="<http://schemas.openxmlformats.org/officeDocument/2006/extended-properties>" xmlns:vt="<http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes>"><Template>Normal.dotm</Template><TotalTime>24</TotalTime><Pages>45</Pages><Words>3517</Words><Characters>20052</Characters><Application>Microsoft Office Word</Application><DocSecurity>0</DocSecurity><Lines>167</Lines><Paragraphs>47</Paragraphs><ScaleCrop>false</ScaleCrop><Company>微软中国</Company><LinksUpToDate>false</LinksUpToDate><CharactersWithSpaces>23522</CharactersWithSpaces><SharedDoc>false</SharedDoc><HyperlinksChanged>false</HyperlinksChanged><AppVersion>15.0000</AppVersion></Properties>

package metadata
import (  "encoding/xml"  "strings")
type OfficeCoreProperty struct {  XMLName        xml.Name `xml:"coreProperties"`  Creator        string   `xml:"creator"`  LastModifiedBy string   `xml:"lastModifiedBy"`}type OfficeAppProperty struct {  XMLName     xml.Name `xml:"Properties"`  Application string   `xml:"Application"`  Company     string   `xml:"Company"`  Version     string   `xml:"AppVersion"`}
var OfficeVersions = map[string]string{  "16": "2016",  "15": "2013",  "14": "2010",  "12": "2007",  "11": "2003",}
func (a *OfficeAppProperty) GetMajorVersion() string {  tokens := strings.Split(a.Version, ".") //截取AppVersion  if len(tokens) < 2 {    return "Unknown"  }  v, ok := OfficeVersions[tokens[0]]  if !ok {    return "Unknown"  }  return v}

// 处理归档和嵌入式XML文档func process(f *zip.File, prop any) error {  rc, err := f.Open()  if err != nil {    return err  }  defer rc.Close()
  if err := xml.NewDecoder(rc).Decode(&prop); err != nil {    return err  }  return nil}
func NewProperties(r *zip.Reader) (*OfficeCoreProperty, *OfficeAppProperty, error) {  var coreProps OfficeCoreProperty  var appProps OfficeAppProperty  for _, f := range r.File {    switch f.Name {    case "docProps/core.xml":      if err := process(f, &coreProps); err != nil {        return nil, nil, err      }    case "docProps/app.xml":      if err := process(f, &appProps); err != nil {        return nil, nil, err      }    default:      continue    }  }  return &coreProps, &appProps, nil}

site:pingan.com.cn && filetype docx && instreamset : (url title) : docx

package main
import (  "GoStudy/Go-Hacking/HTTP/bing/metadata"  "archive/zip"  "bytes"  "fmt"  "github.com/PuerkitoBio/goquery"  "io"  "log"  "net/http"  "net/url"  "os")
// 抓取bing结果并解析文档数据func handler(i int, s *goquery.Selection) {  url, ok := s.Find("a").Attr("href")  if !ok {    return  }  fmt.Printf("%d:%s\\n", i, url)  res, err := http.Get(url)  if err != nil {    return  }  buf, err := io.ReadAll(res.Body)  if err != nil {    return  }  defer func(Body io.ReadCloser) {    err := Body.Close()    if err != nil {      return    }  }(res.Body)
  r, err := zip.NewReader(bytes.NewReader(buf), int64(len(buf)))  if err != nil {    return  }  cp, ap, err := metadata.NewProperties(r)  if err != nil {    return  }  log.Printf("%25s %25s - %s %s \\n", cp.Creator, cp.LastModifiedBy, ap.Application, ap.GetMajorVersion())}func main() {  if len(os.Args) != 3 {    log.Fatalln("Missing required argument. Usage:main.go domain ext")  }  domian := os.Args[1]  filetype := os.Args[2]  q := fmt.Sprintf("site:%s && filetype:%s && instreamset : (url title) : %s",domian,filetype,filetype)  search :=fmt.Sprintf("<https://www.bing.com/search?!=%s>",url.QueryEscape(q))  //client := &http.Client{}  client :=&http.Client{}  req,err :=http.NewRequest("GET",search,nil)  if err != nil {    return  }  req.Header.Add("user-agent","Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36")  resp,err :=client.Do(req)  if err != nil {    return  }  doc,err :=goquery.NewDocumentFromReader(resp.Body)    if err != nil {    log.Fatalln(err)  }  s := "html body div#b_content ol#b_results li.b_algo div.b_title h2"  doc.Find(s).Each(handler)}