package main

import (
"bytes"
"encoding/json"
"flag"
"fmt"
"github.com/elazarl/goproxy"
"io/ioutil"
"log"
"net/http"
"os"
"regexp"
"strconv"
"strings"
"sync"
"time"
)

var (
// request.Body temp var
// RequestBodyMap = make(map[int64][]byte)
RequestBodyMap sync.Map

// http static resource file extension
static_ext []string = []string{
"js",
"css",
"ico",
"woff",
"ttf",
"map",
"woff2",
}

// media resource files type
media_types []string = []string{
"image",
"video",
"audio",
}

// http static resource files
static_types []string = []string{
"application/vnd.google.octet-stream-compressible",
"font/woff",
"font/woff2",
"text/css",
"text/javascript",
"baiduApp/json",
"application/javascript",
"application/x-javascript",
"application/msword",
"application/vnd.ms-excel",
"application/vnd.ms-powerpoint",
"application/x-ms-wmd",
"application/x-shockwave-flash",
}
)

func checkErr(err error) {
if err != nil {
log.Println(err)
}
}

type Response struct {
Origin         string      `json:"origin"`
Method         string      `json:"method"`
Status         int         `json:"status"`
ContentType    string      `json:"content_type"`
ContentLength  uint        `json:"content_length"`
Host           string      `json:"host"`
Port           string      `json:"port"`
URL            string      `json:"url"`
Scheme         string      `json:"scheme"`
Path           string      `json:"path"`
Extension      string      `json:"ext"`
ResponseHeader http.Header `json:"response_header,omitempty"`
ResponseBody   string      `json:"response_body,omitempty"`
RequestHeader  http.Header `json:"request_header,omitempty"`
RequestBody    string      `json:"request_body,omitempty"`
DateStart      time.Time   `json:"date_start"`
DateEnd        time.Time   `json:"date_end"`
}

func handleRequest(req *http.Request, ctx *goproxy.ProxyCtx) (*http.Request, *http.Response) {
reqbody, err := RequestBody(req)
checkErr(err)
// RequestBodyMap[ctx.Session] = reqbody
RequestBodyMap.Store(ctx.Session, reqbody)
// log.Println(req)

return req, nil
}

//func goHandleRequest()(*http.Request, *http.Response){
//
//
//}

func RequestBody(res *http.Request) ([]byte, error) {

buf, err := ioutil.ReadAll(res.Body)
if err != nil {
return nil, err
}
res.Body = ioutil.NopCloser(bytes.NewReader(buf))
// log.Printf(string(buf))
return buf, nil
}

// json.Marshal方法优化，不对html做转义处理
func MarshalHTML(v interface{}) ([]byte, error) {
var buf bytes.Buffer
enc := json.NewEncoder(&buf)
enc.SetEscapeHTML(false)
err := enc.Encode(v)
if err != nil {
return nil, err
}
return buf.Bytes(), nil
}

func handleResponse(resp *http.Response, ctx *goproxy.ProxyCtx) *http.Response {

// Getting the Body
reqbody, ok := RequestBodyMap.Load(ctx.Session)
RequestBodyMap.Delete(ctx.Session)
if ok != false && resp != nil {
respbody, err := ResponseBody(resp)
checkErr(err)
// Attaching capture tool.
if respbody != nil {
RespCapture := New(resp, reqbody.([]byte), respbody).Parser()

static := NewResType(
RespCapture.Extension,
RespCapture.ContentType).isStatic()
//log.Println(RespCapture)
//tmpRespCapture := RespCapture
if static != true {
jsonStr, err := MarshalHTML(RespCapture)
if err != nil {
log.Fatal()
}
//fmt.Println(jsonStr)
//SynProducerCase(RespCapture)
go func() {
//f, err := os.OpenFile("./log/scan.log", os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0666)
//checkErr(err)
//defer f.Close()
//w := bufio.NewWriter(f)
//w.WriteString(string(jsonStr))
//w.Flush()
SynProducerCase(string(jsonStr))
}()

}
}

// fmt.Printf("%s\n", jsonStr)
}
return resp
}
func ResponseBody(res *http.Response) ([]byte, error) {
if res != nil {
defer res.Body.Close()
}
buf, err := ioutil.ReadAll(res.Body)
if err != nil {
return nil, err
}
res.Body = ioutil.NopCloser(bytes.NewReader(buf))
return buf, nil
}

func toJsonHeader(header http.Header) string {
js, err := json.Marshal(header)
checkErr(err)
return string(js)
}
func New(resp *http.Response, reqbody []byte, respbody []byte) *ParserHTTP {
return &ParserHTTP{r: resp, reqbody: reqbody, respbody: respbody, s: time.Now()}
}

func NewResType(ext string, ctype string) *ResType {
var mtype string
if ctype != "" {
mtype = strings.Split(ctype, "/")[0]
}
return &ResType{ext, ctype, mtype}
}

type ParserHTTP struct {
r        *http.Response
reqbody  []byte
respbody []byte
s        time.Time
}

type ResType struct {
ext   string
ctype string
mtype string
}

func (parser *ParserHTTP) Parser() Response {

var (
ctype   string
clength int
StrHost string
StrPort string
)

if len(parser.r.Header["Content-Type"]) >= 1 {
ctype = GetContentType(parser.r.Header["Content-Type"][0])
}

if len(parser.r.Header["Content-Length"]) >= 1 {
clength, _ = strconv.Atoi(parser.r.Header["Content-Length"][0])
}

SliceHost := strings.Split(parser.r.Request.URL.Host, ":")
if len(SliceHost) > 1 {
StrHost, StrPort = SliceHost[0], SliceHost[1]
} else {
StrHost = SliceHost[0]
if parser.r.Request.URL.Scheme == "https" {
StrPort = "443"
} else {
StrPort = "80"
}
}

now := time.Now()

r := Response{
Origin:         parser.r.Request.RemoteAddr,
Method:         parser.r.Request.Method,
Status:         parser.r.StatusCode,
ContentType:    string(ctype),
ContentLength:  uint(clength),
Host:           StrHost,
Port:           StrPort,
URL:            parser.r.Request.URL.String(),
Scheme:         parser.r.Request.URL.Scheme,
Path:           parser.r.Request.URL.Path,
Extension:      GetExtension(parser.r.Request.URL.Path),
ResponseHeader: parser.r.Header,
ResponseBody:   string(parser.respbody),
RequestHeader:  parser.r.Request.Header,
RequestBody:    string(parser.reqbody),
DateStart:      parser.s,
DateEnd:        now,
}

return r
}

func (r *ResType) isStatic() bool {
if ContainsString(static_ext, r.ext) {
return true
} else if ContainsString(static_types, r.ctype) {
return true
} else if ContainsString(media_types, r.mtype) {
return true
}
return false
}

func GetContentType(HeradeCT string) string {
ct := strings.Split(HeradeCT, "; ")[0]
return ct
}

func GetExtension(path string) string {
SlicePath := strings.Split(path, ".")
if len(SlicePath) > 1 {
return SlicePath[len(SlicePath)-1]
}
return ""
}

func ContainsString(sl []string, v string) bool {
for _, vv := range sl {
if vv == v {
return true
}
}
return false
}

func PathExists(path string) (bool, error) {
_, err := os.Stat(path)
if err == nil {
return true, nil
}
if os.IsNotExist(err) {
return false, nil
}
return false, err
}

func main() {

//stopper_cpu := profile.Start(profile.CPUProfile, profile.ProfilePath("."))
//defer stopper_cpu.Stop()
//stopper_mem := profile.Start(profile.MemProfile, profile.ProfilePath("."))
//defer stopper_mem.Stop()
//stopper_mutex := profile.Start(profile.MutexProfile, profile.ProfilePath("."))
//defer stopper_mutex.Stop()
//stopper_block := profile.Start(profile.BlockProfile, profile.ProfilePath("."))
//defer stopper_block.Stop()

fmt.Println("Proxy start")

// 定义代理日志目录
_dir := "log"
exist, err := PathExists(_dir)
if err != nil {
fmt.Printf("get dir error![%v]\n", err)
return
}
if exist {
fmt.Printf("Proxy log dir -> [%v]\n", _dir)
} else {
fmt.Printf("No proxy log dir -> [%v]\n", _dir)
// 创建代理目录
err := os.Mkdir(_dir, os.ModePerm)
if err != nil {
fmt.Printf("Mkdir proxy log failed![%v]\n", err)
} else {
fmt.Printf("Mkdir proxy log success!\n")
}
}
verbose := flag.Bool("v", false, "should every proxy request be logged to stdout")
addr := flag.String("l", ":8080", "on which address should the proxy listen")
flag.Parse()
proxy := goproxy.NewProxyHttpServer()
proxy.Verbose = *verbose
log.Printf("Listening %s \n", *addr)
log.Printf("proxy Start success... \n")
log.Println(goproxy.ReqHostMatches())
proxy.OnRequest(goproxy.ReqHostMatches(regexp.MustCompile(`^.*\.(test|dev)\.(gongsi|yuming)\.com:443$`))).HandleConnect(goproxy.AlwaysMitm)
proxy.OnRequest(goproxy.ReqHostMatches(regexp.MustCompile(`(.*\.(test|dev)\.(gongsi|yuming)\.com|10\.\d+\.\d+\.\d+)$`))).DoFunc(handleRequest)
proxy.OnResponse().DoFunc(handleResponse)
log.Fatal(http.ListenAndServe(*addr, proxy))

}

package main

import (
"encoding/json"
"fmt"
"github.com/imroc/req"
"log"
)

func bacRequest(logPayload string, change string, id int64) {
var reqLog Response
//fmt.Println(string(logPayload))

err := json.Unmarshal([]byte(logPayload), &reqLog) //把流量日志logPayload反序列化成[]byte的json格式的reqLog
if err != nil {
fmt.Println("json Unmarshal failed:", err)
}
//resJsonBool := strings.Contains(reqLog.ResponseHeader.Get("Content-Type"), "application/json")
header, err := processCookie(reqLog.RequestHeader, change)
if err != nil {
log.Println("处理header错误：", err)
return
}

firstResp := []byte(reqLog.ResponseBody) // firstResp 是原始请求里的Response
if reqLog.Method == "GET" {
r, _ := req.Get(reqLog.URL, header) // Request请求开始

//log.Println("修改请求的响应：",r.String()) //Mysql
riskValue := riskBac(firstResp, []byte(r.String()))
//log.Println("相似度的值为: ",riskValue)
reqHeader, _ := json.Marshal(r.Request().Header)
//reqBody, err := json.Marshal(r.Request().Body) //空
respHeader, _ := json.Marshal(r.Response().Header)
//log.Println(respHeader)
httpLogUpdate(string(reqHeader), reqLog.RequestBody, string(respHeader), r.String(), id, change, riskValue)

} else if reqLog.Method == "POST" {
// 1. 看Content-type，如果是json，就要用req的json方法请求；
header.Del("Content-Length")
r, err := req.Post(reqLog.URL, header, reqLog.RequestBody)

if err != nil {
log.Println("POST请求失败：", err)
}
riskValue := riskBac(firstResp, []byte(r.String()))

reqHeader, _ := json.Marshal(r.Request().Header)
//reqBody, err := json.Marshal(r.Request().Body) //空
respHeader, _ := json.Marshal(r.Response().Header)

httpLogUpdate(string(reqHeader), reqLog.RequestBody, string(respHeader), r.String(), id, change, riskValue)
} else if reqLog.Method == "OPTIONS" {
r, err := req.Options(reqLog.URL, header, reqLog.RequestBody)
if err != nil {
log.Println("OPTIONS请求失败：", err)
}
riskValue := riskBac(firstResp, []byte(r.String()))

reqHeader, _ := json.Marshal(r.Request().Header)
//reqBody, err := json.Marshal(r.Request().Body) //空
respHeader, _ := json.Marshal(r.Response().Header)
httpLogUpdate(string(reqHeader), reqLog.RequestBody, string(respHeader), r.String(), id, change, riskValue)

}
}

package main

import (
"github.com/go-redis/redis"
"log"
"net/http"
"regexp"
"strings"
)

func getSSOid(keySsoid string) string {
// 建立redis连接
client := redis.NewClient(&redis.Options{
Addr:     appConfig.redisAddr,
Password: appConfig.redisPass,
DB:       1,
})
defer client.Close()
ping, err := client.Ping().Result()
if err != nil {
log.Println("Redis client connect failed ping status:", err)
}
log.Println("ping status:", ping)
ssoid, err := client.Get(keySsoid).Result()
if err != nil {
log.Println("Get redis key value failed:", err)
}
if len(ssoid) < 5 {
log.Println("error: ssoid value length < 5")
return ";"
}
return ssoid
}

func processCookie(headerInput http.Header, change string) (http.Header, error) {
header := headerInput

// BA认证变更
Access_token := header.Get("access-token")
if len(Access_token) > 10 {
// 删除Cookie
if change == "del" {
// 把ssoid的值全部替换为空并替换Header头中的Cookie字段
header.Set("access-token", "")
//替换Cookie
} else {
newSSOid := getSSOid(change)
header.Set("access-token", newSSOid)
}
}

Cookie := header.Get("Cookie")

// 通过正则取出ssoid=xxx;
reg := regexp.MustCompile(`[.\w]*(ssoid|SSOID|SSO_ID|sso_id|sso_sid|SSO_SID|TGCX)=[0-9a-zA-Z-_*]+`)
//log.Println(reg.FindAllString(Cookie, -1))
client_id := reg.FindAllString(Cookie, -1)
//log.Println(client_id)
//log.Println(len(client_id))
if len(client_id) > 0 {
for _, ssoid_value := range client_id {
cookieArray := strings.Split(ssoid_value, "=") //将cookie=abc;根据等号分割成数组[cookie abc]
//ssoid := cookieArray[0] // com.hello.it.ead.cihah_ssoid
oldSsoidVal := cookieArray[1] // abc;
if len(oldSsoidVal) > 20 {
//删除Cookie
if change == "del" {
// 把ssoid的值全部替换为空并替换Header头中的Cookie字段
Cookie = strings.Replace(Cookie, oldSsoidVal, ";", -1)

//替换Cookie
} else if (change == "ssoid-offline") || (change == "ssoid-online") {
newSSOid := getSSOid(change)
Cookie = strings.Replace(Cookie, oldSsoidVal, newSSOid+";", -1)

} else {
log.Println("change 标识错误")
}
} else {
log.Println("Cookie获取失败：", cookieArray)
}
}
header.Set("Cookie", Cookie)
}
return header, nil

}

package main

import (
"github.com/glaslos/ssdeep"
"log"
)

//通过比较日志response和二次请求中的response相似作为越权风险值
func riskBac(firstResp []byte, afterResp []byte) int {

if len(firstResp) < 30 || len(afterResp) < 30 {
return 30
}

h1, err := ssdeep.FuzzyBytes(firstResp)
if err != nil {
log.Println("ssdeep h1 error:", err)
}
//log.Println(h1)
h2, err := ssdeep.FuzzyBytes(afterResp)
if err != nil {
log.Println("ssdeep h2 error:", err)
}
//log.Println(h2)

var score int
score, err = ssdeep.Distance(h1, h2)
if err != nil {
log.Println("ssdeep distance failed.")
}
log.Println(score)
return score

}

package main

import (
"errors"
"github.com/go-redis/redis"
"github.com/imroc/req"
"github.com/jakecoffman/cron"
"io"
"log"
"os"
)

type cookieMT struct {
//ssoOnlineURL  string
ssoOfflineURL string
}

type tokenMT struct {
tokenOfflineURL string  // 线下C端用户中心passport生成token地址
expenses string // 生活费，已授信，未借款 账号
diversion string // 已开通助贷（马上），未借款 账号
instalment string // 已开通分期，未借款 账号
}

// 获取线下环境ssoid的值
func (c cookieMT) Runssoff() (string, error) {
var resp map[string]interface{}
// Request请求开始
r, err := req.Get(c.ssoOfflineURL) // 线下sso地址
if err != nil {
Error.Println("SSO Offline URL request failed:", err)
}

err = r.ToJSON(&resp)
if err != nil {
Error.Println("SSO Offline URL response r.ToJSON failed:", err)
}
// interface convert to string
if resp["data"] == nil {
return "null", errors.New("获取线下ssoid为空")
}
return resp["data"].(string), nil

}

func (t tokenMT) Runtokenoff(phone string) (string, error){
// Request请求开始
r, err := req.Get(t.tokenOfflineURL+phone) // 线下sso地址
if err != nil {
Error.Println("Token Offline URL request failed:", err)
}

resp := r.String()
return resp, nil
}


// 存线下的ssoid到reids里
func redisSsoOff(client *redis.Client, key string, ssoid string) {
setStatus := client.Set(key, ssoid, 0)
Info.Println("redis setStatus:", setStatus)
}

func redisTokenOff(client *redis.Client, key string, ssoid string) {
setStatus := client.Set(key, ssoid, 0)
Info.Println("redis setStatus:", setStatus)
}

var mainCron *cron.Cron

// 定义日志全局变量
var (
Info    *log.Logger
Warning *log.Logger
Error   *log.Logger
)

// 日志初始化配置
func init() {
errFile, err := os.OpenFile("errors.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
if err != nil {
log.Fatalln("打开日志文件失败：", err)
}

Info = log.New(os.Stdout, "Info:", log.Ldate|log.Ltime|log.Lshortfile)
Warning = log.New(os.Stdout, "Warning:", log.Ldate|log.Ltime|log.Lshortfile)
Error = log.New(io.MultiWriter(os.Stderr, errFile), "Error:", log.Ldate|log.Ltime|log.Lshortfile)

}

func redisTask() {

cookies := cookieMT{
//ssoOnlineURL:  "http://test.com/hahaservice/get?id=pirogue&password=",
ssoOfflineURL: "http://test.com/hahaservice/offline/get?id=pirogue&password=",
}

tokens := tokenMT{
tokenOfflineURL: "http://gege.test.com/api/token?q=",
expenses:        "15xxxxxxxxx",
diversion:       "13xxxxxxxxx",
instalment:      "13xxxxxxxxx",
}

// 建立redis连接
client := redis.NewClient(&redis.Options{
Addr: "localhost:1234",
Password: "xxxxxxxxxx",
DB:       1,
})
ping, err := client.Ping().Result()
if err != nil {
Error.Println("Redis client connect failed ping status:", err)
}
Info.Println("ping status:", ping)

defer client.Close()

// 请求线上接口获取ssoid
//ssoidOnline, err := cookies.Runssonline()
//if err != nil {
//Error.Println(err)
//}

// 请求线下接口获取ssoid
ssoidOffline, err := cookies.Runssoff()
if err != nil {
Error.Println(err)
}

tokenOfflineExpenses , err := tokens.Runtokenoff(tokens.expenses)
if err != nil {
Error.Println(err)
}

tokenOfflineDiversion , err := tokens.Runtokenoff(tokens.diversion)
if err != nil {
Error.Println(err)
}

tokenOfflineInstalment , err := tokens.Runtokenoff(tokens.instalment)
if err != nil {
Error.Println(err)
}

redisSsoOff(client, "ssoid-offline", ssoidOffline)
redisTokenOff(client, "token-expenses", tokenOfflineExpenses)
redisTokenOff(client, "token-diversion", tokenOfflineDiversion)
redisTokenOff(client, "token-instalment", tokenOfflineInstalment)


//redisSsoOn(client, "ssoid-online", ssoidOnline)
}

func main() {


mainCron = cron.New()

// AddJob
tasktime := "0 0 1 * * ?"   //每天凌晨1点
//tasktime := "0 0/1 * * * ? " //每2分钟

mainCron.AddFunc(tasktime, redisTask, "ssopassport")

mainCron.Start()
select {} //阻塞主线程不退出

}

package main

import (
"encoding/xml"
"fmt"
)

type items struct {
XMLName xml.Name `xml:"items"`
Version string   `xml:"burpVersion,attr"`
Itemlist []item `xml:"item"`
}
type item struct {
URL CdataStringUrl`xml:"url"`
METHOD CdataStringMethod `xml:"method"`
Req CdataString `xml:"request"`
}


type CdataString struct {
Value string `xml:",cdata"`
Base64 string `xml:"base64,attr"`
}

type CdataStringUrl struct {
Value string `xml:",cdata"`
}

type CdataStringMethod struct {
Value string `xml:",cdata"`
}

func main() {
v := &items{Version: "2.1.06"}
for i:=0;i<10;i++{

v.Itemlist = append(v.Itemlist, item{URL:CdataStringUrl{Value:"http://123.com"}, METHOD:CdataStringMethod{Value:"GET"}, Req: CdataString{Value: "bbbccc", Base64:"true"}})
}
output, err := xml.MarshalIndent(v, "", "  ")
if err != nil {
fmt.Printf("error: %v\n", err)
}
fmt.Println(string(output))
}