135 lines
2.9 KiB
Go
135 lines
2.9 KiB
Go
package requests
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
func Decorate(req *http.Request) error {
|
|
req.Header.Set("tenant-id", TENANT_ID)
|
|
req.Header.Set("user-type", USER_TYPE)
|
|
req.Header.Set("app-content-encrypted", CONTENT_ENCRYPTED)
|
|
req.Header.Set("Authorization", PARAM_AUTHENTICATION)
|
|
|
|
return nil
|
|
}
|
|
|
|
func encryptRequest(resourcePath string, sendDate int64, tenant, token, body, contentType string) string {
|
|
if len(body) == 0 {
|
|
return ""
|
|
}
|
|
|
|
dateString := strconv.FormatInt(sendDate, 10)
|
|
|
|
// tenant
|
|
if len(resourcePath) != 0 {
|
|
resourcePath = "/" + resourcePath
|
|
}
|
|
|
|
sb3 := Md5(resourcePath+tenant+token+USER_TYPE) + dateString + CONTENT_ENCRYPTED + contentType
|
|
a2 := Md5(sb3)
|
|
a3 := Md5(dateString)
|
|
|
|
return Encrypt(body, a2, a3)
|
|
}
|
|
|
|
func calculateRequestVerification(
|
|
resourcePath string,
|
|
sendDate int64,
|
|
tenant, contentType, bodyEncrypted, token string,
|
|
) string {
|
|
dateString := strconv.FormatInt(sendDate, 10)
|
|
str9 := resourcePath + tenant + token + USER_TYPE
|
|
a2 := Md5(str9)
|
|
str10 := dateString + CONTENT_ENCRYPTED + contentType
|
|
a3 := Md5(a2 + str10)
|
|
str11 := resourcePath + tenant + token + USER_TYPE + dateString + CONTENT_ENCRYPTED + contentType + bodyEncrypted
|
|
|
|
a5 := Md5(a3 + dateString)
|
|
|
|
return HmacSha256(a5, str11)
|
|
}
|
|
|
|
func CreateRequest(baseUrl, path, httpMethod, request, contentType, token, eventId string) (*http.Request, error) {
|
|
sendDate := time.Now().UnixMilli()
|
|
|
|
endpoint := baseUrl + path
|
|
|
|
if len(request) != 0 {
|
|
request = encryptRequest(
|
|
path,
|
|
sendDate,
|
|
TENANT_ID,
|
|
token,
|
|
request,
|
|
contentType)
|
|
}
|
|
|
|
req, err := http.NewRequest(httpMethod, endpoint, bytes.NewReader([]byte(request)))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
Decorate(req)
|
|
req.Header.Set("app-send-date", strconv.FormatInt(sendDate, 10))
|
|
req.Header.Set("original-content-type", contentType)
|
|
|
|
if len(token) != 0 {
|
|
req.Header.Set("blade-auth", token)
|
|
}
|
|
if len(eventId) != 0 {
|
|
req.Header.Set("event-id", eventId)
|
|
}
|
|
|
|
replace := strings.Replace(endpoint, baseUrl, "/", -1)
|
|
|
|
req.Header.Set("app-verification-string",
|
|
calculateRequestVerification(
|
|
replace,
|
|
sendDate,
|
|
TENANT_ID,
|
|
contentType,
|
|
request,
|
|
token))
|
|
|
|
return req, nil
|
|
}
|
|
|
|
func decryptResponse(timeStamp, contentType, cipherText string) string {
|
|
if len(cipherText) == 0 {
|
|
return ""
|
|
}
|
|
|
|
str4 := timeStamp + CONTENT_ENCRYPTED + contentType
|
|
a2 := Md5(str4)
|
|
hashedTimeStamp := Md5(timeStamp)
|
|
|
|
return Decrypt(cipherText, a2, hashedTimeStamp)
|
|
}
|
|
|
|
func DecodeResponse(resp *http.Response) ([]byte, error) {
|
|
if resp.StatusCode != http.StatusOK {
|
|
return nil, errors.New(resp.Status)
|
|
}
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return body, err
|
|
}
|
|
|
|
if resp.Header.Get("app-content-encrypted") != "1" {
|
|
return body, nil
|
|
}
|
|
|
|
decoded := decryptResponse(
|
|
resp.Header.Get("app-send-date"),
|
|
resp.Header.Get("original-content-type"),
|
|
string(body))
|
|
|
|
return []byte(decoded), nil
|
|
}
|