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