xt/ag_tools
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

build(init):项目加入版本库控制。

Browse Source
This commit is contained in:
徐涛
2023-07-17 22:17:40 +08:00
commit 86834970b5
34 changed files with 2149 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
cmd/rsa/decryption.go Normal file
View File

@@ -0,0 +1,126 @@
package rsa
import (
"fmt"
"io"
"os"
"archgrid.xyz/ag/tools/types"
"archgrid.xyz/ag/toolsbox/encryption/rsa"
"archgrid.xyz/ag/toolsbox/serialize/base64"
"archgrid.xyz/ag/toolsbox/serialize/hex"
"github.com/spf13/cobra"
)
var (
rsaDecryptionFromFile bool
rsaDecryptionToFile bool
rsaDecryptionFromEncoding types.ResultEncoding = types.ResultInHex
rsaDecryptionInputFile string
rsaDecryptionOutputFile string
)
var rsaDecryptionCmd = &cobra.Command{
Use: "decrypt",
Short: `使用RSA算法对给定的内容进行解密`,
Long: `使用RSA算法对给定的内容进行解密，生成RSA密钥。如果指定了输入文件，则从输入文件中读取内容进行解密，否则从命令行读取内容进行解密。如果指定了输出文件，则将解密后的内容写入到输出文件中，否则将解密后的内容输出到命令行。`,
Args: cobra.MaximumNArgs(1),
Run: rsaDecryptionExecute,
}
func rsaDecryptionExecute(cmd *cobra.Command, args []string) {
var (
content []byte
cert []byte
keys *rsa.KeyPair
err error
)
if len(privateKeyFile) > 0 {
file, err := os.Open(privateKeyFile)
if err != nil {
fmt.Printf("无法打开RSA私钥文件：%s\n", err)
return
}
cert, err = io.ReadAll(file)
if err != nil {
fmt.Printf("无法读取RSA私钥文件：%s\n", err)
return
}
} else {
fmt.Println("必须提供RSA私钥文件才能够解密。")
return
}
keys, err = rsa.NewFromPEM(cert)
if err != nil {
fmt.Printf("无法解析RSA私钥：%s\n", err)
return
}
if rsaDecryptionFromFile {
if len(rsaDecryptionInputFile) == 0 {
fmt.Println("必须指定输入文件名。")
return
}
file, err := os.Open(rsaDecryptionInputFile)
if err != nil {
fmt.Printf("无法打开输入文件：%s\n", err)
return
}
content, err = io.ReadAll(file)
if err != nil {
fmt.Printf("无法读取输入文件：%s\n", err)
return
}
} else {
if len(args) == 0 {
fmt.Println("必须指定待解密的内容。")
return
}
switch rsaDecryptionFromEncoding {
case types.ResultInHex:
content, err = hex.FromHex(args[0])
if err != nil {
fmt.Printf("无法解析十六进制编码：%s\n", err)
return
}
case types.ResultInBase64:
content, err = base64.FromBase64(args[0])
if err != nil {
fmt.Printf("无法解析Base64编码：%s\n", err)
return
}
}
}
decrypted, err := keys.Decrypt(content)
if err != nil {
fmt.Printf("无法解密：%s\n", err)
return
}
if rsaDecryptionToFile {
if len(rsaDecryptionOutputFile) == 0 {
fmt.Println("必须指定输出文件名。")
return
}
file, err := os.OpenFile(rsaDecryptionOutputFile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
if err != nil {
fmt.Printf("无法打开输出文件：%s\n", err)
return
}
defer file.Close()
_, err = file.Write(decrypted)
if err != nil {
fmt.Printf("无法写入输出文件：%s\n", err)
return
}
} else {
fmt.Printf("解密结果：%s\n", decrypted)
}
}
func init() {
rsaDecryptionCmd.Flags().BoolVarP(&rsaDecryptionFromFile, "from-file", "f", false, "从文件中读取待解密的内容")
rsaDecryptionCmd.Flags().BoolVarP(&rsaDecryptionToFile, "to-file", "t", false, "将解密后的内容写入到文件中")
rsaDecryptionCmd.Flags().VarP(&rsaDecryptionFromEncoding, "from-encoding", "e", "指定输出格式，可选值为hex、base64，默认值为hex。对文件输入格式不起作用。")
rsaDecryptionCmd.Flags().StringVarP(&rsaDecryptionInputFile, "input-file", "i", "", "指定输入文件名")
rsaDecryptionCmd.Flags().StringVarP(&rsaDecryptionOutputFile, "output-file", "o", "", "指定输出文件名")
rsaCmd.AddCommand(rsaDecryptionCmd)
}

127
cmd/rsa/encryption.go Normal file
View File

@@ -0,0 +1,127 @@
package rsa
import (
"fmt"
"io"
"os"
"archgrid.xyz/ag/tools/types"
"archgrid.xyz/ag/toolsbox/encryption/rsa"
"archgrid.xyz/ag/toolsbox/serialize/base64"
"archgrid.xyz/ag/toolsbox/serialize/hex"
"github.com/spf13/cobra"
)
var (
rsaEncryptFromFile bool
rsaEncryptToFile bool
rsaResultOutput types.ResultEncoding = types.ResultInHex
rsaEncryptInputFile string
rsaEncryptOutputFile string
)
var rsaEncryptCmd = &cobra.Command{
Use: "encrypt",
Short: `使用RSA算法对给定的内容进行加密`,
Long: `使用RSA算法对给定的内容进行加密，生成RSA密钥。如果指定了输入文件，则从输入文件中读取内容进行加密，否则从命令行读取内容进行加密。如果指定了输出文件，则将加密后的内容写入到输出文件中，否则将加密后的内容输出到命令行。`,
Args: cobra.MaximumNArgs(1),
Run: rsaEncryptExecute,
}
func rsaEncryptExecute(cmd *cobra.Command, args []string) {
var (
content []byte
cert []byte
keys *rsa.KeyPair
err error
)
if len(publicKeyFile) > 0 {
file, err := os.Open(publicKeyFile)
if err != nil {
fmt.Printf("无法打开RSA公钥文件：%s\n", err)
return
}
cert, err = io.ReadAll(file)
if err != nil {
fmt.Printf("无法读取RSA公钥文件：%s\n", err)
return
}
} else if len(privateKeyFile) > 0 {
file, err := os.Open(privateKeyFile)
if err != nil {
fmt.Printf("无法打开RSA私钥文件：%s\n", err)
return
}
cert, err = io.ReadAll(file)
if err != nil {
fmt.Printf("无法读取RSA私钥文件：%s\n", err)
return
}
} else {
fmt.Println("必须指定RSA公钥文件或RSA私钥文件。")
return
}
keys, err = rsa.NewFromPEM(cert)
if err != nil {
fmt.Printf("无法解析RSA密钥：%s\n", err)
return
}
if rsaEncryptFromFile {
if len(rsaEncryptInputFile) == 0 {
fmt.Println("必须指定输入文件。")
return
}
file, err := os.Open(rsaEncryptInputFile)
if err != nil {
fmt.Printf("无法打开输入文件：%s\n", err)
return
}
content, err = io.ReadAll(file)
if err != nil {
fmt.Printf("无法读取输入文件：%s\n", err)
return
}
} else {
if len(args) == 0 {
fmt.Println("必须指定要加密的内容。")
return
}
content = []byte(args[0])
}
encrypted, err := keys.Encrypt(content)
if err != nil {
fmt.Printf("无法加密内容：%s\n", err)
return
}
if len(rsaEncryptOutputFile) > 0 {
file, err := os.OpenFile(rsaEncryptOutputFile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
if err != nil {
fmt.Printf("无法创建RSA加密文件：%s\n", err)
return
}
_, err = file.Write(encrypted)
if err != nil {
fmt.Printf("无法写入RSA加密文件：%s\n", err)
return
}
fmt.Printf("已将加密结果写入到文件：%s\n", rsaEncryptOutputFile)
} else {
switch rsaResultOutput {
case types.ResultInBase64:
fmt.Printf("加密结果：%s\n", base64.ToBase64(encrypted))
case types.ResultInHex:
fallthrough
default:
fmt.Printf("加密结果：%s\n", hex.ToHex(encrypted))
}
}
}
func init() {
rsaEncryptCmd.PersistentFlags().BoolVarP(&rsaEncryptFromFile, "from-file", "f", false, "从输入文件中读取内容进行加密。")
rsaEncryptCmd.PersistentFlags().BoolVarP(&rsaEncryptToFile, "to-file", "t", false, "将加密后的内容写入到输出文件中。")
rsaEncryptCmd.PersistentFlags().StringVarP(&rsaEncryptInputFile, "input-file", "i", "", "输入文件。")
rsaEncryptCmd.PersistentFlags().StringVarP(&rsaEncryptOutputFile, "output-file", "o", "", "输出文件。")
rsaEncryptCmd.PersistentFlags().VarP(&rsaResultOutput, "output-encode", "e", "加密结果输出格式，可选值有：hex，base64，缺省值为hex。对输出到文件的方式无效。")
rsaCmd.AddCommand(rsaEncryptCmd)
}

71
cmd/rsa/key.go Normal file
View File

@@ -0,0 +1,71 @@
package rsa
import (
"fmt"
"os"
"archgrid.xyz/ag/toolsbox/encryption/rsa"
"github.com/spf13/cobra"
)
var (
rsaKeyOutputFile string
)
var keyGenCmd = &cobra.Command{
Use: "keygen",
Short: "生成RSA密钥对",
Long: `生成RSA密钥对，密钥对将会被保存到指定的文件中。`,
Args: cobra.NoArgs,
Run: keyGenExecute,
}
func keyGenExecute(cmd *cobra.Command, args []string) {
if len(rsaKeyOutputFile) == 0 {
fmt.Println("必须指定密钥输出文件名的前缀。")
return
}
keyPair, err := rsa.NewKeyPair(rsaKeyLength.IntoRSAKeyLength())
if err != nil {
fmt.Printf("无法生成RSA密钥对：%s\n", err)
return
}
privateKeyBytes, err := rsa.EncodePrivateKey(keyPair.PrivateKey)
if err != nil {
fmt.Printf("无法编码RSA私钥：%s\n", err)
return
}
privateKeyFile, err := os.OpenFile(rsaKeyOutputFile+".pri.pem", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
if err != nil {
fmt.Printf("无法创建RSA私钥文件：%s\n", err)
return
}
defer privateKeyFile.Close()
_, err = privateKeyFile.Write(privateKeyBytes)
if err != nil {
fmt.Printf("无法写入RSA私钥文件：%s\n", err)
return
}
publicKeyBytes, err := rsa.EncodePublicKey(keyPair.PublicKey)
if err != nil {
fmt.Printf("无法编码RSA公钥：%s\n", err)
return
}
publicKeyFile, err := os.OpenFile(rsaKeyOutputFile+".pub.pem", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
if err != nil {
fmt.Printf("无法创建RSA公钥文件：%s\n", err)
return
}
defer publicKeyFile.Close()
_, err = publicKeyFile.Write(publicKeyBytes)
if err != nil {
fmt.Printf("无法写入RSA公钥文件：%s\n", err)
return
}
fmt.Printf("RSA密钥对已经保存到文件：%s.pri.pem, %s.pub.pem\n", rsaKeyOutputFile, rsaKeyOutputFile)
}
func init() {
keyGenCmd.Flags().StringVarP(&rsaKeyOutputFile, "output", "o", "", "用于保存密钥输出文件名的前缀。")
rsaCmd.AddCommand(keyGenCmd)
}

29
cmd/rsa/rsa.go Normal file
View File

@@ -0,0 +1,29 @@
package rsa
import (
"archgrid.xyz/ag/tools/types"
"github.com/spf13/cobra"
)
var (
rsaKeyLength types.RSAKeyBits = types.RSA2048
publicKeyFile string
privateKeyFile string
)
var rsaCmd = &cobra.Command{
Use: "rsa",
Short: `RSA加密算法工具`,
Long: `使用RSA算法对给定的内容进行加密或解密，生成RSA密钥。`,
TraverseChildren: true,
}
func init() {
rsaCmd.PersistentFlags().VarP(&rsaKeyLength, "key-length", "l", "RSA密钥长度，可选值有：1024, 2048，缺省值为2048。")
rsaCmd.PersistentFlags().StringVarP(&publicKeyFile, "public-key", "u", "", "RSA公钥文件，用于加密。")
rsaCmd.PersistentFlags().StringVarP(&privateKeyFile, "private-key", "r", "", "RSA私钥文件，用于解密。")
}
func GetRsaCmd() *cobra.Command {
return rsaCmd
}

96
cmd/rsa/sign.go Normal file
View File

@@ -0,0 +1,96 @@
package rsa
import (
"fmt"
"io"
"os"
"archgrid.xyz/ag/tools/types"
"archgrid.xyz/ag/toolsbox/encryption/rsa"
"archgrid.xyz/ag/toolsbox/serialize/base64"
"archgrid.xyz/ag/toolsbox/serialize/hex"
"github.com/spf13/cobra"
)
var (
rsaSignFile bool
rsaSignInputFile string
rsaSignEncoding types.ResultEncoding = types.ResultInHex
)
var rsaSignCmd = &cobra.Command{
Use: "sign",
Short: `使用RSA算法对给定的内容进行签名`,
Long: `使用RSA算法对给定的内容进行签名，生成RSA密钥。如果指定了输入文件，则从输入文件中读取内容进行签名，否则从命令行读取内容进行签名。`,
Args: cobra.MaximumNArgs(1),
Run: rsaSignExecute,
}
func rsaSignExecute(cmd *cobra.Command, args []string) {
var (
content []byte
cert []byte
keys *rsa.KeyPair
err error
)
if len(privateKeyFile) > 0 {
file, err := os.Open(privateKeyFile)
if err != nil {
fmt.Printf("无法打开RSA私钥文件：%s\n", err)
return
}
cert, err = io.ReadAll(file)
if err != nil {
fmt.Printf("无法读取RSA私钥文件：%s\n", err)
return
}
} else {
fmt.Println("必须提供RSA私钥文件才能够签名。")
return
}
keys, err = rsa.NewFromPEM(cert)
if err != nil {
fmt.Printf("无法解析RSA私钥：%s\n", err)
return
}
if rsaSignFile {
if len(rsaSignInputFile) == 0 {
fmt.Println("必须指定输入文件名。")
return
}
file, err := os.Open(rsaSignInputFile)
if err != nil {
fmt.Printf("无法打开输入文件：%s\n", err)
return
}
content, err = io.ReadAll(file)
if err != nil {
fmt.Printf("无法读取输入文件：%s\n", err)
return
}
} else {
if len(args) == 0 {
fmt.Println("必须指定输入内容。")
return
}
content = []byte(args[0])
}
signature, err := keys.Sign(content)
if err != nil {
fmt.Printf("无法签名：%s\n", err)
return
}
switch rsaSignEncoding {
case types.ResultInHex:
fmt.Printf("签名为：%s\n", hex.ToHex(signature))
case types.ResultInBase64:
fmt.Printf("签名为：%s\n", base64.ToBase64(signature))
}
}
func init() {
rsaSignCmd.Flags().BoolVarP(&rsaSignFile, "file", "f", false, "指定对文件内容进行签名")
rsaSignCmd.Flags().StringVarP(&rsaSignInputFile, "input", "i", "", "指定读入内容的文件名")
rsaSignCmd.Flags().VarP(&rsaSignEncoding, "encoding", "e", "指定签名输出编码方式，可选值为hex或base64")
rsaCmd.AddCommand(rsaSignCmd)
}

119
cmd/rsa/verify.go Normal file
View File

@@ -0,0 +1,119 @@
package rsa
import (
"fmt"
"io"
"os"
"archgrid.xyz/ag/tools/types"
"archgrid.xyz/ag/toolsbox/encryption/rsa"
"archgrid.xyz/ag/toolsbox/serialize/base64"
"archgrid.xyz/ag/toolsbox/serialize/hex"
"github.com/spf13/cobra"
)
var (
rsaVerifyFile bool
rsaVerifyInputFile string
rsaVerifyEncoding types.ResultEncoding = types.ResultInHex
)
var rsaVerifyCmd = &cobra.Command{
Use: "verify",
Short: `使用RSA算法对给定的内容进行验证`,
Long: `使用RSA算法对给定的内容进行验证，生成RSA密钥。如果指定了输入文件，则从输入文件中读取内容进行验证，否则从命令行读取内容进行验证。`,
Args: cobra.MaximumNArgs(2),
Run: rsaVerifyExecute,
}
func rsaVerifyExecute(cmd *cobra.Command, args []string) {
var (
content []byte
cert []byte
keys *rsa.KeyPair
err error
)
if len(publicKeyFile) > 0 {
file, err := os.Open(publicKeyFile)
if err != nil {
fmt.Printf("无法打开RSA公钥文件：%s\n", err)
return
}
cert, err = io.ReadAll(file)
if err != nil {
fmt.Printf("无法读取RSA公钥文件：%s\n", err)
return
}
} else if len(privateKeyFile) > 0 {
file, err := os.Open(privateKeyFile)
if err != nil {
fmt.Printf("无法打开RSA私钥文件：%s\n", err)
return
}
cert, err = io.ReadAll(file)
if err != nil {
fmt.Printf("无法读取RSA私钥文件：%s\n", err)
return
}
} else {
fmt.Println("必须提供RSA密钥文件才能够验证。")
return
}
keys, err = rsa.NewFromPEM(cert)
if err != nil {
fmt.Printf("无法解析RSA密钥：%s\n", err)
return
}
if rsaVerifyFile {
if len(rsaVerifyInputFile) == 0 {
fmt.Println("必须指定输入文件名。")
return
}
file, err := os.Open(rsaVerifyInputFile)
if err != nil {
fmt.Printf("无法打开输入文件：%s\n", err)
return
}
content, err = io.ReadAll(file)
if err != nil {
fmt.Printf("无法读取输入文件：%s\n", err)
return
}
} else {
if len(args) < 1 {
fmt.Println("必须指定待验证内容。")
return
}
content = []byte(args[0])
}
var signature []byte
switch rsaVerifyEncoding {
case types.ResultInHex:
signature, err = hex.FromHex(args[len(args)-1])
if err != nil {
fmt.Printf("无法解析签名内容：%s\n", err)
return
}
case types.ResultInBase64:
signature, err = base64.FromBase64(args[len(args)-1])
if err != nil {
fmt.Printf("无法解析签名内容：%s\n", err)
return
}
default:
fmt.Println("不支持的签名内容编码方式。")
return
}
if err = keys.Verify(content, signature); err != nil {
fmt.Printf("验证失败，%s\n", err)
} else {
fmt.Println("验证成功。")
}
}
func init() {
rsaVerifyCmd.Flags().BoolVarP(&rsaVerifyFile, "file", "f", false, "指定从文件中读入待验证内容")
rsaVerifyCmd.Flags().StringVarP(&rsaVerifyInputFile, "input", "i", "", "指定读入内容的文件名")
rsaVerifyCmd.Flags().VarP(&rsaVerifyEncoding, "encoding", "e", "指定签名内容的编码方式，可选值为hex和base64，默认为hex")
rsaCmd.AddCommand(rsaVerifyCmd)
}