Create & Init Project...

app/interface/main/account/service/realname/crypto/BUILD

@@ -0,0 +1,43 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["crypto_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = ["//vendor/github.com/smartystreets/goconvey/convey:go_default_library"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "alipay.go",
+        "key.go",
+        "main.go",
+    ],
+    importpath = "go-common/app/interface/main/account/service/realname/crypto",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = ["//vendor/github.com/pkg/errors:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/interface/main/account/service/realname/crypto/alipay.go

@@ -0,0 +1,123 @@
+package crypto
+
+import (
+	stdcrypto "crypto"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/base64"
+	"encoding/pem"
+	"net/url"
+	"sort"
+	"strings"
+
+	"github.com/pkg/errors"
+)
+
+// Alipay alipay cryptor
+type Alipay struct {
+	aliPub   []byte
+	biliPriv []byte
+}
+
+// NewAlipay is.
+func NewAlipay(aliPub, biliPriv string) (a *Alipay) {
+	return &Alipay{
+		aliPub:   ParsePublicKey(aliPub),
+		biliPriv: ParsePrivateKey(biliPriv),
+	}
+}
+
+func (e *Alipay) splitData(originalData []byte, packageSize int) (r [][]byte) {
+	var src = make([]byte, len(originalData))
+	copy(src, originalData)
+
+	r = make([][]byte, 0)
+	if len(src) <= packageSize {
+		return append(r, src)
+	}
+	for len(src) > 0 {
+		var p = src[:packageSize]
+		r = append(r, p)
+		src = src[packageSize:]
+		if len(src) <= packageSize {
+			r = append(r, src)
+			break
+		}
+	}
+	return r
+}
+
+// EncryptParam rsa encrypt.
+func (e *Alipay) EncryptParam(p url.Values) (ep string, err error) {
+	var (
+		pubInterface interface{}
+		pub          *rsa.PublicKey
+		data         []byte
+		block        *pem.Block
+	)
+	block, _ = pem.Decode(e.aliPub)
+	if block == nil {
+		err = errors.New("private key error")
+		return
+	}
+	if pubInterface, err = x509.ParsePKIXPublicKey(block.Bytes); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	pub = pubInterface.(*rsa.PublicKey)
+	var sd = e.splitData([]byte(p.Encode()), pub.N.BitLen()/8-11)
+	for _, d := range sd {
+		var pd []byte
+		if pd, err = rsa.EncryptPKCS1v15(rand.Reader, pub, d); err != nil {
+			err = errors.WithStack(err)
+			return
+		}
+		data = append(data, pd...)
+	}
+	ep = base64.StdEncoding.EncodeToString(data)
+	return
+}
+
+// SignParam sign alipay param
+func (e *Alipay) SignParam(p url.Values) (sign string, err error) {
+	if p == nil {
+		p = make(url.Values)
+	}
+	var pList = make([]string, 0)
+	for key := range p {
+		var value = strings.TrimSpace(p.Get(key))
+		if len(value) > 0 {
+			pList = append(pList, key+"="+value)
+		}
+	}
+	sort.Strings(pList)
+	var src = strings.Join(pList, "&")
+
+	var h = stdcrypto.SHA256.New()
+	if _, err = h.Write([]byte(src)); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	var (
+		hashed = h.Sum(nil)
+		pri    *rsa.PrivateKey
+		data   []byte
+		block  *pem.Block
+	)
+	block, _ = pem.Decode(e.biliPriv)
+	if block == nil {
+		err = errors.New("private key error")
+		return
+	}
+	if pri, err = x509.ParsePKCS1PrivateKey(block.Bytes); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if data, err = rsa.SignPKCS1v15(rand.Reader, pri, stdcrypto.SHA256, hashed); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	sign = base64.StdEncoding.EncodeToString(data)
+	return
+}

app/interface/main/account/service/realname/crypto/crypto_test.go

@@ -0,0 +1,40 @@
+package crypto
+
+import (
+	"bytes"
+	"fmt"
+	"testing"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+var (
+	rsaBase64 = make([]byte, 1000)
+	aesBase64 = make([]byte, 5000000)
+)
+
+func TestEncrypt(t *testing.T) {
+	Convey("encrypt", t, func() {
+		// TODO
+	})
+}
+
+func BenchmarkBytesByFMT(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_ = fmt.Sprintf("%04x%s%s", len(rsaBase64), rsaBase64, aesBase64)
+	}
+}
+
+func BenchmarkBytesByBuffer(b *testing.B) {
+	var buf bytes.Buffer
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		fmt.Fprintf(&buf, "%04x", len(rsaBase64))
+		buf.Write(rsaBase64)
+		buf.Write(aesBase64)
+		b.StopTimer()
+		buf.Reset()
+		b.StartTimer()
+		_ = buf.Bytes()
+	}
+}

app/interface/main/account/service/realname/crypto/key.go

@@ -0,0 +1,47 @@
+package crypto
+
+import (
+	"bytes"
+	"strings"
+)
+
+// ParsePublicKey parse raw public key to pem formation
+func ParsePublicKey(raw string) (result []byte) {
+	return parseKey(raw, "-----BEGIN PUBLIC KEY-----", "-----END PUBLIC KEY-----")
+}
+
+// ParsePrivateKey parse raw priv key to pem formation
+func ParsePrivateKey(raw string) (result []byte) {
+	return parseKey(raw, "-----BEGIN RSA PRIVATE KEY-----", "-----END RSA PRIVATE KEY-----")
+}
+
+func parseKey(raw, prefix, suffix string) (result []byte) {
+	raw = strings.Replace(raw, prefix, "", 1)
+	raw = strings.Replace(raw, suffix, "", 1)
+	raw = strings.Replace(raw, " ", "", -1)
+	raw = strings.Replace(raw, "\n", "", -1)
+	raw = strings.Replace(raw, "\r", "", -1)
+	raw = strings.Replace(raw, "\t", "", -1)
+
+	var ll = 64
+	var sl = len(raw)
+	var c = sl / ll
+	if sl%ll > 0 {
+		c = c + 1
+	}
+
+	var buf bytes.Buffer
+	buf.WriteString(prefix + "\n")
+	for i := 0; i < c; i++ {
+		var b = i * ll
+		var e = b + ll
+		if e > sl {
+			buf.WriteString(raw[b:])
+		} else {
+			buf.WriteString(raw[b:e])
+		}
+		buf.WriteString("\n")
+	}
+	buf.WriteString(suffix)
+	return buf.Bytes()
+}

app/interface/main/account/service/realname/crypto/main.go

@@ -0,0 +1,208 @@
+package crypto
+
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/md5"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/pem"
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+// const .
+const (
+	BlockSizeMIN = 16 // AES-128
+	BlockSizeMID = 24 // AES-192
+	BlockSizeMAX = 32 // AES-256
+)
+
+// Main mainsite cryptor
+type Main struct {
+	publicKey, privateKey []byte
+}
+
+// NewMain is.
+func NewMain(pub, priv string) (e *Main) {
+	return &Main{
+		publicKey:  []byte(pub),
+		privateKey: []byte(priv),
+	}
+}
+
+// IMGEncrypt rsa + AES-128
+func (e *Main) IMGEncrypt(raw []byte) (data []byte, err error) {
+	if len(raw) == 0 {
+		return
+	}
+	var (
+		hash             = md5.New()
+		randToken        []byte
+		rsaData, aesData []byte
+		aesBase64        []byte
+		rsaBase64Str     string
+		buf              bytes.Buffer
+	)
+	if _, err = hash.Write([]byte(strconv.FormatInt(time.Now().UnixNano(), 10))); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	randToken = []byte(hex.EncodeToString(hash.Sum(nil)))
+	if rsaData, err = e.RsaEncrypt(randToken); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if aesData, err = e.AESEncrypt(randToken, raw, BlockSizeMIN); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	rsaBase64Str = base64.StdEncoding.EncodeToString(rsaData)
+	aesBase64 = make([]byte, base64.StdEncoding.EncodedLen(len(aesData)))
+	base64.StdEncoding.Encode(aesBase64, aesData)
+
+	fmt.Fprintf(&buf, "%04x", len(rsaBase64Str))
+	buf.Write([]byte(rsaBase64Str))
+	buf.Write(aesBase64)
+	data = buf.Bytes()
+	return
+}
+
+// IMGDecrypt rsa + AES-128
+func (e *Main) IMGDecrypt(raw []byte) (data []byte, err error) {
+	if len(raw) == 0 {
+		return
+	}
+	var (
+		rsaLen            int64
+		rsaRandToken      []byte
+		randToken         []byte
+		aesBase64         []byte
+		aesData           []byte
+		base64DecodedSize int
+	)
+	if rsaLen, err = strconv.ParseInt(string(raw[:4]), 16, 64); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if rsaRandToken, err = base64.StdEncoding.DecodeString(string(raw[4 : 4+rsaLen])); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if randToken, err = e.RsaDecrypt(rsaRandToken); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	aesBase64 = raw[4+rsaLen:]
+	aesData = make([]byte, base64.StdEncoding.DecodedLen(len(aesBase64)))
+	if base64DecodedSize, err = base64.StdEncoding.Decode(aesData, aesBase64); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if data, err = e.AESDecrypt(randToken, aesData[:base64DecodedSize], BlockSizeMIN); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+// RsaEncrypt rsa encrypt.
+func (e *Main) RsaEncrypt(text []byte) (data []byte, err error) {
+	var (
+		block *pem.Block
+	)
+	block, _ = pem.Decode(e.publicKey)
+	if block == nil {
+		return nil, errors.New("public key error")
+	}
+	var (
+		pubInterface interface{}
+		pub          *rsa.PublicKey
+	)
+	if pubInterface, err = x509.ParsePKIXPublicKey(block.Bytes); err != nil {
+		err = errors.WithStack(err)
+		return nil, err
+	}
+	pub = pubInterface.(*rsa.PublicKey)
+	if data, err = rsa.EncryptPKCS1v15(rand.Reader, pub, text); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+// RsaDecrypt rsa decrypt.
+func (e *Main) RsaDecrypt(text []byte) (data []byte, err error) {
+	var (
+		block *pem.Block
+	)
+	block, _ = pem.Decode(e.privateKey)
+	if block == nil {
+		return nil, errors.New("private key error")
+	}
+	var (
+		privateKey *rsa.PrivateKey
+	)
+	if privateKey, err = x509.ParsePKCS1PrivateKey(block.Bytes); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	if data, err = rsa.DecryptPKCS1v15(rand.Reader, privateKey, text); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	return
+}
+
+// AESEncrypt AES-128, AES-192, or AES-256 encrypt.
+// mod 16, 24, or 32 bytes
+func (e *Main) AESEncrypt(key, text []byte, mod int) (data []byte, err error) {
+	var (
+		block cipher.Block
+	)
+	if block, err = aes.NewCipher(key[:mod]); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	msg := pkPadding(text, block.BlockSize())
+	ciphertext := make([]byte, len(msg))
+	cbc := cipher.NewCBCEncrypter(block, key[mod:])
+	cbc.CryptBlocks(ciphertext, []byte(msg))
+	return ciphertext, nil
+}
+
+// AESDecrypt AES-128, AES-192, or AES-256 decrypt.
+// mod 16, 24, or 32 bytes
+func (e *Main) AESDecrypt(key, text []byte, mod int) (data []byte, err error) {
+	var (
+		block cipher.Block
+	)
+	if block, err = aes.NewCipher(key[:mod]); err != nil {
+		err = errors.WithStack(err)
+		return
+	}
+	blockModel := cipher.NewCBCDecrypter(block, key[mod:])
+	ciphertext := make([]byte, len(text))
+	blockModel.CryptBlocks(ciphertext, text)
+	ciphertext = pkUnPadding(ciphertext)
+	return ciphertext, nil
+}
+
+func pkPadding(src []byte, blockSize int) []byte {
+	padding := blockSize - len(src)%blockSize
+	padtext := bytes.Repeat([]byte{byte(0)}, padding)
+	return append(src, padtext...)
+}
+
+func pkUnPadding(src []byte) []byte {
+	length := len(src)
+	unpadding := int(src[length-1])
+	return src[:(length - unpadding)]
+}