Skip to content
jzbzPublic

About

OpenPGP certificate manager for Linux, macOS and Windows. Pure Rust, built on Sequoia and Slint

Resources

Stars

0 stars

Watchers

0 watching

Forks

Latest commit

 

History

244 Commits

Folders and files

Repository files navigation

rPGP

CI

An OpenPGP certificate manager for Linux, macOS and Windows, in the spirit of KDE's Kleopatra: a window that lists your certificates and lets you generate, import, export, sign, encrypt, decrypt and verify without touching a command line.

Rust throughout, Slint for the GUI, Sequoia for the OpenPGP implementation. No webview, no Qt, no C++, no gpg subprocess.

Status: feature-complete against Kleopatra's common workflows, and young. Generating, importing, exporting, certifying, revoking, looking up, publishing, and signing, encrypting, decrypting and verifying both files and text all work from the window — including on a smartcard. Nothing here has been used in anger by anyone but its author.

rPGP's certificate list, with Carol verified through a certification from Trent

Layout

Crate Contents
crates/rpgp-core Certificate store, key generation, encrypt/decrypt/sign/verify, certification, web-of-trust, revocation and key lifecycle. No GUI types.
crates/rpgp-gui Slint front end. Binary is rpgp.

The GUI depends only on rpgp-core's own types — no sequoia_openpgp type reaches a Slint callback — so the OpenPGP layer stays replaceable.

Inside crates/rpgp-gui/ui:

File Contents
theme.slint Colour, spacing and type tokens, plus the icon paths.
widgets.slint Buttons, fields, pills, the certificate list and its scope tabs, the status line, the revocation banner, the dialog frame — the app's own controls.
dialogs.slint New key pair, Sign / Encrypt, Decrypt / Verify, Certify, Revoke, Lifecycle, Lookup, Details, Notepad, About.
app-window.slint The shell that assembles them.
types.slint Structs shared with Rust.

Look and feel

The app follows the system light/dark setting but not a platform widget style. The scrollbars, the one part std-widgets still draws, are where a style would show, and build.rs pins fluent for every platform: Slint's native style, which a build could otherwise select, would draw them cupertino on macOS and fluent elsewhere, which reads as two different products. Nor is the font the platform's: the interface is set in Geist, which app-window.slint bundles and makes the window's default family. What is left of the platform is the window frame, the file chooser, the message box that reports a failure to start, the application menu in the macOS menu bar, and the system font that draws any character Geist does not have. On a Wayland desktop that leaves the frame to the app, winit draws it, in an Adwaita-like style.

Everything else is drawn by the design system in theme.slint and widgets.slint. Only the scrolling comes from std-widgets: ListView, which is virtualised, for lists, and ScrollView for whatever else can outgrow the window. Icons are Lucide SVGs, vendored under ui/icons and recoloured through Image's colorize, so one file serves every tone in both themes.

The labels on filled buttons, and text in the text and text-dim inks, are drawn at 4.5:1 or more against what is behind them, in both themes, as WCAG asks of text this small. text-faint falls short of that, and is kept for what the eye may pass over, such as placeholders, counts and section headings. tests/accessibility.rs holds the theme to this, and looks at the pixels of the lines that used to be faint. Pill labels are not held to it yet: drawn in a status colour on a wash of the same colour, several fall short of it, down to about 4:1 on a selected row of the list.

Long operations run on a worker thread and report back through the event loop, so generating an RSA-4096 key does not freeze the window.

Build and run

Needs the Cap'n Proto compiler (capnp) installed.

cargo run -p rpgp-gui
cargo test --workspace

Some tests are #[ignore]d because they need the network, a smartcard, a PIN prompt or your own gpg-agent. Run them with -- --ignored. No other test reaches your agent: the ones that exercise the agent start one of their own in a temporary directory, or stand in for one, and those that need GnuPG skip where it is not installed.

To try the app with content in it, seed a throwaway store. The example writes only inside the directory it is given, laid out as the app lays out its data directory, so on Linux XDG_DATA_HOME points the app at it:

cargo run -p rpgp-core --example seed-demo-store -- /tmp/rpgp-demo && XDG_DATA_HOME=/tmp/rpgp-demo cargo run -p rpgp-gui

The second half is for Linux alone. The dirs crate reads XDG_DATA_HOME there but not on macOS or Windows, where the app opens your own store whatever the variable says.

Installing

A release carries a Flatpak bundle for x86_64 and aarch64, a universal .app for macOS, and for Windows one self-contained .exe and a per-user installer around that same .exe. The macOS bundle is signed with a Developer ID and notarised by Apple, so it opens on first launch rather than having to be talked past Gatekeeper; neither Windows file is signed, so SmartScreen warns the first time one downloaded in a browser is run, and then lets you through.

brew install --cask jzbz/tap/rpgp                  # macOS, from the tap
flatpak install ./rpgp-*.flatpak                   # Linux, from the bundle
winget install jzbz.rPGP                           # Windows

The cask lives in github.com/jzbz/homebrew-tap, a tap of this project's own; packaging/homebrew/README.md says why that rather than homebrew-cask. Whatever the route, the signed SHA256SUMS on the release is worth checking first.

From 0.1.4, winget installs rPGP through that installer, for your account only and without asking for an administrator: rPGP goes in the Start Menu and in Apps & Features, Win+R rpgp starts it from a normal, not elevated, Run box, and winget uninstall jzbz.rPGP, with rPGP closed, takes all of that away again without touching your certificates or keys. That starts once winget's community repository carries a version with the installer, which follows each release by hand and waits on winget's reviewers; until then winget install jzbz.rPGP gives 0.1.3's bare .exe. winget show jzbz.rPGP says which: its installer type reads inno for the installer and portable for the bare .exe. A winget install of 0.1.3 or earlier is the bare .exe, which winget will not upgrade to the installer: once winget offers the installer, close rPGP, then run winget uninstall jzbz.rPGP and winget install jzbz.rPGP, once. Your keys stay where they are through both, and the new install finds them. packaging/winget/README.md has the detail.

Verifying a download

A release carries the Flatpak bundles, a SHA256SUMS listing them, and a SHA256SUMS.asc signing that list. Fetch the signing key once, from GitHub:

curl -sL https://github.com/jzbz.gpg | gpg --import

or from a keyserver, which is the better of the two — it does not come from the same host as the release:

gpg --locate-keys jz@jz.bz

Either way the fingerprint below is what to trust, not where you got it. Then check the signature before the files:

gpg --verify SHA256SUMS.asc SHA256SUMS && sha256sum -c --ignore-missing SHA256SUMS

gpg --verify has to report a Good signature from 252B 901C 8885 3CF9 F939 2559 2497 38C8 641C 3359; any other key, or none, and the rest is meaningless. --ignore-missing checks whichever bundle you actually downloaded and stays quiet about the other architecture.

A freshly imported key also draws "WARNING: This key is not certified with a trusted signature". That is expected and is not a failed check: it says the key carries no web-of-trust path from anything you already trust, which a key you just fetched never does. The signature is still good. Compare the fingerprint gpg prints against the one above and move on, or sign the key locally (gpg --lsign-key jz@jz.bz) to silence it on later releases.

The order is the whole point. SHA256SUMS sits in the same release as the files it describes, so by itself it catches a truncated download and nothing else — anyone able to replace a bundle could replace the list beside it just as easily. The signature is what turns it into a check, and it is made by hand: the key never goes near CI, so a compromised workflow can publish a bundle but cannot sign for one.

None of which needs gpg, incidentally. Import the signing key into rPGP, open Decrypt / Verify, give it SHA256SUMS.asc, and it will ask for the file that goes with it. Circular for the download you have not verified yet, and perfectly sound for every release after that.

Stack decisions

GUI: Slint on winit, rendering through wgpu

slint is pulled in with default-features = false, because two of its defaults are unwanted. backend-default compiles in the Qt backend whenever qmake is on the build machine's PATH and then prefers it at runtime, so a default build renders through Qt on one developer's machine and winit on another. And renderer-femtovg is FemtoVG over OpenGL, which is deprecated on macOS; renderer-femtovg-wgpu is the same renderer over Vulkan and Metal. renderer-skia is never enabled — it needs a C++ toolchain.

A machine with no usable GPU gets the software renderer. Slint does that by itself only when wgpu finds no GPU at all. A GPU that wgpu finds but that cannot draw into a window — an X server without DRI3, some VMs — leaves Slint with no window on Linux, and, going by Slint's source (neither has been run with such a GPU), with an error on Windows and macOS. rPGP then restarts itself once on the software renderer, unless the window that failed was already on it. How is documented above configure_renderer and watch_first_window in crates/rpgp-gui/src/lib.rs.

OpenPGP: Sequoia with the RustCrypto backend

sequoia-openpgp defaults to Nettle (C). This build selects crypto-rust, which demands two explicit opt-ins — allow-experimental-crypto, because the backend is not one of Sequoia's mature ones, and allow-variable-time-crypto, because it does not guarantee constant-time operation everywhere.

Both are real warnings rather than paperwork: this build is more exposed to timing side channels than a Nettle or OpenSSL build. On a desktop where an attacker is not co-resident that is an acceptable trade for OpenPGP cryptography with no C in it. It would not be on a shared host.

compression-bzip2 is off, as it links C bzip2. The cost is that BZip2-compressed messages cannot be read; nothing modern produces them.

What is not pure Rust

Library Via Why
ring rustls The cryptography under every HTTPS connection, for WKD and keyserver lookup and for publishing: keyserver.rs builds its TLS on ring's provider. C and assembly, built into every release.
libsqlite3 sequoia-cert-store → rusqlite cert-d keeps a SQLite index for lookup by e-mail and subkey. Not optional in that crate. Linked from the system on Linux and macOS. On Windows sequoia-cert-store turns on rusqlite's bundled feature, so SQLite's C source is compiled into the .exe.
fontconfig i-slint-core System font discovery on Linux.
libwayland winit, smithay-clipboard Loaded at runtime on a Wayland session.

Building also needs the Cap'n Proto compiler (capnp), for sequoia-ipc.

Certifying and trust

Two different questions get asked about a certificate, and rPGP shows both because confusing them is how people end up trusting the wrong key:

  • Validity — is the certificate internally sound? Self-signatures check out, not expired, not revoked. This is the valid / expired / revoked pill, and it says nothing about who the certificate belongs to.
  • Authentication — does the name on it belong to the person you think? This is the verified / partly verified pill, computed by sequoia-wot from the certifications in the store. A perfectly valid certificate from a stranger is unauthenticated, and so is one that has expired or been revoked, however well it was certified while it was live: sequoia-wot 0.15.2, which rPGP pins, finds no path to it, so a key you confirmed years ago reads as unverified once it expires.

What a certificate calls itself is its maker's to write, so the window shows a user ID as the certificate has it, save for what cannot be seen: each control character, a newline among them, and each format character, a bidirectional override or isolate, a zero-width space and their like, is written out as its code point, [U+202E]. Slint lays text out by the Unicode bidirectional algorithm, overrides included, so a user ID holding one could draw its address backwards and, left open, turn the app's own words round after it, and a newline made one user ID read as two. A zero-width joiner or non-joiner with a visible character outside ASCII on each side is left alone, since Persian and the Indic scripts spell with them, as do emoji sequences. A revocation's note is shown the same way, under the reason and quoted, since anyone holding the key can write it. A copy takes the text as shown, but nothing else changes: a user ID is still found, certified and revoked by the text the certificate carries.

A person's old and new keys usually carry the same user ID, as do the Modern and Compatible pair that New key pair offers, so every list a key is chosen from, the recipients and the Sign as and Certify with lists, shows each key's ID beside it.

Certifying is done from a certificate's details pane. A certification always names one user ID — OpenPGP has no way to vouch for a certificate as a whole — so the dialog lists them and you tick the ones you actually checked. The options map onto OpenPGP as follows:

Dialog What it writes
Confidence: Full / Partial trust amount 120 / 60; anything but Full becomes a trust signature
Publishable an exportable certification, shareable and included in exports
(unticked) a local certification: export_file writes out neither it nor its withdrawal, unless that withdrawal also takes back a publishable one it replaced
Trusted introducer a trust signature of depth 1: keys they certify count here too

A certification is always made with the certifier's primary key, whatever flags the certificate puts on its subkeys, because that is the only key sequoia-wot accepts one from; a certification a subkey made counts for nobody. Nor is a certification made that sequoia-wot would discount from the start: certifying a key that has expired, has been revoked or is not valid under the standard policy, or a user ID that is not valid UTF-8, is refused before any key is unlocked.

The details pane lists every certification on a certificate and ticks the ones sequoia-wot counts, by its own rule: a certifier's newest word on a user ID replaces the one before it, a withdrawal takes back what came before it, and a certification that has expired, that a subkey made, that was made with SHA-1 (as GnuPG 1.x and 2.0 did by default), that was made of a key already expired or revoked or since revoked as compromised, or whose certifier's key has since been revoked as compromised is listed with the reason it does not count. A tick says that sequoia-wot counts the certification as an edge of the web of trust, and no more. Whether the name is authenticated is still the verified pill's to say: that takes a path of such edges from one of your trust roots, and the pill weighs the certificate and the user ID themselves as well, so a ticked row can sit under a pill that says otherwise. Only what counts, or will once the date it carries comes, is offered for withdrawal, so a certification of your own that sequoia-wot does not count, a SHA-1 one among them, is listed without a way to withdraw it.

Trust roots are where authentication starts. Every key you generate here is a root automatically — the alternative is a fresh install where nothing authenticates until the user finds a checkbox — and any other certificate can be marked one by hand from its details pane.

A secret key that arrives by import is deliberately not a root. Holding the secret half is what the rule used to test, and importing is how someone else's key can satisfy it: a file containing a keypair they generated would otherwise buy them a trust root in your store, and with it a verified badge on whatever identities that key had certified. The key still works for decrypting and signing — it simply does not vouch for anyone until you say so. Restoring your own backup is the same story: tick Trust root once, and it stays.

The graph is rebuilt on every store reload rather than cached. At five thousand certificates that rebuild is about 24ms of a 100ms read; a certificate that is not a root and that nobody has certified is not searched for a path, since none can reach it. A caching layer would have to be invalidated by every certification, revocation and trust-root change, and taking the read off the event loop was the cheaper answer to the same complaint. A keyring well past that size will still want the cache.

Encrypting with a password

A message can be encrypted to certificates, to passwords, or to both at once — the session key is wrapped separately for each, so any one of them opens it. Encrypting to a password alone is what gpg -c produces, and rPGP now reads that too: the decryption helper tries the supplied passphrase against the symmetric envelopes before concluding a message was not meant for us.

That is one field doing two jobs on the way in and two on the way out. In Sign / Encrypt the passphrase that unlocks your signing key and the password that anyone will need are deliberately separate fields, because confusing them would hand out the wrong secret.

A message that is signed as well as encrypted names every certificate it was encrypted to inside its signature, so that a recipient cannot simply send it on to someone else as though the signer had meant it for them: where a signature names recipients and the certificate whose key opened the message is not among them, rPGP reports the signature as not valid. A password has no certificate to name, so a message opened with its password is not checked this way, and neither is a signed message sent on with no encryption at all, which rPGP shows as not encrypted.

The check goes by which certificate rPGP takes the key that opened the message to belong to, and one key can be carried by several: binding someone's encryption key to a certificate of your own needs nothing from them. A key only gpg-agent holds, a card key for one, is taken to belong to the first certificate in your store that carries it, version 6 fingerprints before version 4 ones and each version in hex order. So once you have imported a certificate that someone has bound your key to, and it comes before yours, messages the agent opens with that key are credited to him. A message he was sent and sends on to you then reads as meant for you, and signed messages that really were meant for you read as not valid, since their signatures name your certificate and not his; for that he need send you nothing. A secret key in rPGP's own store is out of his reach: a message it opens is credited to the certificate that key is kept with. And where two certificates of your own carry one encryption key, as when a card's keys are added to a new certificate, a message whose signature names one of them can be credited to the other and read as not valid.

When a message is for one of your keys that has a passphrase, and none was entered or the one entered does not unlock it, the failure says so and names the key, rather than that no secret key opens the message. Only for a key the message names: one sent to hidden recipients could be for anybody, and asking for your passphrase then would ask for one that may never work. Where the message is for a password as well, the failure says that the key's passphrase or the message's password would open it, or that what was entered is neither, since the one field is tried as both. Where what was entered does unlock the key and the key then turns out to be damaged, the failure says that instead, rather than sending you back to a passphrase that is right.

Reading such a message costs whatever its sender decided it should. The packet names the password-hashing parameters, and Argon2's are a memory size and a pass count that the recipient pays once for every (envelope × candidate password) — before the password is checked, so a wrong guess costs as much as a right one. rPGP spends at most what RFC 9580's own recommended parameters ask for: 2 GiB hashed once per attempt, and four such attempts for the whole message however many envelopes it carries or encryption layers it nests. An envelope priced above that is passed over, and if nothing else opens the message the failure says so rather than reporting a wrong password, because from the outside the two look identical. Nothing in ordinary use comes near the limit: GnuPG and the library rPGP is built on both hash passwords with iterated SHA-256, whose cost its own encoding already bounds.

Revocation

Revocation is one-way and public: the signature becomes part of the certificate, and anyone who already has a copy keeps it forever. Three separate things can be retracted, and the UI keeps them apart:

  • Your own key, from its details pane. Pick a reason and optionally leave a note. Choosing secret key may be compromised makes it a hard revocation, which also invalidates signatures the key made in the past — including every certification it ever issued, so anyone it had authenticated drops back to unverified. A key retired with a soft reason keeps the button, as Mark as compromised…, until it carries a hard revocation: the soft one leaves standing every signature the key made before it, and any a thief dates to then, and only a hard one takes those back.
  • A certification you made, without touching the other person's key. Only your endorsement is withdrawn.
  • Someone else's key, by importing the revocation certificate they published. The Import button takes it: a revocation is a bare signature rather than a certificate, so it falls through CertParser to read_revocation_file, which checks each revocation in the file against the certificate it names before anything is stored. Every one that verifies is applied, however many the file holds and in however many armor blocks; the status line names what was revoked, and says why about any that revoked nothing here. A revocation made by a designated revoker — a key another certificate names as allowed to revoke it — is not applied, and Import says so, whether it comes alone or attached to the certificate as GnuPG's --desig-revoke writes it. One that comes alone is refused with the name of the certificate here that it revokes, found by verifying the signature when the revoker's certificate is here too, and otherwise by the two bytes of its hash that a signature carries in the clear, the test Sequoia itself makes before keeping such a revocation with a certificate. RFC 9580 deprecates the mechanism, and honouring one would take every check of whether a key is revoked, Sequoia's own key filters among them, consulting a second certificate.

A revoked certificate is then refused for anything new: encrypting to it, signing with it, certifying it or vouching with it, changing its expiry, adding a user ID. Soft reasons are refused alongside hard ones, because replaced by a newer key still says the owner has stopped using this one. Two things are deliberately left out of that. Reading is one — a revoked key still opens what it was sent, and whether its old signatures still verify is the reason's business rather than the refusal's, a soft revocation leaving them standing where a hard one does not, exactly as the first bullet above says. Withdrawing a certification is the other: taking back what a key already said is not new use of it, so it does not go through the refusal at all. The refusal needs a check of its own because Sequoia's per-key filters cannot express it: revoked(false) asks a subkey about its own revocation, and revoking a certificate as a whole leaves its subkeys unmarked.

That second exemption holds whatever has happened to the key since. After a soft revocation, or once the key has expired, every certification it made before then still counts — sequoia-wot judges a certifier as it stood when it certified — and withdrawing them is the only remedy there is, so the withdrawal is signed with the primary key regardless, locally or through the agent, and takes effect. A hard revocation is where it ends: it already takes back every certification the key ever made, so there is nothing left to withdraw, and the details pane says so beside each of them rather than offering a withdrawal.

The list says the same thing rather than something of its own. The capability letters on a row — C, S, E — are what this app will do with the certificate, not an inventory of the flags on its keys, so a revoked certificate shows none of them and the recipient, signer and certifier pickers never offer it. The same rule is why a certificate you accept SHA-1 from shows none either: that acceptance is for checking signatures, and every operation judges the certificate strictly.

A revocation certificate is now written at key generation, to $XDG_DATA_HOME/rpgp/revocations/<fingerprint>.rev, and can be exported from the details pane. It is the way back if the secret key or its passphrase is lost: applying it needs neither, because it was signed while the key was in hand. It cannot be recreated afterwards, which is why it is written once, at the only moment the key is certainly available. If that write fails, on a full disk say, the key is kept all the same and the status line says it has no revocation certificate; the details pane then offers none to export, and the key can still be revoked from there for as long as you hold it and its passphrase.

Import is how it is applied, and Import is also where it goes by mistake: it is a plain public key block that sits beside the key in a backup being restored. So when Import is handed a bare revocation certificate, the form rPGP and GnuPG write, it asks before storing a revocation of any key whose secret you hold, naming the key and saying whether the revocation is hard, and stores nothing if you cancel. On Linux and Windows the file dialog leaves the window usable, so another dialog can be open by the time a file is chosen; then Import asks nothing and stores nothing, and the status line says to close that dialog and import the file again. Someone else's revocation is applied without asking: it is theirs to make, and would arrive unasked with their certificate from a keyserver refresh. A key is yours when this store holds its secret, or when gpg-agent does, in its own store or on a card: gpg --gen-revoke writes a revocation certificate for such a key that reads just like rPGP's own. The agent holds a key when it holds any of the keys rPGP would ask it to sign, certify or decrypt with. Those are known from the survey that follows each reload of the list, so until the agent has answered, and when none answers, a revocation of one of them is taken for someone else's.

Only a bare revocation certificate is asked about. A certificate that arrives with its revocation already attached is merged like any other import, and revokes the key without a question even when it is yours: an export of a revoked key, a revocation certificate some tools write that way, and a backup made by appending a revocation certificate to the key it revokes, as cat key.asc key.rev does, since the second block's signature is read onto the key in the first. The copy GnuPG saves by itself, in openpgp-revocs.d, has a colon put before its armor, which has to be removed before Import will read it.

If the secret key file itself no longer reads, which is when a revocation certificate is most likely to be needed, the revocation is still stored in the public certificate, the copy the list, exports and Publish use, and the status line says the secret key file could not be updated to match. The same holds when the Revoke button's revocation reaches the public certificate and the secret key file then cannot be written.

One timing rule runs through all of this. OpenPGP gives the newest signature of a kind the last word — a key's expiry is read off its newest self-signature, a soft revocation stands only until a newer one, a certification counts until the same certifier makes a newer certification or withdrawal — and its timestamps have one-second granularity. So every signature rPGP makes to replace another is dated at least a second after the newest one it replaces: an expiry change, a revocation of a key, a subkey or a user ID, a certification, a withdrawal. Where that one was made in the current second, as it is when you certify and immediately change your mind, the operation waits for the next second rather than dating its signature ahead of the clock, so the change counts as soon as the status bar reports it. Where it is dated more than a few seconds ahead, a clock is wrong — this machine's, or the one that made it — and the operation is refused with that signature's date, rather than signing something that would count nowhere until then, or never at all. A hard revocation is the exception: nothing dated after one undoes it, so it is never held up.

A user ID you retire can be brought back: adding the same name again binds it anew, and the newer binding supersedes the retirement. Anyone holding a copy of the key from between the two still sees it retired.

A user ID is checked before it is bound, to a new key or to one you hold: it needs a name or an address, it cannot hold a control character, as text pasted with a tab or a carriage return in it would, and what stands between < and > has to be an e-mail address, or a URI, so <> and Alice <alice> are refused. A name alone, an address alone and a comment in parentheses before the address are all accepted, since keys made with GnuPG commonly carry each of them; GnuPG itself checks less, and makes a key for <>. A name the key already carries is not checked when it is added back, so one made elsewhere and retired here comes back as it was.

Smartcards and YubiKeys

Card keys are reached through the user's gpg-agent, not by talking to the reader. That is not a preference: scdaemon holds the card with an exclusive PC/SC transaction, so a second process asking the reader directly gets SCARD_E_SHARING_VIOLATION. It is why Kleopatra goes through gpg-agent too.

Two things follow, both good. rPGP never sees a PIN — the agent runs the user's own pinentry. And there is no PC/SC dependency.

rPGP finds the agent by asking gpgconf where it listens, and has gpgconf start one if none is running and the GnuPG home is there. It looks for gpgconf on PATH first, and then where GnuPG is installed. An app opened from the Finder or the Dock is not given the PATH a shell has, so on macOS that is where Homebrew (/opt/homebrew/bin, /usr/local/bin), GPG Suite (/usr/local/MacGPG2/bin) and MacPorts (/opt/local/bin) put it; on Windows, GnuPG\bin under Program Files (x86) and Program Files; and elsewhere, /usr/bin. On Windows the paths Gpg4win's gpgconf prints are used as they are, with no cygpath; a GnuPG built for Cygwin or MSYS2, if its gpgconf comes first on PATH, needs its cygpath there too.

The Flatpak reaches the host's agent through the socket in /run/user/<uid>/gnupg that its manifest shares, and through nothing else. It cannot see ~/.gnupg, which holds the host's secret keys, so it starts no agent of its own: the host's has to be running, or be started by systemd when its socket is opened, as some distributions set up. A gpg command on the host that needs the agent, such as one that signs, decrypts or lists secret keys, starts it, and so does gpgconf --launch gpg-agent. The directory itself has to be there when rPGP starts, since Flatpak shares only what exists at that moment: where nothing has run GnuPG since login, and systemd does not listen for it, rPGP has to be restarted once something has. An agent serving a GnuPG home other than the Flatpak's GNUPGHOME, or ~/.gnupg where that is unset, is not reached, because GnuPG gives each such home's socket a directory of its own.

Signing, certifying and decrypting all work on a card, whether rPGP's store holds only the key's public certificate or also the stubs gpg --export-secret-keys writes in place of the keys on the card: rPGP passes a stub over and asks the agent, as it does for a key it holds no secret of, unless another key of the certificate that can sign came across whole, as the section on coming from GnuPG explains. Where the agent puts its prompt is the agent's business: sequoia-gpg-agent builds those options from GPG_TTY, TERM and DISPLAY when a crypto operation opens its connection. The connection that only lists keys deliberately sets none, for the reason in the note in connected in agent.rs. What a passphrase prompt says is rPGP's to give, and it gives what GnuPG's own does: the certificate's primary user ID, the key's ID, and for a subkey the primary key's ID too.

A pinentry that asks in a terminal, pinentry-curses or pinentry-tty, cannot ask for rPGP started from the desktop. gpg hands the agent the terminal it runs in, through GPG_TTY, and sequoia-gpg-agent hands on GPG_TTY or the terminal on standard input; rPGP started from the desktop has neither, so every PIN or passphrase prompt the agent puts up for it fails at once. For pinentry-curses the agent answers "Inappropriate ioctl for device ", which rPGP reports as a pinentry that asks in a terminal; for pinentry-tty it answers "Operation cancelled", which cannot be told from pressing Cancel. Where gpg-agent runs in a language other than English, its words are passed on as it gave them. The cure is a graphical pinentry, such as pinentry-qt or pinentry-gnome3 on Linux and pinentry-mac on macOS: name it with pinentry-program in gpg-agent.conf in the GnuPG home, ~/.gnupg unless GNUPGHOME says otherwise, and run gpgconf --reload gpg-agent. For the Flatpak that is the host's gpg-agent.conf, since the prompt is the host agent's.

Certifying takes the certificate's primary key, so Certify identity… is offered once some key's primary can sign: its secret is in rPGP's store, as key material rather than the stub GnuPG exports in place of a primary kept offline or on a card, or the agent holds it, in its own store or on a card. The certifier list puts "(smartcard)" in front of one on a card, where the key ID beside it cannot crowd the mark out, and the details pane names the card a key signs from by the number gpg -K gives it, 0006 18132963 for an OpenPGP card, the manufacturer's and then the card's own. A card holding only the subkeys, the primary being kept offline as many YubiKey guides advise, signs and decrypts through the agent but is not offered as a certifier, and nor is a key imported from gpg --export-secret-subkeys, unless the agent holds its primary. What the agent holds is learnt by the survey after each reload of the list, so a key only the agent holds opens Certify once the agent has answered, which is at once unless the agent has hung; a dialog opened before then lists only the keys in rPGP's store. The details pane counts the same keys as yours, and an expired one too, since what it certified before it expired still stands: a certification one of them made is marked as yours and offered for withdrawal, which signs through the agent, once the agent has answered.

A message the keys in rPGP's own store do not open is taken to the agent, and only to a key it could be for: the key each of its session-key packets names, or, for a packet that names none, each key the agent holds of the same kind. Packets that name a key come first, and card keys before those in the agent's own store. Each key is taken once, however many of your certificates carry it, and asked only about the packets it could open, of which a message to hidden recipients can have several. A message encrypted to a password alone, or to nobody in your store, never reaches the agent. If the agent refuses, because its prompt was cancelled, the card is not there or it has no pinentry to ask with, the decryption stops and reports what the agent said, rather than putting up the next prompt and then reporting that no secret key opens the message. The agent's answer reaches rPGP without its error code, and in your language, so a cancelled prompt cannot be told from a card that turned down one packet: a message another of your keys would have opened is not tried with that key after a refusal. Decrypt again with the card in, or with the passphrase to hand.

The exception is an RSA key on a card, asked about a packet that names no key. A message to hidden recipients carries packets for other people's keys that can look just like one for yours, and the card turns down another RSA key's packet with an error, as it does a cancelled prompt. Stopping there would leave such a message unreadable on the card whenever someone else's packet came first, so rPGP goes on to the next packet, and reports the refusal only if none opens the message. If you cancel the PIN prompt for such a message, it comes back once for each packet left. A wrong PIN is turned down the same way and brings the prompt back too, and every wrong PIN entered uses up one of the card's tries.

One case is not handled: when hidden recipients have keys on a NIST curve and on the Brainpool curve of the same size, whose points look alike, the agent turns down a packet for the other kind of curve, and a message where one comes before yours does not open through the agent.

Keyservers

Lookup tries the Web Key Directory before a keyserver, and publishing uploads to keys.openpgp.org. RPGP_KEYSERVER overrides the server, for an internal one or for testing against a local stand-in rather than uploading to public infrastructure.

An internal keyserver's certificate usually comes from the organisation's own CA, and that works wherever the CA is in the operating system's certificate store, where curl and gpg look for it too. A server's certificate is checked against Mozilla's roots, compiled in, and against the system's anchors beside them: the distribution's CA bundle and certificate directories on Linux, the certificates the user, administrator and system trust settings mark as trusted on macOS, and the Trusted Root Certification Authorities store as the current user sees it on Windows. Only the anchors come from the system. The check is rustls's own, so the system opens no connection for revocation data, or for anything else, that the network guard described below would not see. The store is read once, at the first lookup or upload, so a CA installed or removed while rPGP is running takes effect at its next start, and one removed stays trusted until then.

SSL_CERT_FILE, a file of PEM certificates, and SSL_CERT_DIR, directories of them separated as in PATH, replace the system store when either is set, on every platform. Mozilla's roots stay either way, so SSL_CERT_FILE naming a private CA alone trusts that CA and the public roots, and nothing else.

The cost is trusting whatever the store holds. On a managed network that inspects TLS, the inspecting CA is in the store: lookups there work where they used to fail, and that CA can read and rewrite what a WKD host or a keyserver sends, as it already can for curl and gpg on the same machine. Where that is not wanted, pointing SSL_CERT_FILE at a file holding only the CAs you mean to trust, or an empty one, leaves the rest of the store out.

The Flatpak sees none of the host's store. Its /etc/ssl and /etc/pki are the freedesktop runtime's own, holding that runtime's copy of Mozilla's roots and nothing added on the host; the runtime hands the host's trust on through p11-kit, but only to software that asks p11-kit for it, and rPGP reads the PEM files instead. A private CA reaches the Flatpak through SSL_CERT_FILE, from a place the sandbox can read:

mkdir -p ~/.var/app/app.rpgp.rPGP/config
cp corp-ca.pem ~/.var/app/app.rpgp.rPGP/config/
flatpak override --user \
  --env=SSL_CERT_FILE=$HOME/.var/app/app.rpgp.rPGP/config/corp-ca.pem \
  app.rpgp.rPGP

What a WKD host serves is kept only where it carries the address that was asked for, and only that identity is kept on it — both are requirements of the specification, and neither was applied. A domain serving alice@evil.example could answer with Bob <bob@bank.example>, and the result was listed as coming from the web key directory, which is the strongest provenance this app shows; an import then stored every user ID on it, and the certify dialog offers those pre-ticked. Which of the two WKD URLs is fetched is decided by whether openpgpkey.<domain> resolves, not by trying the delegated host and moving on when it does not answer with a key: a 404 there is an answer, and treating it as a failure handed every unpublished address at a delegating domain to whoever runs the apex web site. A domain that wildcards its DNS and publishes by the direct method loses WKD by this rule, which the specification puts on the site; the lookup falls through to the keyserver as it does for any address with no WKD key.

A keyserver reply is held to the weaker half of the same rule: it must be an answer to the question. RPGP_KEYSERVER may name any HKP server, verifying or not, and a fingerprint query answered with an unrelated certificate used to be listed as found. A certificate answers for a fingerprint or key ID only where it is that certificate's own primary key or a subkey it has signed for, since appending a key packet to somebody else's certificate takes no signature at all. What this cannot settle is whose a properly bound subkey is, as two certificates may bind one key. A free-text name search is left as the server returned it.

A lookup is the least trusted fetch the app makes: a WKD URL is built from the domain half of whatever address was typed, and a redirect names whatever the server chooses. So neither is allowed to reach this machine or its network. An address written as an address is refused before a URL is built, and a name is resolved by a guard that hands reqwest only the addresses it approved — which also means no second DNS answer can arrive between the check and the connection. Without this, alice@127.0.0.1:8080 was a port probe and evil.example with an A record of 127.0.0.1 was the same probe wearing a name.

"This machine or its network" is loopback, RFC1918, link-local and the rest of the usual list, and also shared address space, 100.64.0.0/10: a carrier's NAT puts the subscriber's own network there, and so does Tailscale, whose tailnet addresses were refused on the IPv6 side as unique-local and not refused at all on the IPv4 side. An IPv6 address that carries an IPv4 one inside it is judged by the address inside — IPv4-mapped, the well-known NAT64 prefix, 6to4 and Teredo — while local-use NAT64 and site-local are refused outright. Proxy environment variables are ignored, for the same reason: HTTPS_PROXY would put the target name in a CONNECT line for the proxy to resolve on the far side, which is the guard switched off, and it broke ordinary lookups besides, since a proxy named by a host that resolves privately was itself refused.

The server named by RPGP_KEYSERVER is the one exception, because an internal keyserver is precisely a name that resolves to a private address and that is what the variable is for. It is exempt only on the fetches this app aims at it, and the exemption is decided from a hostname, because a hostname is all a resolver is handed. So a WKD address whose domain happens to be that host does not inherit it, nor does a redirect naming that host from anywhere else; on the keyserver's own fetches a redirect to another port on that host is refused in the redirect policy, which is the one place the port is visible. Nothing else is exempt, including a redirect away from that server.

Publishing cannot be undone — a keyserver has no delete — so the dialog says so, names the key it is about to upload, and uses the same danger styling as revocation. Only your own keys are offered, and the upload refuses any other. Only the public half is ever sent, and no local certification goes with it, nor the withdrawal of one: publish serialises the certificate rather than the transferable secret key, and uses export_to_vec, which omits signatures marked non-exportable, as a withdrawal is whenever all it takes back was local. A test asserts on the upload body itself, parsing it back to check both properties.

Where outputs go

Sign / Encrypt and Decrypt put their output beside the input: notes.txt is encrypted to notes.txt.asc or signed as notes.txt.sig, and notes.txt.asc decrypts to notes.txt. A file already at that name is never overwritten: the output steps aside to the next free name, notes (1).txt for a decrypted notes.txt.

The Flatpak asks instead. Run opens a save dialog with that name filled in, and the output goes wherever you choose there. The sandbox is given only the files you pick in the desktop's file chooser, and the portal standing between it and your files keeps anything else written beside one of them to itself: it reaches your disk only as a hidden .xdp- file, never under the name you would look for.

While an encrypt or decrypt runs, its output is written to a .part file beside it and renamed into place only once it is complete, so one that fails leaves nothing behind, and a file you chose to replace stays as it was. One cut off before it can clear up, by a crash or by closing the window while it runs, can leave its .part file behind, as a hidden .xdp- file in the Flatpak; after a decrypt that file holds the plaintext written so far, and it can be deleted. On Linux and macOS a decrypted file can be read by you alone: it is 0600 from the moment it is created, whatever your umask. On Windows it takes the permissions of the folder it lands in, as any new file does. Encrypted files and signatures are meant to be passed on, so they get the permissions any new file of yours gets.

Where certificates live

Public certificates go in a pgp-cert-d directory, the same layout sq uses, so they are shared with other Sequoia tooling rather than locked in this app:

$XDG_DATA_HOME/pgp.cert.d          (override with RPGP_CERT_STORE)

That sharing is a property of a native build. The Flatpak keeps its store inside ~/.var/app/app.rpgp.rPGP/data and shares it with nothing: XDG_DATA_HOME points into the sandbox there, and Flathub does not grant access to the real one without an exception.

RPGP_CERT_STORE moves the public certificates and nothing else, so it cannot make the two builds share one store. A native build pointed at the Flatpak's ~/.var/app/app.rpgp.rPGP/data/pgp.cert.d, which it can reach as it is, lists the certificates the Flatpak does, though no longer the ones sq uses. Secret keys, the revocation certificates and the lists of trust roots, of imported keys and of certificates you accept SHA-1 from stay with each build, in its own rpgp directory (below). So a key generated in one build cannot sign or decrypt in the other and is not a trust root there, what it certified can read as verified in one and not in the other, and the build without its secret deletes the certificate as it would anyone else's, with no word of a secret key.

Every time the list is read, at Refresh and after each change made here, each certificate in it is checked against its file, so a certificate that sq or a second rPGP window has changed or deleted in cert-d shows up as it now is.

Secret keys do not go there — cert-d is a store of public certificates, and a transferable secret key in it would be readable by every tool that scans the directory. They live in their own directory, one binary TSK per file:

$XDG_DATA_HOME/rpgp/secrets/<fingerprint>.pgp

Those files are 0600 in a 0700 directory, tightened every time the store is opened rather than only when a key is written, so a store created by an earlier build is repaired rather than left exposed. The rpgp directory above it, which holds the revocation certificates and the lists of trust roots, of imported keys and of certificates you accept SHA-1 from, is 0700 too. A key generated with a passphrase is encrypted with it. A key generated without one is not, and then the file permissions are all that protects it.

Two rPGP windows can share one store. Each change to a key or a list is made under a lock file in the rpgp directory, so the two take turns rather than undo each other's changes, and each file is replaced whole, so a crash or a full disk part-way through leaves the previous version rather than a damaged one.

What protects a key in memory

A key is decrypted for the span of a single operation and then dropped. Sequoia keeps it sealed in RAM even while it is unlocked, and zeroes it on drop, so a partial read of the process — the class of attack Spectre and coldboot fall into — yields nothing useful.

That sealing does not survive a complete read of the address space, because the key it is sealed with lives in that same space. What rPGP does about that differs by platform, and the gap is wide enough to spell out:

Linux. The process is marked non-dumpable. That suppresses the core dump and also revokes ptrace, including from another process of the same user, so gdb will not attach and a crash leaves nothing in coredumpctl.

macOS. RLIMIT_CORE is set, though that half has not been tested — the hardening tests are Linux-only. There is no equivalent of the non-dumpable flag, so debugger attach is denied at signing time rather than by the process itself: the released bundle is codesigned with the hardened runtime and no entitlements file, so it carries no get-task-allow and task_for_pid fails for a debugger run by the same user. packaging/macos-sign.sh is what applies it. A macOS binary you built yourself is unsigned and gets none of that — assume a debugger can attach to that one.

Windows. Nothing. The process sets no core-dump limit there and refuses no debugger, and nothing else in rPGP stands in for either, so a process running as the same user can open rPGP and read its memory, and nothing keeps key material out of a crash dump that Windows is set up to collect.

Keeping passphrases off the accessibility bus and off the clipboard is not platform-specific and applies on all three.

Slint publishes what an ordinary text field holds to assistive technology, as it should, and for a password field one bullet per character, with the caret and an event for every key: not the passphrase, but its length, to anything listening on the bus. GTK publishes as much for its own password entries, and Chromium a bullet per character too. rPGP's passphrase fields publish less. A screen reader is told each one's name, that it is a password field, whether it can be typed into and when it has focus, and nothing about what is in it: no characters, no count, no caret, and no event as keys are typed into it. tests/atspi.rs checks that on a real AT-SPI bus on Linux; on Windows and macOS it follows from AccessKit's and Slint's code, but has not been observed. The cost falls on screen-reader users: the field echoes no keys, there is no way to review how much has been typed, a braille display shows no dots, and a magnifier follows the field but not the caret inside it.

That is what the fields themselves publish. Two things around them still tell the bus something:

  • In New key pair, the passphrase and its repeat are compared only when the repeat field loses focus and when Create key pair is pressed. The note that they do not match comes, goes and changes only then. It is announced as it appears, and again, with its words changed, at each comparison that finds the two still differing. A refused Create empties the repeat field and puts focus in it, ready for the passphrase to be typed again. Typing the repeat changes nothing that is published, so the passphrase's length cannot be counted off it, but each comparison tells the bus whether the two matched.
  • While no recipient is chosen, whether a password has been typed for the message is what enables Run in Sign / Encrypt, and Encrypt and Sign & Encrypt in the notepad, so the bus learns whether that field is empty: the buttons come on with its first character and go off when it is emptied.

Nor does any of it hide that keys are being pressed: on X11 any program can watch the keyboard itself.

Slint's text fields also copy and cut a selection unmasked, and on Linux put whatever the mouse selects in the primary selection. rPGP's passphrase fields refuse copy and cut, and a click only focuses them: the mouse does not select in them.

Set RPGP_ALLOW_DEBUG=1 to turn off what the process does itself, the core-dump limit and on Linux the non-dumpable flag, when you need a backtrace. It cannot lift the hardened runtime a signed macOS bundle carries, and on Windows there is nothing for it to turn off.

None of this is a privilege boundary. Key material passes through the GUI process, so root, or anything holding CAP_SYS_PTRACE, can still read it while an operation is in flight. rPGP wipes its own copy of a passphrase once the operation is done with it, but the passphrase you type cannot be scrubbed at all, because Slint's own string type keeps unzeroed copies, including an undo buffer. For the same reason a message decrypted in the notepad is dropped from the window when the notepad closes, not scrubbed from memory. Only a key on a card avoids this entirely, since its secret never leaves the card. For a key in gpg-agent's own store, neither the key nor its passphrase enters rPGP, since the agent decrypts the key in its own process and takes the passphrase at its own prompt.

What goes on the clipboard

A fingerprint, key ID or user ID copied from the details pane goes on the clipboard like any other copy, a user ID as it is shown, with any character it hides written out. What the notepad's Copy puts there can be a decrypted message, so it goes out marked private, with each platform's way of asking clipboard managers and clipboard history to leave it out: x-kde-passwordManagerHint on X11 and through the Wayland data-control protocols, ExcludeClipboardContentFromMonitorProcessing on Windows, and org.nspasteboard.ConcealedType on macOS. On X11 a private copy is also withdrawn when rPGP's window closes, if it is still what the clipboard holds, rather than left for a clipboard manager to keep; whatever has been copied since, in rPGP or anywhere else, is left alone. Telling the two apart takes a connection to the X server over a Unix-domain socket on the same machine, the server's X-Resource extension, which the X.Org server builds in by default, Xvfb and XWayland included, and a server that names rPGP's own process as the one at the other end of that connection. Where any of that is missing, rPGP leaves the clipboard as it is, and the copy goes only when rPGP exits: on a display reached over TCP, which is how ssh -X and -Y forward one; through any other forwarder, which the server sees in rPGP's place; without the extension; and in the Flatpak, whose sandbox numbers processes apart from the server. One case gets past those checks: a forwarder on a Unix socket in another PID namespace than rPGP's, a container's say, whose number in the server's namespace happens to be the one rPGP has in its own. A copy marked private that another program made through that forwarder would then be taken for rPGP's, and withdrawn.

The mark is a request, and it has limits:

  • Any program can read the clipboard while the text is on it, and a clipboard manager that ignores the convention keeps it anyway.
  • In the Flatpak on GNOME, KDE Plasma or sway, where the app is not offered data-control, the Copy buttons go through Slint's own clipboard, over the window's own Wayland connection, which offers plain text and nothing else. The copy goes out unmarked, and the status line says so.
  • Text selected in the notepad's output and copied with Ctrl+C goes through Slint's own clipboard, which marks nothing, and on Linux selecting it with the mouse puts it in the primary selection as well. The Copy button is the way to copy a decrypted message, and the only way to copy all of a long one: the output box shows the first 8 KiB or 500 lines, less on a screen scaled above 100%, and says so when there is more.
  • Nothing clears the clipboard after a while. A clipboard manager records a copy the moment it is made, so a timer would not keep a message out of its history; the mark is what does that.

Coming from GnuPG

rPGP does not read ~/.gnupg, and nothing it does will disturb it. Public certificates need no export at all: point Import at ~/.gnupg/pubring.kbx.

Nor do secret keys, to sign, certify and decrypt. Once a key's public certificate is here, rPGP does all three by asking gpg-agent, whether the agent keeps the key in its own store or on a card, as the section on smartcards above describes: the agent's own prompt takes the passphrase or PIN, and the secret never enters rPGP. The rest still needs the secret in rPGP's own store: publishing the key, revoking it, changing its expiry, adding a user ID, and revoking a user ID or a subkey. Until then the key is listed under Other people, not My keys, and revoking it takes a revocation certificate from gpg --gen-revoke, brought in through Import as the section on revocation above describes. To copy secret keys into rPGP's own store, export them, since GnuPG keeps them in gpg-agent's own format:

gpg --export --armor > /tmp/rpgp-public.asc && gpg --export-secret-keys --armor > /tmp/rpgp-secret.asc

Import both with the Import button. Public certificates land in cert-d and secret keys in the secrets directory; a file containing both is handled in one pass.

Four caveats:

  • This copies secret key material. The keys then exist twice, under two different protections: gpg-agent's, and rPGP's weaker on-disk one. Delete /tmp/rpgp-secret.asc afterwards, and understand that rPGP's copy is only as safe as the passphrase on it.
  • A key on a card comes across as a stub. --export-secret-keys emits only a stub for a key that lives on a YubiKey, since its secret cannot leave the card, as --export-secret-subkeys does for a primary kept offline. rPGP passes a stub over and asks gpg-agent, so the card keys sign, certify and decrypt as above, as they do with just their public certificates here. What the stubs add is the key's place under My keys, and with it the details pane's operations on the key. Publishing signs nothing, so a stub is enough for it. The rest sign with the primary key: they work where its secret came across, as it does when only the subkeys are on the card, and where the primary is a stub too they are refused, with the stub named. Revoking such a key then takes a revocation certificate from gpg --gen-revoke, as it does with only the public certificate here. A secret that did come across is used before the agent is asked, so a primary that signs as well as certifies, as GnuPG's default primary does, signs messages here, with its passphrase, rather than the signing key on the card.
  • Ownertrust does not come across. It has no direct counterpart here, so --export-ownertrust has nowhere to go: authentication starts from trust roots instead, as the section on certifying above describes. A key of your own from GnuPG, imported or left with the agent, is not one until you tick Trust root in its details pane.
  • Elliptic-curve keys are read the long way. GnuPG 2.3 and later, exporting a key with a passphrase, write an elliptic-curve secret with a length that counts its leading zero bits, and Sequoia, the library rPGP is built on, refuses that: every Curve25519 encryption subkey, about half of the Ed25519, NIST P-256 and P-384 keys, and more of the P-521 and Brainpool ones. rPGP decrypts such a secret a second time and takes it once the checksum GnuPG wrote under the encryption holds and the secret proves to belong to the key's public half. One that passes the checksum and fails that test is reported as damaged, not as a wrong passphrase. The file in the secrets directory stays as GnuPG wrote it, so this happens at every unlock, and the second decryption leaves a whole copy of the secret in memory that is freed without being cleared, where the ordinary one leaves at most its last few bytes. A key on a Brainpool curve still cannot be used: this build has no support for those curves.

How each part of ~/.gnupg comes across:

  • pubring.kbx can be imported directly. It is GnuPG's Keybox container rather than an OpenPGP keyring, so CertParser cannot read it, but sequoia-ipc's keybox module can. Point Import at it — the file is recognised by its magic bytes rather than its name — and every public certificate comes across. X.509 records in the same file are skipped.
  • Secret keys under private-keys-v1.d are in gpg-agent's own S-expression format, not OpenPGP, and rPGP does not read them: it asks the agent to use them, through sequoia-gpg-agent, as above.
  • A pre-2.1 ~/.gnupg/pubring.gpg is a plain OpenPGP keyring and imports as-is today.

Licence

MIT — see LICENSE.

Two dependencies add obligations MIT does not, both relevant only when shipping binaries: Slint's royalty-free terms require attribution, which is the badge below, and sequoia-openpgp is LGPL-2.0-or-later linked statically.

Made with Slint

vendor/i-slint-backend-winit is not rPGP's code: it is Slint's winit backend, 1.18.1 with one fix from Slint's development branch applied until Slint 1.19 ships it (the root Cargo.toml says which, and why). It is under Slint's licence, as the rest of Slint is, and keeps its licence texts in its LICENSES directory and its SPDX headers. It goes with Slint 1.19, and this paragraph with it; the root Cargo.toml lists the rest of what goes.

The bundled fonts (Geo, Source Code Pro, Geist) are SIL Open Font License 1.1, which requires its text to ship with them; it sits beside them in crates/rpgp-gui/ui/fonts. Icons are Lucide, ISC, likewise.

About

OpenPGP certificate manager for Linux, macOS and Windows. Pure Rust, built on Sequoia and Slint

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Contributors

Languages