一个脚本绕过了Go语言SSL验证

http.DefaultTransport.(*http.Transport).TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
 _, err := http.Get("https://golang.org/")

tr := &http.Transport{
        TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
    }
    client := &http.Client{Transport: tr}
    _, err := client.Get("https://golang.org/")

func (c *Conn) verifyServerCertificate(certificates [][]byte) error {
  activeHandles := make([]*activeCert, len(certificates))
  certs := make([]*x509.Certificate, len(certificates))
  for i, asn1Data := range certificates {
    cert, err := globalCertCache.newCert(asn1Data)
    if err != nil {
      c.sendAlert(alertBadCertificate)
      return errors.New("tls: failed to parse certificate from server: " + err.Error())
    }
    activeHandles[i] = cert
    certs[i] = cert.cert
  }

  if !c.config.InsecureSkipVerify {
    opts := x509.VerifyOptions{
      Roots: c.config.RootCAs,
      CurrentTime: c.config.time(),
      DNSName: c.config.ServerName,
      Intermediates: x509.NewCertPool(),
    }

    for _, cert := range certs[1:] {
      opts.Intermediates.AddCert(cert)
    }
    var err error
    c.verifiedChains, err = certs[0].Verify(opts)
    if err != nil {
      c.sendAlert(alertBadCertificate)
      return &CertificateVerificationError{UnverifiedCertificates: certs, Err: err}
    }
  }

package main

import (
   "io/ioutil"
   "log"
   "net/http"
)

func main() {
   resp, err := http.Get("https://ipinfo.io/")
   if err != nil {
      log.Fatalln(err)
   }
   
  //We Read the response body on the line below.
   body, err := ioutil.ReadAll(resp.Body)
   if err != nil {
      log.Fatalln(err)
   }
   
   //Convert the body to type string
   sb := string(body)
   log.Printf(sb)
}

#!/usr/bin/env python3
import subprocess
import argparse

supported_versions_to_bytes = {
        '11': [b"x00x0Fx85xB3x04x00x00", b"x00x0Fx84xB3x04x00x00"],
        '12': [b"x00x00x0Fx85x43x05x00x00", b"x00x00x0Fx84x43x05x00x00"],
        '13': [b"x00x00x0Fx85x32x05x00x00", b"x00x00x0Fx84x32x05x00x00"],
        '14': [b"x00x00x0Fx85x48x05x00x00", b"x00x00x0Fx84x48x05x00x00"],
        '15': [b"x00x00x0Fx85x3Ax06x00x00", b"x00x00x0Fx84x3Ax06x00x00"],
        '16': [b"x00x00x0Fx85x5Ax06x00x00", b"x00x00x0Fx84x5Ax06x00x00"],
        '17': [b"x00x00x0Fx85x7Fx01x00x00", b"x00x00x0Fx84x7Fx01x00x00"],
        '18': [b"x00x00x0Fx85x7Cx01x00x00", b"x00x00x0fx84x7Cx01x00x00"],
        '19': [b"x00x00x0Fx85x7Bx01x00x00", b"x00x00x0fx84x7Bx01x00x00"],
        '20': [b"x00x00x0Fx85x84x01x00x00", b"x00x00x0Fx84x84x01x00x00"],
        '21': [b"x00x00x0Fx85x82x01x00x00", b"x00x00x0Fx84x82x01x00x00"]
}


def replace_file_bytes(file_path, old_bytes, new_bytes):
    with open(file_path, 'rb') as f:
        data = f.read()
        position = data.find(old_bytes)
    
    if(-1 == position):
        raise Exception("cannot find bytes, maybe the program is already patched?")

    with open(file_path, 'rb+') as file:
        file.seek(position)
        existing_bytes = file.read(len(old_bytes))
            
        if existing_bytes == old_bytes:
            file.seek(position)
            file.write(new_bytes)
      
def run_command(command):
    result = subprocess.run(command, shell=True, capture_output=True, text=True)
    return result.stdout.strip()
      
def get_go_bin_version(filename):
    output = run_command(f"strings {filename} | grep '^go1' | head -n 1")
    if "" == output:
        output = run_command(f"strings {filename} | grep 'Go cmd/compile' | head -n 1 | cut -d' ' -f 3")
        if "" == output:
            output = run_command(f"strings {filename} | grep -Eo 'go[0-9]+.[0-9]+(.[0-9]+)?' | head -n 1")
    return output

def get_args():
    parser = argparse.ArgumentParser(description='Get a filename and patches it ssl verification check')
    parser.add_argument("-f", "--filename", help='File to patch', required=True)
    parser.add_argument("-v", "--version", help='Input version of Golang app')
    parser.add_argument("-g", "--get-version", help='tries to get the app Golang version', action='store_true')
    return parser.parse_args()

def main():
    args = get_args()
    version = get_go_bin_version(args.filename).split('.')[1]
    if args.get_version:
        print("Assuming that the Golang version is: %s" % version)
        return
    if args.version:
        version = args.version
    old_bytes = supported_versions_to_bytes[version][0]
    new_bytes = supported_versions_to_bytes[version][1]
    replace_file_bytes(args.filename, old_bytes, new_bytes)

if "__main__" == __name__:
    main()