Package cryptor contains some functions for data encryption and decryption. Support base64, md5, hmac, aes, des, rsa.
- https://github.com/duke-git/lancet/blob/main/cryptor/basic.go
- https://github.com/duke-git/lancet/blob/main/cryptor/encrypt.go
import (
"github.com/duke-git/lancet/v2/cryptor"
)
- AesEcbEncrypt
- AesEcbDecrypt
- AesCbcEncrypt
- AesCbcDecrypt
- AesCtrCrypt
- AesCfbEncrypt
- AesCfbDecrypt
- AesOfbEncrypt
- AesOfbDecrypt
- Base64StdEncode
- Base64StdDecode
- DesEcbEncrypt
- DesEcbDecrypt
- DesCbcEncrypt
- DesCbcDecrypt
- DesCtrCrypt
- DesCfbEncrypt
- DesCfbDecrypt
- DesOfbEncrypt
- DesOfbDecrypt
- HmacMd5
- HmacSha1
- HmacSha256
- HmacSha512
- Md5String
- Md5File
- Sha1
- Sha256
- Sha512
- GenerateRsaKey
- RsaEncrypt
- RsaDecrypt
Encrypt data with key use AES ECB algorithm. Length of `key` param should be 16, 24 or 32.
Signature:
func AesEcbEncrypt(data, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefghijklmnop"
encrypted := cryptor.AesEcbEncrypt([]byte(data), []byte(key))
decrypted := cryptor.AesEcbDecrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Decrypt data with key use AES ECB algorithm. Length of `key` param should be 16, 24 or 32.
Signature:
func AesEcbDecrypt(encrypted, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefghijklmnop"
encrypted := cryptor.AesEcbEncrypt([]byte(data), []byte(key))
decrypted := cryptor.AesEcbDecrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Encrypt data with key use AES CBC algorithm. Length of `key` param should be 16, 24 or 32.
Signature:
func AesCbcEncrypt(data, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefghijklmnop"
encrypted := cryptor.AesCbcEncrypt([]byte(data), []byte(key))
decrypted := cryptor.AesCbcDecrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Decrypt data with key use AES CBC algorithm. Length of `key` param should be 16, 24 or 32.
Signature:
func AesCbcDecrypt(encrypted, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefghijklmnop"
encrypted := cryptor.AesCbcEncrypt([]byte(data), []byte(key))
decrypted := cryptor.AesCbcDecrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Encrypt or decrypt data with key use AES CTR algorithm. Length of `key` param should be 16, 24 or 32.
Signature:
func AesCtrCrypt(data, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefghijklmnop"
encrypted := cryptor.AesCtrCrypt([]byte(data), []byte(key))
decrypted := cryptor.AesCtrCrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Encrypt data with key use AES CFB algorithm. Length of `key` param should be 16, 24 or 32.
Signature:
func AesCfbEncrypt(data, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefghijklmnop"
encrypted := cryptor.AesCfbEncrypt([]byte(data), []byte(key))
decrypted := cryptor.AesCfbDecrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Decrypt data with key use AES CBC algorithm. Length of `key` param should be 16, 24 or 32.
Signature:
func AesCfbDecrypt(encrypted, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefghijklmnop"
encrypted := cryptor.AesCfbEncrypt([]byte(data), []byte(key))
decrypted := cryptor.AesCfbDecrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Enecrypt data with key use AES OFB algorithm. Length of `key` param should be 16, 24 or 32.
Signature:
func AesOfbEncrypt(data, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefghijklmnop"
encrypted := cryptor.AesOfbEncrypt([]byte(data), []byte(key))
decrypted := cryptor.AesCfbDecrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Decrypt data with key use AES OFB algorithm. Length of `key` param should be 16, 24 or 32.
Signature:
func AesOfbDecrypt(encrypted, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefghijklmnop"
encrypted := cryptor.AesOfbEncrypt([]byte(data), []byte(key))
decrypted := cryptor.AesCfbDecrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Encode string with base64 encoding.
Signature:
func Base64StdEncode(s string) string
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
base64Str := cryptor.Base64StdEncode("hello")
fmt.Println(base64Str)
// Output:
// aGVsbG8=
}
Decode a base64 encoded string.
Signature:
func Base64StdDecode(s string) string
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
str := cryptor.Base64StdDecode("aGVsbG8=")
fmt.Println(str)
// Output:
// hello
}
Encrypt data with key use DES ECB algorithm. Length of `key` param should be 8.
Signature:
func DesEcbEncrypt(data, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefgh"
encrypted := cryptor.DesEcbEncrypt([]byte(data), []byte(key))
decrypted := cryptor.DesEcbDecrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Decrypt data with key use DES ECB algorithm. Length of `key` param should be 8.
Signature:
func DesEcbDecrypt(encrypted, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefgh"
encrypted := cryptor.DesEcbEncrypt([]byte(data), []byte(key))
decrypted := cryptor.DesEcbDecrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Encrypt data with key use DES CBC algorithm. Length of `key` param should be 8.
Signature:
func DesCbcEncrypt(data, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefgh"
encrypted := cryptor.DesCbcEncrypt([]byte(data), []byte(key))
decrypted := cryptor.DesCbcDecrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Decrypt data with key use DES CBC algorithm. Length of `key` param should be 8.
Signature:
func DesCbcDecrypt(encrypted, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefgh"
encrypted := cryptor.DesCbcEncrypt([]byte(data), []byte(key))
decrypted := cryptor.DesCbcDecrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Encrypt or decrypt data with key use DES CTR algorithm. Length of `key` param should be 8.
Signature:
func DesCtrCrypt(data, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefgh"
encrypted := cryptor.DesCtrCrypt([]byte(data), []byte(key))
decrypted := cryptor.DesCtrCrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Encrypt data with key use DES CFB algorithm. Length of `key` param should be 8.
Signature:
func DesCfbEncrypt(data, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefgh"
encrypted := cryptor.DesCfbEncrypt([]byte(data), []byte(key))
decrypted := cryptor.DesCfbDecrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Decrypt data with key use DES CBC algorithm. Length of `key` param should be 8.
Signature:
func DesCfbDecrypt(encrypted, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefgh"
encrypted := cryptor.DesCfbEncrypt([]byte(data), []byte(key))
decrypted := cryptor.DesCfbDecrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Enecrypt data with key use DES OFB algorithm. Length of `key` param should be 8.
Signature:
func DesOfbEncrypt(data, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefgh"
encrypted := cryptor.DesOfbEncrypt([]byte(data), []byte(key))
decrypted := cryptor.DesOfbDecrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Decrypt data with key use DES OFB algorithm. Length of `key` param should be 8.
Signature:
func DesOfbDecrypt(encrypted, key []byte) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
data := "hello"
key := "abcdefgh"
encrypted := cryptor.DesOfbEncrypt([]byte(data), []byte(key))
decrypted := cryptor.DesOfbDecrypt(encrypted, []byte(key))
fmt.Println(string(decrypted))
// Output:
// hello
}
Get the md5 hmac hash of string.
Signature:
func HmacMd5(data, key string) string
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
str := "hello"
key := "12345"
hms := cryptor.HmacMd5(str, key)
fmt.Println(hms)
// Output:
// e834306eab892d872525d4918a7a639a
}
Get the sha1 hmac hash of string.
Signature:
func HmacSha1(data, key string) string
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
str := "hello"
key := "12345"
hms := cryptor.HmacSha1(str, key)
fmt.Println(hms)
// Output:
// 5c6a9db0cccb92e36ed0323fd09b7f936de9ace0
}
Get the sha256 hmac hash of string
Signature:
func HmacSha256(data, key string) string
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
str := "hello"
key := "12345"
hms := cryptor.HmacSha256(str, key)
fmt.Println(hms)
// Output:
// 315bb93c4e989862ba09cb62e05d73a5f376cb36f0d786edab0c320d059fde75
}
Get the sha512 hmac hash of string.
Signature:
func HmacSha512(data, key string) string
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
str := "hello"
key := "12345"
hms := cryptor.HmacSha512(str, key)
fmt.Println(hms)
// Output:
// dd8f1290a9dd23d354e2526d9a2e9ce8cffffdd37cb320800d1c6c13d2efc363288376a196c5458daf53f8e1aa6b45a6d856303d5c0a2064bff9785861d48cfc
}
Get the md5 value of string.
Signature:
func Md5String(s string) string
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
str := "hello"
md5Str := cryptor.Md5String(str)
fmt.Println(md5Str)
// Output:
// 5d41402abc4b2a76b9719d911017c592
}
Get the md5 value of file.
Signature:
func Md5File(filepath string) (string, error)
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
s := cryptor.Md5File("./main.go"))
fmt.Println(s)
}
Get the sha1 value of string.
Signature:
func Sha1(data string) string
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
str := "hello"
result := cryptor.Sha1(str)
fmt.Println(result)
// Output:
// aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
}
Get the sha256 value of string.
Signature:
func Sha256(data string) string
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
str := "hello"
result := cryptor.Sha256(str)
fmt.Println(result)
// Output:
// 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
}
Get the sha512 value of string.
Signature:
func Sha512(data string) string
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
str := "hello"
result := cryptor.Sha512(str)
fmt.Println(result)
// Output:
// 9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043
}
Create the rsa public and private key file in current directory.
Signature:
func GenerateRsaKey(keySize int, priKeyFile, pubKeyFile string) error
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
if err != nil {
fmt.Println(err)
}
}
Encrypt data with public key file useing ras algorithm.
Signature:
func RsaEncrypt(data []byte, pubKeyFileName string) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
if err != nil {
return
}
data := []byte("hello")
encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
fmt.Println(string(decrypted))
// Output:
// hello
}
Decrypt data with private key file useing ras algorithm.
Signature:
func RsaDecrypt(data []byte, privateKeyFileName string) []byte
Example:
package main
import (
"fmt"
"github.com/duke-git/lancet/v2/cryptor"
)
func main() {
err := cryptor.GenerateRsaKey(4096, "rsa_private.pem", "rsa_public.pem")
if err != nil {
return
}
data := []byte("hello")
encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
fmt.Println(string(decrypted))
// Output:
// hello
}