publish lancet

cryptor/aes.go

@@ -0,0 +1,168 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package cryptor implements some util functions to encrypt and decrypt.
+// Note:
+// 1. for aes crypt function, the `key` param length should be 16, 24 or 32. if not, will panic.
+package cryptor
+
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"io"
+)
+
+// AesEcbEncrypt encrypt data with key use AES ECB algorithm
+// len(key) should be 16, 24 or 32
+func AesEcbEncrypt(data, key []byte) []byte {
+	cipher, _ := aes.NewCipher(generateAesKey(key))
+	length := (len(data) + aes.BlockSize) / aes.BlockSize
+	plain := make([]byte, length*aes.BlockSize)
+	copy(plain, data)
+	pad := byte(len(plain) - len(data))
+	for i := len(data); i < len(plain); i++ {
+		plain[i] = pad
+	}
+	encrypted := make([]byte, len(plain))
+	for bs, be := 0, cipher.BlockSize(); bs <= len(data); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
+		cipher.Encrypt(encrypted[bs:be], plain[bs:be])
+	}
+
+	return encrypted
+}
+
+// AesEcbDecrypt decrypt data with key use AES ECB algorithm
+// len(key) should be 16, 24 or 32
+func AesEcbDecrypt(encrypted, key []byte) []byte {
+	cipher, _ := aes.NewCipher(generateAesKey(key))
+	decrypted := make([]byte, len(encrypted))
+	//
+	for bs, be := 0, cipher.BlockSize(); bs < len(encrypted); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
+		cipher.Decrypt(decrypted[bs:be], encrypted[bs:be])
+	}
+
+	trim := 0
+	if len(decrypted) > 0 {
+		trim = len(decrypted) - int(decrypted[len(decrypted)-1])
+	}
+
+	return decrypted[:trim]
+}
+
+// AesCbcEncrypt encrypt data with key use AES CBC algorithm
+// len(key) should be 16, 24 or 32
+func AesCbcEncrypt(data, key []byte) []byte {
+	// len(key) should be 16, 24 or 32
+	block, _ := aes.NewCipher(key)
+	blockSize := block.BlockSize()
+	data = pkcs7Padding(data, blockSize)
+	blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])
+
+	encrypted := make([]byte, len(data))
+	blockMode.CryptBlocks(encrypted, data)
+	return encrypted
+}
+
+// AesEcbDecrypt decrypt data with key use AES CBC algorithm
+// len(key) should be 16, 24 or 32
+func AesCbcDecrypt(encrypted, key []byte) []byte {
+	block, _ := aes.NewCipher(key)
+	blockSize := block.BlockSize()
+	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])
+
+	decrypted := make([]byte, len(encrypted))
+	blockMode.CryptBlocks(decrypted, encrypted)
+	decrypted = pkcs7UnPadding(decrypted)
+	return decrypted
+}
+
+// AesCtrCrypt encrypt data with key use AES CTR algorithm
+// len(key) should be 16, 24 or 32
+func AesCtrCrypt(data, key []byte) []byte {
+	block, _ := aes.NewCipher(key)
+
+	iv := bytes.Repeat([]byte("1"), block.BlockSize())
+	stream := cipher.NewCTR(block, iv)
+
+	dst := make([]byte, len(data))
+	stream.XORKeyStream(dst, data)
+
+	return dst
+}
+
+// AesCfbEncrypt encrypt data with key use AES CFB algorithm
+// len(key) should be 16, 24 or 32
+func AesCfbEncrypt(data, key []byte) []byte {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+
+	encrypted := make([]byte, aes.BlockSize+len(data))
+	iv := encrypted[:aes.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic(err)
+	}
+
+	stream := cipher.NewCFBEncrypter(block, iv)
+	stream.XORKeyStream(encrypted[aes.BlockSize:], data)
+	return encrypted
+}
+
+// AesCfbDecrypt decrypt data with key use AES CFB algorithm
+// len(encrypted) should be great than 16, len(key) should be 16, 24 or 32
+func AesCfbDecrypt(encrypted, key []byte) []byte {
+	block, _ := aes.NewCipher(key)
+	if len(encrypted) < aes.BlockSize {
+		panic("encrypted data is too short")
+	}
+	iv := encrypted[:aes.BlockSize]
+	encrypted = encrypted[aes.BlockSize:]
+
+	stream := cipher.NewCFBDecrypter(block, iv)
+	stream.XORKeyStream(encrypted, encrypted)
+	return encrypted
+}
+
+// AesOfbEncrypt encrypt data with key use AES OFB algorithm
+// len(key) should be 16, 24 or 32
+func AesOfbEncrypt(data, key []byte) []byte {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+	data = pkcs7Padding(data, aes.BlockSize)
+	encrypted := make([]byte, aes.BlockSize+len(data))
+	iv := encrypted[:aes.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic(err)
+	}
+
+	stream := cipher.NewOFB(block, iv)
+	stream.XORKeyStream(encrypted[aes.BlockSize:], data)
+	return encrypted
+}
+
+// AesOfbDecrypt decrypt data with key use AES OFB algorithm
+// len(key) should be 16, 24 or 32
+func AesOfbDecrypt(data, key []byte) []byte {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+
+	iv := data[:aes.BlockSize]
+	data = data[aes.BlockSize:]
+	if len(data)%aes.BlockSize != 0 {
+		return nil
+	}
+
+	decrypted := make([]byte, len(data))
+	mode := cipher.NewOFB(block, iv)
+	mode.XORKeyStream(decrypted, data)
+
+	decrypted = pkcs7UnPadding(decrypted)
+	return decrypted
+}

cryptor/aes_test.go

@@ -0,0 +1,72 @@
+package cryptor
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/utils"
+)
+
+func TestAesEcbEncrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefghijklmnop"
+
+	aesEcbEncrypt := AesEcbEncrypt([]byte(data), []byte(key))
+	aesEcbDecrypt := AesEcbDecrypt(aesEcbEncrypt, []byte(key))
+
+	if string(aesEcbDecrypt) != data {
+		utils.LogFailedTestInfo(t, "AesEcbEncrypt/AesEcbDecrypt", data, data, string(aesEcbDecrypt))
+		t.FailNow()
+	}
+}
+
+func TestAesCbcEncrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefghijklmnop"
+
+	aesCbcEncrypt := AesCbcEncrypt([]byte(data), []byte(key))
+	aesCbcDecrypt := AesCbcDecrypt(aesCbcEncrypt, []byte(key))
+
+	if string(aesCbcDecrypt) != data {
+		utils.LogFailedTestInfo(t, "AesCbcEncrypt/AesCbcDecrypt", data, data, string(aesCbcDecrypt))
+		t.FailNow()
+	}
+}
+
+func TestAesCtrCrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefghijklmnop"
+
+	aesCtrCrypt := AesCtrCrypt([]byte(data), []byte(key))
+	aesCtrDeCrypt := AesCtrCrypt(aesCtrCrypt, []byte(key))
+
+	if string(aesCtrDeCrypt) != data {
+		utils.LogFailedTestInfo(t, "AesCtrCrypt", data, data, string(aesCtrDeCrypt))
+		t.FailNow()
+	}
+}
+
+func TestAesCfbEncrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefghijklmnop"
+
+	aesCfbEncrypt := AesCfbEncrypt([]byte(data), []byte(key))
+	aesCfbDecrypt := AesCfbDecrypt(aesCfbEncrypt, []byte(key))
+
+	if string(aesCfbDecrypt) != data {
+		utils.LogFailedTestInfo(t, "AesCfbEncrypt/AesCfbDecrypt", data, data, string(aesCfbDecrypt))
+		t.FailNow()
+	}
+}
+
+func TestAesOfbEncrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefghijklmnop"
+
+	aesOfbEncrypt := AesOfbEncrypt([]byte(data), []byte(key))
+	aesOfbDecrypt := AesOfbDecrypt(aesOfbEncrypt, []byte(key))
+
+	if string(aesOfbDecrypt) != data {
+		utils.LogFailedTestInfo(t, "AesOfbEncrypt/AesOfbDecrypt", data, data, string(aesOfbDecrypt))
+		t.FailNow()
+	}
+}

cryptor/basic.go

@@ -0,0 +1,96 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package cryptor implements some util functions to encrypt and decrypt.
+// Contain base64, hmac, sha, aes, des, and rsa
+package cryptor
+
+import (
+	"crypto/hmac"
+	"crypto/md5"
+	"crypto/sha1"
+	"crypto/sha256"
+	"crypto/sha512"
+	"encoding/base64"
+	"encoding/hex"
+	"io/ioutil"
+)
+
+// Base64StdEncode encode string with base64 encoding
+func Base64StdEncode(s string) string {
+	return base64.StdEncoding.EncodeToString([]byte(s))
+}
+
+// Base64StdEncode decode a base64 encoded string
+func Base64StdDecode(s string) string {
+	b, _ := base64.StdEncoding.DecodeString(s)
+	return string(b)
+}
+
+// Md5Str return the md5 value of string
+func Md5String(s string) string {
+	h := md5.New()
+	h.Write([]byte(s))
+	return hex.EncodeToString(h.Sum(nil))
+}
+
+// Md5File return the md5 value of file
+func Md5File(filename string) (string, error) {
+	f, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return "", err
+	}
+
+	h := md5.New()
+	h.Write(f)
+	return hex.EncodeToString(h.Sum(nil)), nil
+}
+
+// HmacMd5 return the hmac hash of string use md5
+func HmacMd5(data, key string) string {
+	h := hmac.New(md5.New, []byte(key))
+	h.Write([]byte(data))
+	return hex.EncodeToString(h.Sum([]byte("")))
+}
+
+// HmacSha1 return the hmac hash of string use sha1
+func HmacSha1(data, key string) string {
+	h := hmac.New(sha1.New, []byte(key))
+	h.Write([]byte(data))
+	return hex.EncodeToString(h.Sum([]byte("")))
+}
+
+// HmacSha256 return the hmac hash of string use sha256
+func HmacSha256(data, key string) string {
+	h := hmac.New(sha256.New, []byte(key))
+	h.Write([]byte(data))
+	return hex.EncodeToString(h.Sum([]byte("")))
+}
+
+// HmacSha512 return the hmac hash of string use sha512
+func HmacSha512(data, key string) string {
+	h := hmac.New(sha512.New, []byte(key))
+	h.Write([]byte(data))
+	return hex.EncodeToString(h.Sum([]byte("")))
+}
+
+// Sha1 return the sha1 value (SHA-1 hash algorithm) of string
+func Sha1(data string) string {
+	sha1 := sha1.New()
+	sha1.Write([]byte(data))
+	return hex.EncodeToString(sha1.Sum([]byte("")))
+}
+
+// Sha256 return the sha256 value (SHA256 hash algorithm) of string
+func Sha256(data string) string {
+	sha256 := sha256.New()
+	sha256.Write([]byte(data))
+	return hex.EncodeToString(sha256.Sum([]byte("")))
+}
+
+// Sha512 return the sha512 value (SHA512 hash algorithm) of string
+func Sha512(data string) string {
+	sha512 := sha512.New()
+	sha512.Write([]byte(data))
+	return hex.EncodeToString(sha512.Sum([]byte("")))
+}

cryptor/basic_test.go

@@ -0,0 +1,133 @@
+package cryptor
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/duke-git/lancet/utils"
+)
+
+func TestBase64StdEncode(t *testing.T) {
+	s := "hello world"
+	bs := Base64StdEncode(s)
+
+	if bs != "aGVsbG8gd29ybGQ=" {
+		utils.LogFailedTestInfo(t, "Base64StdEncode", s, "aGVsbG8gd29ybGQ=", bs)
+		t.FailNow()
+	}
+}
+
+func TestBase64StdDecode(t *testing.T) {
+	bs := "aGVsbG8gd29ybGQ="
+	s := Base64StdDecode(bs)
+
+	if s != "hello world" {
+		utils.LogFailedTestInfo(t, "Base64StdDecode", bs, "hello world=", s)
+		t.FailNow()
+	}
+}
+
+func TestMd5String(t *testing.T) {
+	s := "hello"
+	smd5 := Md5String(s)
+	expected := "5d41402abc4b2a76b9719d911017c592"
+
+	if smd5 != expected {
+		utils.LogFailedTestInfo(t, "Md5String", s, expected, smd5)
+		t.FailNow()
+	}
+}
+
+func TestMd5File(t *testing.T) {
+	file, _ := os.Create("./hello.txt")
+	defer file.Close()
+	file.WriteString("hello\n")
+
+	fileMd5, err := Md5File("./hello.txt")
+	if err != nil {
+		t.FailNow()
+	}
+	fmt.Println(fileMd5)
+}
+
+func TestHmacMd5(t *testing.T) {
+	s := "hello world"
+	key := "12345"
+	hmacMd5 := HmacMd5(s, key)
+	expected := "5f4c9faaff0a1ad3007d9ddc06abe36d"
+
+	if hmacMd5 != expected {
+		utils.LogFailedTestInfo(t, "HmacMd5", s, expected, hmacMd5)
+		t.FailNow()
+	}
+}
+
+func TestHmacSha1(t *testing.T) {
+	s := "hello world"
+	key := "12345"
+	hmacSha1 := HmacSha1(s, key)
+	expected := "3826f812255d8683f051ee97346d1359234d5dbd"
+
+	if hmacSha1 != expected {
+		utils.LogFailedTestInfo(t, "HmacSha1", s, expected, hmacSha1)
+		t.FailNow()
+	}
+}
+
+func TestHmacSha256(t *testing.T) {
+	s := "hello world"
+	key := "12345"
+	hmacSha256 := HmacSha256(s, key)
+	expected := "9dce2609f2d67d41f74c7f9efc8ccd44370d41ad2de52982627588dfe7289ab8"
+
+	if hmacSha256 != expected {
+		utils.LogFailedTestInfo(t, "HmacSha256", s, expected, hmacSha256)
+		t.FailNow()
+	}
+}
+
+func TestHmacSha512(t *testing.T) {
+	s := "hello world"
+	key := "12345"
+	hmacSha512 := HmacSha512(s, key)
+	expected := "5b1563ac4e9b49c9ada8ccb232588fc4f0c30fd12f756b3a0b95af4985c236ca60925253bae10ce2c6bf9af1c1679b51e5395ff3d2826c0a2c7c0d72225d4175"
+
+	if hmacSha512 != expected {
+		utils.LogFailedTestInfo(t, "HmacSha512", s, expected, hmacSha512)
+		t.FailNow()
+	}
+}
+
+func TestSha1(t *testing.T) {
+	s := "hello world"
+	sha1 := Sha1(s)
+	expected := "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed"
+
+	if sha1 != expected {
+		utils.LogFailedTestInfo(t, "Sha1", s, expected, sha1)
+		t.FailNow()
+	}
+}
+
+func TestSha256(t *testing.T) {
+	s := "hello world"
+	sha256 := Sha256(s)
+	expected := "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
+
+	if sha256 != expected {
+		utils.LogFailedTestInfo(t, "Sha256", s, expected, sha256)
+		t.FailNow()
+	}
+}
+
+func TestSha512(t *testing.T) {
+	s := "hello world"
+	sha512 := Sha512(s)
+	expected := "309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f"
+
+	if sha512 != expected {
+		utils.LogFailedTestInfo(t, "Sha512", s, expected, sha512)
+		t.FailNow()
+	}
+}

cryptor/crypt_util.go

@@ -0,0 +1,37 @@
+package cryptor
+
+import "bytes"
+
+func generateAesKey(key []byte) []byte {
+	genKey := make([]byte, 16)
+	copy(genKey, key)
+	for i := 16; i < len(key); {
+		for j := 0; j < 16 && i < len(key); j, i = j+1, i+1 {
+			genKey[j] ^= key[i]
+		}
+	}
+	return genKey
+}
+
+func generateDesKey(key []byte) []byte {
+	genKey := make([]byte, 8)
+	copy(genKey, key)
+	for i := 8; i < len(key); {
+		for j := 0; j < 8 && i < len(key); j, i = j+1, i+1 {
+			genKey[j] ^= key[i]
+		}
+	}
+	return genKey
+}
+
+func pkcs7Padding(src []byte, blockSize int) []byte {
+	padding := blockSize - len(src)%blockSize
+	padText := bytes.Repeat([]byte{byte(padding)}, padding)
+	return append(src, padText...)
+}
+
+func pkcs7UnPadding(src []byte) []byte {
+	length := len(src)
+	unPadding := int(src[length-1])
+	return src[:(length - unPadding)]
+}

cryptor/des.go

@@ -0,0 +1,166 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package cryptor implements some util functions to encrypt and decrypt.
+package cryptor
+
+import (
+	"bytes"
+	"crypto/cipher"
+	"crypto/des"
+	"crypto/rand"
+	"io"
+)
+
+// DesEcbEncrypt encrypt data with key use DES ECB algorithm
+// len(key) should be 8
+func DesEcbEncrypt(data, key []byte) []byte {
+	cipher, _ := des.NewCipher(generateDesKey(key))
+	length := (len(data) + des.BlockSize) / des.BlockSize
+	plain := make([]byte, length*des.BlockSize)
+	copy(plain, data)
+	pad := byte(len(plain) - len(data))
+	for i := len(data); i < len(plain); i++ {
+		plain[i] = pad
+	}
+	encrypted := make([]byte, len(plain))
+	for bs, be := 0, cipher.BlockSize(); bs <= len(data); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
+		cipher.Encrypt(encrypted[bs:be], plain[bs:be])
+	}
+
+	return encrypted
+}
+
+// DesEcbDecrypt decrypt data with key use DES ECB algorithm
+// len(key) should be 8
+func DesEcbDecrypt(encrypted, key []byte) []byte {
+	cipher, _ := des.NewCipher(generateDesKey(key))
+	decrypted := make([]byte, len(encrypted))
+	//
+	for bs, be := 0, cipher.BlockSize(); bs < len(encrypted); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
+		cipher.Decrypt(decrypted[bs:be], encrypted[bs:be])
+	}
+
+	trim := 0
+	if len(decrypted) > 0 {
+		trim = len(decrypted) - int(decrypted[len(decrypted)-1])
+	}
+
+	return decrypted[:trim]
+}
+
+// DesCbcEncrypt encrypt data with key use DES CBC algorithm
+// len(key) should be 8
+func DesCbcEncrypt(data, key []byte) []byte {
+	block, _ := des.NewCipher(key)
+	blockSize := block.BlockSize()
+	data = pkcs7Padding(data, blockSize)
+	blockMode := cipher.NewCBCEncrypter(block, key[:blockSize])
+
+	encrypted := make([]byte, len(data))
+	blockMode.CryptBlocks(encrypted, data)
+	return encrypted
+}
+
+// DesCbcDecrypt decrypt data with key use DES CBC algorithm
+// len(key) should be 8
+func DesCbcDecrypt(encrypted, key []byte) []byte {
+	block, _ := des.NewCipher(key)
+	blockSize := block.BlockSize()
+	blockMode := cipher.NewCBCDecrypter(block, key[:blockSize])
+
+	decrypted := make([]byte, len(encrypted))
+	blockMode.CryptBlocks(decrypted, encrypted)
+	decrypted = pkcs7UnPadding(decrypted)
+	return decrypted
+}
+
+// DesCtrCrypt encrypt data with key use DES CTR algorithm
+// len(key) should be 8
+func DesCtrCrypt(data, key []byte) []byte {
+	block, _ := des.NewCipher(key)
+
+	iv := bytes.Repeat([]byte("1"), block.BlockSize())
+	stream := cipher.NewCTR(block, iv)
+
+	dst := make([]byte, len(data))
+	stream.XORKeyStream(dst, data)
+
+	return dst
+}
+
+// DesCfbEncrypt encrypt data with key use DES CFB algorithm
+// len(key) should be 8
+func DesCfbEncrypt(data, key []byte) []byte {
+	block, err := des.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+
+	encrypted := make([]byte, des.BlockSize+len(data))
+	iv := encrypted[:des.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic(err)
+	}
+
+	stream := cipher.NewCFBEncrypter(block, iv)
+	stream.XORKeyStream(encrypted[des.BlockSize:], data)
+	return encrypted
+}
+
+// DesCfbDecrypt decrypt data with key use DES CFB algorithm
+// len(encrypted) should be great than 16, len(key) should be 8
+func DesCfbDecrypt(encrypted, key []byte) []byte {
+	block, _ := des.NewCipher(key)
+	if len(encrypted) < des.BlockSize {
+		panic("encrypted data is too short")
+	}
+	iv := encrypted[:des.BlockSize]
+	encrypted = encrypted[des.BlockSize:]
+
+	stream := cipher.NewCFBDecrypter(block, iv)
+	stream.XORKeyStream(encrypted, encrypted)
+	return encrypted
+}
+
+// DesOfbEncrypt encrypt data with key use DES OFB algorithm
+// len(key) should be 16, 24 or 32
+func DesOfbEncrypt(data, key []byte) []byte {
+	block, err := des.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+	data = pkcs7Padding(data, des.BlockSize)
+	encrypted := make([]byte, des.BlockSize+len(data))
+	iv := encrypted[:des.BlockSize]
+	if _, err := io.ReadFull(rand.Reader, iv); err != nil {
+		panic(err)
+	}
+
+	stream := cipher.NewOFB(block, iv)
+	stream.XORKeyStream(encrypted[des.BlockSize:], data)
+	return encrypted
+}
+
+// DesOfbDecrypt decrypt data with key use DES OFB algorithm
+// len(key) should be 8
+func DesOfbDecrypt(data, key []byte) []byte {
+	block, err := des.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+
+	iv := data[:des.BlockSize]
+	data = data[des.BlockSize:]
+	if len(data)%des.BlockSize != 0 {
+		return nil
+	}
+
+	decrypted := make([]byte, len(data))
+	mode := cipher.NewOFB(block, iv)
+	mode.XORKeyStream(decrypted, data)
+
+	decrypted = pkcs7UnPadding(decrypted)
+	return decrypted
+
+}

cryptor/des_test.go

@@ -0,0 +1,72 @@
+package cryptor
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/utils"
+)
+
+func TestDesEcbEncrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefgh"
+
+	desEcbEncrypt := DesEcbEncrypt([]byte(data), []byte(key))
+	desEcbDecrypt := DesEcbDecrypt(desEcbEncrypt, []byte(key))
+
+	if string(desEcbDecrypt) != data {
+		utils.LogFailedTestInfo(t, "DesEcbEncrypt/DesEcbDecrypt", data, data, string(desEcbDecrypt))
+		t.FailNow()
+	}
+}
+
+func TestDesCbcEncrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefgh"
+
+	desCbcEncrypt := DesCbcEncrypt([]byte(data), []byte(key))
+	desCbcDecrypt := DesCbcDecrypt(desCbcEncrypt, []byte(key))
+
+	if string(desCbcDecrypt) != data {
+		utils.LogFailedTestInfo(t, "DesCbcEncrypt/DesCbcDecrypt", data, data, string(desCbcDecrypt))
+		t.FailNow()
+	}
+}
+
+func TestDesCtrCrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefgh"
+
+	desCtrCrypt := DesCtrCrypt([]byte(data), []byte(key))
+	desCtrDeCrypt := DesCtrCrypt(desCtrCrypt, []byte(key))
+
+	if string(desCtrDeCrypt) != data {
+		utils.LogFailedTestInfo(t, "DesCtrCrypt", data, data, string(desCtrDeCrypt))
+		t.FailNow()
+	}
+}
+
+func TestDesCfbEncrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefgh"
+
+	desCfbEncrypt := DesCfbEncrypt([]byte(data), []byte(key))
+	desCfbDecrypt := DesCfbDecrypt(desCfbEncrypt, []byte(key))
+
+	if string(desCfbDecrypt) != data {
+		utils.LogFailedTestInfo(t, "DesCfbEncrypt/DesCfbDecrypt", data, data, string(desCfbDecrypt))
+		t.FailNow()
+	}
+}
+
+func TestDesOfbEncrypt(t *testing.T) {
+	data := "hello world"
+	key := "abcdefgh"
+
+	desOfbEncrypt := DesOfbEncrypt([]byte(data), []byte(key))
+	desOfbDecrypt := DesOfbDecrypt(desOfbEncrypt, []byte(key))
+
+	if string(desOfbDecrypt) != data {
+		utils.LogFailedTestInfo(t, "DesOfbEncrypt/DesOfbDecrypt", data, data, string(desOfbDecrypt))
+		t.FailNow()
+	}
+}

cryptor/rsa.go

@@ -0,0 +1,116 @@
+// Copyright 2021 dudaodong@gmail.com. All rights reserved.
+// Use of this source code is governed by MIT license
+
+// Package cryptor implements some util functions to encrypt and decrypt.
+package cryptor
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/pem"
+	"os"
+)
+
+// GenerateRsaKey make  a rsa private key, and return key file name
+// Generated key file is `rsa_private.pem` and `rsa_public.pem` in current path
+func GenerateRsaKey(keySize int, priKeyFile, pubKeyFile string) {
+	// private key
+	privateKey, err := rsa.GenerateKey(rand.Reader, keySize)
+	if err != nil {
+		panic(err)
+	}
+
+	derText := x509.MarshalPKCS1PrivateKey(privateKey)
+
+	block := pem.Block{
+		Type:  "rsa private key",
+		Bytes: derText,
+	}
+
+	//file,err := os.Create("rsa_private.pem")
+	file, err := os.Create(priKeyFile)
+	if err != nil {
+		panic(err)
+	}
+	pem.Encode(file, &block)
+	file.Close()
+
+	// public key
+	publicKey := privateKey.PublicKey
+
+	derpText, err := x509.MarshalPKIXPublicKey(&publicKey)
+	if err != nil {
+		panic(err)
+	}
+
+	block = pem.Block{
+		Type:  "rsa public key",
+		Bytes: derpText,
+	}
+
+	//file,err = os.Create("rsa_public.pem")
+	file, err = os.Create(pubKeyFile)
+	if err != nil {
+		panic(err)
+	}
+	pem.Encode(file, &block)
+	file.Close()
+}
+
+// RsaEncrypt encrypt data with ras algorithm
+func RsaEncrypt(data []byte, pubKeyFileName string) []byte {
+	file, err := os.Open(pubKeyFileName)
+	if err != nil {
+		panic(err)
+	}
+	fileInfo, err := file.Stat()
+	if err != nil {
+		panic(err)
+	}
+	defer file.Close()
+	buf := make([]byte, fileInfo.Size())
+	file.Read(buf)
+
+	block, _ := pem.Decode(buf)
+
+	pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
+	if err != nil {
+		panic(err)
+	}
+	pubKey := pubInterface.(*rsa.PublicKey)
+
+	cipherText, err := rsa.EncryptPKCS1v15(rand.Reader, pubKey, data)
+	if err != nil {
+		panic(err)
+	}
+	return cipherText
+}
+
+// RsaDecrypt decrypt data with ras algorithm
+func RsaDecrypt(data []byte, privateKeyFileName string) []byte {
+	file, err := os.Open(privateKeyFileName)
+	if err != nil {
+		panic(err)
+	}
+	fileInfo, err := file.Stat()
+	if err != nil {
+		panic(err)
+	}
+	buf := make([]byte, fileInfo.Size())
+	defer file.Close()
+	file.Read(buf)
+
+	block, _ := pem.Decode(buf)
+
+	priKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
+	if err != nil {
+		panic(err)
+	}
+
+	plainText, err := rsa.DecryptPKCS1v15(rand.Reader, priKey, data)
+	if err != nil {
+		panic(err)
+	}
+	return plainText
+}

cryptor/rsa_test.go

@@ -0,0 +1,19 @@
+package cryptor
+
+import (
+	"testing"
+
+	"github.com/duke-git/lancet/utils"
+)
+
+func TestRsaEncrypt(t *testing.T) {
+	GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
+	data := []byte("hello world")
+	encrypted := RsaEncrypt(data, "rsa_public.pem")
+	decrypted := RsaDecrypt(encrypted, "rsa_private.pem")
+
+	if string(data) != string(decrypted) {
+		utils.LogFailedTestInfo(t, "RsaEncrypt/RsaDecrypt", string(data), string(data), string(decrypted))
+		t.FailNow()
+	}
+}