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