From 033d327f4f3fa5fc082bd2882df181b08a37e1d0 Mon Sep 17 00:00:00 2001 From: starainrt Date: Sun, 17 Mar 2024 18:19:44 +0800 Subject: [PATCH] update --- aes/aes.go | 38 +++++--- aes/cmd.go | 18 ++-- cert/cert.go | 219 +++++++++++++++++++++++++++++++++++++++++++++-- cert/cmd.go | 111 +++++++++++++++++++++++- go.mod | 4 +- go.sum | 4 +- hash/hash.go | 201 ++++++++++++++++++++++++++++++++++++++++++- keygen/cmd.go | 2 +- keygen/keygen.go | 13 ++- main.go | 3 +- 10 files changed, 575 insertions(+), 38 deletions(-) diff --git a/aes/aes.go b/aes/aes.go index c7dc15d..0e8fa7c 100644 --- a/aes/aes.go +++ b/aes/aes.go @@ -10,7 +10,7 @@ import ( "b612.me/staros" ) -func EncodeStr(str string, key []byte) string { +func EncodeStr(str string, key []byte) (string, error) { if len(key) < 16 { key = starcrypto.Md5(key) } else { @@ -19,19 +19,25 @@ func EncodeStr(str string, key []byte) string { key = key[:32] } } - ensdata := starcrypto.AesEncryptCFBNoBlock([]byte(str), key) - return starcrypto.Base91EncodeToString(ensdata) + ensdata, err := starcrypto.CustomEncryptAesCFB([]byte(str), key) + if err != nil { + return "", err + } + return starcrypto.Base64Encode(ensdata), nil } -func DecodeStr(str string, key []byte) string { +func DecodeStr(str string, key []byte) (string, error) { if len(key) < 16 { key = starcrypto.Md5(key) } else { key = key[:len(key)/16*16] } - strtmp := starcrypto.Base91DecodeString(str) - str = string(strtmp) - return string(starcrypto.AesDecryptCFBNoBlock([]byte(str), key)) + strtmp, err := starcrypto.Base64Decode(str) + if err != nil { + return "", err + } + p, err := starcrypto.CustomDecryptAesCFB(strtmp, key) + return string(p), err } func EncodeFile(fpath, out string, key []byte) error { @@ -64,8 +70,13 @@ func EncodeFile(fpath, out string, key []byte) error { } fmt.Printf("已完成：%.2f%%\r", float64(sumAll)/float64(stat.Size())*100) sumAll += int64(n) - encodeBytes := starcrypto.AesEncryptCFBNoBlock(buf[:n], key) - fpdst.Write(encodeBytes) + if n > 0 { + encodeBytes, err := starcrypto.CustomEncryptAesCFBNoBlock(buf[:n], key, key) + if err != nil { + return err + } + fpdst.Write(encodeBytes) + } if err == io.EOF { fmt.Print("已完成：100% \n") break @@ -104,8 +115,13 @@ func DecodeFile(fpath, out string, key []byte) error { } fmt.Printf("已完成：%.2f%%\r", float64(sumAll)/float64(stat.Size())*100) sumAll += int64(n) - encodeBytes := starcrypto.AesDecryptCFBNoBlock(buf[:n], key) - fpdst.Write(encodeBytes) + if n > 0 { + encodeBytes, err := starcrypto.CustomDecryptAesCFBNoBlock(buf[:n], key, key) + if err != nil { + return err + } + fpdst.Write(encodeBytes) + } if err == io.EOF { fmt.Print("已完成：100% \n") break diff --git a/aes/cmd.go b/aes/cmd.go index 225a69a..c5fb19e 100644 --- a/aes/cmd.go +++ b/aes/cmd.go @@ -14,9 +14,9 @@ import ( ) var Cmd = &cobra.Command{ - Use: "aes-cfb", - Short: "使用aes-cfb处理文件或字符串", - Long: "使用aes-cfb处理文件或字符串", + Use: "aescfb", + Short: "使用自定义aes-cfb处理文件或字符串", + Long: "使用自定义aes-cfb处理文件或字符串", Run: func(this *cobra.Command, args []string) { var err error ok, _ := this.Flags().GetBool("file") @@ -70,10 +70,18 @@ var Cmd = &cobra.Command{ } } else { if !de { - data := EncodeStr(args[0], byteKey) + data, err := EncodeStr(args[0], byteKey) + if err != nil { + starlog.Criticalln(err) + return + } fmt.Println(data) } else { - data := DecodeStr(args[0], byteKey) + data, err := DecodeStr(args[0], byteKey) + if err != nil { + starlog.Criticalln(err) + return + } fmt.Println(string(data)) } } diff --git a/cert/cert.go b/cert/cert.go index 61a5093..27eed57 100644 --- a/cert/cert.go +++ b/cert/cert.go @@ -1,11 +1,13 @@ package cert import ( + "b612.me/starcrypto" "b612.me/starlog" "crypto/dsa" "crypto/ecdh" "crypto/ecdsa" "crypto/ed25519" + "crypto/rand" "crypto/rsa" "crypto/x509" "encoding/pem" @@ -294,7 +296,59 @@ func ParseCert(data []byte, pwd string) { default: starlog.Green("未知公钥类型\n") } - return + continue + case "RSA PRIVATE KEY": + n, err := x509.ParsePKCS1PrivateKey(block.Bytes) + if err != nil { + starlog.Errorf("解析私钥错误：%s\n", err) + continue + } + starlog.Infof("这是一个RSA私钥文件\n") + starlog.Green("私钥位数：%d\n", n.Size()) + starlog.Green("私钥长度：%d\n", n.N.BitLen()) + starlog.Green("私钥指数：%d\n", n.E) + starlog.Green("私钥系数：%d\n", n.D) + starlog.Green("私钥质数p：%d\n", n.Primes[0]) + starlog.Green("私钥质数q：%d\n", n.Primes[1]) + starlog.Green("私钥系数dP：%d\n", n.Precomputed.Dp) + starlog.Green("私钥系数dQ：%d\n", n.Precomputed.Dq) + starlog.Green("私钥系数qInv：%d\n", n.Precomputed.Qinv) + case "RSA PUBLIC KEY": + n, err := x509.ParsePKCS1PublicKey(block.Bytes) + if err != nil { + starlog.Errorf("解析公钥错误：%s\n", err) + continue + } + starlog.Green("这是一个RSA公钥\n") + starlog.Green("公钥位数：%d\n", n.Size()) + starlog.Green("公钥长度：%d\n", n.N.BitLen()) + starlog.Green("公钥指数：%d\n", n.E) + case "EC PRIVATE KEY": + n, err := x509.ParseECPrivateKey(block.Bytes) + if err != nil { + starlog.Errorf("解析私钥错误：%s\n", err) + continue + } + starlog.Green("这是一个ECDSA私钥\n") + starlog.Green("私钥位数：%d\n", n.Curve.Params().BitSize) + starlog.Green("私钥曲线：%s\n", n.Curve.Params().Name) + starlog.Green("私钥长度：%d\n", n.Params().BitSize) + starlog.Green("私钥系数：%d\n", n.D) + starlog.Green("私钥公钥X：%d\n", n.PublicKey.X) + starlog.Green("私钥公钥Y：%d\n", n.PublicKey.Y) + case "EC PUBLIC KEY": + p, err := x509.ParsePKIXPublicKey(block.Bytes) + if err != nil { + starlog.Errorf("解析公钥错误：%s\n", err) + continue + } + n := p.(*ecdsa.PublicKey) + starlog.Green("这是一个ECDSA公钥\n") + starlog.Green("公钥位数：%d\n", n.Curve.Params().BitSize) + starlog.Green("公钥曲线：%s\n", n.Curve.Params().Name) + starlog.Green("公钥长度：%d\n", n.Params().BitSize) + starlog.Green("公钥公钥X：%d\n", n.X) + starlog.Green("公钥公钥Y：%d\n", n.Y) default: starlog.Infof("未知证书文件类型\n") } @@ -556,6 +610,62 @@ func GetCert(data []byte, pwd string) ([]any, []x509.Certificate, error) { starlog.Green("未知公钥类型\n") } return common, certs, nil + case "RSA PRIVATE KEY": + n, err := x509.ParsePKCS1PrivateKey(block.Bytes) + if err != nil { + starlog.Errorf("解析私钥错误：%s\n", err) + continue + } + starlog.Infof("这是一个RSA私钥文件\n") + starlog.Green("私钥位数：%d\n", n.Size()) + starlog.Green("私钥长度：%d\n", n.N.BitLen()) + starlog.Green("私钥指数：%d\n", n.E) + starlog.Green("私钥系数：%d\n", n.D) + starlog.Green("私钥质数p：%d\n", n.Primes[0]) + starlog.Green("私钥质数q：%d\n", n.Primes[1]) + starlog.Green("私钥系数dP：%d\n", n.Precomputed.Dp) + starlog.Green("私钥系数dQ：%d\n", n.Precomputed.Dq) + starlog.Green("私钥系数qInv：%d\n", n.Precomputed.Qinv) + common = append(common, n) + case "RSA PUBLIC KEY": + n, err := x509.ParsePKCS1PublicKey(block.Bytes) + if err != nil { + starlog.Errorf("解析公钥错误：%s\n", err) + continue + } + starlog.Green("这是一个RSA公钥\n") + starlog.Green("公钥位数：%d\n", n.Size()) + starlog.Green("公钥长度：%d\n", n.N.BitLen()) + starlog.Green("公钥指数：%d\n", n.E) + common = append(common, n) + case "EC PRIVATE KEY": + n, err := x509.ParseECPrivateKey(block.Bytes) + if err != nil { + starlog.Errorf("解析私钥错误：%s\n", err) + continue + } + starlog.Green("这是一个ECDSA私钥\n") + starlog.Green("私钥位数：%d\n", n.Curve.Params().BitSize) + starlog.Green("私钥曲线：%s\n", n.Curve.Params().Name) + starlog.Green("私钥长度：%d\n", n.Params().BitSize) + starlog.Green("私钥系数：%d\n", n.D) + starlog.Green("私钥公钥X：%d\n", n.PublicKey.X) + starlog.Green("私钥公钥Y：%d\n", n.PublicKey.Y) + common = append(common, n) + case "EC PUBLIC KEY": + p, err := x509.ParsePKIXPublicKey(block.Bytes) + if err != nil { + starlog.Errorf("解析公钥错误：%s\n", err) + continue + } + n := p.(*ecdsa.PublicKey) + starlog.Green("这是一个ECDSA公钥\n") + starlog.Green("公钥位数：%d\n", n.Curve.Params().BitSize) + starlog.Green("公钥曲线：%s\n", n.Curve.Params().Name) + starlog.Green("公钥长度：%d\n", n.Params().BitSize) + starlog.Green("公钥公钥X：%d\n", n.X) + starlog.Green("公钥公钥Y：%d\n", n.Y) + common = append(common, n) default: starlog.Infof("未知证书文件类型\n") } @@ -604,7 +714,7 @@ func Pkcs1(data []byte, pwd string, originName string, outpath string) error { if err != nil { return err } - for _, v := range keys { + for idx, v := range keys { if v == nil { continue } @@ -614,24 +724,121 @@ func Pkcs1(data []byte, pwd string, originName string, outpath string) error { if err != nil { return err } - err = os.WriteFile(outpath+"/"+originName+".pkcs1", pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: data}), 0644) + err = os.WriteFile(fmt.Sprintf("%s/%s_%v.pkcs1", outpath, originName, idx), pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: data}), 0644) if err != nil { return err } else { - starlog.Green("已将私钥保存到%s\n", outpath+"/"+originName+".pkcs8") + starlog.Green("已将私钥保存到%s\n", fmt.Sprintf("%s/%s_%v.pkcs1", outpath, originName, idx)) } case *rsa.PublicKey: data = x509.MarshalPKCS1PublicKey(n) if err != nil { return err } - err = os.WriteFile(outpath+"/"+originName+".pub.pkcs1", pem.EncodeToMemory(&pem.Block{Type: "RSA PUBLIC KEY", Bytes: data}), 0644) + err = os.WriteFile(fmt.Sprintf("%s/%s_%v.pub.pkcs1", outpath, originName, idx), pem.EncodeToMemory(&pem.Block{Type: "RSA PUBLIC KEY", Bytes: data}), 0644) if err != nil { return err } else { - starlog.Green("已将公钥保存到%s\n", outpath+"/"+originName+".pub.pkcs1") + starlog.Green("已将公钥保存到%s\n", fmt.Sprintf("%s/%s_%v.pub.pkcs1", outpath, originName, idx)) } } } return nil } + +func Pkcs12(keys []any, certs []x509.Certificate, enPwd string, originName string, outpath string) error { + var priv any + for _, v := range keys { + if v == nil { + continue + } + switch n := v.(type) { + case *ecdsa.PrivateKey, *rsa.PrivateKey, *dsa.PrivateKey, *ed25519.PrivateKey, *ecdh.PrivateKey: + priv = n + break + } + } + if priv == nil { + return errors.New("未找到私钥") + } + if len(certs) == 0 { + return errors.New("未找到证书") + } + mainCert := certs[0] + var certChain []*x509.Certificate + for _, v := range certs[1:] { + certChain = append(certChain, &v) + } + + pfxData, err := pkcs12.Encode(rand.Reader, priv, &mainCert, certChain, enPwd) + if err != nil { + return err + } + err = os.WriteFile(outpath+"/"+originName+".pfx", pfxData, 0644) + if err != nil { + starlog.Errorf("保存失败：%s\n", err) + return err + } + starlog.Green("已将PKCS12文件保存到%s\n", outpath+"/"+originName+".pfx") + return nil +} + +func Tran(data []byte, pwd string, originName string, outpath string) error { + keys, _, err := GetCert(data, pwd) + if err != nil { + return err + } + for idx, v := range keys { + if v == nil { + continue + } + switch n := v.(type) { + case *ecdsa.PrivateKey, *rsa.PrivateKey: + data, err = starcrypto.EncodePrivateKey(n, "") + if err != nil { + return err + } + err = os.WriteFile(fmt.Sprintf("%s/%s_%v.tran.key", outpath, originName, idx), data, 0644) + if err != nil { + return err + } else { + starlog.Green("已将私钥保存到%s\n", fmt.Sprintf("%s/%s_%v.tran.key", outpath, originName, idx)) + } + case *ecdsa.PublicKey, *rsa.PublicKey: + data, err = starcrypto.EncodePublicKey(n) + if err != nil { + return err + } + err = os.WriteFile(fmt.Sprintf("%s/%s_%v.tran.pub", outpath, originName, idx), data, 0644) + if err != nil { + return err + } else { + starlog.Green("已将公钥保存到%s\n", fmt.Sprintf("%s/%s_%v.tran.pub", outpath, originName, idx)) + } + case *dsa.PrivateKey, *ed25519.PrivateKey, *ecdh.PrivateKey: + data, err = x509.MarshalPKCS8PrivateKey(n) + if err != nil { + return err + } + err = os.WriteFile(outpath+"/"+originName+".tran.key", pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: data}), 0644) + if err != nil { + return err + } else { + starlog.Green("已将私钥保存到%s\n", outpath+"/"+originName+".tran.key") + } + case *dsa.PublicKey, *ed25519.PublicKey, *ecdh.PublicKey: + data, err = x509.MarshalPKIXPublicKey(n) + if err != nil { + return err + } + err = os.WriteFile(outpath+"/"+originName+".tran.pub", pem.EncodeToMemory(&pem.Block{Type: "PUBLIC KEY", Bytes: data}), 0644) + if err != nil { + return err + } else { + starlog.Green("已将公钥保存到%s\n", outpath+"/"+originName+".tran.pub") + } + + } + } + return nil +} diff --git a/cert/cmd.go b/cert/cmd.go index c50ab24..65e5200 100644 --- a/cert/cmd.go +++ b/cert/cmd.go @@ -4,6 +4,7 @@ import ( "b612.me/starcrypto" "b612.me/stario" "b612.me/starlog" + "crypto/x509" "fmt" "github.com/spf13/cobra" "os" @@ -27,6 +28,7 @@ var csr string var pubKey string var caKeyPwd string var passwd string +var enPasswd string var Cmd = &cobra.Command{ Use: "cert", @@ -191,11 +193,23 @@ func init() { CmdGen.Flags().StringVarP(&caKeyPwd, "caKeyPwd", "p", "", "CA私钥密码") Cmd.AddCommand(CmdGen) - CmdParse.Flags().StringVarP(&passwd, "passwd", "p", "", "证书密码") + CmdParse.Flags().StringVarP(&passwd, "passwd", "p", "", "pfx解密密码") Cmd.AddCommand(CmdParse) - CmdPkcs8.Flags().StringVarP(&passwd, "passwd", "p", "", "证书密码") - CmdPkcs8.Flags().StringVarP(&savefolder, "savefolder", "s", "./", "保存文件夹") + CmdPkcs8.Flags().StringVarP(&passwd, "passwd", "p", "", "pfx解密密码") + CmdPkcs8.Flags().StringVarP(&savefolder, "savefolder", "s", ".", "保存文件夹") Cmd.AddCommand(CmdPkcs8) + CmdPkcs1.Flags().StringVarP(&passwd, "passwd", "p", "", "pfx解密密码") + CmdPkcs1.Flags().StringVarP(&savefolder, "savefolder", "s", ".", "保存文件夹") + Cmd.AddCommand(CmdPkcs1) + CmdPkcs12.Flags().StringVarP(&passwd, "passwd", "p", "", "pfx解密密码") + CmdPkcs12.Flags().StringVarP(&enPasswd, "pfx-passwd", "P", "", "pfx加密密码") + CmdPkcs12.Flags().StringVarP(&savefolder, "savefolder", "s", ".", "保存文件夹") + Cmd.AddCommand(CmdPkcs12) + + CmdBasic.Flags().StringVarP(&passwd, "passwd", "p", "", "pfx解密密码") + CmdBasic.Flags().StringVarP(&savefolder, "savefolder", "s", ".", "保存文件夹") + Cmd.AddCommand(CmdBasic) + } var CmdPkcs8 = &cobra.Command{ @@ -213,7 +227,96 @@ var CmdPkcs8 = &cobra.Command{ starlog.Errorln("读取证书错误", err) continue } - Pkcs8(data, passwd, filepath.Base(v), savefolder) + err = Pkcs8(data, passwd, filepath.Base(v), savefolder) + if err != nil { + starlog.Errorln("pkcs8转换错误", err) + continue + } + fmt.Println("\n-------" + v + "转换完毕---------\n") + } + }, +} + +var CmdPkcs1 = &cobra.Command{ + Use: "pkcs1", + Short: "pkcs1转换", + Long: "pkcs1转换", + Run: func(cmd *cobra.Command, args []string) { + if len(args) == 0 { + starlog.Errorln("请输入证书文件") + os.Exit(1) + } + for _, v := range args { + data, err := os.ReadFile(v) + if err != nil { + starlog.Errorln("读取证书错误", err) + continue + } + err = Pkcs1(data, passwd, filepath.Base(v), savefolder) + if err != nil { + starlog.Errorln("pkcs1转换错误", err) + continue + } + fmt.Println("\n-------" + v + "转换完毕---------\n") + } + }, +} + +var CmdPkcs12 = &cobra.Command{ + Use: "pkcs12", + Short: "pkcs12转换", + Long: "pkcs12转换", + Run: func(cmd *cobra.Command, args []string) { + if len(args) == 0 { + starlog.Errorln("请输入证书文件") + os.Exit(1) + } + var keys []any + var certs []x509.Certificate + + for _, v := range args { + data, err := os.ReadFile(v) + if err != nil { + starlog.Errorln("读取证书错误", err) + continue + } + key, cert, err := GetCert(data, passwd) + if err != nil { + starlog.Errorln("证书读取错误", err) + os.Exit(1) + } + keys = append(keys, key...) + certs = append(certs, cert...) + } + err := Pkcs12(keys, certs, enPasswd, filepath.Base(args[0]), savefolder) + if err != nil { + starlog.Errorln("pkcs12转换错误", err) + os.Exit(1) + } + fmt.Println("\n-------pfk转换完毕---------\n") + }, +} + +var CmdBasic = &cobra.Command{ + Use: "basic", + Short: "证书转换为基本类型", + Long: "证书转换为基本类型", + Run: func(cmd *cobra.Command, args []string) { + if len(args) == 0 { + starlog.Errorln("请输入证书文件") + os.Exit(1) + } + for _, v := range args { + data, err := os.ReadFile(v) + if err != nil { + starlog.Errorln("读取证书错误", err) + continue + } + err = Tran(data, passwd, filepath.Base(v), savefolder) + if err != nil { + starlog.Errorln("证书转换错误", err) + continue + } fmt.Println("\n-------" + v + "转换完毕---------\n") } }, diff --git a/go.mod b/go.mod index bb35849..6648ec5 100644 --- a/go.mod +++ b/go.mod @@ -4,7 +4,7 @@ go 1.19 require ( b612.me/notify v1.2.5 - b612.me/starcrypto v0.0.4 + b612.me/starcrypto v0.0.5 b612.me/stario v0.0.9 b612.me/starlog v1.3.3 b612.me/starnet v0.1.8 @@ -24,6 +24,7 @@ require ( github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 github.com/spf13/cobra v1.8.0 github.com/things-go/go-socks5 v0.0.5 + golang.org/x/crypto v0.21.0 software.sslmate.com/src/go-pkcs12 v0.4.0 ) @@ -36,7 +37,6 @@ require ( github.com/kr/fs v0.1.0 // indirect github.com/pkg/sftp v1.13.4 // indirect github.com/spf13/pflag v1.0.5 // indirect - golang.org/x/crypto v0.21.0 // indirect golang.org/x/image v0.6.0 // indirect golang.org/x/mod v0.14.0 // indirect golang.org/x/net v0.21.0 // indirect diff --git a/go.sum b/go.sum index 165a993..adb75e4 100644 --- a/go.sum +++ b/go.sum @@ -1,8 +1,8 @@ b612.me/notify v1.2.5 h1:fASpzi8YAo78g6jKnefzfbsQz0nGNYFbClB2Bylj+MA= b612.me/notify v1.2.5/go.mod h1:GTnAdC6v9krGxtC8Gkn8TcyUsYnHSiHjRAXsONPiLpI= b612.me/starcrypto v0.0.3/go.mod h1:pF5A16p8r/h1G0x7ZNmmAF6K1sdIMpbCUxn2WGC8gZ0= -b612.me/starcrypto v0.0.4 h1:4obj3QC9SoFop9WA3xKNS99WCvRrxZnvEUMBVzrD4HM= -b612.me/starcrypto v0.0.4/go.mod h1:pF5A16p8r/h1G0x7ZNmmAF6K1sdIMpbCUxn2WGC8gZ0= +b612.me/starcrypto v0.0.5 h1:Aa4pRDO2lBH2Aw+vz8NuUtRb73J8z5aOa9SImBY5sq4= +b612.me/starcrypto v0.0.5/go.mod h1:pF5A16p8r/h1G0x7ZNmmAF6K1sdIMpbCUxn2WGC8gZ0= b612.me/stario v0.0.9 h1:bFDlejUJMwZ12a09snZJspQsOlkqpDAl9qKPEYOGWCk= b612.me/stario v0.0.9/go.mod h1:x4D/x8zA5SC0pj/uJAi4FyG5p4j5UZoMEZfvuRR6VNw= b612.me/starlog v1.3.3 h1:xYCHouOTpo6dsFg2A92TqTznxvRPPS/ovMWs7CJZ9WI= diff --git a/hash/hash.go b/hash/hash.go index 3553f20..a04fe32 100644 --- a/hash/hash.go +++ b/hash/hash.go @@ -1,15 +1,26 @@ package hash import ( - "b612.me/starcrypto" + "crypto/hmac" + "crypto/md5" + "crypto/sha1" + "crypto/sha256" + "crypto/sha512" "encoding/hex" "fmt" + "golang.org/x/crypto/md4" + "golang.org/x/crypto/ripemd160" + "hash" + "hash/crc32" + "io" "os" "b612.me/starlog" "github.com/spf13/cobra" ) +var hmacKey string + var Cmd = &cobra.Command{ Use: "hash", Short: "多种方法哈希值校验", @@ -18,7 +29,7 @@ var Cmd = &cobra.Command{ var cumethod, method []string var result = make(map[string]string) var err error - cumethod = []string{"md5", "crc32", "sha512", "sha384", "sha256", "sha224", "sha1"} + cumethod = []string{"md5", "crc32", "sha512", "sha384", "sha256", "sha224", "sha1", "md4", "ripemd160", "hmacmd5", "hmacmd4", "hmacsha1", "hmacsha224", "hmacsha256", "hmacsha384", "hmacsha512"} if ok, _ := this.Flags().GetBool("all"); ok { method = cumethod } else { @@ -37,7 +48,7 @@ var Cmd = &cobra.Command{ } } if ok, _ := this.Flags().GetBool("file"); ok { - result, err = starcrypto.FileSumAll(args[0], method, func(pect float64) { + result, err = FileSumAll(args[0], hmacKey, method, func(pect float64) { if pect != 100.0 { fmt.Printf("校验已完成：%f%%\r", pect) } else { @@ -46,7 +57,7 @@ var Cmd = &cobra.Command{ }) } else { var bres map[string][]byte - bres, err = starcrypto.SumAll([]byte(args[0]), method) + bres, err = SumAll([]byte(args[0]), hmacKey, method) if err == nil { for k, v := range bres { result[k] = hex.EncodeToString(v) @@ -63,6 +74,7 @@ var Cmd = &cobra.Command{ } func init() { + Cmd.Flags().StringVarP(&hmacKey, "hmac-key", "k", "b612.me", "HMAC密钥") Cmd.Flags().BoolP("all", "a", false, "使用所有的校验方法") Cmd.Flags().BoolP("file", "f", false, "对指定文件进行校验") Cmd.Flags().BoolP("md5", "m", false, "进行MD5校验（默认）") @@ -72,4 +84,185 @@ func init() { Cmd.Flags().Bool("sha256", false, "进行SHA256校验") Cmd.Flags().Bool("sha224", false, "进行SHA224校验") Cmd.Flags().Bool("sha1", false, "进行SHA1校验") + Cmd.Flags().Bool("md4", false, "进行MD4校验") + Cmd.Flags().Bool("ripemd160", false, "进行RIPEMD160校验") + Cmd.Flags().Bool("hmacmd5", false, "进行HMACMD5校验") + Cmd.Flags().Bool("hmacmd4", false, "进行HMACMD4校验") + Cmd.Flags().Bool("hmacsha1", false, "进行HMACSHA1校验") + Cmd.Flags().Bool("hmacsha224", false, "进行HMACSHA224校验") + Cmd.Flags().Bool("hmacsha256", false, "进行HMACSHA256校验") + Cmd.Flags().Bool("hmacsha384", false, "进行HMACSHA384校验") + Cmd.Flags().Bool("hmacsha512", false, "进行HMACSHA512校验") +} + +func FileSumAll(filepath string, key 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", "md4", "ripemd160", "hmacmd5", "hmacmd4", "hmacsha1", "hmacsha224", "hmacsha256", "hmacsha384", "hmacsha512"} + } + 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() + md4sum := md4.New() + ripemd160sum := ripemd160.New() + hmacmd5sum := hmac.New(md5.New, []byte(key)) + hmacmd4sum := hmac.New(md4.New, []byte(key)) + hmacsha1sum := hmac.New(sha1.New, []byte(key)) + hmacsha224sum := hmac.New(sha256.New224, []byte(key)) + hmacsha256sum := hmac.New(sha256.New, []byte(key)) + hmacsha384sum := hmac.New(sha512.New384, []byte(key)) + hmacsha512sum := hmac.New(sha512.New, []byte(key)) + 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 + case "md4": + methods["md4"] = md4sum + case "ripemd160": + methods["ripemd160"] = ripemd160sum + case "hmacmd5": + methods["hmacmd5"] = hmacmd5sum + case "hmacmd4": + methods["hmacmd4"] = hmacmd4sum + case "hmacsha1": + methods["hmacsha1"] = hmacsha1sum + case "hmacsha224": + methods["hmacsha224"] = hmacsha224sum + case "hmacsha256": + methods["hmacsha256"] = hmacsha256sum + case "hmacsha384": + methods["hmacsha384"] = hmacsha384sum + case "hmacsha512": + methods["hmacsha512"] = hmacsha512sum + } + } + + 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 +} + +func SumAll(data []byte, key string, 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", "md4", "ripemd160", "hmacmd5", "hmacmd4", "hmacsha1", "hmacsha224", "hmacsha256", "hmacsha384", "hmacsha512"} + } + sum512 := sha512.New() + sum384 := sha512.New384() + sum256 := sha256.New() + sum224 := sha256.New224() + sum1 := sha1.New() + crcsum := crc32.NewIEEE() + md5sum := md5.New() + md4sum := md4.New() + ripemd160sum := ripemd160.New() + hmacmd5sum := hmac.New(md5.New, []byte(key)) + hmacmd4sum := hmac.New(md4.New, []byte(key)) + hmacsha1sum := hmac.New(sha1.New, []byte(key)) + hmacsha224sum := hmac.New(sha256.New224, []byte(key)) + hmacsha256sum := hmac.New(sha256.New, []byte(key)) + hmacsha384sum := hmac.New(sha512.New384, []byte(key)) + hmacsha512sum := hmac.New(sha512.New, []byte(key)) + 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 + case "md4": + methods["md4"] = md4sum + case "ripemd160": + methods["ripemd160"] = ripemd160sum + case "hmacmd5": + methods["hmacmd5"] = hmacmd5sum + case "hmacmd4": + methods["hmacmd4"] = hmacmd4sum + case "hmacsha1": + methods["hmacsha1"] = hmacsha1sum + case "hmacsha224": + methods["hmacsha224"] = hmacsha224sum + case "hmacsha256": + methods["hmacsha256"] = hmacsha256sum + case "hmacsha384": + methods["hmacsha384"] = hmacsha384sum + case "hmacsha512": + methods["hmacsha512"] = hmacsha512sum + } + } + 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 } diff --git a/keygen/cmd.go b/keygen/cmd.go index 8a1c789..503fd66 100644 --- a/keygen/cmd.go +++ b/keygen/cmd.go @@ -23,7 +23,7 @@ var outpath string var sshPub bool func init() { - Cmd.Flags().StringVarP(&k.Type, "type", "t", "rsa", "Key Type: rsa, ecdsa") + Cmd.Flags().StringVarP(&k.Type, "type", "t", "rsa", "Key Type: rsa, ecdsa, ed25519") Cmd.Flags().StringVarP(&k.Encrypt, "encrypt", "e", "", "Encrypt Key with Password (not recommended)") Cmd.Flags().IntVarP(&k.Bits, "bits", "b", 2048, "Key Bits Rsa: 1024, 2048, 4096 Ecdsa: 224, 256, 384, 521") Cmd.Flags().StringVarP(&k.Prefix, "prefix", "p", "mykey", "Output File Prefix") diff --git a/keygen/keygen.go b/keygen/keygen.go index 1fa9935..c68fd3d 100644 --- a/keygen/keygen.go +++ b/keygen/keygen.go @@ -5,6 +5,7 @@ import ( "b612.me/staros" "crypto" "crypto/ecdsa" + "crypto/ed25519" "crypto/elliptic" "crypto/rand" "crypto/rsa" @@ -13,6 +14,7 @@ import ( "encoding/hex" "encoding/pem" "errors" + "fmt" "io" "math/big" "os" @@ -61,7 +63,7 @@ func (k *KeyGen) Gen() error { if err != nil { return err } - case "ecdsa": + case "ecdsa", "ecdh": var cr elliptic.Curve switch k.Bits { case 224: @@ -79,6 +81,11 @@ func (k *KeyGen) Gen() error { if err != nil { return err } + case "ed25519": + pub, priv, err = ed25519.GenerateKey(rand.Reader) + if err != nil { + return err + } default: return errors.New("invalid key type,only support rsa,ecdsa") } @@ -166,8 +173,10 @@ func (k *KeyGen) GenerateCert(priv crypto.PrivateKey) ([]byte, []byte, error) { } case *ecdsa.PrivateKey: cert, err = MakeCert(priv.(*ecdsa.PrivateKey), rootCsr, rootCsr, priv.(*ecdsa.PrivateKey).Public()) + case ed25519.PrivateKey: + cert, err = MakeCert(priv.(ed25519.PrivateKey), rootCsr, rootCsr, priv.(ed25519.PrivateKey).Public()) default: - return nil, nil, errors.New("invalid private key type") + return nil, nil, errors.New("invalid private key type:" + fmt.Sprintf("%T", priv)) } csrPem := pem.EncodeToMemory(&pem.Block{ diff --git a/main.go b/main.go index a145687..393f18a 100644 --- a/main.go +++ b/main.go @@ -1,6 +1,7 @@ package main import ( + "b612.me/apps/b612/aes" "b612.me/apps/b612/attach" "b612.me/apps/b612/base64" "b612.me/apps/b612/base85" @@ -48,7 +49,7 @@ func init() { base64.Cmd, base85.Cmd, base91.Cmd, attach.Cmd, detach.Cmd, df.Cmd, dfinder.Cmd, ftp.Cmd, generate.Cmd, hash.Cmd, image.Cmd, merge.Cmd, search.Cmd, split.Cmd, vic.Cmd, calc.Cmd, net.Cmd, rmt.Cmds, rmt.Cmdc, keygen.Cmd, dns.Cmd, whois.Cmd, socks5.Cmd, httproxy.Cmd, smtpserver.Cmd, smtpclient.Cmd, - cert.Cmd) + cert.Cmd, aes.Cmd) } func main() {