README
¶
Secure
Secure is a simple package to easily work with the most common cryptography functions.
Installation:
go get github.com/catamat/secure@latest
Example:
package main
import (
"fmt"
"os"
"github.com/catamat/secure"
)
func main() {
asymmetric()
fmt.Println("---")
signing()
fmt.Println("---")
hashing()
fmt.Println("---")
symmetric()
fmt.Println("---")
utilities()
}
func asymmetric() {
var privFile bool
var pubFile bool
if _, err := os.Stat("private.pem"); err == nil {
privFile = true
}
if _, err := os.Stat("public.pem"); err == nil {
pubFile = true
}
if !privFile || !pubFile {
// Create the keys
privKey, pubKey := secure.RSAGenerateKeyPair(4096)
// Export the keys to PEM
privPem := secure.RSAExportPrivateKeyAsPEM(privKey)
pubPem, _ := secure.RSAExportPublicKeyAsPEM(pubKey)
if err := os.WriteFile("private.pem", privPem, 0644); err != nil {
fmt.Println("Error: Can't write private.pem file")
return
}
if err := os.WriteFile("public.pem", pubPem, 0644); err != nil {
fmt.Println("Error: Can't write public.pem file")
return
}
}
// Load the keys
privPem, err := os.ReadFile("private.pem")
if err != nil {
fmt.Println("Error: Can't read private.pem file")
return
}
pubPem, err := os.ReadFile("public.pem")
if err != nil {
fmt.Println("Error: Can't read public.pem file")
return
}
// Import the keys from PEM
privKey, _ := secure.RSAParsePrivateKeyFromPEM(privPem)
pubKey, _ := secure.RSAParsePublicKeyFromPEM(pubPem)
text := []byte("This is super secret message!")
// Encrypt RSA with OAEP message
encryptedMessage, _ := secure.RSAEncryptWithOAEP(text, pubKey, nil)
fmt.Println("Asymmetric Encrypted Message:", string(encryptedMessage))
// Decrypt RSA with OAEP message
decryptedMessage, _ := secure.RSADecryptWithOAEP(encryptedMessage, privKey, nil)
fmt.Println("Asymmetric Decrypted Message:", string(decryptedMessage))
}
func hashing() {
password := []byte("supersecretpassword")
// Generate Bcrypt hash
hashedPassword, _ := secure.BcryptGenerateHash(password, 0)
fmt.Println("Hashed password:", string(hashedPassword))
// Compare Bcrypt hash
err := secure.BcryptCompareHash(hashedPassword, password)
if err != nil {
fmt.Println("Invalid password")
} else {
fmt.Println("Valid password")
}
// Generate Argon2 hash
hashedPassword, _ = secure.Argon2idGenerateHash(password, 64*1024, 1, 2, 16, 32)
fmt.Println("Hashed password:", string(hashedPassword))
// Compare Argon2 hash
err = secure.Argon2idCompareHash(hashedPassword, password)
if err != nil {
fmt.Println("Invalid password")
} else {
fmt.Println("Valid password")
}
}
func signing() {
// Load the keys
privPem, err := os.ReadFile("private.pem")
if err != nil {
fmt.Println("Error: Can't read private.pem file")
return
}
pubPem, err := os.ReadFile("public.pem")
if err != nil {
fmt.Println("Error: Can't read public.pem file")
return
}
// Import the keys from PEM
privKey, _ := secure.RSAParsePrivateKeyFromPEM(privPem)
pubKey, _ := secure.RSAParsePublicKeyFromPEM(pubPem)
text := []byte("Verifiable message!")
// Sign RSA with PSS message
signedMessage, _ := secure.RSASignWithPSS(text, privKey)
fmt.Println("Signed Message:", string(signedMessage))
// Verify RSA with PSS message
err = secure.RSAVerifyWithPSS(text, signedMessage, pubKey)
if err != nil {
fmt.Println("Invalid message")
} else {
fmt.Println("Valid message")
}
}
func symmetric() {
key := []byte("supersecretpassword")
text := []byte("This is super secret message!")
// Encrypt AES with GCM message
encryptedMessage, _ := secure.AESEncryptWithGCM(text, key)
fmt.Println("Symmetric Encrypted Message:", string(encryptedMessage))
// Decrypt AES with GCM message
decryptedMessage, _ := secure.AESDecryptWithGCM(encryptedMessage, key)
fmt.Println("Symmetric Decrypted Message:", string(decryptedMessage))
}
func utilities() {
// Generate random tokens
t1, _ := secure.GenerateRandomString(32, false, true, false, false)
fmt.Println("Token 1:", string(t1))
t2, _ := secure.GenerateRandomString(32, true, false, false, false)
fmt.Println("Token 2:", string(t2))
t3, _ := secure.GenerateRandomString(32, true, true, false, false)
fmt.Println("Token 3:", string(t3))
t4, _ := secure.GenerateRandomString(32, true, true, true, false)
fmt.Println("Token 4:", string(t4))
t5, _ := secure.GenerateRandomString(32, true, true, true, true)
fmt.Println("Token 5:", string(t5))
// Generate human passwords
p1, _ := secure.GenerateHumanPassword(0, 0)
fmt.Println("Password 1:", string(p1))
p2, _ := secure.GenerateHumanPassword(5, 2)
fmt.Println("Password 2:", string(p2))
}
Documentation
¶
Overview ¶
Package secure is a simple package to easily work with the most common cryptography functions.
Index ¶
- func AESDecryptWithGCM(encryptedText []byte, key []byte) ([]byte, error)
- func AESEncryptWithGCM(plainText []byte, key []byte) ([]byte, error)
- func Argon2idCompareHash(hashedPassword []byte, password []byte) error
- func Argon2idGenerateHash(plainPassword []byte, memory uint32, time uint32, threads uint8, ...) ([]byte, error)
- func BcryptCompareHash(hashedPassword []byte, password []byte) error
- func BcryptGenerateHash(plainPassword []byte, cost int) ([]byte, error)
- func DecodeBase64(data []byte) ([]byte, error)
- func EncodeBase64(data []byte) []byte
- func GenerateHumanPassword(letters int, digits int) (string, error)
- func GenerateRandomBytes(length int) ([]byte, error)
- func GenerateRandomString(length int, upperCase bool, lowerCase bool, digits bool, symbols bool) (string, error)
- func GenerateRandomStringURLSafe(length int) (string, error)
- func RSADecryptWithOAEP(encryptedText []byte, privKey *rsa.PrivateKey, label []byte) ([]byte, error)
- func RSAEncryptWithOAEP(plainText []byte, pubKey *rsa.PublicKey, label []byte) ([]byte, error)
- func RSAExportPrivateKeyAsPEM(privKey *rsa.PrivateKey) []byte
- func RSAExportPublicKeyAsPEM(pubKey *rsa.PublicKey) ([]byte, error)
- func RSAGenerateKeyPair(bits int) (*rsa.PrivateKey, *rsa.PublicKey)
- func RSAParsePrivateKeyFromPEM(privPem []byte) (*rsa.PrivateKey, error)
- func RSAParsePublicKeyFromPEM(pubPem []byte) (*rsa.PublicKey, error)
- func RSASignWithPSS(plainText []byte, privKey *rsa.PrivateKey) ([]byte, error)
- func RSAVerifyWithPSS(signedText []byte, signature []byte, pubKey *rsa.PublicKey) error
- func ScryptDeriveKey(password []byte, salt []byte) ([]byte, []byte, error)
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func AESDecryptWithGCM ¶ added in v0.2.0
AESDecryptWithGCM decrypts an encrypted text using the key.
func AESEncryptWithGCM ¶ added in v0.2.0
AESEncryptWithGCM encrypts a plain text using the key.
func Argon2idCompareHash ¶ added in v0.2.3
Argon2idCompareHash compares an hashed password with its plain equivalent.
func Argon2idGenerateHash ¶ added in v0.2.3
func Argon2idGenerateHash(plainPassword []byte, memory uint32, time uint32, threads uint8, saltLength int, keyLength uint32) ([]byte, error)
Argon2idGenerateHash generates a new hash from a plain password with the given parameters.
func BcryptCompareHash ¶ added in v0.2.0
BcryptCompareHash compares an hashed password with its plain equivalent.
func BcryptGenerateHash ¶ added in v0.2.0
BcryptGenerateHash generates a new hash from a plain password at the given cost.
func DecodeBase64 ¶
DecodeBase64 decodes data in base64 format.
func EncodeBase64 ¶
EncodeBase64 encodes data in base64 format.
func GenerateHumanPassword ¶
GenerateHumanPassword generates a human readable password.
func GenerateRandomBytes ¶ added in v0.2.2
GenerateRandomBytes generates securely random bytes.
func GenerateRandomString ¶ added in v0.2.2
func GenerateRandomString(length int, upperCase bool, lowerCase bool, digits bool, symbols bool) (string, error)
GenerateRandomString generates a random string.
func GenerateRandomStringURLSafe ¶ added in v0.2.2
GenerateRandomStringURLSafe generates a URL-safe, base64 encoded, random string.
func RSADecryptWithOAEP ¶ added in v0.2.0
func RSADecryptWithOAEP(encryptedText []byte, privKey *rsa.PrivateKey, label []byte) ([]byte, error)
RSADecryptWithOAEP decrypts an encrypted text using a private key.
func RSAEncryptWithOAEP ¶ added in v0.2.0
RSAEncryptWithOAEP encrypts a plain text using a public key.
func RSAExportPrivateKeyAsPEM ¶ added in v0.2.0
func RSAExportPrivateKeyAsPEM(privKey *rsa.PrivateKey) []byte
RSAExportPrivateKeyAsPEM encodes a private key in a PEM block.
func RSAExportPublicKeyAsPEM ¶ added in v0.2.0
RSAExportPublicKeyAsPEM encodes a public key in a PEM block.
func RSAGenerateKeyPair ¶ added in v0.2.0
func RSAGenerateKeyPair(bits int) (*rsa.PrivateKey, *rsa.PublicKey)
RSAGenerateKeyPair generates a key pair from a variable bit size.
func RSAParsePrivateKeyFromPEM ¶ added in v0.2.0
func RSAParsePrivateKeyFromPEM(privPem []byte) (*rsa.PrivateKey, error)
RSAParsePrivateKeyFromPEM decodes a private key from a PEM block.
func RSAParsePublicKeyFromPEM ¶ added in v0.2.0
RSAParsePublicKeyFromPEM decodes a public key from a PEM block.
func RSASignWithPSS ¶ added in v0.2.0
func RSASignWithPSS(plainText []byte, privKey *rsa.PrivateKey) ([]byte, error)
RSASignWithPSS signs a plain text using a private key.
func RSAVerifyWithPSS ¶ added in v0.2.0
RSAVerifyWithPSS verifies a signed text using a public key.
Types ¶
This section is empty.
Source Files
Click to show internal directories.
Click to hide internal directories.