crypto

Documentation

Overview

Package crypto handles all encryption, decryption, hashing, and parsing of keys.

Index

• func DecodeStringB64(stringB64 string) ([]byte, error)
• func DecryptWithPrivateKey(privateKey *rsa.PrivateKey, data []byte) ([]byte, error)
• func DecryptWithSymKey(symKey []byte, encryptedData []byte) ([]byte, error)
• func EncodeToB64String(data []byte) string
• func EncryptWithPublicKey(publicKey *rsa.PublicKey, data []byte) ([]byte, error)
• func EncryptWithSymKey(symKey []byte, data []byte) ([]byte, error)
• func GeneratePrivateKey() *rsa.PrivateKey
• func GenerateSymKey() []byte
• func GetSymKeyFromHash(seed []byte) []byte
• func Hash(key []byte) []byte
• func HashB64(key []byte) string
• func HashLong(key []byte) []byte
• func HashLongB64(key []byte) string
• func HashShort(key []byte) []byte
• func HashShortB64(key []byte) string
• func MarshalPrivateKey(key *rsa.PrivateKey) []byte
• func ParsePrivateKey(key []byte) (*rsa.PrivateKey, error)
• func ParsePrivateKeyB64(privateKeyB64 string) (*rsa.PrivateKey, error)
• func ParsePublicKey(key []byte) (*rsa.PublicKey, error)
• func ParsePublicKeyB64(publicKeyB64 string) (*rsa.PublicKey, error)
• func ParseSymKeyB64(symKeyB64 string) ([]byte, error)
• func PrivateKeyToBytes(privateKey *rsa.PrivateKey) []byte
• func PublicKeyToBytes(publicKey *rsa.PublicKey) []byte
• func ValidatePrivateKey(key []byte) bool
• func ValidatePublicKey(key []byte) bool
• func ValidateSymKey(key []byte) bool

Examples

• DecodeStringB64
• DecryptWithPrivateKey
• DecryptWithSymKey
• EncodeToB64String
• EncryptWithPublicKey
• EncryptWithSymKey
• GetSymKeyFromHash
• Hash
• MarshalPrivateKey
• ParsePrivateKey
• ParsePrivateKeyB64
• ParsePublicKey
• ParsePublicKeyB64
• ParseSymKeyB64
• PrivateKeyToBytes
• PublicKeyToBytes
• ValidatePrivateKey
• ValidatePublicKey
• ValidateSymKey

Functions

func DecodeStringB64

func DecodeStringB64(stringB64 string) ([]byte, error)

DecodeStringB64 parses a B64 string into a []byte.

Example

b64String := base64.StdEncoding.EncodeToString([]byte("data"))

DecodeStringB64(b64String)

func DecryptWithPrivateKey

func DecryptWithPrivateKey(privateKey *rsa.PrivateKey, data []byte) ([]byte, error)

DecryptWithPrivateKey decrypts data using the provided RSA private key.

Example

data := []byte("data")
privateKey := GeneratePrivateKey()
publicKey := privateKey.Public().(*rsa.PublicKey)

encryptedData, _ := EncryptWithPublicKey(publicKey, data)

DecryptWithPrivateKey(privateKey, encryptedData)

func DecryptWithSymKey

func DecryptWithSymKey(symKey []byte, encryptedData []byte) ([]byte, error)

DecryptWithSymKey decrypts data with the provided AES sym key.

Example

data := []byte("data")
symKey := GenerateSymKey()

encryptedData, _ := EncryptWithSymKey(symKey, data)

DecryptWithSymKey(symKey, encryptedData)

func EncodeToB64String

func EncodeToB64String(data []byte) string

EncodeToB64String encodes data to a b64 string.

Example

data := []byte("data")

EncodeToB64String(data)

func EncryptWithPublicKey

func EncryptWithPublicKey(publicKey *rsa.PublicKey, data []byte) ([]byte, error)

EncryptWithPublicKey encrypts data using the provided RSA public key.

Example

data := []byte("data")
privateKey := GeneratePrivateKey()
publicKey := privateKey.Public().(*rsa.PublicKey)

EncryptWithPublicKey(publicKey, data)

func EncryptWithSymKey

func EncryptWithSymKey(symKey []byte, data []byte) ([]byte, error)

EncryptWithSymKey encrypts data using the provided AES sym key.

Example

data := []byte("data")
symKey := GenerateSymKey()

EncryptWithSymKey(symKey, data)

func GeneratePrivateKey

func GeneratePrivateKey() *rsa.PrivateKey

GeneratePrivateKey generates a random 2048-bit RSA Private Key.

func GenerateSymKey

func GenerateSymKey() []byte

GenerateSymKey generates a random 32-byte AES symmetric key.

func GetSymKeyFromHash

func GetSymKeyFromHash(seed []byte) []byte

GetSymKeyFromHash returns a sym key derived from the hash of the input seed.

Example

data := []byte("data")

GetSymKeyFromHash(data)

func Hash

func Hash(key []byte) []byte

Hash returns the hash of the given key using SHA-256.

Example

data := []byte("data")

Hash(data)

func HashB64

func HashB64(key []byte) string

HashB64 returns the base64 encoding of the SHA-256 hash of the given key.

func HashLong

func HashLong(key []byte) []byte

HashLong returns the SHA-512 of the given key. len=32

func HashLongB64

func HashLongB64(key []byte) string

HashLongB64 returns the base64 encoding of the SHA-512 hash of the given key.

func HashShort

func HashShort(key []byte) []byte

HashShort returns the hash of the given key using SHA-1.

func HashShortB64

func HashShortB64(key []byte) string

HashShortB64 returns the base64 encoding of the SHA-1 hash of the given key.

func MarshalPrivateKey

func MarshalPrivateKey(key *rsa.PrivateKey) []byte

MarshalPrivateKey marshals a *rsa.PrivateKey into a []byte.

Example

privateKey := GeneratePrivateKey()

MarshalPrivateKey(privateKey)

func ParsePrivateKey

func ParsePrivateKey(key []byte) (*rsa.PrivateKey, error)

ParsePrivateKey parses key bytes into a *rsa.PrivateKey.

Example

privateKeyBytes := MarshalPrivateKey(GeneratePrivateKey())

ParsePrivateKey(privateKeyBytes)

func ParsePrivateKeyB64

func ParsePrivateKeyB64(privateKeyB64 string) (*rsa.PrivateKey, error)

ParsePrivateKeyB64 parses a B64 key string into a *rsa.PrivateKey.

Example

privateKey := GeneratePrivateKey()
privateKeyBytes := x509.MarshalPKCS1PrivateKey(privateKey)
privateKeyB64 := base64.StdEncoding.EncodeToString(privateKeyBytes)

ParsePrivateKeyB64(privateKeyB64)

func ParsePublicKey

func ParsePublicKey(key []byte) (*rsa.PublicKey, error)

ParsePublicKey parses key bytes into a *rsa.PublicKey.

Example

privateKey := GeneratePrivateKey()
publicKeyBytes, _ := x509.MarshalPKIXPublicKey(privateKey.Public())

ParsePublicKey(publicKeyBytes)

func ParsePublicKeyB64

func ParsePublicKeyB64(publicKeyB64 string) (*rsa.PublicKey, error)

ParsePublicKeyB64 parses a B64 key string into a *rsa.PublicKey.

Example

privateKey := GeneratePrivateKey()
publicKeyBytes, _ := x509.MarshalPKIXPublicKey(privateKey.Public())
publicKeyB64 := base64.StdEncoding.EncodeToString(publicKeyBytes)

ParsePublicKeyB64(publicKeyB64)

func ParseSymKeyB64

func ParseSymKeyB64(symKeyB64 string) ([]byte, error)

ParseSymKeyB64 decodes a B64 sym key, confirms the result is a valid sym key, and returns. If not, return error.

Example

symKeyB64 := base64.StdEncoding.EncodeToString(GenerateSymKey())

ParseSymKeyB64(symKeyB64)

func PrivateKeyToBytes

func PrivateKeyToBytes(privateKey *rsa.PrivateKey) []byte

PrivateKeyToBytes marshals a *rsa.PrivateKey into a []byte.

Example

privateKey := GeneratePrivateKey()

PrivateKeyToBytes(privateKey)

func PublicKeyToBytes

func PublicKeyToBytes(publicKey *rsa.PublicKey) []byte

PublicKeyToBytes marshals a *rsa.PublicKey into a []byte.

Example

privateKey := GeneratePrivateKey()
publicKey := privateKey.Public().(*rsa.PublicKey)

PublicKeyToBytes(publicKey)

func ValidatePrivateKey

func ValidatePrivateKey(key []byte) bool

ValidatePrivateKey returns true if the key is a valid RSA private key.

Example

privateKey := GeneratePrivateKey()
privateKeyBytes := x509.MarshalPKCS1PrivateKey(privateKey)

validPrivateKey := ValidatePrivateKey(privateKeyBytes)

fmt.Println(validPrivateKey)

Output:

true

func ValidatePublicKey

func ValidatePublicKey(key []byte) bool

ValidatePublicKey returns true if the key is a valid RSA public key.

Example

privateKey := GeneratePrivateKey()
publicKeyBytes, _ := x509.MarshalPKIXPublicKey(privateKey.Public())

validPublicKey := ValidatePublicKey(publicKeyBytes)

fmt.Println(validPublicKey)

Output:

true

func ValidateSymKey

func ValidateSymKey(key []byte) bool

ValidateSymKey validates a key is a sym key by checking its length.

Example

symKey := GenerateSymKey()

validSymKey := ValidateSymKey(symKey)

fmt.Println(validSymKey)

Output:

true