Create & Init Project...

app/interface/main/report-click/service/crypto/aes/BUILD

@@ -0,0 +1,44 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["aes_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/report-click/service/crypto/padding:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["aes.go"],
+    importpath = "go-common/app/interface/main/report-click/service/crypto/aes",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/report-click/service/crypto/cipher:go_default_library",
+        "//app/interface/main/report-click/service/crypto/padding: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/report-click/service/crypto/aes/aes.go

@@ -0,0 +1,103 @@
+package aes
+
+import (
+	iaes "crypto/aes"
+	icipher "crypto/cipher"
+	"errors"
+
+	"go-common/app/interface/main/report-click/service/crypto/cipher"
+	"go-common/app/interface/main/report-click/service/crypto/padding"
+)
+
+var (
+	ErrAesBlockSize = errors.New("plaintext is not a multiple of the block size")
+	ErrAesSrcSize   = errors.New("ciphertext too short")
+	ErrAesIVSize    = errors.New("iv size is not a block size")
+)
+
+// ECBEncrypt aes ecb encrypt.
+func ECBEncrypt(src, key []byte, p padding.Padding) ([]byte, error) {
+	if p == nil {
+		if len(src) < iaes.BlockSize || len(src)%iaes.BlockSize != 0 {
+			return nil, ErrAesBlockSize
+		}
+	} else {
+		src = p.Padding(src, iaes.BlockSize)
+	}
+	b, err := iaes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	mode := cipher.NewECBEncrypter(b)
+	encryptText := make([]byte, len(src))
+	mode.CryptBlocks(encryptText, src)
+	return encryptText, nil
+}
+
+// ECBDecrypt aes ecb decrypt.
+func ECBDecrypt(src, key []byte, p padding.Padding) ([]byte, error) {
+	if len(src) < iaes.BlockSize || len(src)%iaes.BlockSize != 0 {
+		return nil, ErrAesSrcSize
+	}
+	b, err := iaes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	mode := cipher.NewECBDecrypter(b)
+	decryptText := make([]byte, len(src))
+	mode.CryptBlocks(decryptText, src)
+	if p == nil {
+		return decryptText, nil
+	} else {
+		return p.Unpadding(decryptText, iaes.BlockSize)
+	}
+}
+
+// CBCEncrypt aes cbc encrypt.
+func CBCEncrypt(src, key, iv []byte, p padding.Padding) ([]byte, error) {
+	// check iv
+	if len(iv) != iaes.BlockSize {
+		return nil, ErrAesIVSize
+	}
+	if p == nil {
+		// if no padding check src
+		if len(src) < iaes.BlockSize || len(src)%iaes.BlockSize != 0 {
+			return nil, ErrAesSrcSize
+		}
+	} else {
+		// padding
+		src = p.Padding(src, iaes.BlockSize)
+	}
+	block, err := iaes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	mode := icipher.NewCBCEncrypter(block, iv)
+	encryptText := make([]byte, len(src))
+	mode.CryptBlocks(encryptText, src)
+	return encryptText, nil
+}
+
+// CBCDecrypt aes cbc decrypt.
+func CBCDecrypt(src, key, iv []byte, p padding.Padding) ([]byte, error) {
+	// check src
+	if len(src) < iaes.BlockSize || len(src)%iaes.BlockSize != 0 {
+		return nil, ErrAesSrcSize
+	}
+	// check iv
+	if len(iv) != iaes.BlockSize {
+		return nil, ErrAesIVSize
+	}
+	block, err := iaes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	mode := icipher.NewCBCDecrypter(block, iv)
+	decryptText := make([]byte, len(src))
+	mode.CryptBlocks(decryptText, src)
+	if p == nil {
+		return decryptText, nil
+	} else {
+		return p.Unpadding(decryptText, iaes.BlockSize)
+	}
+}

app/interface/main/report-click/service/crypto/aes/aes_test.go

@@ -0,0 +1,24 @@
+package aes
+
+import (
+	"testing"
+
+	"go-common/app/interface/main/report-click/service/crypto/padding"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestAES(t *testing.T) {
+	var (
+		aesKey = ""
+		aesIv  = ""
+		bs     = []byte("this is  test massage ")
+	)
+	Convey("aes test ", t, func() {
+		bs, _ = CBCDecrypt(bs, []byte(aesKey), []byte(aesIv), padding.PKCS5)
+		ECBDecrypt(bs, []byte(aesKey), padding.PKCS5)
+		bs = []byte("this is  test massage ")
+		bs, _ = CBCEncrypt(bs, []byte(aesKey), []byte(aesIv), padding.PKCS5)
+		CBCDecrypt(bs, []byte(aesKey), []byte(aesIv), padding.PKCS5)
+	})
+}

app/interface/main/report-click/service/crypto/cipher/BUILD

@@ -0,0 +1,40 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_test",
+    "go_library",
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["ecb_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/report-click/service/crypto/padding:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["ecb.go"],
+    importpath = "go-common/app/interface/main/report-click/service/crypto/cipher",
+    tags = ["automanaged"],
+)
+
+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/report-click/service/crypto/cipher/ecb.go

@@ -0,0 +1,76 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Electronic Code Book (ECB) mode.
+
+// ECB provides confidentiality by assigning a fixed ciphertext block to each
+// plaintext block.
+
+// See NIST SP 800-38A, pp 08-09
+
+package cipher
+
+import (
+	"crypto/cipher"
+)
+
+type ecb struct {
+	b         cipher.Block
+	blockSize int
+}
+
+func newECB(b cipher.Block) *ecb {
+	return &ecb{
+		b:         b,
+		blockSize: b.BlockSize(),
+	}
+}
+
+type ecbEncrypter ecb
+
+// NewECBEncrypter returns a BlockMode which encrypts in electronic code book
+// mode, using the given Block.
+func NewECBEncrypter(b cipher.Block) cipher.BlockMode {
+	return (*ecbEncrypter)(newECB(b))
+}
+
+func (x *ecbEncrypter) BlockSize() int { return x.blockSize }
+
+func (x *ecbEncrypter) CryptBlocks(dst, src []byte) {
+	if len(src)%x.blockSize != 0 {
+		panic("crypto/cipher: input not full blocks")
+	}
+	if len(dst) < len(src) {
+		panic("crypto/cipher: output smaller than input")
+	}
+	for len(src) > 0 {
+		x.b.Encrypt(dst, src[:x.blockSize])
+		src = src[x.blockSize:]
+		dst = dst[x.blockSize:]
+	}
+}
+
+type ecbDecrypter ecb
+
+// NewECBDecrypter returns a BlockMode which decrypts in electronic code book
+// mode, using the given Block.
+func NewECBDecrypter(b cipher.Block) cipher.BlockMode {
+	return (*ecbDecrypter)(newECB(b))
+}
+
+func (x *ecbDecrypter) BlockSize() int { return x.blockSize }
+
+func (x *ecbDecrypter) CryptBlocks(dst, src []byte) {
+	if len(src)%x.blockSize != 0 {
+		panic("crypto/cipher: input not full blocks")
+	}
+	if len(dst) < len(src) {
+		panic("crypto/cipher: output smaller than input")
+	}
+	for len(src) > 0 {
+		x.b.Decrypt(dst, src[:x.blockSize])
+		src = src[x.blockSize:]
+		dst = dst[x.blockSize:]
+	}
+}

app/interface/main/report-click/service/crypto/cipher/ecb_test.go

@@ -0,0 +1,29 @@
+package cipher
+
+import (
+	iaes "crypto/aes"
+	"testing"
+
+	"go-common/app/interface/main/report-click/service/crypto/padding"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestECB(t *testing.T) {
+	var (
+		aesKey = "903ef9925be1300f843b41df2ca55410"
+		bs     = []byte("this is  test massage ")
+	)
+	Convey("cipher test ", t, func() {
+		var p = padding.PKCS5
+		bs = p.Padding(bs, iaes.BlockSize)
+		b, _ := iaes.NewCipher([]byte(aesKey))
+		ecbe := NewECBEncrypter(b)
+		encryptText := make([]byte, len(bs))
+		ecbe.CryptBlocks(encryptText, bs)
+		ecbd := NewECBDecrypter(b)
+		decryptText := make([]byte, len(bs))
+		ecbd.CryptBlocks(decryptText, bs)
+		p.Unpadding(bs, iaes.BlockSize)
+	})
+}

app/interface/main/report-click/service/crypto/padding/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 = ["pkcs5_test.go"],
+    embed = [":go_default_library"],
+    rundir = ".",
+    tags = ["automanaged"],
+    deps = [
+        "//app/interface/main/report-click/service/crypto/cipher:go_default_library",
+        "//vendor/github.com/smartystreets/goconvey/convey:go_default_library",
+    ],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "padding.go",
+        "pkcs5.go",
+    ],
+    importpath = "go-common/app/interface/main/report-click/service/crypto/padding",
+    tags = ["automanaged"],
+)
+
+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/report-click/service/crypto/padding/padding.go

@@ -0,0 +1,15 @@
+package padding
+
+import (
+	"errors"
+)
+
+var (
+	ErrPaddingSize = errors.New("pkcs5 padding size error")
+)
+
+// Padding is interface used for crypto.
+type Padding interface {
+	Padding(src []byte, blockSize int) []byte
+	Unpadding(src []byte, blockSize int) ([]byte, error)
+}

app/interface/main/report-click/service/crypto/padding/pkcs5.go

@@ -0,0 +1,30 @@
+package padding
+
+var (
+	PKCS5 = &pkcs5{}
+)
+
+// pkcs5Padding is a pkcs5 padding struct.
+type pkcs5 struct{}
+
+// Padding implements the Padding interface Padding method.
+func (p *pkcs5) Padding(src []byte, blockSize int) []byte {
+	srcLen := len(src)
+	padLen := byte(blockSize - (srcLen % blockSize))
+	pd := make([]byte, srcLen+int(padLen))
+	copy(pd, src)
+	for i := srcLen; i < len(pd); i++ {
+		pd[i] = padLen
+	}
+	return pd
+}
+
+// Unpadding implements the Padding interface Unpadding method.
+func (p *pkcs5) Unpadding(src []byte, blockSize int) ([]byte, error) {
+	srcLen := len(src)
+	paddingLen := int(src[srcLen-1])
+	if paddingLen >= srcLen || paddingLen > blockSize {
+		return nil, ErrPaddingSize
+	}
+	return src[:srcLen-paddingLen], nil
+}

app/interface/main/report-click/service/crypto/padding/pkcs5_test.go

@@ -0,0 +1,29 @@
+package padding
+
+import (
+	iaes "crypto/aes"
+	"testing"
+
+	"go-common/app/interface/main/report-click/service/crypto/cipher"
+
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestECB(t *testing.T) {
+	var (
+		aesKey = "903ef9925be1300f843b41df2ca55410"
+		bs     = []byte("this is  test massage ")
+	)
+	Convey("cipher test ", t, func() {
+		var p = PKCS5
+		bs = p.Padding(bs, iaes.BlockSize)
+		b, _ := iaes.NewCipher([]byte(aesKey))
+		ecbe := cipher.NewECBEncrypter(b)
+		encryptText := make([]byte, len(bs))
+		ecbe.CryptBlocks(encryptText, bs)
+		ecbd := cipher.NewECBDecrypter(b)
+		decryptText := make([]byte, len(bs))
+		ecbd.CryptBlocks(decryptText, bs)
+		p.Unpadding(bs, iaes.BlockSize)
+	})
+}