GopenPGP V3

GopenPGP supports three types of signatures:

1. Detached Signatures: The signature is separate from the message. Use .Sign().SigningKey(key).Detached().New() and .Sign(message, crypto.Armor). Verify using .VerifyDetached().
2. Inline Signatures: The signature is embedded within the armored message. Use .Sign().SigningKey(key).New() and .Sign(message, crypto.Armor). Verify using .VerifyInline().
3. Cleartext Signed Messages: The message remains readable but includes a signature block. Use .Sign().SigningKey(key).New() and .SignCleartext(message). Verify using .VerifyCleartext().

// Detached Signature Example
signer, err := pgp.Sign().SigningKey(aliceKeyPriv).Detached().New()
signature, err := signer.Sign(signingMessage, crypto.Armor)

verifier, err := pgp.Verify().VerificationKey(aliceKeyPub).New()
verifyResult, err := verifier.VerifyDetached(signingMessage, signature, crypto.Armor)

To use asymmetric encryption, load your public and private keys using crypto.NewKeyFromArmored(pubkey) and crypto.NewPrivateKeyFromArmored(privkey, passphrase).

Basic Encryption/Decryption

Use pgp.Encryption().Recipient(publicKey).New() to encrypt for a specific recipient. Use pgp.Decryption().DecryptionKey(privateKey).New() to decrypt. Always call decHandle.ClearPrivateParams() after use to clear sensitive data from memory.

Signing and Encryption

To sign a message while encrypting, chain .SigningKey(privateKey) to the encryption handle. During decryption, use .VerificationKey(publicKey) on the decryption handle and check decrypted.SignatureError() to verify the signature.

Multiple Recipients and Hidden Recipients

• Multiple Recipients: Use crypto.NewKeyRing(key) to create a keyring and recipients.AddKey(key) to add more, then pass the keyring to .Recipients(recipients).
• Hidden Recipients: Use .HiddenRecipient(key) to prevent the recipient's fingerprint from being visible in the key packet. When decrypting, you must call .DisableIntendedRecipients() on the decryption handle to avoid signature errors caused by the missing intended recipient list.

// Encrypt and sign plaintext message from alice to bob
encHandle, err := pgp.Encryption().
  Recipient(bobKeyPub).
  SigningKey(aliceKeyPriv).
  New()
pgpMessage, err := encHandle.Encrypt([]byte("my message"))
armored, err := pgpMessage.ArmorBytes()

// Decrypt armored encrypted message using the private key and obtain the plaintext
decHandle, err := pgp.Decryption().
  DecryptionKey(bobKeyPriv).
  VerificationKey(aliceKeyPub).
  New()
decrypted, err := decHandle.Decrypt(armored, crypto.Armor)
if sigErr := decrypted.SignatureError(); sigErr != nil {
  // Signature verification failed
}
myMessage := decrypted.Bytes()

encHandle.ClearPrivateParams()
decHandle.ClearPrivateParams()

You can perform symmetric encryption and decryption using a passphrase without requiring PGP keys. Use pgp.Encryption().Password(password).New() to create an encryption handle and pgp.Decryption().Password(password).New() for decryption.

Note that using crypto.PGPWithProfile(profile.RFC9580()) is recommended for modern security standards, as it uses Argon2 for key protection and AEAD (AES-256, OCB mode) for encryption.

import "github.com/ProtonMail/gopenpgp/v3/crypto"
import "github.com/ProtonMail/gopenpgp/v3/profile"

password := []byte("hunter2")

// Using RFC 9580 profile
pgp := crypto.PGPWithProfile(profile.RFC9580())

// Encrypt data with a password
encHandle, err := pgp.Encryption().Password(password).New()
pgpMessage, err := encHandle.Encrypt([]byte("my message"))
armored, err := pgpMessage.ArmorBytes()

// Decrypt data with a password
decHandle, err := pgp.Decryption().Password(password).New()
decrypted, err := decHandle.Decrypt(armored, crypto.Armor)
myMessage := decrypted.Bytes()

For large datasets, use the streaming API to avoid loading entire messages into memory.

1. Encryption: Use encHandle.EncryptingWriter(writer, crypto.Armor) to get a writer that encrypts data as it is written. Use io.Copy to stream from a source reader to the encryption writer.
2. Decryption: Use decHandle.DecryptingReader(reader, crypto.Armor) to get a reader. Use ptReader.ReadAllAndVerifySignature() to read the content and verify the signature in one step.

// Encrypt plain text stream and write the output to a file
encHandle, err := pgp.Encryption().
  Recipient(bobKeyPub).
  SigningKey(aliceKeyPriv).
  New()
messageReader, err := os.Open("msg.txt")
ciphertextWriter, err := os.Create("out.pgp")

ptWriter, err := encHandle.EncryptingWriter(ciphertextWriter, crypto.Armor)
_, err = io.Copy(ptWriter, messageReader)
err = ptWriter.Close()

// Decrypt stream and read the result to memory
decHandle, err := pgp.Decryption().
  DecryptionKey(bobKeyPriv).
  VerificationKey(aliceKeyPub).
  New()
ptReader, err := decHandle.DecryptingReader(ctFileRead, crypto.Armor)
decResult, err := ptReader.ReadAllAndVerifySignature()
if sigErr := decResult.SignatureError(); sigErr != nil {
  // Handle sigErr
}
// Access decrypted message with decResult.Bytes()