mirror of
https://github.com/duke-git/lancet.git
synced 2025-09-26 19:41:20 +08:00
586 lines
10 KiB
Go
586 lines
10 KiB
Go
package cryptor
|
|
|
|
import (
|
|
"crypto"
|
|
"fmt"
|
|
)
|
|
|
|
func ExampleAesEcbEncrypt() {
|
|
data := "hello"
|
|
key := "abcdefghijklmnop"
|
|
|
|
encrypted := AesEcbEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := AesEcbDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleAesEcbDecrypt() {
|
|
data := "hello"
|
|
key := "abcdefghijklmnop"
|
|
|
|
encrypted := AesEcbEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := AesEcbDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleAesCbcEncrypt() {
|
|
data := "hello"
|
|
key := "abcdefghijklmnop"
|
|
|
|
encrypted := AesCbcEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := AesCbcDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleAesCbcDecrypt() {
|
|
data := "hello"
|
|
key := "abcdefghijklmnop"
|
|
|
|
encrypted := AesCbcEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := AesCbcDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleAesCtrCrypt() {
|
|
data := "hello"
|
|
key := "abcdefghijklmnop"
|
|
|
|
encrypted := AesCtrCrypt([]byte(data), []byte(key))
|
|
decrypted := AesCtrCrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleAesCfbEncrypt() {
|
|
data := "hello"
|
|
key := "abcdefghijklmnop"
|
|
|
|
encrypted := AesCfbEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := AesCfbDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleAesCfbDecrypt() {
|
|
data := "hello"
|
|
key := "abcdefghijklmnop"
|
|
|
|
encrypted := AesCfbEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := AesCfbDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleAesOfbEncrypt() {
|
|
data := "hello"
|
|
key := "abcdefghijklmnop"
|
|
|
|
encrypted := AesOfbEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := AesOfbDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleAesOfbDecrypt() {
|
|
data := "hello"
|
|
key := "abcdefghijklmnop"
|
|
|
|
encrypted := AesOfbEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := AesOfbDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleAesGcmEncrypt() {
|
|
data := "hello"
|
|
key := "abcdefghijklmnop"
|
|
|
|
encrypted := AesGcmEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := AesGcmDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleAesGcmDecrypt() {
|
|
data := "hello"
|
|
key := "abcdefghijklmnop"
|
|
|
|
encrypted := AesGcmEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := AesGcmDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleDesEcbEncrypt() {
|
|
data := "hello"
|
|
key := "abcdefgh"
|
|
|
|
encrypted := DesEcbEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := DesEcbDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleDesEcbDecrypt() {
|
|
data := "hello"
|
|
key := "abcdefgh"
|
|
|
|
encrypted := DesEcbEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := DesEcbDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleDesCbcEncrypt() {
|
|
data := "hello"
|
|
key := "abcdefgh"
|
|
|
|
encrypted := DesCbcEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := DesCbcDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleDesCbcDecrypt() {
|
|
data := "hello"
|
|
key := "abcdefgh"
|
|
|
|
encrypted := DesCbcEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := DesCbcDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleDesCtrCrypt() {
|
|
data := "hello"
|
|
key := "abcdefgh"
|
|
|
|
encrypted := DesCtrCrypt([]byte(data), []byte(key))
|
|
decrypted := DesCtrCrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleDesCfbEncrypt() {
|
|
data := "hello"
|
|
key := "abcdefgh"
|
|
|
|
encrypted := DesCfbEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := DesCfbDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleDesCfbDecrypt() {
|
|
data := "hello"
|
|
key := "abcdefgh"
|
|
|
|
encrypted := DesCfbEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := DesCfbDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleDesOfbEncrypt() {
|
|
data := "hello"
|
|
key := "abcdefgh"
|
|
|
|
encrypted := DesOfbEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := DesOfbDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleDesOfbDecrypt() {
|
|
data := "hello"
|
|
key := "abcdefgh"
|
|
|
|
encrypted := DesOfbEncrypt([]byte(data), []byte(key))
|
|
|
|
decrypted := DesOfbDecrypt(encrypted, []byte(key))
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleGenerateRsaKey() {
|
|
// Create ras private and public pem file
|
|
err := GenerateRsaKey(4096, "rsa_private_example.pem", "rsa_public_example.pem")
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
fmt.Println("foo")
|
|
|
|
// Output:
|
|
// foo
|
|
}
|
|
|
|
func ExampleRsaEncrypt() {
|
|
// Create ras private and public pem file
|
|
err := GenerateRsaKey(4096, "rsa_private_example.pem", "rsa_public_example.pem")
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
data := []byte("hello")
|
|
encrypted := RsaEncrypt(data, "rsa_public_example.pem")
|
|
decrypted := RsaDecrypt(encrypted, "rsa_private_example.pem")
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleRsaDecrypt() {
|
|
// Create ras private and public pem file
|
|
err := GenerateRsaKey(4096, "rsa_private_example.pem", "rsa_public_example.pem")
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
data := []byte("hello")
|
|
encrypted := RsaEncrypt(data, "rsa_public_example.pem")
|
|
decrypted := RsaDecrypt(encrypted, "rsa_private_example.pem")
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleBase64StdEncode() {
|
|
base64Str := Base64StdEncode("hello")
|
|
|
|
fmt.Println(base64Str)
|
|
|
|
// Output:
|
|
// aGVsbG8=
|
|
}
|
|
|
|
func ExampleBase64StdDecode() {
|
|
str := Base64StdDecode("aGVsbG8=")
|
|
|
|
fmt.Println(str)
|
|
|
|
// Output:
|
|
// hello
|
|
}
|
|
|
|
func ExampleHmacMd5() {
|
|
str := "hello"
|
|
key := "12345"
|
|
|
|
hms := HmacMd5(str, key)
|
|
fmt.Println(hms)
|
|
|
|
// Output:
|
|
// e834306eab892d872525d4918a7a639a
|
|
}
|
|
|
|
func ExampleHmacMd5WithBase64() {
|
|
str := "hello"
|
|
key := "12345"
|
|
|
|
hms := HmacMd5WithBase64(str, key)
|
|
fmt.Println(hms)
|
|
|
|
// Output:
|
|
// 6DQwbquJLYclJdSRinpjmg==
|
|
}
|
|
|
|
func ExampleHmacSha1() {
|
|
str := "hello"
|
|
key := "12345"
|
|
|
|
hms := HmacSha1(str, key)
|
|
fmt.Println(hms)
|
|
|
|
// Output:
|
|
// 5c6a9db0cccb92e36ed0323fd09b7f936de9ace0
|
|
}
|
|
|
|
func ExampleHmacSha1WithBase64() {
|
|
str := "hello"
|
|
key := "12345"
|
|
|
|
hms := HmacSha1WithBase64(str, key)
|
|
fmt.Println(hms)
|
|
|
|
// Output:
|
|
// XGqdsMzLkuNu0DI/0Jt/k23prOA=
|
|
}
|
|
|
|
func ExampleHmacSha256() {
|
|
str := "hello"
|
|
key := "12345"
|
|
|
|
hms := HmacSha256(str, key)
|
|
fmt.Println(hms)
|
|
|
|
// Output:
|
|
// 315bb93c4e989862ba09cb62e05d73a5f376cb36f0d786edab0c320d059fde75
|
|
}
|
|
|
|
func ExampleHmacSha256WithBase64() {
|
|
str := "hello"
|
|
key := "12345"
|
|
|
|
hms := HmacSha256WithBase64(str, key)
|
|
fmt.Println(hms)
|
|
|
|
// Output:
|
|
// MVu5PE6YmGK6Ccti4F1zpfN2yzbw14btqwwyDQWf3nU=
|
|
}
|
|
|
|
func ExampleHmacSha512() {
|
|
str := "hello"
|
|
key := "12345"
|
|
|
|
hms := HmacSha512(str, key)
|
|
fmt.Println(hms)
|
|
|
|
// Output:
|
|
// dd8f1290a9dd23d354e2526d9a2e9ce8cffffdd37cb320800d1c6c13d2efc363288376a196c5458daf53f8e1aa6b45a6d856303d5c0a2064bff9785861d48cfc
|
|
}
|
|
|
|
func ExampleHmacSha512WithBase64() {
|
|
str := "hello"
|
|
key := "12345"
|
|
|
|
hms := HmacSha512WithBase64(str, key)
|
|
fmt.Println(hms)
|
|
|
|
// Output:
|
|
// 3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A==
|
|
}
|
|
|
|
func ExampleMd5String() {
|
|
md5Str := Md5String("hello")
|
|
fmt.Println(md5Str)
|
|
|
|
// Output:
|
|
// 5d41402abc4b2a76b9719d911017c592
|
|
}
|
|
|
|
func ExampleMd5StringWithBase64() {
|
|
md5Str := Md5StringWithBase64("hello")
|
|
fmt.Println(md5Str)
|
|
|
|
// Output:
|
|
// XUFAKrxLKna5cZ2REBfFkg==
|
|
}
|
|
|
|
func ExampleMd5Byte() {
|
|
md5Str := Md5Byte([]byte{'a'})
|
|
fmt.Println(md5Str)
|
|
|
|
// Output:
|
|
// 0cc175b9c0f1b6a831c399e269772661
|
|
}
|
|
|
|
func ExampleMd5ByteWithBase64() {
|
|
md5Str := Md5ByteWithBase64([]byte("hello"))
|
|
fmt.Println(md5Str)
|
|
|
|
// Output:
|
|
// XUFAKrxLKna5cZ2REBfFkg==
|
|
}
|
|
|
|
func ExampleSha1() {
|
|
result := Sha1("hello")
|
|
fmt.Println(result)
|
|
|
|
// Output:
|
|
// aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
|
|
}
|
|
|
|
func ExampleSha1WithBase64() {
|
|
result := Sha1WithBase64("hello")
|
|
fmt.Println(result)
|
|
|
|
// Output:
|
|
// qvTGHdzF6KLavt4PO0gs2a6pQ00=
|
|
}
|
|
|
|
func ExampleSha256() {
|
|
result := Sha256("hello")
|
|
fmt.Println(result)
|
|
|
|
// Output:
|
|
// 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
|
|
}
|
|
|
|
func ExampleSha256WithBase64() {
|
|
result := Sha256WithBase64("hello")
|
|
fmt.Println(result)
|
|
|
|
// Output:
|
|
// LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=
|
|
}
|
|
|
|
func ExampleSha512() {
|
|
result := Sha512("hello")
|
|
fmt.Println(result)
|
|
|
|
// Output:
|
|
// 9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043
|
|
}
|
|
|
|
func ExampleSha512WithBase64() {
|
|
result := Sha512WithBase64("hello")
|
|
fmt.Println(result)
|
|
|
|
// Output:
|
|
// m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
|
|
}
|
|
|
|
func ExampleRsaEncryptOAEP() {
|
|
pri, pub := GenerateRsaKeyPair(1024)
|
|
|
|
data := []byte("hello world")
|
|
label := []byte("123456")
|
|
|
|
encrypted, err := RsaEncryptOAEP(data, label, *pub)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
decrypted, err := RsaDecryptOAEP([]byte(encrypted), label, *pri)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
fmt.Println(string(decrypted))
|
|
|
|
// Output:
|
|
// hello world
|
|
}
|
|
|
|
func ExampleRsaSign() {
|
|
data := []byte("This is a test data for RSA signing")
|
|
hash := crypto.SHA256
|
|
|
|
privateKey := "./rsa_private_example.pem"
|
|
publicKey := "./rsa_public_example.pem"
|
|
|
|
signature, err := RsaSign(hash, data, privateKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = RsaVerifySign(hash, data, signature, publicKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
fmt.Println("ok")
|
|
|
|
// Output:
|
|
// ok
|
|
}
|
|
|
|
func ExampleRsaVerifySign() {
|
|
data := []byte("This is a test data for RSA signing")
|
|
hash := crypto.SHA256
|
|
|
|
privateKey := "./rsa_private_example.pem"
|
|
publicKey := "./rsa_public_example.pem"
|
|
|
|
signature, err := RsaSign(hash, data, privateKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = RsaVerifySign(hash, data, signature, publicKey)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
fmt.Println("ok")
|
|
|
|
// Output:
|
|
// ok
|
|
}
|