第一版

-package common
+package socialwork_sdk
 
 
 import (
 import (
 	"bytes"
 	"bytes"
@@ -7,7 +7,7 @@ import (
 	"encoding/base64"
 	"encoding/base64"
 )
 )
 
 
-func Aes_CBC_Decrypt(crypted []byte, key, iv []byte) ([]byte, error) {
+func aes_CBC_Decrypt(crypted []byte, key, iv []byte) ([]byte, error) {
 	block, err := aes.NewCipher(key)
 	block, err := aes.NewCipher(key)
 	if err != nil {
 	if err != nil {
 		return nil, err
 		return nil, err
@@ -26,7 +26,7 @@ func unpadding(cipherText []byte) []byte {
 	return cipherText
 	return cipherText
 }
 }
 
 
-func Aes_CBC_Encrypt(data []byte, key, iv []byte) (string, error) {
+func aes_CBC_Encrypt(data []byte, key, iv []byte) (string, error) {
 	block, err := aes.NewCipher(key)
 	block, err := aes.NewCipher(key)
 	if err != nil {
 	if err != nil {
 		return "", err
 		return "", err

+package socialwork_sdk
+
+const (
+	orderUrl = "socialwork/v1/external/atandard"
+)

+package socialwork_sdk
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/http/cookiejar"
+	"strings"
+)
+
+const (
+	post = "POST"
+	get  = "GET"
+	put  = "PUT"
+)
+
+func makeHttpRequestV4(method, url string, headers map[string]string, entity map[string]interface{}, jar *cookiejar.Jar) (string, int, error) {
+	var body io.Reader
+	var err error
+
+	if entity != nil {
+		switch method {
+		case post, put:
+			if len(entity) == 1 && entity["jsonbody"] != nil {
+				jsonBody, ok := entity["jsonbody"].(string)
+				if ok {
+					body = bytes.NewBuffer([]byte(jsonBody))
+				}
+			} else {
+				b, err := json.Marshal(entity)
+				if err != nil {
+					return "", 0, err
+				}
+
+				b = bytes.Replace(b, []byte("\\u003c"), []byte("<"), -1)
+				b = bytes.Replace(b, []byte("\\u003e"), []byte(">"), -1)
+				b = bytes.Replace(b, []byte("\\u0026"), []byte("&"), -1)
+
+				body = bytes.NewBuffer(b)
+			}
+
+		case get:
+			if len(entity) > 0 {
+				params := make([]string, len(entity))
+				index := 0
+				for k, v := range entity {
+					_v := fmt.Sprintf("%v", v)
+					params[index] = fmt.Sprintf("%s=%v", k, _v)
+					index++
+				}
+				queryStr := strings.Join(params, "&")
+				url = fmt.Sprintf("%s?%s", url, queryStr)
+			}
+		}
+	}
+
+	req, err := http.NewRequest(method, url, body)
+	if err != nil {
+		return "", 0, err
+	}
+	// set the http request header
+	for key, value := range headers {
+		req.Header.Set(key, value)
+	}
+	if entity != nil && (method == post || method == put) {
+		req.Header.Set("Content-Type", "application/json;charset=utf-8")
+		req.Header.Set("Accept", "application/json")
+	}
+	req.Header.Add("Connection", "close")
+	req.Header.Set("User-Agent", "Mozilla/5.0 (X11; Linux i686; U;) Gecko/20070322 Kazehakase/0.4.5")
+
+	//跳过证书验证
+	//	tr := &http.Transport{
+	//		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+	//	}
+	client := http.DefaultClient
+	if jar != nil {
+		client = &http.Client{
+			Jar: jar,
+		}
+	}
+	//	client.Transport = tr
+
+	fmt.Printf("xuht================Request: %+v\n", *req)
+	res, err := client.Do(req)
+	if err != nil {
+		fmt.Println("faild to do the request with error ", err)
+		return "", 0, err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != http.StatusOK && res.StatusCode != http.StatusCreated && res.StatusCode != http.StatusNoContent {
+		resBody, _ := ioutil.ReadAll(res.Body)
+		fmt.Println("code is not 200 ", res.StatusCode, string(resBody))
+		return "", 0, errors.New("http request failed to call")
+	}
+	resBody, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		fmt.Println("could not read the response body")
+		return "", 0, errors.New("the response could not be read")
+	}
+
+	return string(resBody), res.StatusCode, nil
+}

+package model
+
+type OrderModel struct {
+	Data         string `json:"data"`
+	Sign         string `json:"sign"`
+	PtCode       string `json:"pt_code"`
+	BusinessCode string `json:"business_code"`
+}

 package socialwork_sdk
 package socialwork_sdk
 
 
 import (
 import (
+	"encoding/base64"
 	"encoding/json"
 	"encoding/json"
-	"gitlab.workai.com.cn/chenang/socialwork-sdk/common"
+	"gitlab.workai.com.cn/chenang/socialwork-sdk/model"
 	"log"
 	"log"
 )
 )
 
 
@@ -11,26 +12,28 @@ type OrderClient struct {
 	IV                 string `json:"iv"`
 	IV                 string `json:"iv"`
 	PublicKey          string `json:"public_key"`
 	PublicKey          string `json:"public_key"`
 	CustomerPrivateKey string `json:"customer_private_key"`
 	CustomerPrivateKey string `json:"customer_private_key"`
+	PtCode             string `json:"pt_code"`
+	IP                 string `json:"ip"`
 }
 }
 
 
-func NewOrderClient(key, iv, customerPrivateKey, publicKey string) *OrderClient {
+func NewOrderClient(key, iv, customerPrivateKey, publicKey, ip string) *OrderClient {
 	return &OrderClient{
 	return &OrderClient{
 		Key:                key,
 		Key:                key,
 		IV:                 iv,
 		IV:                 iv,
 		PublicKey:          publicKey,
 		PublicKey:          publicKey,
 		CustomerPrivateKey: customerPrivateKey,
 		CustomerPrivateKey: customerPrivateKey,
+		IP:                 ip,
 	}
 	}
 }
 }
 
 
-func (o *OrderClient) EncryptAndSign(res interface{}) (string, string, error) {
-	bs, _ := json.Marshal(res)
-	cipherText, err := common.Aes_CBC_Encrypt(bs, []byte(o.Key), []byte(o.IV))
+func (o *OrderClient) EncryptAndSign(bs []byte) (string, string, error) {
+	cipherText, err := aes_CBC_Encrypt(bs, []byte(o.Key), []byte(o.IV))
 	if err != nil {
 	if err != nil {
 		log.Printf("Aes_CBC_Encrypt.failed.err=%v\n", err)
 		log.Printf("Aes_CBC_Encrypt.failed.err=%v\n", err)
 		return "", "", err
 		return "", "", err
 	}
 	}
 
 
-	sign, err := common.RsaSignWithMd5Hex(cipherText, o.CustomerPrivateKey)
+	sign, err := rsaSignWithMd5Hex(cipherText, o.CustomerPrivateKey)
 	if err != nil {
 	if err != nil {
 		log.Printf("RsaSignWithMd5Hex.failed.err=%v\n", err)
 		log.Printf("RsaSignWithMd5Hex.failed.err=%v\n", err)
 		return "", "", err
 		return "", "", err
@@ -38,6 +41,52 @@ func (o *OrderClient) EncryptAndSign(res interface{}) (string, string, error) {
 	return cipherText, sign, nil
 	return cipherText, sign, nil
 }
 }
 
 
-func (o *OrderClient) PrintVersion() string {
-	return "1.0"
+func (o *OrderClient) DecryptAndVerySign(cipherText, sign string) ([]byte, error) {
+	_cipherText, err := base64.StdEncoding.DecodeString(cipherText)
+	if err != nil {
+		return nil, err
+	}
+	err = rsaVerifySignWithMd5Base64(cipherText, sign, o.PublicKey)
+	if err != nil {
+		return nil, err
+	}
+	content, err := aes_CBC_Decrypt(_cipherText, []byte(o.Key), []byte(o.IV))
+	if err != nil {
+		return nil, err
+	}
+	return content, nil
+}
+
+func (o *OrderClient) SendRequest(businessCode, reqBody string) (string, error) {
+	//校验参数 reqbody
+	checkErr := o.checkParams(businessCode, reqBody)
+	if checkErr != nil {
+		return "", checkErr
+	}
+	cipherText, sign, err := o.EncryptAndSign([]byte(reqBody))
+	if err != nil {
+		return "", err
+	}
+
+	orderModel := model.OrderModel{
+		Data:         cipherText,
+		Sign:         sign,
+		PtCode:       o.PtCode,
+		BusinessCode: businessCode,
+	}
+
+	_orderModel, err := json.Marshal(orderModel)
+	if err != nil {
+		return "", err
+	}
+	respBody, _, err := makeHttpRequestV4(post, o.IP+orderUrl, nil, map[string]interface{}{"jsonbody": string(_orderModel)}, nil)
+	if err != nil {
+		return "", err
+	}
+
+	return respBody, nil
+}
+
+func (o *OrderClient) checkParams(businessCode, reqBody string) error {
+	return nil
 }
 }

-package common
+package socialwork_sdk
 
 
 import (
 import (
 	"crypto"
 	"crypto"
@@ -10,7 +10,7 @@ import (
 	"encoding/pem"
 	"encoding/pem"
 )
 )
 
 
-func RsaSignWithMd5Hex(data string, prvKey string) (string, error) {
+func rsaSignWithMd5Hex(data string, prvKey string) (string, error) {
 	block, _ := pem.Decode([]byte(prvKey))
 	block, _ := pem.Decode([]byte(prvKey))
 	privateKey, err := x509.ParsePKCS8PrivateKey(block.Bytes)
 	privateKey, err := x509.ParsePKCS8PrivateKey(block.Bytes)
 	if err != nil {
 	if err != nil {
@@ -29,3 +29,22 @@ func RsaSignWithMd5Hex(data string, prvKey string) (string, error) {
 	out := base64.StdEncoding.EncodeToString(signature)
 	out := base64.StdEncoding.EncodeToString(signature)
 	return out, nil
 	return out, nil
 }
 }
+
+func rsaVerifySignWithMd5Base64(originalData, signData, pubKey string) error {
+	sign, err := base64.StdEncoding.DecodeString(signData)
+	if err != nil {
+		return err
+	}
+	block, _ := pem.Decode([]byte(pubKey))
+	pub, err := x509.ParsePKIXPublicKey(block.Bytes)
+	if err != nil {
+		return err
+	}
+	hash := md5.New()
+	hash.Write([]byte(originalData))
+	err = rsa.VerifyPKCS1v15(pub.(*rsa.PublicKey), crypto.MD5, hash.Sum(nil), sign)
+	if err != nil {
+		return err
+	}
+	return nil
+}