tools/util/tools.go

package util

import (
	"bytes"
	"crypto/aes"
	"crypto/cipher"
	"crypto/md5"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"icloudapp.cn/tools/entity"
	"math/rand"
	"os"
	"strings"
	"time"
)

func Getwd() string {
	path, err := os.Getwd()
	if err != nil {
		return ""
	}
	return path
}
func RandNum(n int32) int32 {
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	return r.Int31n(n)
}

func RandomStr(length int) string {
	letterBytes := "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
	b := make([]byte, length)
	letterLen := int32(len(letterBytes))
	for i := range b {
		b[i] = letterBytes[RandNum(letterLen)]
	}
	return string(b)
}

// RandomNumberStr 随机字符串
func RandomNumberStr(length int) string {
	numberBytes := "0123456789"
	letterLen := int32(len(numberBytes))
	b := make([]byte, length)
	for i := range b {
		b[i] = numberBytes[RandNum(letterLen)]
	}
	return string(b)
}

// Sign 生成可签名的字符串
func Sign(str string, salt string) string {
	if len(salt) == 0 {
		salt = "K4de3"
	}
	var bt bytes.Buffer
	bt.WriteString(str)
	bt.WriteString("-")
	bt.WriteString(salt)

	crypt := md5.Sum(bt.Bytes())

	return fmt.Sprintf("%x", crypt)
}

// EncryptWidthTime 生成带过期时间的字符串
func EncryptWidthTime(str string, expired int64, key string) (string, error) {
	currentTimestamp := time.Now().Unix()
	arr := entity.EncryptData{Str: str, Expired: currentTimestamp + expired}
	data, err := json.Marshal(arr)
	if err != nil {
		return "", err
	}
	return Encrypt(string(data), key), nil
}

// DecryptWithTime 解密带时间戳的地府穿
func DecryptWithTime(str string, key string) (string, error) {
	decode := Decrypt(str, key)
	var data entity.EncryptData

	if err := json.Unmarshal([]byte(decode), &data); err != nil {
		return "", err
	}
	currentTimestamp := time.Now().Unix()
	if currentTimestamp >= data.Expired {
		return "", errors.New("加密串已过期")
	}
	return data.Str, nil
}

// Encrypt 加密字符串
func Encrypt(str string, key string) string {
	keyByte := []byte(key)

	keyByte = pkcs5Padding(keyByte, 16)
	block, err := aes.NewCipher(keyByte)
	if err != nil {
		fmt.Println(err.Error())
	}
	blockSize := block.BlockSize() // 获取秘钥块的长度

	origData := pkcs5Padding([]byte(str), blockSize)                // 补全码
	blockMode := cipher.NewCBCEncrypter(block, keyByte[:blockSize]) // 加密模式
	encrypted := make([]byte, len(origData))                        // 创建数组
	blockMode.CryptBlocks(encrypted, origData)                      // 加密
	return hex.EncodeToString(encrypted)
}

// Decrypt 解密字符串
func Decrypt(str string, key string) string {
	hexDecode, _ := hex.DecodeString(str)
	str = string(hexDecode)
	keyByte := []byte(key)
	keyByte = pkcs5Padding(keyByte, 16)
	block, err := aes.NewCipher(keyByte) // 分组秘钥
	if err != nil {
		fmt.Println(err.Error())
	}
	blockSize := block.BlockSize()                                  // 获取秘钥块的长度
	blockMode := cipher.NewCBCDecrypter(block, keyByte[:blockSize]) // 加密模式
	decrypted := make([]byte, len(hexDecode))                       // 创建数组
	blockMode.CryptBlocks(decrypted, hexDecode)                     // 解密
	fmt.Println("decrypted", string(decrypted))
	decrypted = pkcs5UnPadding(decrypted) // 去除补全码

	return string(decrypted)
}

// 补齐字符串
func pkcs5Padding(ciphertext []byte, blockSize int) []byte {
	padding := blockSize - len(ciphertext)%blockSize
	padText := bytes.Repeat([]byte{byte(padding)}, padding)
	return append(ciphertext, padText...)
}

// 去掉补齐的字符串
func pkcs5UnPadding(origData []byte) []byte {
	length := len(origData)
	unPadding := int(origData[length-1])
	return origData[:(length - unPadding)]
}

// 自动生成key
func GenerateKey(key []byte) (genKey []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
}

// NewError error
func NewError(args ...string) error {
	var buffer strings.Builder
	for i, v := range args {
		if i > 0 {
			buffer.WriteString(" : \t")
		}
		buffer.WriteString(v)
	}
	return errors.New(buffer.String())
}

// TransparentPNG 透明背景图
func TransparentPNG() []byte {
	str := "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAAXNSR0IB2cksfwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAANQTFRFAAAAp3o92gAAAAF0Uk5TAEDm2GYAAAAKSURBVHicY2AAAAACAAFIr6RxAAAAAElFTkSuQmCC"
	trans, _ := base64.StdEncoding.DecodeString(str)
	return trans
}

// CutString 字符串裁切
func CutString(str string, start, end int) string {
	if end <= 0 {
		return ""
	}
	strRune := []rune(str)
	strLen := len(strRune) //utf8.RuneCountInString(str)
	if strLen <= start {
		return ""
	}
	if strLen < end {
		end = strLen
	}
	return string(strRune[start:end])
}