ObjectivePGP Documentation

A Keyring acts as a storage container (in-memory or on-disk) for PGP keys. You can use ObjectivePGP.defaultKeyring for a shared instance or initialize a new Keyring().

Common operations include:

• Accessing all keys via .keys
• Importing keys via .import(keys:) or .import(keyIdentifier:fromPath:)
• Deleting keys via .delete(keys:)
• Finding keys by identifier or User ID

let keyring = Keyring()
let allKeys = keyring.keys
keyring.import(keys: [key])
keyring.delete(keys: [key])

keyring.import(keyIdentifier:"979E4B03DFFE30C6", fromPath:"/path/to/secring.gpg")
if let key = keyring.findKey("979E4B03DFFE30C6") {
    // key found in keyring
}

keyring.findKeys("Name <email@example.com>").forEach(key) { 
    // process key
}

You can manually copy and embed the pre-built frameworks from the Frameworks/ directory in the repository into your project. The available formats are:

• ObjectivePGP.framework
• ObjectivePGP.xcframework

Add the following line to your Podfile to install ObjectivePGP using CocoaPods.

pod 'ObjectivePGP'

To add ObjectivePGP to your Swift project, add the following dependency to your Package.swift file. It is recommended to use .upToNextMinor(from: "0.99.4") to ensure compatibility.

dependencies: [
    .package(url: "https://github.com/krzyzanowskim/ObjectivePGP.git", .upToNextMinor(from: "0.99.4"))
]

Use the Armor class to convert binary PGP data (keys or messages) into an ASCII-armored format suitable for text-based transmission like email.

Important: Use the correct PGPArmorType to ensure the correct headers are applied.

// Example: Armoring an encrypted message
let armoredMessage = Armor.armored(encryptedData, as: .message)

// Example: Armoring a public key
let armoredKey = Armor.armored(publicKeyData, as: .publicKey)

You can export the entire contents of a Keyring to a file, or export specific keys as raw data.

To export specific keys by type, use exportKeys(of:) with .public or .secret.

// Write keyring to file
try keyring.export().write(to: URL(fileURLWithPath: "keyring.gpg"))

// Public keys (Data)
let publicKeys = keyring.exportKeys(of: .public)

Use KeyGenerator to create a new PGP key pair for a specific User ID. You can optionally provide a passphrase for the secret key.

let key = KeyGenerator().generate(for: "marcin@example.com", passphrase: "password")
let publicKey = try key.export(keyType: .public)
let secretKey = try key.export(keyType: .secret)

Perform encryption and decryption operations. When encrypting, you can optionally add a signature. When decrypting, you can optionally verify the signature of the sender.

let encrypted = try ObjectivePGP.encrypt(fileContent, addSignature: true, using: [key1, key2])
let decrypted = try ObjectivePGP.decrypt(encrypted, andVerifySignature: true, using: [key1])

You can load one or more PGP keys (public or private) directly from a file on disk using readKeys(fromPath:) in Swift or readKeysFromPath:error: in Objective-C.

let keys = try ObjectivePGP.readKeys(fromPath: "/path/to/key.asc")

Use ObjectivePGP.sign to create a signature for data (with an option for detached signatures) and ObjectivePGP.verify to validate a signature against the original data using the appropriate keys.

let signature = try ObjectivePGP.sign(encryptedBin, detached: true, using: [key1])
try ObjectivePGP.verify(encryptedBin, withSignature: signature, using: [key1])