mirror of https://github.com/daffainfo/nuclei.git
142 lines
2.9 KiB
Go
142 lines
2.9 KiB
Go
package projectfile
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/sha256"
|
|
"encoding/gob"
|
|
"encoding/hex"
|
|
"io"
|
|
"io/ioutil"
|
|
"net/http"
|
|
)
|
|
|
|
func hash(v interface{}) (string, error) {
|
|
data, err := marshal(v)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
sh := sha256.New()
|
|
|
|
_, err = io.WriteString(sh, string(data))
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return hex.EncodeToString(sh.Sum(nil)), nil
|
|
}
|
|
|
|
func marshal(data interface{}) ([]byte, error) {
|
|
var b bytes.Buffer
|
|
enc := gob.NewEncoder(&b)
|
|
err := enc.Encode(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return b.Bytes(), nil
|
|
}
|
|
|
|
func unmarshal(data []byte, obj interface{}) error {
|
|
dec := gob.NewDecoder(bytes.NewBuffer(data))
|
|
err := dec.Decode(obj)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type HTTPRecord struct {
|
|
Request []byte
|
|
Response *InternalResponse
|
|
}
|
|
|
|
type InternalRequest struct {
|
|
Target string
|
|
HTTPMajor int
|
|
HTTPMinor int
|
|
Method string
|
|
Headers map[string][]string
|
|
Body []byte
|
|
}
|
|
|
|
type InternalResponse struct {
|
|
HTTPMajor int
|
|
HTTPMinor int
|
|
StatusCode int
|
|
StatusReason string
|
|
Headers map[string][]string
|
|
Body []byte
|
|
}
|
|
|
|
// Unused
|
|
// func newInternalRequest() *InternalRequest {
|
|
// return &InternalRequest{
|
|
// Headers: make(map[string][]string),
|
|
// }
|
|
// }
|
|
|
|
func newInternalResponse() *InternalResponse {
|
|
return &InternalResponse{
|
|
Headers: make(map[string][]string),
|
|
}
|
|
}
|
|
|
|
// Unused
|
|
// func toInternalRequest(req *http.Request, target string, body []byte) *InternalRequest {
|
|
// intReq := newInternalRquest()
|
|
|
|
// intReq.Target = target
|
|
// intReq.HTTPMajor = req.ProtoMajor
|
|
// intReq.HTTPMinor = req.ProtoMinor
|
|
// for k, v := range req.Header {
|
|
// intReq.Headers[k] = v
|
|
// }
|
|
// intReq.Headers = req.Header
|
|
// intReq.Method = req.Method
|
|
// intReq.Body = body
|
|
|
|
// return intReq
|
|
// }
|
|
|
|
func toInternalResponse(resp *http.Response, body []byte) *InternalResponse {
|
|
intResp := newInternalResponse()
|
|
|
|
intResp.HTTPMajor = resp.ProtoMajor
|
|
intResp.HTTPMinor = resp.ProtoMinor
|
|
intResp.StatusCode = resp.StatusCode
|
|
intResp.StatusReason = resp.Status
|
|
for k, v := range resp.Header {
|
|
intResp.Headers[k] = v
|
|
}
|
|
intResp.Body = body
|
|
return intResp
|
|
}
|
|
|
|
func fromInternalResponse(intResp *InternalResponse) *http.Response {
|
|
var contentLength int64
|
|
if intResp.Body != nil {
|
|
contentLength = int64(len(intResp.Body))
|
|
}
|
|
return &http.Response{
|
|
ProtoMinor: intResp.HTTPMinor,
|
|
ProtoMajor: intResp.HTTPMajor,
|
|
Status: intResp.StatusReason,
|
|
StatusCode: intResp.StatusCode,
|
|
Header: intResp.Headers,
|
|
ContentLength: contentLength,
|
|
Body: ioutil.NopCloser(bytes.NewReader(intResp.Body)),
|
|
}
|
|
}
|
|
|
|
// Unused
|
|
// func fromInternalRequest(intReq *InternalRequest) *http.Request {
|
|
// return &http.Request{
|
|
// ProtoMinor: intReq.HTTPMinor,
|
|
// ProtoMajor: intReq.HTTPMajor,
|
|
// Header: intReq.Headers,
|
|
// ContentLength: int64(len(intReq.Body)),
|
|
// Body: ioutil.NopCloser(bytes.NewReader(intReq.Body)),
|
|
// }
|
|
// }
|