starcrypto/crypto.go

package starcrypto

import (
	"bufio"
	"crypto/aes"
	"crypto/cipher"
	"crypto/md5"
	"crypto/rand"
	"crypto/sha1"
	"crypto/sha256"
	"crypto/sha512"
	"encoding/binary"
	"encoding/hex"
	"errors"
	"fmt"
	"hash"
	"hash/crc32"
	"io"
	"io/ioutil"
	rands "math/rand"
	"os"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"
	"time"
)

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))
}

// 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
}

// 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
	}
	var sum int64
	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 += int64(n)
			go shell(float64(sum) / filebig * 100)
			fpdst.Write(buf[0:n])
		}
		fpsrc.Close()
	}
	return nil
}

// 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())
	var sum int64
	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 += int64(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())
	var sum int64
	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 += int64(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
}

func AesEncryptCFBNoBlock(origData []byte, key []byte) (encrypted []byte) {
	block, err := aes.NewCipher(key)
	if err != nil {
		panic(err)
	}
	encrypted = make([]byte, len(origData))
	iv := Sha1(key)[:16]
	stream := cipher.NewCFBEncrypter(block, iv)
	stream.XORKeyStream(encrypted, origData)
	return encrypted
}
func AesDecryptCFBNoBlock(encrypted []byte, key []byte) (decrypted []byte) {
	block, _ := aes.NewCipher(key)
	iv := Sha1(key)[:16]
	stream := cipher.NewCFBDecrypter(block, iv)
	stream.XORKeyStream(encrypted, encrypted)
	return encrypted
}