Cryptography Library

This library provides a comprehensive set of cryptographic utilities for hashing, encryption, and key management. It supports both symmetric and asymmetric cryptography, as well as various hashing algorithms.

Features

• Symmetric encryption using AES-GCM.
• Asymmetric encryption using RSA.
• Hashing with Argon2, bcrypt, and HMAC.
• Key generation and parsing utilities.

Installation

To use this library, add it to your Go project:

go get github.com/go-universal/cryptography

API Documentation

Symmetric Encryption

Creates a new symmetric encryption driver.

func NewSymmetric(key SimpleKey, signer HashingAlgo) Cryptography

key, _ := cryptography.NewSimpleKey(cryptography.Simple32)
driver := cryptography.NewSymmetric(key, cryptography.SHA256)

data := []byte("my secret data")

// Encrypt
encrypted, _ := driver.EncryptBase64(data)

// Decrypt
decrypted, _ := driver.DecryptBase64(encrypted)
fmt.Println(string(decrypted)) // Output: my secret data

Asymmetric Encryption

Creates a new asymmetric encryption driver with a private key.

func NewAsymmetric(key RSAKey, signer HashingAlgo) Cryptography

NewAsymmetricClient

Creates a new asymmetric encryption driver with a public key.

func NewAsymmetricClient(public *rsa.PublicKey, signer HashingAlgo) Cryptography

key, _ := cryptography.NewRSAKey(cryptography.RSA2048)
driver := cryptography.NewAsymmetric(*key, cryptography.SHA256)

data := []byte("my secret data")

// Encrypt
encrypted, _ := driver.EncryptBase64(data)

// Decrypt
decrypted, _ := driver.DecryptBase64(encrypted)
fmt.Println(string(decrypted)) // Output: my secret data

Hashing

Creates a new Argon2 hasher.

func NewArgon2Hasher(
    saltLength SimpleLength, keyLength uint32,
    memory uint32, iterations uint32, parallelism uint8,
) Hasher

Creates a new bcrypt hasher.

func NewBcryptHasher(cost int) Hasher

Creates a new HMAC hasher.

func HMacHasher(key []byte, algo HashingAlgo) Hasher

password := []byte("my_password")

// Argon2
argon2Hasher := cryptography.NewArgon2Hasher(0, 0, 0, 0, 0)
hashed, _ := argon2Hasher.Hash(password)
valid, _ := argon2Hasher.Validate(hashed, password)
fmt.Println(valid) // Output: true

// bcrypt
bcryptHasher := cryptography.NewBcryptHasher(0)
hashed, _ = bcryptHasher.Hash(password)
valid, _ = bcryptHasher.Validate(hashed, password)
fmt.Println(valid) // Output: true

Key Management

Simple Key

Generates a new random key of the specified length.

func NewSimpleKey(length SimpleLength) (SimpleKey, error)

RSA Key

Generates a new RSA private key of the specified length.

func NewRSAKey(length RSALength) (*RSAKey, error)

Parse Private Key

Parses an RSA private key from PKCS#1 or PKCS#8 format.

func ParsePrivateKey(key []byte, isPEM bool) (*RSAKey, error)

Parse Public Key

Parses an RSA public key from PKIX or PKCS#1 format.

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

// Generate a new RSA key
rsaKey, _ := cryptography.NewRSAKey(cryptography.RSA2048)

// Export and parse the private key
privateKeyPEM, _ := rsaKey.PrivateKeyPEM(true)
parsedKey, _ := cryptography.ParsePrivateKey(privateKeyPEM, true)

// Export and parse the public key
publicKeyPEM, _ := rsaKey.PublicKeyPEM(true)
parsedPublicKey, _ := cryptography.ParsePublicKey(publicKeyPEM, true)

License

This project is licensed under the ISC License. See the LICENSE file for details.