Skip to content
On this page

# Cryptor ​

Package cryptor contains some functions for data encryption and decryption. Support base64, md5, hmac, aes, des, rsa.

## Source: ​

- https://github.com/duke-git/lancet/blob/main/cryptor/basic.go
- https://github.com/duke-git/lancet/blob/main/cryptor/crypto.go

## Usage: ​

go

    import (
        "github.com/duke-git/lancet/v2/cryptor"
    )

    import (
        "github.com/duke-git/lancet/v2/cryptor"
    )

## Index ​

- AesEcbEncrypt
- AesEcbDecrypt
- AesCbcEncrypt
- AesCbcDecrypt
- AesCtrCrypt
- AesCfbEncrypt
- AesCfbDecrypt
- AesOfbEncrypt
- AesOfbDecrypt
- Base64StdEncode
- Base64StdDecode
- DesEcbEncrypt
- DesEcbDecrypt
- DesCbcEncrypt
- DesCbcDecrypt
- DesCtrCrypt
- DesCfbEncrypt
- DesCfbDecrypt
- DesOfbEncrypt
- DesOfbDecrypt
- HmacMd5
- HmacMd5WithBase64
- HmacSha1
- HmacSha1WithBase64
- HmacSha256
- HmacSha256WithBase64
- HmacSha512
- HmacSha512WithBase64
- Md5String
- Md5StringWithBase64
- Md5Byte
- Md5ByteWithBase64
- Md5File
- Sha1
- Sha1WithBase64
- Sha256
- Sha256WithBase64
- Sha512
- Sha512WithBase64
- GenerateRsaKey
- RsaEncrypt
- RsaDecrypt

## Documentation ​

### AesEcbEncrypt ​

Encrypt data with key use AES ECB algorithm. Length of `key` param should be 16, 24 or 32.

Signature:

go

    func AesEcbEncrypt(data, key []byte) []byte

    func AesEcbEncrypt(data, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### AesEcbDecrypt ​

Decrypt data with key use AES ECB algorithm. Length of `key` param should be 16, 24 or 32.

Signature:

go

    func AesEcbDecrypt(encrypted, key []byte) []byte

    func AesEcbDecrypt(encrypted, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### AesCbcEncrypt ​

Encrypt data with key use AES CBC algorithm. Length of `key` param should be 16, 24 or 32.

Signature:

go

    func AesCbcEncrypt(data, key []byte) []byte

    func AesCbcEncrypt(data, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### AesCbcDecrypt ​

Decrypt data with key use AES CBC algorithm. Length of `key` param should be 16, 24 or 32.

Signature:

go

    func AesCbcDecrypt(encrypted, key []byte) []byte

    func AesCbcDecrypt(encrypted, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### AesCtrCrypt ​

Encrypt or decrypt data with key use AES CTR algorithm. Length of `key` param should be 16, 24 or 32.

Signature:

go

    func AesCtrCrypt(data, key []byte) []byte

    func AesCtrCrypt(data, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### AesCfbEncrypt ​

Encrypt data with key use AES CFB algorithm. Length of `key` param should be 16, 24 or 32.

Signature:

go

    func AesCfbEncrypt(data, key []byte) []byte

    func AesCfbEncrypt(data, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### AesCfbDecrypt ​

Decrypt data with key use AES CBC algorithm. Length of `key` param should be 16, 24 or 32.

Signature:

go

    func AesCfbDecrypt(encrypted, key []byte) []byte

    func AesCfbDecrypt(encrypted, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### AesOfbEncrypt ​

Enecrypt data with key use AES OFB algorithm. Length of `key` param should be 16, 24 or 32.

Signature:

go

    func AesOfbEncrypt(data, key []byte) []byte

    func AesOfbEncrypt(data, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### AesOfbDecrypt ​

Decrypt data with key use AES OFB algorithm. Length of `key` param should be 16, 24 or 32.

Signature:

go

    func AesOfbDecrypt(encrypted, key []byte) []byte

    func AesOfbDecrypt(encrypted, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### Base64StdEncode ​

Encode string with base64 encoding.

Signature:

go

    func Base64StdEncode(s string) string

    func Base64StdEncode(s string) string

Example:Run

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        base64Str := cryptor.Base64StdEncode("hello")
        fmt.Println(base64Str)

        // Output:
        // aGVsbG8=
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        base64Str := cryptor.Base64StdEncode("hello")
        fmt.Println(base64Str)

        // Output:
        // aGVsbG8=
    }

### Base64StdDecode ​

Decode a base64 encoded string.

Signature:

go

    func Base64StdDecode(s string) string

    func Base64StdDecode(s string) string

Example:Run

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := cryptor.Base64StdDecode("aGVsbG8=")
        fmt.Println(str)

        // Output:
        // hello
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := cryptor.Base64StdDecode("aGVsbG8=")
        fmt.Println(str)

        // Output:
        // hello
    }

### DesEcbEncrypt ​

Encrypt data with key use DES ECB algorithm. Length of `key` param should be 8.

Signature:

go

    func DesEcbEncrypt(data, key []byte) []byte

    func DesEcbEncrypt(data, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### DesEcbDecrypt ​

Decrypt data with key use DES ECB algorithm. Length of `key` param should be 8.

Signature:

go

    func DesEcbDecrypt(encrypted, key []byte) []byte

    func DesEcbDecrypt(encrypted, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### DesCbcEncrypt ​

Encrypt data with key use DES CBC algorithm. Length of `key` param should be 8.

Signature:

go

    func DesCbcEncrypt(data, key []byte) []byte

    func DesCbcEncrypt(data, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### DesCbcDecrypt ​

Decrypt data with key use DES CBC algorithm. Length of `key` param should be 8.

Signature:

go

    func DesCbcDecrypt(encrypted, key []byte) []byte

    func DesCbcDecrypt(encrypted, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### DesCtrCrypt ​

Encrypt or decrypt data with key use DES CTR algorithm. Length of `key` param should be 8.

Signature:

go

    func DesCtrCrypt(data, key []byte) []byte

    func DesCtrCrypt(data, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### DesCfbEncrypt ​

Encrypt data with key use DES CFB algorithm. Length of `key` param should be 8.

Signature:

go

    func DesCfbEncrypt(data, key []byte) []byte

    func DesCfbEncrypt(data, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### DesCfbDecrypt ​

Decrypt data with key use DES CBC algorithm. Length of `key` param should be 8.

Signature:

go

    func DesCfbDecrypt(encrypted, key []byte) []byte

    func DesCfbDecrypt(encrypted, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### DesOfbEncrypt ​

Enecrypt data with key use DES OFB algorithm. Length of `key` param should be 8.

Signature:

go

    func DesOfbEncrypt(data, key []byte) []byte

    func DesOfbEncrypt(data, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### DesOfbDecrypt ​

Decrypt data with key use DES OFB algorithm. Length of `key` param should be 8.

Signature:

go

    func DesOfbDecrypt(encrypted, key []byte) []byte

    func DesOfbDecrypt(encrypted, key []byte) []byte

Example:Run

go

    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
    }

    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
    }

### HmacMd5 ​

Get the md5 hmac hash of string.

Signature:

go

    func HmacMd5(str, key string) string

    func HmacMd5(str, key string) string

Example:Run

go

    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
    }

    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
    }

### HmacMd5WithBase64 ​

Get the md5 hmac hash of base64 string.

Signature:

go

    func HmacMd5WithBase64(str, key string) string

    func HmacMd5WithBase64(str, key string) string

Example:Run

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := "hello"
        key := "12345"

        hms := cryptor.HmacMd5WithBase64(str, key)
        fmt.Println(hms)

        // Output:
        // 6DQwbquJLYclJdSRinpjmg==
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := "hello"
        key := "12345"

        hms := cryptor.HmacMd5WithBase64(str, key)
        fmt.Println(hms)

        // Output:
        // 6DQwbquJLYclJdSRinpjmg==
    }

### HmacSha1 ​

Get the sha1 hmac hash of string.

Signature:

go

    func HmacSha1(str, key string) string

    func HmacSha1(str, key string) string

Example:Run

go

    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
    }

    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
    }

### HmacSha1WithBase64 ​

Return the hmac hash of string use sha1 with base64.

Signature:

go

    func HmacSha1WithBase64(str, key string) string

    func HmacSha1WithBase64(str, key string) string

Example:Run

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := "hello"
        key := "12345"

        hms := cryptor.HmacSha1WithBase64(str, key)
        fmt.Println(hms)

        // Output:
        // XGqdsMzLkuNu0DI/0Jt/k23prOA=
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := "hello"
        key := "12345"

        hms := cryptor.HmacSha1WithBase64(str, key)
        fmt.Println(hms)

        // Output:
        // XGqdsMzLkuNu0DI/0Jt/k23prOA=
    }

### HmacSha256 ​

Get the sha256 hmac hash of string

Signature:

go

    func HmacSha256(str, key string) string

    func HmacSha256(str, key string) string

Example:Run

go

    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
    }

    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
    }

### HmacSha256WithBase64 ​

Return the hmac hash of string use sha256 with base64.

Signature:

go

    func HmacSha256WithBase64(str, key string) string

    func HmacSha256WithBase64(str, key string) string

Example:Run

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := "hello"
        key := "12345"

        hms := cryptor.HmacSha256WithBase64(str, key)
        fmt.Println(hms)

        // Output:
        // MVu5PE6YmGK6Ccti4F1zpfN2yzbw14btqwwyDQWf3nU=
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := "hello"
        key := "12345"

        hms := cryptor.HmacSha256WithBase64(str, key)
        fmt.Println(hms)

        // Output:
        // MVu5PE6YmGK6Ccti4F1zpfN2yzbw14btqwwyDQWf3nU=
    }

### HmacSha512 ​

Get the sha512 hmac hash of string.

Signature:

go

    func HmacSha512(str, key string) string

    func HmacSha512(str, key string) string

Example:Run

go

    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
    }

    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
    }

### HmacSha512WithBase64 ​

Return the hmac hash of string use sha512 with base64.

Signature:

go

    func HmacSha512WithBase64(str, key string) string

    func HmacSha512WithBase64(str, key string) string

Example:Run

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := "hello"
    	key := "12345"

    	hms := cryptor.HmacSha512WithBase64(str, key)
    	fmt.Println(hms)

    	// Output:
    	// 3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A==
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := "hello"
    	key := "12345"

    	hms := cryptor.HmacSha512WithBase64(str, key)
    	fmt.Println(hms)

    	// Output:
    	// 3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A==
    }

### Md5String ​

Get the md5 value of string.

Signature:

go

    func Md5String(s string) string

    func Md5String(s string) string

Example:Run

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := "hello"

        md5Str := cryptor.Md5String(str)
        fmt.Println(md5Str)

        // Output:
        // 5d41402abc4b2a76b9719d911017c592
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := "hello"

        md5Str := cryptor.Md5String(str)
        fmt.Println(md5Str)

        // Output:
        // 5d41402abc4b2a76b9719d911017c592
    }

### Md5StringWithBase64 ​

Return the md5 value of string with base64.

Signature:

go

    func Md5StringWithBase64(s string) string

    func Md5StringWithBase64(s string) string

Example:Run

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        md5Str := cryptor.Md5StringWithBase64("hello")
    	fmt.Println(md5Str)

    	// Output:
    	// XUFAKrxLKna5cZ2REBfFkg==
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        md5Str := cryptor.Md5StringWithBase64("hello")
    	fmt.Println(md5Str)

    	// Output:
    	// XUFAKrxLKna5cZ2REBfFkg==
    }

### Md5Byte ​

Return the md5 string of byte slice.

Signature:

go

    func Md5Byte(data []byte) string

    func Md5Byte(data []byte) string

Example:Run

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        md5Str := cryptor.Md5Byte([]byte{'a'})
    	fmt.Println(md5Str)

    	// Output:
    	// 0cc175b9c0f1b6a831c399e269772661
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        md5Str := cryptor.Md5Byte([]byte{'a'})
    	fmt.Println(md5Str)

    	// Output:
    	// 0cc175b9c0f1b6a831c399e269772661
    }

### Md5ByteWithBase64 ​

Return the md5 string of byte slice with base64.

Signature:

go

    func Md5ByteWithBase64(data []byte) string

    func Md5ByteWithBase64(data []byte) string

Example:Run

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        md5Str := cryptor.Md5ByteWithBase64([]byte("hello"))
    	fmt.Println(md5Str)

    	// Output:
    	// XUFAKrxLKna5cZ2REBfFkg==
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        md5Str := cryptor.Md5ByteWithBase64([]byte("hello"))
    	fmt.Println(md5Str)

    	// Output:
    	// XUFAKrxLKna5cZ2REBfFkg==
    }

### Md5File ​

Get the md5 value of file.

Signature:

go

    func Md5File(filepath string) (string, error)

    func Md5File(filepath string) (string, error)

Example:

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        s := cryptor.Md5File("./main.go"))
        fmt.Println(s)
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        s := cryptor.Md5File("./main.go"))
        fmt.Println(s)
    }

### Sha1 ​

Get the sha1 value of string.

Signature:

go

    func Sha1(str string) string

    func Sha1(str string) string

Example:Run

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := "hello"

        result := cryptor.Sha1(str)
        fmt.Println(result)

        // Output:
        // aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := "hello"

        result := cryptor.Sha1(str)
        fmt.Println(result)

        // Output:
        // aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
    }

### Sha1WithBase64 ​

Return the sha1 value (SHA-1 hash algorithm) of base64 string.

Signature:

go

    func Sha1WithBase64(str string) string

    func Sha1WithBase64(str string) string

Example:Run

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        result := cryptor.Sha1WithBase64("hello")
    	fmt.Println(result)

    	// Output:
    	// qvTGHdzF6KLavt4PO0gs2a6pQ00=
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        result := cryptor.Sha1WithBase64("hello")
    	fmt.Println(result)

    	// Output:
    	// qvTGHdzF6KLavt4PO0gs2a6pQ00=
    }

### Sha256 ​

Get the sha256 value of string.

Signature:

go

    func Sha256(str string) string

    func Sha256(str string) string

Example:Run

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := "hello"

        result := cryptor.Sha256(str)
        fmt.Println(result)

        // Output:
        // 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := "hello"

        result := cryptor.Sha256(str)
        fmt.Println(result)

        // Output:
        // 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
    }

### Sha256WithBase64 ​

Return the sha256 value (SHA256 hash algorithm) of base64 string.

Signature:

go

    func Sha256WithBase64(str string) string

    func Sha256WithBase64(str string) string

Example:Run

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        result := cryptor.Sha256WithBase64("hello")
    	fmt.Println(result)

    	// Output:
    	// LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        result := cryptor.Sha256WithBase64("hello")
    	fmt.Println(result)

    	// Output:
    	// LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=
    }

### Sha512 ​

Get the sha512 value of string.

Signature:

go

    func Sha512(str string) string

    func Sha512(str string) string

Example:Run

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := "hello"

        result := cryptor.Sha512(str)
        fmt.Println(result)

        // Output:
        // 9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        str := "hello"

        result := cryptor.Sha512(str)
        fmt.Println(result)

        // Output:
        // 9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043
    }

### Sha512WithBase64 ​

Get the sha512 value of string with base64.

Signature:

go

    func Sha512WithBase64(str string) string

    func Sha512WithBase64(str string) string

Example:Run

go

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        result := cryptor.Sha512WithBase64("hello")
    	fmt.Println(result)

    	// Output:
    	// m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
    }

    package main

    import (
        "fmt"
        "github.com/duke-git/lancet/v2/cryptor"
    )

    func main() {
        result := cryptor.Sha512WithBase64("hello")
    	fmt.Println(result)

    	// Output:
    	// m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
    }

### GenerateRsaKey ​

Create the rsa public and private key file in current directory.

Signature:

go

    func GenerateRsaKey(keySize int, priKeyFile, pubKeyFile string) error

    func GenerateRsaKey(keySize int, priKeyFile, pubKeyFile string) error

Example:Run

go

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

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

### RsaEncrypt ​

Encrypt data with public key file useing ras algorithm.

Signature:

go

    func RsaEncrypt(data []byte, pubKeyFileName string) []byte

    func RsaEncrypt(data []byte, pubKeyFileName string) []byte

Example:Run

go

    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
    }

    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
    }

### RsaDecrypt ​

Decrypt data with private key file useing ras algorithm.

Signature:

go

    func RsaDecrypt(data []byte, privateKeyFileName string) []byte

    func RsaDecrypt(data []byte, privateKeyFileName string) []byte

Example:Run

go

    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
    }

    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
    }