init

crypto.go

@@ -0,0 +1,936 @@
+package starcrypto
+
+import (
+	"bufio"
+	"crypto"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/md5"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/sha1"
+	"crypto/sha256"
+	"crypto/sha512"
+	"crypto/x509"
+	"encoding/base64"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/pem"
+	"errors"
+	"fmt"
+	"hash"
+	"hash/crc32"
+	"io"
+	"io/ioutil"
+	rands "math/rand"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"golang.org/x/crypto/ssh"
+)
+
+// Base64Encode 输出格式化后的Base64字符串
+func Base64Encode(bstr []byte) string {
+	return base64.StdEncoding.EncodeToString(bstr)
+}
+
+// Base64Decode 输出解密前的Base64数据
+func Base64Decode(str string) ([]byte, error) {
+	return base64.StdEncoding.DecodeString(str)
+}
+
+func String(bstr []byte) string {
+	return hex.EncodeToString(bstr)
+}
+
+// MD5 输出MD5校验值
+func Md5(bstr []byte) []byte {
+	md5sum := md5.New()
+	md5sum.Write(bstr)
+	return md5sum.Sum(nil)
+}
+
+func Md5Str(bstr []byte) string {
+	return String(Md5(bstr))
+}
+
+// CRC32 输出CRC32校验值
+func Crc32(bstr []byte) []byte {
+	crcsum := crc32.NewIEEE()
+	crcsum.Write(bstr)
+	return crcsum.Sum(nil)
+}
+
+func Crc32Str(bstr []byte) string {
+	return String(Crc32(bstr))
+}
+
+// SHA512 输出SHA512校验值
+func Sha512(bstr []byte) []byte {
+	shasum := sha512.New()
+	shasum.Write(bstr)
+	return shasum.Sum(nil)
+}
+
+func Sha512Str(bstr []byte) string {
+	return String(Sha512(bstr))
+}
+
+// SHA384 输出SHA384校验值
+func Sha384(bstr []byte) []byte {
+	shasum := sha512.New384()
+	shasum.Write(bstr)
+	return shasum.Sum(nil)
+}
+
+func Sha384Str(bstr []byte) string {
+	return String(Sha384(bstr))
+}
+
+// SHA256 输出SHA256校验值
+func Sha256(bstr []byte) []byte {
+	shasum := sha256.New()
+	shasum.Write(bstr)
+	return shasum.Sum(nil)
+}
+
+func Sha256Str(bstr []byte) string {
+	return String(Sha256(bstr))
+}
+
+// SHA224 输出SHA224校验值
+func Sha224(bstr []byte) []byte {
+	shasum := sha256.New224()
+	shasum.Write(bstr)
+	return shasum.Sum(nil)
+}
+
+func Sha224Str(bstr []byte) string {
+	return String(Sha224(bstr))
+}
+
+// SHA1 输出SHA1校验值
+func Sha1(bstr []byte) []byte {
+	shasum := sha1.New()
+	shasum.Write(bstr)
+	return shasum.Sum(nil)
+}
+
+func Sha1Str(bstr []byte) string {
+	return String(Sha512(bstr))
+}
+
+func GenerateKey(bits int) (*rsa.PrivateKey, *rsa.PublicKey, error) {
+	private, err := rsa.GenerateKey(rand.Reader, bits)
+	if err != nil {
+		return nil, nil, err
+	}
+	return private, &private.PublicKey, nil
+
+}
+
+func EncodePrivateKey(private *rsa.PrivateKey) []byte {
+	return pem.EncodeToMemory(&pem.Block{
+		Bytes: x509.MarshalPKCS1PrivateKey(private),
+		Type:  "RSA PRIVATE KEY",
+	})
+}
+
+func EncodePublicKey(public *rsa.PublicKey) ([]byte, error) {
+	publicBytes, err := x509.MarshalPKIXPublicKey(public)
+	if err != nil {
+		return nil, err
+	}
+	return pem.EncodeToMemory(&pem.Block{
+		Bytes: publicBytes,
+		Type:  "PUBLIC KEY",
+	}), nil
+}
+
+//EncodeSSHKey
+func EncodeSSHKey(public *rsa.PublicKey) ([]byte, error) {
+	publicKey, err := ssh.NewPublicKey(public)
+	if err != nil {
+		return nil, err
+	}
+	return ssh.MarshalAuthorizedKey(publicKey), nil
+}
+
+func MakeSSHKeyPair() (string, string, error) {
+
+	pkey, pubkey, err := GenerateKey(2048)
+	if err != nil {
+		return "", "", err
+	}
+
+	pub, err := EncodeSSHKey(pubkey)
+	if err != nil {
+		return "", "", err
+	}
+
+	//glog.Info("privateKey=[%s]\n pubKey=[%s]",string(EncodePrivateKey(pkey)),string(pub))
+	return string(EncodePrivateKey(pkey)), string(pub), nil
+}
+
+// SumAll 可以对同一数据进行多种校验
+func SumAll(data []byte, method []string) (map[string][]byte, error) {
+	result := make(map[string][]byte)
+	methods := make(map[string]hash.Hash)
+	var iscrc bool
+	if len(method) == 0 {
+		method = []string{"sha512", "sha256", "sha384", "sha224", "sha1", "crc32", "md5"}
+	}
+	sum512 := sha512.New()
+	sum384 := sha512.New384()
+	sum256 := sha256.New()
+	sum224 := sha256.New224()
+	sum1 := sha1.New()
+	crcsum := crc32.NewIEEE()
+	md5sum := md5.New()
+	for _, v := range method {
+		switch v {
+		case "md5":
+			methods["md5"] = md5sum
+		case "crc32":
+			iscrc = true
+		case "sha1":
+			methods["sha1"] = sum1
+		case "sha224":
+			methods["sha224"] = sum224
+		case "sha256":
+			methods["sha256"] = sum256
+		case "sha384":
+			methods["sha384"] = sum384
+		case "sha512":
+			methods["sha512"] = sum512
+		}
+	}
+	for _, v := range methods {
+		v.Write(data)
+	}
+	if iscrc {
+		crcsum.Write(data)
+	}
+
+	for k, v := range methods {
+		result[k] = v.Sum(nil)
+	}
+	if iscrc {
+		result["crc32"] = crcsum.Sum(nil)
+	}
+	return result, nil
+}
+
+// FileSum 输出文件内容校验值，method为单个校验方法,小写
+//例：FileSum("./test.txt","md5",shell(pect float64){fmt.Sprintf("已完成 %f\r",pect)})
+func FileSum(filepath, method string, shell func(float64)) (string, error) {
+	var sum hash.Hash
+	var sum32 hash.Hash32
+	var issum32 bool
+	var result string
+	fp, err := os.Open(filepath)
+	if err != nil {
+		return "", err
+	}
+	switch method {
+	case "sha512":
+		sum = sha512.New()
+	case "sha384":
+		sum = sha512.New384()
+	case "sha256":
+		sum = sha256.New()
+	case "sha224":
+		sum = sha256.New224()
+	case "sha1":
+		sum = sha1.New()
+	case "crc32":
+		sum32 = crc32.NewIEEE()
+		issum32 = true
+	case "md5":
+		sum = md5.New()
+	default:
+		return "", errors.New("Cannot Recognize The Method:" + method)
+	}
+	writer := 0
+	stat, _ := os.Stat(filepath)
+	filebig := float64(stat.Size())
+	if !issum32 {
+		//	if _, err := io.Copy(sum, fp); err != nil {
+		for {
+			buf := make([]byte, 1048574)
+			n, err := fp.Read(buf)
+			if err != nil {
+				if err == io.EOF {
+					break
+				}
+				return result, err
+			}
+			writer += n
+			pect := (float64(writer) / filebig) * 100
+			go shell(pect)
+			sum.Write(buf[0:n])
+		}
+		result = hex.EncodeToString(sum.Sum(nil))
+	} else {
+		for {
+			buf := make([]byte, 1048574)
+			n, err := fp.Read(buf)
+			if err != nil {
+				if err == io.EOF {
+					break
+				}
+				return result, err
+			}
+			writer += n
+			pect := (float64(writer) / filebig) * 100
+			go shell(pect)
+			sum32.Write(buf[0:n])
+		}
+		result = hex.EncodeToString(sum32.Sum(nil))
+	}
+	return result, nil
+}
+
+// FileSumAll 可以对同一文件进行多种校验
+func FileSumAll(filepath string, method []string, shell func(float64)) (map[string]string, error) {
+	result := make(map[string]string)
+	methods := make(map[string]hash.Hash)
+	var iscrc bool
+
+	if len(method) == 0 {
+		method = []string{"sha512", "sha256", "sha384", "sha224", "sha1", "crc32", "md5"}
+	}
+	fp, err := os.Open(filepath)
+	defer fp.Close()
+	if err != nil {
+		return result, err
+	}
+	stat, _ := os.Stat(filepath)
+	filebig := float64(stat.Size())
+	sum512 := sha512.New()
+	sum384 := sha512.New384()
+	sum256 := sha256.New()
+	sum224 := sha256.New224()
+	sum1 := sha1.New()
+	crcsum := crc32.NewIEEE()
+	md5sum := md5.New()
+	for _, v := range method {
+		switch v {
+		case "md5":
+			methods["md5"] = md5sum
+		case "crc32":
+			iscrc = true
+		case "sha1":
+			methods["sha1"] = sum1
+		case "sha224":
+			methods["sha224"] = sum224
+		case "sha256":
+			methods["sha256"] = sum256
+		case "sha384":
+			methods["sha384"] = sum384
+		case "sha512":
+			methods["sha512"] = sum512
+		}
+	}
+
+	writer := 0
+	for {
+		buf := make([]byte, 1048574)
+		n, err := fp.Read(buf)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return result, err
+		}
+		writer += n
+		pect := (float64(writer) / filebig) * 100
+		go shell(pect)
+		for _, v := range methods {
+			v.Write(buf[0:n])
+		}
+		if iscrc {
+			crcsum.Write(buf[0:n])
+		}
+	}
+	for k, v := range methods {
+		result[k] = hex.EncodeToString(v.Sum(nil))
+	}
+	if iscrc {
+		result["crc32"] = hex.EncodeToString(crcsum.Sum(nil))
+	}
+	return result, nil
+}
+
+// Attach 合并src与dst文件并输出到output中
+func Attach(src, dst, output string) error {
+	fpsrc, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer fpsrc.Close()
+	fpdst, err := os.Open(dst)
+	if err != nil {
+		return err
+	}
+	defer fpdst.Close()
+	fpout, err := os.Create(output)
+	if err != nil {
+		return err
+	}
+	defer fpout.Close()
+	if _, err := io.Copy(fpout, fpsrc); err != nil {
+		return err
+	}
+	for {
+		buf := make([]byte, 1048574)
+		n, err := fpdst.Read(buf)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		fpout.Write(buf[0:n])
+	}
+	return nil
+}
+
+// Detach 按bytenum字节大小分割src文件到dst1与dst2两个新文件中去
+func Detach(src string, bytenum int, dst1, dst2 string) error {
+	fpsrc, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer fpsrc.Close()
+	fpdst1, err := os.Create(dst1)
+	if err != nil {
+		return err
+	}
+	defer fpdst1.Close()
+	fpdst2, err := os.Create(dst2)
+	if err != nil {
+		return err
+	}
+	defer fpdst2.Close()
+	sumall := 0
+	var buf []byte
+	for {
+		if bytenum-sumall < 1048576 {
+			buf = make([]byte, bytenum-sumall)
+		} else {
+			buf = make([]byte, 1048576)
+		}
+		n, err := fpsrc.Read(buf)
+		if err != nil {
+			return err
+		}
+		sumall += n
+		fpdst1.Write(buf[0:n])
+		if sumall == bytenum {
+			break
+		}
+	}
+	for {
+		buf = make([]byte, 1048576)
+		n, err := fpsrc.Read(buf)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		fpdst2.Write(buf[0:n])
+	}
+	return nil
+}
+
+// Base64EncodeFile 用base64方法编码src文件到dst文件中去，shell传入当前进度
+func Base64EncodeFile(src, dst string, shell func(float64)) error {
+	fpsrc, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer fpsrc.Close()
+	stat, _ := os.Stat(src)
+	filebig := float64(stat.Size())
+	sum := 0
+	fpdst, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+	defer fpdst.Close()
+	b64 := base64.NewEncoder(base64.StdEncoding, fpdst)
+	for {
+		buf := make([]byte, 1048575)
+		n, err := fpsrc.Read(buf)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		sum += n
+		go shell(float64(sum) / filebig * 100)
+		b64.Write(buf[0:n])
+	}
+	return nil
+}
+
+// Base64DecodeFile 用base64方法解码src文件到dst文件中去，shell传入当前进度
+func Base64DecodeFile(src, dst string, shell func(float64)) error {
+	fpsrc, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer fpsrc.Close()
+	stat, _ := os.Stat(src)
+	filebig := float64(stat.Size())
+	sum := 0
+	defer fpsrc.Close()
+	fpdst, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+	defer fpdst.Close()
+	b64 := base64.NewDecoder(base64.StdEncoding, fpsrc)
+	for {
+		buf := make([]byte, 1048576)
+		n, err := b64.Read(buf)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		sum += n
+		go shell(float64(sum) / filebig * 100)
+		fpdst.Write(buf[0:n])
+	}
+	return nil
+}
+
+// SplitFile 把src文件按要求分割到dst中去,dst应传入带*号字符串
+// 如果bynum=true 则把文件分割成num份
+// 如果bynum=false 则把文件按num字节分成多份
+func SplitFile(src, dst string, num int, bynum bool, shell func(float64)) error {
+	fpsrc, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer fpsrc.Close()
+	stat, _ := os.Stat(src)
+	filebig := float64(stat.Size())
+	if bynum {
+		if int(filebig) < num {
+			return errors.New("file is too small to split")
+		}
+	}
+	balance := int(filebig/float64(num)) + 1
+	if !bynum {
+		balance = num
+	}
+	nownum := 0
+	fpdst, err := os.Create(strings.Replace(dst, "*", fmt.Sprint(nownum), -1))
+	if err != nil {
+		return err
+	}
+	defer fpdst.Close()
+	var sum, tsum int = 0, 0
+	var buf []byte
+	for {
+		if balance-sum < 1048576 {
+			buf = make([]byte, balance-sum)
+		} else {
+			buf = make([]byte, 1048576)
+		}
+		n, err := fpsrc.Read(buf)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		sum += n
+		tsum += n
+		fpdst.Write(buf[0:n])
+		go shell(float64(tsum) / filebig * 100)
+		if sum == balance {
+			fpdst.Close()
+			nownum++
+			fpdst, err = os.Create(strings.Replace(dst, "*", fmt.Sprint(nownum), -1))
+			if err != nil {
+				return err
+			}
+			sum = 0
+		}
+	}
+	return nil
+}
+
+// MergeFile 合并src文件到dst文件中去，src文件应传入带*号字符串
+func MergeFile(src, dst string, shell func(float64)) error {
+	tmp := strings.Replace(src, "*", "0", -1)
+	dir, err := ioutil.ReadDir(filepath.Dir(tmp))
+	if err != nil {
+		return err
+	}
+	base := filepath.Base(src)
+	tmp = strings.Replace(base, "*", "(\\d+)", -1)
+	reg := regexp.MustCompile(tmp)
+	count := 0
+	var filebig float64
+	for _, v := range dir {
+		if reg.MatchString(v.Name()) {
+			count++
+			filebig += float64(v.Size())
+		}
+	}
+	fpdst, err := os.Create(dst)
+	defer fpdst.Close()
+	if err != nil {
+		return err
+	}
+	sum := 0
+	for i := 0; i < count; i++ {
+		fpsrc, err := os.Open(strings.Replace(src, "*", strconv.Itoa(i), -1))
+		if err != nil {
+			return err
+		}
+		for {
+			buf := make([]byte, 1048576)
+			n, err := fpsrc.Read(buf)
+			if err != nil {
+				if err == io.EOF {
+					break
+				}
+				return err
+			}
+			sum += n
+			go shell(float64(sum) / filebig * 100)
+			fpdst.Write(buf[0:n])
+		}
+		fpsrc.Close()
+	}
+	return nil
+}
+
+// RSAEncrypt RSA公钥加密
+func RSAEncrypt(data, public []byte) ([]byte, error) {
+	blk, _ := pem.Decode(public)
+	if blk == nil {
+		return []byte{}, errors.New("public key error")
+	}
+	pubkey, err := x509.ParsePKIXPublicKey(blk.Bytes)
+	if err != nil {
+		return []byte{}, err
+	}
+	return rsa.EncryptPKCS1v15(rand.Reader, pubkey.(*rsa.PublicKey), data)
+}
+
+// RSADecrypt RSA私钥解密
+func RSADecrypt(data, private []byte, password string) ([]byte, error) {
+	var prikey *rsa.PrivateKey
+	var err error
+	var bytes []byte
+	blk, _ := pem.Decode(private)
+	if blk == nil {
+		return []byte{}, errors.New("private key error！")
+	}
+	if password != "" {
+		tmp, err := x509.DecryptPEMBlock(blk, []byte(password))
+		if err != nil {
+			return []byte{}, err
+		}
+		bytes = tmp
+	} else {
+		bytes = blk.Bytes
+	}
+	prikey, err = x509.ParsePKCS1PrivateKey(bytes)
+	if err != nil {
+		tmp, err := x509.ParsePKCS8PrivateKey(bytes)
+		if err != nil {
+			return []byte{}, err
+		}
+		prikey = tmp.(*rsa.PrivateKey)
+	}
+	return rsa.DecryptPKCS1v15(rand.Reader, prikey, data)
+}
+
+// RSASign RSA私钥签名加密
+func RSASign(hashdata, private []byte, password string, hashtype crypto.Hash) ([]byte, error) {
+	var prikey *rsa.PrivateKey
+	var err error
+	var bytes []byte
+	blk, _ := pem.Decode(private)
+	if blk == nil {
+		return []byte{}, errors.New("private key error！")
+	}
+	if password != "" {
+		tmp, err := x509.DecryptPEMBlock(blk, []byte(password))
+		if err != nil {
+			return []byte{}, err
+		}
+		bytes = tmp
+	} else {
+		bytes = blk.Bytes
+	}
+	prikey, err = x509.ParsePKCS1PrivateKey(bytes)
+	if err != nil {
+		tmp, err := x509.ParsePKCS8PrivateKey(bytes)
+		if err != nil {
+			return []byte{}, err
+		}
+		prikey = tmp.(*rsa.PrivateKey)
+	}
+	return rsa.SignPKCS1v15(rand.Reader, prikey, hashtype, hashdata)
+}
+
+// RSAVerify RSA公钥签名验证
+func RSAVerify(data, hashdata, public []byte, hashtype crypto.Hash) error {
+	blk, _ := pem.Decode(public)
+	if blk == nil {
+		return errors.New("public key error！")
+	}
+	pubkey, err := x509.ParsePKIXPublicKey(blk.Bytes)
+	if err != nil {
+		return err
+	}
+	return rsa.VerifyPKCS1v15(pubkey.(*rsa.PublicKey), hashtype, hashdata, data)
+}
+
+// VicqueEncodeV1 Best！
+func VicqueEncodeV1(srcdata []byte, key string) []byte {
+	var keys []int
+	var saku, piku uint8
+	data := make([]byte, len(srcdata))
+	copy(data, srcdata)
+	binary.Read(rand.Reader, binary.LittleEndian, &saku)
+	binary.Read(rand.Reader, binary.LittleEndian, &piku)
+	keys = append(keys, len(key)+int(saku))
+	lens := len(data)
+	for _, v := range key {
+		keys = append(keys, int(byte(v))+int(saku)-int(piku))
+	}
+	lenkey := len(keys)
+	for k, v := range data {
+		if k == lens/2 {
+			break
+		}
+		nv := int(v)
+		t := 0
+		if k%2 == 0 {
+			nv += keys[k%lenkey]
+			if nv > 255 {
+				nv -= 256
+			}
+			t = int(data[lens-1-k])
+			t += keys[k%lenkey]
+			if t > 255 {
+				t -= 256
+			}
+		} else {
+			nv -= keys[k%lenkey]
+			if nv < 0 {
+				nv += 256
+			}
+			t = int(data[lens-1-k])
+			t -= keys[k%lenkey]
+			if t > 255 {
+				t += 256
+			}
+		}
+		data[k] = byte(t)
+		data[lens-1-k] = byte(nv)
+	}
+	data = append(data, byte(saku), byte(piku))
+	return data
+}
+
+// VicqueDecodeV1 Best！
+func VicqueDecodeV1(srcdata []byte, key string) []byte {
+	var keys []int
+	var saku, piku int
+	data := make([]byte, len(srcdata))
+	copy(data, srcdata)
+	lens := len(data)
+	saku = int(data[lens-2])
+	piku = int(data[lens-1])
+	keys = append(keys, len(key)+int(saku))
+	for _, v := range key {
+		keys = append(keys, int(byte(v))+int(saku)-int(piku))
+	}
+	lenkey := len(keys)
+	lens -= 2
+	for k, v := range data {
+		if k == lens/2 {
+			break
+		}
+		nv := int(v)
+		t := 0
+		if k%2 == 0 {
+			nv -= keys[k%lenkey]
+			if nv < 0 {
+				nv += 256
+			}
+			t = int(data[lens-1-k])
+			t -= keys[k%lenkey]
+			if t > 255 {
+				t += 256
+			}
+		} else {
+			nv += keys[k%lenkey]
+			if nv > 255 {
+				nv -= 256
+			}
+			t = int(data[lens-1-k])
+			t += keys[k%lenkey]
+			if t > 255 {
+				t -= 256
+			}
+		}
+		data[k] = byte(t)
+		data[lens-1-k] = byte(nv)
+	}
+	return data[:lens]
+}
+
+// VicqueEncodeV1File best
+func VicqueEncodeV1File(src, dst, pwd string, shell func(float64)) error {
+	fpsrc, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer fpsrc.Close()
+	stat, _ := os.Stat(src)
+	filebig := float64(stat.Size())
+	sum := 0
+	defer fpsrc.Close()
+	fpdst, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+	defer fpdst.Close()
+	for {
+		buf := make([]byte, 1048576)
+		n, err := fpsrc.Read(buf)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		sum += n
+		go shell(float64(sum) / filebig * 100)
+		data := VicqueEncodeV1(buf[0:n], pwd)
+		fpdst.Write(data)
+	}
+	return nil
+}
+
+// VicqueDecodeV1File best
+func VicqueDecodeV1File(src, dst, pwd string, shell func(float64)) error {
+	fpsrc, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer fpsrc.Close()
+	stat, _ := os.Stat(src)
+	filebig := float64(stat.Size())
+	sum := 0
+	defer fpsrc.Close()
+	fpdst, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+	defer fpdst.Close()
+	for {
+		buf := make([]byte, 1048578)
+		n, err := fpsrc.Read(buf)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		sum += n
+		go shell(float64(sum) / filebig * 100)
+		data := VicqueDecodeV1(buf[0:n], pwd)
+		fpdst.Write(data)
+	}
+	return nil
+}
+
+// FillWithRandom 随机写filesize大小的文件，每次buf大小为bufcap，随机bufnum个字符
+func FillWithRandom(filepath string, filesize int, bufcap int, bufnum int, shell func(float64)) error {
+	var buf [][]byte
+	var buftmp []byte
+	rands.Seed(time.Now().Unix())
+	if bufnum <= 0 {
+		bufnum = 1
+	}
+	if bufcap > filesize {
+		bufcap = filesize
+	}
+	myfile, err := os.Create(filepath)
+	if err != nil {
+		return err
+	}
+	defer myfile.Close()
+	writer := bufio.NewWriter(myfile)
+	for i := 0; i < bufnum; i++ {
+		buftmp = []byte{}
+		for j := 0; j < bufcap; j++ {
+			buftmp = append(buftmp, byte(rands.Intn(256)))
+		}
+		buf = append(buf, buftmp)
+	}
+	sum := 0
+	for {
+		if filesize-sum < bufcap {
+			writer.Write(buf[rands.Intn(bufnum)][0 : filesize-sum])
+			sum += filesize - sum
+		} else {
+			writer.Write(buf[rands.Intn(bufnum)])
+			sum += bufcap
+		}
+		go shell(float64(sum) / float64(filesize) * 100)
+		if sum >= filesize {
+			break
+		}
+	}
+	writer.Flush()
+	return nil
+}
+
+// =================== CFB ======================
+func AesEncryptCFB(origData []byte, key []byte) (encrypted []byte) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+	encrypted = make([]byte, aes.BlockSize+len(origData))
+	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:], origData)
+	return encrypted
+}
+func AesDecryptCFB(encrypted []byte, key []byte) (decrypted []byte) {
+	block, _ := aes.NewCipher(key)
+	if len(encrypted) < aes.BlockSize {
+		panic("ciphertext too short")
+	}
+	iv := encrypted[:aes.BlockSize]
+	encrypted = encrypted[aes.BlockSize:]
+
+	stream := cipher.NewCFBDecrypter(block, iv)
+	stream.XORKeyStream(encrypted, encrypted)
+	return encrypted
+}