95.1.50. pepsi-keys

manage the end-to-end key store: identities, peer keys and anchors

Section du manuel:

1

95.1.50.1.1. Nom

pepsi-keys - générer, importer, publier et retirer du matériel de clé de bout en bout.

95.1.50.1.2. Synopsis

pepsi-keys [GLOBAL-OPTIONS] identity list [–address ADDRESS] [–json] [–served]

pepsi-keys [GLOBAL-OPTIONS] identity show IDENTITY-ID [–json]

pepsi-keys [GLOBAL-OPTIONS] identity generate ADDRESS –protocol PROTOCOL [–name NAME] [–days N] [–no-publish] [–csr] [–shared | –split]

pepsi-keys [GLOBAL-OPTIONS] identity import ADDRESS –protocol PROTOCOL –purpose PURPOSE –public FILE [–private FILE] [–algorithm NAME] [–primary] [–no-publish]

pepsi-keys [GLOBAL-OPTIONS] identity export IDENTITY-ID [–private] [–pem]

pepsi-keys [GLOBAL-OPTIONS] identity csr IDENTITY-ID

pepsi-keys [GLOBAL-OPTIONS] identity revoke IDENTITY-ID [–reason TEXT] [–upload]

pepsi-keys [GLOBAL-OPTIONS] identity forget-private IDENTITY-ID [-y]

pepsi-keys [GLOBAL-OPTIONS] identity set-primary IDENTITY-ID

pepsi-keys [GLOBAL-OPTIONS] identity publish [IDENTITY-ID] [–wkd] [–vks] [–retry [–dry-run]] [-y]

pepsi-keys [GLOBAL-OPTIONS] identity unpublish IDENTITY-ID

pepsi-keys [GLOBAL-OPTIONS] identity delete IDENTITY-ID [-y]

pepsi-keys [GLOBAL-OPTIONS] identity retire

pepsi-keys [GLOBAL-OPTIONS] identity rotate-due [–dry-run]

pepsi-keys [GLOBAL-OPTIONS] peer list [–address ADDRESS] [–json]

pepsi-keys [GLOBAL-OPTIONS] peer show ADDRESS [–protocol PROTOCOL] [–json]

pepsi-keys [GLOBAL-OPTIONS] peer unclaimed [–address ADDRESS] [–all-sources] [–json]

pepsi-keys [GLOBAL-OPTIONS] peer import ADDRESS –protocol PROTOCOL –file FILE [–pin]

pepsi-keys [GLOBAL-OPTIONS] peer pin | unpin | remove PEER-KEY-ID

pepsi-keys [GLOBAL-OPTIONS] peer refresh [–address ADDRESS | –expire PEER-KEY-ID] [–expiring-within-days DAYS] [–limit N]

pepsi-keys [GLOBAL-OPTIONS] peer prune [–retain-days DAYS] [–dry-run]

pepsi-keys [GLOBAL-OPTIONS] peer screen [–dry-run]

pepsi-keys [GLOBAL-OPTIONS] peer capability list [–address ADDRESS] [–json]

pepsi-keys [GLOBAL-OPTIONS] peer capability set ADDRESS aead | cbc

pepsi-keys [GLOBAL-OPTIONS] peer capability unset ADDRESS

pepsi-keys [GLOBAL-OPTIONS] peer capability forget FINGERPRINT

pepsi-keys [GLOBAL-OPTIONS] blocklist update [–force]

pepsi-keys [GLOBAL-OPTIONS] blocklist status [–json]

pepsi-keys [GLOBAL-OPTIONS] blocklist dismiss | restore –import N | –list NAME

pepsi-keys [GLOBAL-OPTIONS] ct-logs update [–force]

pepsi-keys [GLOBAL-OPTIONS] ct-logs status [–json]

pepsi-keys [GLOBAL-OPTIONS] ca list [–json]

pepsi-keys [GLOBAL-OPTIONS] ca add FILE [–label TEXT] [–accept-nameless] [–domain DOMAIN]…

pepsi-keys [GLOBAL-OPTIONS] ca scope CA-ID –domain DOMAIN… | –any

pepsi-keys [GLOBAL-OPTIONS] ca accept-nameless CA-ID yes | no

pepsi-keys [GLOBAL-OPTIONS] ca enable | disable | remove CA-ID

pepsi-keys [GLOBAL-OPTIONS] identity –otp CODE COMMAND …

pepsi-keys [GLOBAL-OPTIONS] otp status [ADDRESS | –console LOGIN] [–json]

pepsi-keys [GLOBAL-OPTIONS] otp enroll | remove ADDRESS [–otp CODE]

pepsi-keys [GLOBAL-OPTIONS] otp reset ADDRESS

pepsi-keys [GLOBAL-OPTIONS] otp enroll | reset –console LOGIN

pepsi-keys [GLOBAL-OPTIONS] wrap rotate [–dry-run]

pepsi-keys [GLOBAL-OPTIONS] dns ADDRESS

pepsi-keys [GLOBAL-OPTIONS] mpki domain list [–json]

pepsi-keys [GLOBAL-OPTIONS] mpki domain show | check DOMAIN [–json]

pepsi-keys [GLOBAL-OPTIONS] mpki domain set DOMAIN [–enable | –disable] [SETTING-OPTIONS]

pepsi-keys [GLOBAL-OPTIONS] mpki credential set DOMAIN [–file FILE]

pepsi-keys [GLOBAL-OPTIONS] mpki credential remove DOMAIN

pepsi-keys [GLOBAL-OPTIONS] mpki user list [–domain DOMAIN] [–deleted] [–json]

pepsi-keys [GLOBAL-OPTIONS] mpki user add ADDRESS –given-name NAME –surname NAME [–select SELECTION]

pepsi-keys [GLOBAL-OPTIONS] mpki user set ADDRESS [–given-name NAME] [–surname NAME] [–confirm] [–select SELECTION]

pepsi-keys [GLOBAL-OPTIONS] mpki user delete ADDRESS

pepsi-keys [GLOBAL-OPTIONS] mpki user import FILE –ldif | –csv [–domain DOMAIN] [–mail-attribute ATTR] [–given-name-attribute ATTR] [–surname-attribute ATTR] [–prune] [–dry-run] [–yes] [–json]

pepsi-keys [GLOBAL-OPTIONS] mpki order list [–domain DOMAIN] [–address ADDRESS] [–open] [–limit N] [–json]

pepsi-keys [GLOBAL-OPTIONS] mpki order release | retry | cancel ORDER-ID

pepsi-keys [GLOBAL-OPTIONS] mpki notices [–domain DOMAIN] [–unread] [–read ID… | –read-all] [–json]

pepsi-keys [GLOBAL-OPTIONS] mpki run [–domain DOMAIN] [–json]

95.1.50.1.3. Description

pepsi-keys est l’outil de l’opérateur pour le magasin de clés de la cryptographie de bout en bout de Pepsi — les trois tables qui contiennent chaque clé dont le traitement OpenPGP et S/MIME a besoin :

pepsi.crypto_identity

Les paires de clés des adresses que nous servons, moitié privée comprise et enveloppée au repos (custody = local, une clé MTA). Utilisées pour signer le courrier sortant et déchiffrer le courrier entrant. Elle contient aussi les propres clés des utilisateurs, dont la moitié privée ne réside que dans leur client de messagerie (custody = client, une clé MUA ; voir Clés MTA et clés MUA).

pepsi.peer_key

Les clés publiques et certificats des correspondants distants, quelle qu’en soit la provenance, chacun accompagné de la source dont il vient, d’un verdict de validité et d’une échéance de cache. Sert à chiffrer le courrier sortant et à vérifier les signatures entrantes.

pepsi.ca_trust

Les certificats d’autorité qu’une chaîne S/MIME entrante doit atteindre pour que sa signature compte comme digne de confiance.

L’outil n’est pas une étape. Il gère directement des lignes, à la manière de pepsi-whitelist(1) et de pepsi-settings(1), se connectant à la même base de données que les autres composants par la section partagée [pepsi-postgres] et lisant les options CRYPTO_* de [pepsi] ainsi que la section [pepsi-crypto] décrite dans pepsi.conf(5).

C’est un binaire autonome plutôt qu’une partie de l’exécutable pepsi unifié pour deux raisons : c’est le seul programme de l’arbre qui génère du matériel de clé, et un site peut l’installer setuid (voir Privilèges).

Les commandes mpki ajoutent une PKI gérée : des certificats S/MIME qu’une autorité de certification commerciale délivre pour les utilisateurs d’un domaine, commandés, installés, renouvelés et révoqués par Pepsi (voir Commandes de PKI gérée).

95.1.50.1.3.1. Capacité, non forme

Le matériel d’une adresse est stocké à raison d’une ligne par capacité, jamais comme « l’identité ». Le purpose de chaque ligne vaut sign, encrypt ou both :

  • une identité OpenPGP est une unique ligne both — une clé transférable dont la clé primaire, capable de signer, porte une sous-clé de chiffrement : la séparation est donc intrinsèque et ne coûte rien ;

  • une identité S/MIME est normalement faite de deux lignes, un certificat avec digitalSignature et un avec keyEncipherment/keyAgreement ;

  • avec [pepsi] CRYPTO_SMIME_SHARED_KEY = yes, c’est à la place un seul certificat both portant les deux usages de clé (RSA seulement).

Cette option ne décide que de l’allure des identités nouvellement créées. Les deux formes sont prises en charge de façon permanente et peuvent coexister pour une même adresse, par exemple un ancien certificat partagé encore valide à côté d’une paire séparée fraîchement délivrée. Chaque consultation correspond donc à une capacité (sign ou both ; encrypt ou both) plutôt que de compter des lignes. Les listages et identity show impriment le purpose exactement pour cette raison.

95.1.50.1.3.2. Le retrait est asymétrique

Pepsi remet du texte clair dans la boîte aux lettres : une clé privée de déchiffrement n’est donc nécessaire que pour le courrier encore en vol et pour le texte chiffré qu’un opérateur a archivé — jamais pour lire sa propre boîte. Une clé privée de signature, une fois retirée, ne peut plus rien faire de légitime : rien ne resigne jamais du vieux courrier. Donc, à l’expiration ou à la révocation :

  • la moitié privée d’une ligne sign est détruite, et seule la moitié publique est conservée pour que les anciennes signatures restent vérifiables ;

  • la moitié privée d’une ligne encrypt est conservée ;

  • une ligne both suit la règle du déchiffrement, car la détruire ôterait la capacité de déchiffrer avec elle. C’est le prix du mode à certificat partagé : y révoquer une clé de signature compromise met aussi fin à la capacité de recevoir du nouveau courrier chiffré.

private_purged_at note quand du matériel a été abandonné, de sorte que « délibérément détruit » reste distinguable de « jamais détenu » ; identity list comme identity show le rapportent.

95.1.50.1.3.3. Clés MTA et clés MUA

Une adresse peut détenir des clés de deux sortes. Une clé MTA (custody = local) est une clé dont Pepsi détient la moitié privée : pepsi-stage-encrypt(1) signe avec elle, pepsi-stage-decrypt(1) ouvre le courrier avec elle, et elle est annoncée dans les en-têtes Autocrypt:. Elle est créée par identity generate, par une importation avec –private, ou automatiquement à la première soumission d’un utilisateur sous [stage-encrypt] ENABLE_PEP. Une clé MUA (custody = client) est la propre clé de l’utilisateur issue de son client de messagerie : publique seulement pour toujours, jamais principale. Pepsi chiffre vers elle et laisse passer sans l’ouvrir le courrier chiffré vers elle, mais ne peut jamais signer ni déchiffrer avec elle. Elle est créée par une importation sans –private, par la console web ou l’API, par la commande de courriel register, ou automatiquement à partir de l’en-tête Autocrypt: du courrier que l’utilisateur soumet lui-même.

La face publique d’une adresse est la plus récente clé MUA active lorsqu’il y en a une, sinon la clé MTA active principale. C’est la première clé que sert le Web Key Directory, et la clé vers laquelle est chiffré le courrier local destiné à l’utilisateur. À côté d’une clé MUA, l’annuaire sert aussi les autres clés MUA actives de l’utilisateur (les plus récentes d’abord, au plus huit ; le courrier local est aussi chiffré vers ces clés), jamais la clé MTA. La clé MTA n’est pas retirée lorsqu’une clé MUA apparaît ; elle continue de déchiffrer le courrier des correspondants qui l’utilisent encore. identity show affiche la garde et si l’identité est la face publique.

95.1.50.1.3.4. Les téléversements vers le serveur de clés sont demandés par identité

Chaque identité enregistre si son téléversement vers le serveur de clés a été demandé (crypto_identity.vks_wanted). Les clés générées automatiquement et les clés MUA enregistrées automatiquement démarrent avec cet indicateur éteint : Autocrypt et le propre Web Key Directory du déploiement sont la façon dont on les trouve, et un téléversement ne peut pas être retiré. Les clés faites à la main (identity generate, identity import, et le generate web et par courriel) prennent [pepsi-keys] VKS_PUBLISH comme valeur par défaut, et –no-publish le garde éteint. Une demande explicite l’allume quoi que dise VKS_PUBLISH : identity publish –vks, Téléverser vers le serveur de clés de la console web, ou la commande de courriel publish. identity publish –retry téléverse exactement les lignes où il est allumé, de sorte que « non téléversé » est un état enregistré, et identity show le rapporte.

95.1.50.1.3.5. Propriété

Une identité est indexée sur l”adresse mise en minuscules. Lorsque les règles de localité de pepsi-common ([pepsi-crypto] LOCAL_DOMAINS, RECIPIENT_DELIMITER et TARGETS, se rabattant sur [pepsi-ingress] ACCEPTED_DOMAINS et la plage d’uid d”/etc/login.defs) résolvent cette adresse vers un compte local, le login passwd est consigné dans crypto_identity.login ; sinon la colonne vaut NULL — une adresse de rôle, un domaine hébergé, un déploiement placé devant un Exchange.

Cette colonne est la règle d’accès. Un appelant non privilégié ne peut voir et modifier que les identités dont le login est le sien, résolu depuis l’entrée passwd de l’uid réel — non $USER, non un argument, non l’uid effectif. Une identité sans compte propriétaire n’appartient à personne en particulier et est donc réservée à l’opérateur : traiter « sans propriétaire » comme « à tout le monde » rendrait chaque adresse de rôle inscriptible par chaque utilisateur local.

root, ainsi que les comptes pepsi-crypto, pepsi et pepsi-owner, peuvent gérer toutes les identités. Les clés de pairs et les ancres de confiance n’ont pas d’espace de noms par utilisateur : ce sont la clé de quelqu’un d’autre, ou une politique valant pour tout le déploiement. Chaque sous-commande peer et ca, list compris, est donc réservée à l’opérateur, tout comme wrap rotate et identity retire.

95.1.50.1.3.6. Privilèges

Atteindre une clé privée demande deux choses, et elles sont gardées séparément :

  • le rôle de base de données pepsi-crypto, le seul auquel la colonne crypto_identity.private_wrapped soit accordée (hormis le propriétaire du schéma pepsi-owner, qui la lit en vertu de la propriété mais ne peut pas lire la clé de chiffrement de clés). Tout rôle de service ordinaire détient un droit au niveau colonne qui l’omet ; cela vaut aussi pour le compte pepsi, sous lequel s’exécute chaque worker d’étape ordinaire. Une compromission ailleurs dans le pipeline livre donc la moitié publique de chaque identité et rien de plus (voir pepsi-setup(1)) ;

  • la clé de chiffrement de clés, qui ne vit que dans le système de fichiers, dans secrets.d/pepsi-crypto.secret.

La base de données seule ne livre donc que du texte chiffré, et la clé de chiffrement de clés seule ne livre rien du tout.

pepsi-keys n’endosse l’identité pepsi-crypto que pour la durée de chaque appel à la base de données. Exécuté en tant que root, il devient ce compte le temps de l’appel (root n’a pas de rôle de base de données à lui) puis revient ; exécuté en tant que pepsi-crypto ou pepsi-owner, il se connecte simplement sous sa propre identité ; lancé depuis une installation setuid, il élève ses identifiants effectifs vers le propriétaire du binaire. L’authentification par pair de PostgreSQL se fonde sur l”uid effectif, non sur le gid : un bit setgid accorderait donc le groupe qui garde le fragment de secret mais pas l’identité de base de données — un programme qui doit être ce rôle doit être ce compte.

Tel qu’il est livré, le binaire ne porte aucun bit setuid (mode 0755) : un binaire capable d’ouvrir chaque clé privée d’un déploiement est une prise bien plus grosse que l’unique table de pepsi-whitelist(1), la valeur par défaut est donc que seul l’opérateur l’exécute. Un site qui veut que les utilisateurs ordinaires gèrent leurs propres identités le rend setuid pepsi-crypto.

L’autorité en vigueur diffère entre les deux installations. La règle de propriété par identité ci-dessus ne s’applique que lorsque le binaire porte réellement le bit setuid : un appelant est traité comme privilégié lorsqu’il est root, lorsque son login est l’un des comptes privilégiés, ou lorsque le binaire n’est pas setuid du tout. Sur l’installation 0755 livrée, chaque appelant est donc privilégié du point de vue de ce programme, et seul PostgreSQL se dresse entre un utilisateur et les identités d’un autre — l’appelant s’authentifie sous sa propre identité et les droits de la base de données décident. C’est la conception voulue, mais cela signifie qu’accorder à quelqu’un le rôle de base de données pepsi-crypto lui remet chaque identité du déploiement, quoi qu’aurait dit par ailleurs la règle de propriété de ce programme. Lorsqu’il est setuid, les trois mêmes précautions que prend pepsi-whitelist(1) s’appliquent : les identifiants effectifs sont abaissés vers l’utilisateur appelant avant toute autre chose, les variables d’environnement qui orientent la découverte de la configuration (HOME, XDG_CONFIG_HOME), l’expansion de ${DATADIR} (PATH) et libpq (PG*) sont supprimées, et -c/–config est refusé aux appelants non privilégiés — la configuration nomme la base de données et la clé de chiffrement de clés.

95.1.50.1.4. Commandes

95.1.50.1.4.1. Commandes d’identité

identity list [–address ADDRESS] [–json] [–served]

Liste les identités sous forme de tableau : identifiant, adresse, protocole, finalité, statut, si la ligne est la principale pour sa capacité, si elle est publiée, l’état de sa moitié privée (yes/no/purged, ou client pour la propre clé MUA de l’utilisateur, dont Pepsi n’a jamais détenu la moitié privée) et son expiration. Un appelant non privilégié ne voit que les siennes. –address restreint le listage à une adresse ; –json émet les lignes en JSON à la place.

–served demande aussi, pour chaque adresse listée ayant une identité publiée et active, ce que reçoit un correspondant : les deux méthodes Web Key Directory et les enregistrements OPENPGPKEY et SMIMEA, récupérés avec les clients durcis et les paramètres [pepsi-keydiscovery] de la découverte de clés. Une colonne SERVED nomme les canaux qui servent l’empreinte de chaque identité (wkd-advanced, wkd-direct, openpgpkey, smimea ; none pour une identité publiée et active que rien ne sert ; - pour une identité qui n’est pas destinée à être servie), et sous le tableau chaque canal en désaccord avec le magasin de clés est listé : MISMATCH lorsqu’il sert une empreinte que le magasin ne publie pas pour cette adresse – un autre serveur web à l’apex du domaine, un enregistrement DNS resté d’un renouvellement, une clé que quelqu’un d’autre y a placée –, INCOMPLETE, ABSENT ou FAILED sinon. Avec –json, la sortie devient un objet avec identities (les lignes) et served (un rapport par adresse). Le réseau est interrogé après la fermeture de la connexion à la base de données, en tant qu’utilisateur appelant. Les réponses sont celles qu’obtient cet hôte ; un serveur qui répond différemment à d’autres demandeurs n’est pas détecté.

identity show IDENTITY-ID [–json]

Affiche une identité en entier, y compris son empreinte, son algorithme, sa garde (local pour une clé MTA, client pour la propre clé MUA de l’utilisateur), si elle est la face publique de l’adresse (la clé donnée aux correspondants), wrap_key_id, les horodatages, toute raison de révocation, le hachage de partie locale Web Key Directory sous lequel l’adresse est servie, et son état sur le serveur de clés : l’un de verified at TIME, uploaded at TIME , awaiting confirmation, upload requested ou not uploaded (not requested).

identity generate ADDRESS –protocol openpgp|smime [OPTIONS]

Crée du matériel de clé pour ADDRESS et le stocke, moitié privée enveloppée. Le nouveau matériel devient le principal pour sa capacité ; rien d’existant n’est réécrit ni remplacé, de sorte que le matériel précédent reste utilisable pour déchiffrer ce qui lui a déjà été envoyé.

OpenPGP produit un unique enregistrement both en employant [pepsi] CRYPTO_OPENPGP_ALGORITHM (ed25519, la valeur par défaut, ou rsa à CRYPTO_GENERATE_RSA_BITS, qui doit valoir 2048, 3072, 4096 ou 8192). S/MIME produit la paire signature/chiffrement en employant CRYPTO_SMIME_ALGORITHM (p256, la valeur par défaut, p384 ou rsa), chacune avec un certificat auto-signé pour un usage immédiat.

–name NAME

Nom affiché pour l’identifiant utilisateur OpenPGP (Name <address>) ou le sujet du certificat. Sans lui, l’identifiant utilisateur est l’adresse nue.

–days N

Durée de vie du matériel généré. Vaut par défaut [pepsi-crypto] IDENTITY_VALIDITY_DAYS (730, soit deux ans).

–no-publish

Ne pas servir la moitié publique par le Web Key Directory ni la téléverser. Par défaut une nouvelle identité est publiée — on ne peut pas chiffrer vers une clé que personne ne peut récupérer — et son téléversement vers le serveur de clés est demandé lorsque [pepsi-keys] VKS_PUBLISH est activé.

La génération sur demande est toujours permise, même pour une adresse qui a déjà la propre clé MUA de l’utilisateur ou une clé révoquée ; seule la création automatique refuse une adresse ayant une identité quelconque.

–csr

Imprime en outre une demande de signature de certificat PKCS#10 portant sur chaque clé générée, de sorte qu’une véritable autorité puisse délivrer un certificat de remplacement pour la même clé sans en changer. S/MIME seulement ; OpenPGP n’a pas d’objet équivalent.

–shared

Force un seul certificat S/MIME portant les deux usages de clé, quoi que dise CRYPTO_SMIME_SHARED_KEY. Refusé avec un CRYPTO_SMIME_ALGORITHM à courbes elliptiques, y compris la valeur par défaut p256, de sorte qu’il nécessite CRYPTO_SMIME_ALGORITHM = rsa : une seule clé EC faisant à la fois ECDSA et ECDH est une réutilisation de clé entre algorithmes que plusieurs clients S/MIME rejettent.

–split

Force les certificats de signature et de chiffrement séparés. Mutuellement exclusif avec –shared ; sans l’un ni l’autre, la valeur par défaut configurée s’applique.

identity import ADDRESS –protocol P –purpose PURPOSE –public FILE [OPTIONS]

Stocke du matériel généré ailleurs. PURPOSE vaut sign, encrypt ou both et doit décrire ce que le matériel sait réellement faire , car chaque consultation ultérieure porte là-dessus. La moitié publique est une clé transférable OpenPGP ou un certificat X.509 (DER ou PEM, détecté) ; - lit l’entrée standard. L’empreinte est dérivée du matériel lui-même : l’empreinte OpenPGP, ou le SHA-256 du DER du certificat.

–private FILE

La moitié privée — une clé secrète transférable OpenPGP, ou une clé PKCS#8 — qui est enveloppée avant d’être stockée, comme clé MTA (custody = local). Sans elle, seule la moitié publique est conservée. Pour OpenPGP, la ligne est alors enregistrée comme la propre clé MUA de l’utilisateur (custody = client), qui n’est jamais principale (–primary est ignoré pour elle) : Pepsi peut la publier et chiffrer vers elle, mais jamais signer ni déchiffrer avec elle. Elle préempte la création automatique de clé pour l’adresse et devient la face publique de l’adresse ; le courrier chiffré vers elle est transmis au client de messagerie sans être ouvert. Une importation S/MIME publique seulement conserve custody = local – typiquement un certificat émis par une AC sur une clé déjà présente dans le magasin (voir identity csr).

–algorithm NAME

Nom d’algorithme à noter. À titre indicatif ; vaut imported par défaut.

–primary

Fait de ceci le matériel employé pour les nouveaux messages de sa capacité.

–no-publish

Ne pas publier la moitié publique. Sinon, le téléversement vers le serveur de clés est demandé lorsque [pepsi-keys] VKS_PUBLISH est activé.

identity export IDENTITY-ID [–private] [–pem]

Écrit le matériel sur la sortie standard dans sa forme binaire propre — paquets OpenPGP ou DER X.509 — de sorte qu’il puisse être acheminé directement vers un autre outil. Une clé OpenPGP publique est écrite sans certifications de tiers, telle qu’elle est publiée.

–private

Exporte la moitié privée plutôt que la publique, en la désenveloppant d’abord. Échoue lorsque la ligne n’en détient aucune, en nommant lequel de « jamais détenue » et « purgée » s’applique.

–pem

Enveloppe le matériel X.509 dans un bloc PEM. Le matériel OpenPGP n’a pas de forme PEM et est refusé avec un renvoi vers gpg --enarmor.

identity csr IDENTITY-ID

Imprime une demande de signature de certificat PKCS#10 portant sur la clé privée existante d’une identité, avec l’usage de clé qu’implique son purpose. C’est le chemin qui compte une fois qu’une identité est en service : le certificat auto-signé permet de démarrer, et la même clé — déjà publiée, déjà employée pour recevoir du courrier chiffré — est ensuite présentée à une véritable autorité sans en changer. Identités S/MIME seulement, et seulement tant que la moitié privée est encore détenue. La même demande est disponible sans terminal : POST /api/v1/identities/{id}/csr et la page d’identité de la console la demandent à pepsi-setup apply sous forme de tâche identity-csr, et le certificat émis est installé avec POST /api/v1/identities/{id}/certificate (identity-certificate), qui vérifie qu’il porte sur la propre clé de l’identité (voir pepsi-httpd(1) et pepsi-setup(1)).

identity revoke IDENTITY-ID [–reason TEXT] [–upload]

Retire une identité. La ligne devient revoked et cesse d’être principale ; la moitié publique est conservée pour que les signatures faites avant la révocation restent vérifiables. La moitié privée d’une ligne sign est détruite ici et maintenant ; une ligne encrypt ou both conserve la sienne, et la commande le dit. TEXT est noté avec la ligne.

Pour une identité OpenPGP dont la moitié privée est encore détenue, la commande construit d’abord un certificat de révocation — signé par la clé qu’il retire, avec TEXT comme motif — et le stocke comme moitié publique de l’identité, dans la même instruction qui révoque la ligne (et détruit la moitié privée d’une ligne sign). Le Web Key Directory sert alors la clé comme révoquée, après toute clé utilisable de l’adresse, de sorte que le client d’un correspondant qui la rafraîchit apprend qu’elle est morte ; et lorsque la clé avait été téléversée vers un serveur de clés, la révocation y est téléversée aussitôt, ou par identity publish –retry si cela échoue. Si le certificat ne peut pas être produit (pas de clé de chiffrement de clés, par exemple), rien n’est révoqué et la commande échoue. La commande retire par e-mail de pepsi-stage-encrypt(1) et la tâche revoke-identity de la console révoquent de la même manière.

Aucun certificat ne peut être produit pour une identité S/MIME (c’est son émetteur qui la révoque), pour la propre clé MUA d’un utilisateur (la moitié privée se trouve dans son client de messagerie) ou pour une clé dont la moitié privée a déjà été détruite ; une telle identité cesse simplement d’être servie, et la commande indique que les correspondants qui la détiennent ne sont pas informés.

–upload envoie la révocation au serveur de clés configuré même lorsque la clé n’y a jamais été téléversée ; une clé qui a été téléversée la reçoit sans cette option. On peut dire à un serveur de clés qu’une clé est révoquée, jamais lui dire de l’oublier.

identity forget-private IDENTITY-ID [-y, –yes]

Détruit définitivement la clé privée d’une identité, en laissant la moitié publique. C’est le seul moyen par lequel une clé de déchiffrement quitte le magasin, et il est irréversible : tout ce qui est encore en file d’attente dans pepsi.workqueue, tout ce qui se trouve dans une archive chiffrée et tout message remis à nouveau plus tard depuis une sauvegarde devient illisible. Le courrier déjà remis n’est pas affecté. La commande imprime exactement cela et demande confirmation ; –yes saute la question, et sans terminal ni –yes la réponse est non, de sorte qu’une exécution sans surveillance ne puisse détruire du matériel de clé parce que personne n’était là pour s’y opposer.

identity set-primary IDENTITY-ID

Fait de ceci le matériel employé pour les nouveaux messages de son triplet (adresse, protocole, finalité). Seule une identité active peut être rendue principale. La précédente principale du même triplet est rétrogradée.

identity publish IDENTITY-ID [–wkd] [–vks] [-y, –yes]

Sert la moitié publique de l’identité par le Web Key Directory. C’est le canal réversible — notre propre serveur, notre propre domaine — et c’est celui que nomme –wkd ; c’est aussi le canal par défaut, l’indicateur n’existe donc que pour rendre le canal explicite. Le matériel reste utilisable dans les deux cas.

–vks enregistre en outre la demande de téléversement (vks_wanted), téléverse la clé vers le serveur de clés configuré et lui demande d’envoyer le lien de confirmation à l’adresse. Comme la demande est enregistrée avant la tentative, un téléversement échoué est réessayé par identity publish –retry plutôt qu’oublié. C’est irréversible : on pourra plus tard dire au serveur de clés que la clé est révoquée, mais jamais lui dire de l’oublier, et l’adresse devient un enregistrement public permanent. La commande imprime exactement ce qui ne peut être repris et demande confirmation ; –yes saute la question, et sans terminal ni –yes la réponse est non. OpenPGP seulement — il n’existe pas de serveur de clés pour S/MIME, dont le canal de publication est l’enregistrement SMIMEA qu’imprime dns.

identity publish –retry [–dry-run]

Traite chaque identité OpenPGP publiée et active dont le téléversement a été demandé (vks_wanted) et qui n’est pas encore vérifiée sur le serveur de clés, plutôt qu’une seule. C’est la forme à exécuter périodiquement : pepsi-keys-publish-retry.timer l’exécute toutes les heures. Elle n’est pas conditionnée par [pepsi-keys] VKS_PUBLISH : cette option décide seulement si les clés faites à la main démarrent avec une demande, et la propre demande d’un utilisateur est honorée quoi qu’elle dise. Une clé créée automatiquement n’est jamais sur la liste à moins que son propriétaire ne l’ait demandé.

Elle existe parce que la publication est un protocole en deux temps : un téléversement rend un jeton, seul le jeton autorise le courrier de confirmation, et seul un lien suivi amène le serveur à servir la clé par adresse. Une clé téléversée mais jamais confirmée est stockée et pourtant introuvable. Chaque tour demande d’abord au serveur de clés si l’adresse est déjà servie, et sinon téléverse et demande la vérification. Un lien de confirmation suivi par pepsi-stage-vks-confirm(1), par un humain ou lors d’une exécution antérieure dont l’écriture en base de données n’a pas abouti met donc fin à la boucle tout autant. Les identités sont espacées de VKS_RETRY_INTERVAL, au plus VKS_BATCH par exécution, et abandonnées après VKS_MAX_ATTEMPTS, le motif restant sur la ligne pour identity show. –dry-run liste ce qui serait publié et ne change rien. Réservé à l’opérateur.

Sa seconde liste de travail est celle des révocations : chaque identité OpenPGP révoquée dont la clé avait été téléversée et dont le serveur de clés n’a pas encore accepté le certificat de révocation (vks_revoked_at), espacées et plafonnées selon les mêmes compteurs. Quelle que soit la façon dont la clé a été révoquée — cette commande, la commande retire par e-mail ou la console —, c’est par cette tâche que sa révocation atteint le serveur de clés.

identity unpublish IDENTITY-ID

Cesse de servir l’identité par le Web Key Directory, et oublie sa comptabilité de serveur de clés afin que la tâche de reprise la laisse tranquille et qu’une republication ultérieure reparte de zéro.

Cela ne retire rien d’un serveur de clés, car rien ne le peut. Lorsque l’identité avait été téléversée, la commande le dit et renvoie vers identity revoke –upload, qui est le seul moyen de dire au monde que la clé est morte (la comptabilité qu’elle oublie est ce qui y enverrait sinon la révocation sans l’option).

identity delete IDENTITY-ID [-y, –yes]

Supprime la ligne purement et simplement, moitié publique comprise. Confirmé comme forget-private. Préférez revoke, qui garde la moitié publique afin que les anciennes signatures restent vérifiables ; une identité supprimée ne laisse absolument rien derrière elle.

identity retire

Exécute le balayage de retrait sur chaque identité : tout ce qui a dépassé son expires_at devient expired, le matériel privé de signature est détruit et horodaté, et le matériel de déchiffrement (y compris celui d’une ligne both partagée) est laissé intact. pepsi-keys-retire.timer l’exécute quotidiennement ; identity revoke applique la même règle en ligne pour une identité. Réservé à l’opérateur.

identity rotate-due [–dry-run]

L’exécution planifiée du profil de confidentialité persistante, désactivée sauf si [pepsi-crypto] ENCRYPTION_ROTATION_DAYS est défini (voir pepsi.conf(5) et le chapitre du manuel sur la gestion des clés). D’abord, chaque clé détenue par le serveur (custody = local) capable de déchiffrer et plus ancienne que ce nombre de jours est remplacée : une nouvelle clé est générée comme le ferait identity generate et devient la principale, publiée via WKD lorsque l’ancienne l’était et mise en file pour le serveur de clés lorsque l’ancienne l’était ; l’ancienne clé est révoquée (motif superseded) par le même chemin qu”identity revoke, de sorte qu’une clé OpenPGP reçoit son certificat de révocation et que le Web Key Directory la sert comme révoquée ; contrairement à une clé révoquée à la main, elle continue d’ouvrir le courrier chiffré pour elle jusqu’à ce que sa moitié privée soit détruite. Une clé OpenPGP est remplacée entièrement (une seule clé signe et déchiffre) ; d’une paire S/MIME scindée, seul le certificat de chiffrement est remplacé, et de nouveaux enregistrements SMIMEA sont dus (dns). Audité comme key.identity.rotate. Ensuite, la moitié privée de chaque clé de déchiffrement détenue par le serveur et retirée (révoquée ou expirée) depuis plus de RETIRED_PRIVATE_GRACE_DAYS (30 par défaut) est détruite – sauf si un message encore dans la file, à n’importe quelle étape ou dans n’importe quel statut (en attente, garé, en échec), est chiffré pour elle, jugé d’après les identifiants de destinataire du texte chiffré le plus extérieur du message stocké ; une telle clé est conservée, les identifiants de file étant nommés, et réessayée à l’exécution suivante. La destruction est la même opération qu”identity forget-private et est auditée comme key.identity.forget-private. La propre clé d’un utilisateur (garde client) n’est jamais renouvelée ni purgée, et une clé de signature seule n’est jamais purgée par cette commande. Idempotent ; --dry-run indique ce qui est dû et ne change rien. pepsi-keys-rotate.timer l’exécute quotidiennement. Réservé à l’opérateur.

95.1.50.1.4.2. Commandes de pairs

peer list [–address ADDRESS] [–json]

Liste les clés de pairs en cache : identifiant, adresse, protocole, source, validité, si la recherche qui l’a produite a été validée par DNSSEC, si elle est épinglée, et l’empreinte. Une ligne que pepsi-keydisc(1) a retirée parce que la liste de révocation de son émetteur la nommait se lit revoked et se termine par -- revoked DATE: REASON (quel point de distribution l’a listée, le code de raison de l’entrée et sa date ; revoked_at et revoked_reason dans le JSON). Une telle ligne n’est une clé pour personne – pepsi-stage-encrypt(1) traite l’adresse comme une adresse sans clé – et reste listée jusqu’à ce qu’une découverte la remplace (un certificat réémis depuis la même source le peut) ou que peer remove l’abandonne.

peer show ADDRESS [–protocol PROTOCOL] [–json]

Montre les clés en cache pour ADDRESS, après application de la règle de correspondance : une correspondance exacte d’adresse l’emporte toujours, et une ligne *@domain n’est consultée qu’en l’absence de correspondance exacte (elle est signalée dans la sortie comme repli valant pour tout le domaine). PROTOCOL vaut openpgp par défaut. Une ligne révoquée est affichée avec la même note -- revoked que dans peer list ; elle est listée, non utilisée.

peer unclaimed [–address ADDRESS] [–all-sources] [–json]

Liste les adresses que ce déploiement sert et qui ne détiennent aucune identité chez nous, mais ont une clé de pair moissonnée ou reçue par gossip — les clés qu’un inconnu peut implanter en nous envoyant un message avec un From: falsifié. Les clés sont moissonnées sur l’en-tête From:, que l’expéditeur écrit, et l’authentification entrante est fail-open : sur un déploiement qui n’impose pas DMARC sur son propre domaine, une telle ligne peut donc désigner l’un de nos propres utilisateurs. Là où nous détenons une identité, la ligne est inerte (notre propre clé la préempte) ; là où nous n’en détenons pas, elle décide avec quoi le courrier destiné à cet utilisateur est chiffré. C’est délibéré, car c’est aussi le seul moyen pour qu’un utilisateur qui utilise GnuPG dans son propre client voie sa vraie clé utilisée ici. Il s’agit donc d’une liste de travail, non d’une alarme : confirmez chaque clé avec son propriétaire, puis importez-la comme identité (identity import sans –private), après quoi elle est inerte, ou retirez-la (peer remove).

Servie signifie que le domaine figure dans [pepsi-ingress] ACCEPTED_DOMAINS ou [pepsi-crypto] LOCAL_DOMAINS ; aucun compte passwd n’est requis. Aucune identité signifie aucune identité active capable de chiffrer, la même règle qu’applique la préemption de l’étape de chiffrement, de sorte qu’une adresse dont la seule identité a expiré, a été révoquée ou ne peut que signer est listée ; la colonne IDS compte ses identités dans tout état. Moissonnée désigne la source inbound ou inbound-signed (l’en-tête Autocrypt: propre de l’expéditeur ou sa clé jointe, cette dernière issue d’un message que couvrait la signature DKIM de son domaine) ou gossip (l”Autocrypt-Gossip: d’un tiers) ; –all-sources inclut aussi les clés découvertes, manuelles et d’API, soit l’ensemble que rapporte GET /api/v1/peers/unclaimed. Une ligne *@domain n’est jamais listée. Lecture seule et réservé à l’opérateur. Le code de sortie est 0 que quelque chose ait été trouvé ou non ; avec –json, un rapport vide est [], ce que doit tester une vérification périodique.

peer import ADDRESS –protocol P –file FILE [–pin]

Stocke la clé d’un correspondant à la main (- lit l’entrée standard). La ligne est notée avec la source manual, qui surclasse tout mécanisme de découverte, et c’est la seule source autorisée à porter une adresse *@domain — une contrainte de base de données, non une convention, de sorte qu’aucune réponse de découverte pour une adresse ne puisse jamais être généralisée à un domaine entier. Une clé *@domain authentifie le domaine (en pratique sa passerelle), non un expéditeur individuel : une signature qui se vérifie contre elle montre que le détenteur de la clé du domaine a signé, non quel utilisateur du domaine a écrit le message, et chiffrer vers elle atteint la passerelle plutôt que la personne. Lorsque le certificat ne nomme aucune adresse, la commande le signale en le stockant : une signature faite avec une telle clé est rapportée valid pour chaque adresse From: du domaine. N’en saisissez une que pour une passerelle partenaire à qui vous faites confiance pour signer au nom de chacun de ses utilisateurs.

Une clé qui entre en conflit avec une clé déjà stockée ne la remplace que si elle surclasse tout ce qui s’y trouve ; une ligne épinglée n’est jamais délogée, et la commande dit lequel de stocké, rafraîchi, remplacé et conservé s’est produit. (L’unique exception au « seulement si elle surclasse » est la règle du plus récent l’emporte du palier Autocrypt, qui n’implique jamais de clé manual, dans un sens comme dans l’autre — voir pepsi-keydisc(1).)

Importer une clé déjà stockée (même empreinte) fusionne le fichier dans le certificat stocké au lieu de le remplacer, de sorte qu’un export plus ancien ne peut pas annuler une révocation que porte la copie stockée.

Une clé dont la moitié privée est connue est refusée : une clé figurant sur la liste des clés connues comme compromises (Commandes de la liste des clés compromises : badkeys, les clés faibles OpenSSL de Debian, et les modules qu’un peer screen antérieur a factorisés), ou une clé RSA dont le module trahit ses facteurs premiers (ROCA, nombres premiers proches, un petit facteur).

–pin

Épingle la clé importée, de sorte que la découverte ne la remplace jamais.

peer pin PEER-KEY-ID, peer unpin PEER-KEY-ID

Pose ou retire l’épinglage sur une clé stockée.

peer refresh [–address ADDRESS] [–expire PEER-KEY-ID] [–expiring-within-days DAYS] [–limit N]

Revalide les clés de pairs en cache. Elle ne rafraîchit jamais que des clés qui existent déjà : elle ne découvre jamais de clé pour une adresse qui n’en a aucune. Pepsi consulte une adresse lorsqu’il a du courrier pour elle, ce qui explique que la découverte soit pilotée par le pipeline (pepsi-keydisc(1)) plutôt que par cette commande.

Trois formes, choisies par les indicateurs :

–address ADDRESS

Exécute tout l’éventail de découverte pour une adresse dans ce processus — chaque méthode de [pepsi-keydiscovery] SOURCES en même temps, avec la règle d’arrêt à délai de grâce sur le rang — et stocke ce qu’elle trouve avec la bonne source et le bon indicateur DNSSEC. Une ligne par méthode est imprimée : le protocole et l’empreinte (marquée (dnssec) pour une réponse DANE validée par le bit AD), no key, ou l’erreur. Cela règle aussi la demande de découverte de l’adresse, ce qui libère tout message garé sur elle. Une adresse exclue par ALLOW_DOMAINS/DENY_DOMAINS est refusée plutôt qu’interrogée.

–expire PEER-KEY-ID

Efface l’échéance de cache d’une ligne, de sorte que le prochain message pour cette adresse la récupère à nouveau. Aucune entrée-sortie réseau, et mutuellement exclusif avec –address.

(aucun des deux indicateurs)

Balayage : chaque clé arrivée à échéance — son refresh_after est dépassé, ou sa propre expiration tombe dans –expiring-within-days (7 par défaut) — est revérifiée, jusqu’à –limit clés (100 par défaut), seulement par la méthode par laquelle elle a été apprise : une clé vks auprès du serveur de clés, une clé wkd ou wkd-direct auprès de la même méthode Web Key Directory, une clé dane dans le DNS, une clé ldap dans l’annuaire — et seulement tant que cette méthode figure encore dans SOURCES. Les clés qui ne proviennent d’aucune méthode réseau (inbound, inbound-signed et gossip, moissonnées dans le courrier ; manual/api, saisies à la main) ne sont jamais rafraîchies par le réseau, pas plus que les clés épinglées ou les lignes *@domain ; de telles clés ne sont même pas sélectionnées, de sorte qu’elles n’épuisent jamais –limit. Le nombre de clés revalidées est imprimé. C’est le corps naturel d’une minuterie périodique, et pepsi-keys-refresh.timer l’exécute quotidiennement (avec --limit 200). Le serveur de clés n’est donc informé que des correspondants dont il a lui-même fourni les clés, une fois par CACHE_TTL ; ALLOW_DOMAINS/DENY_DOMAINS s’appliquent, [stage-encrypt] DISCOVERY non.

peer prune [–retain-days DAYS] [–dry-run]

Supprime les clés de pairs expirées et les demandes de découverte périmées — deux tables, un seul travail. Une clé de pair expirée depuis plus de DAYS (7 par défaut) est retirée sauf si elle est épinglée. L’expiration est celle que la clé indique elle-même — l’auto-signature courante d’une clé primaire OpenPGP, le notAfter d’un X.509 — enregistrée chaque fois qu’une clé est apprise, que ce soit par découverte, par moisson ou par gossip (une clé importée à la main n’en enregistre aucune, et une clé qui n’en indique aucune n’est jamais élaguée) ; du côté de pepsi.key_request, une ligne réglée dont l’entrée négative a vieilli au-delà de la même fenêtre, comme une ligne en attente abandonnée depuis aussi longtemps au-delà de son échéance, n’ont plus rien à dire et partent aussi. –dry-run rapporte combien de clés portent une expiration et ne sont pas épinglées, et ne retire rien.

peer screen [–dry-run]

Trouve les clés stockées dont la moitié privée est connue, et les retire du cache. Deux tests portent sur chaque clé de pair et sur la moitié publique de chaque identité non révoquée :

  • un PGCD par lots sur tous leurs modules RSA (arbres de produits et de restes de Bernstein) : deux clés produites par un générateur à court d’entropie peuvent partager un facteur premier, et un seul gcd factorise alors les deux. Aucun test d’une clé isolée ne peut le voir ; c’est une propriété de la paire. Un module factorisé est consigné dans la liste des clés connues comme compromises (pepsi.compromised_key, liste screen), de sorte que la même clé est refusée à l’usage et n’est plus stockée, ni par la découverte de clés ni lorsqu’un message la porte (pepsi-stage-autocrypt-learn(1)) ;

  • la liste des clés connues comme compromises elle-même (Commandes de la liste des clés compromises), pour les clés stockées avant que la liste ne les connaisse.

Une clé de pair qui échoue à l’un ou l’autre test est supprimée, y compris une clé épinglée (un épinglage dit à qui appartient la clé, et une clé factorisée appartient à n’importe qui), et chacune est consignée dans le journal d’audit comme key.peer.compromised (sévérité warning). Nos propres identités sont signalées, jamais modifiées : la clé privée d’une identité factorisée est calculable, le remède (la révoquer, en créer une nouvelle) appartient à l’opérateur, et l’examen écrit une ligne key.identity.compromised de sévérité error et le dit sur la sortie standard. –dry-run signale et ne change rien. Les doublons exacts (une même clé stockée sous deux adresses) ne sont pas un facteur partagé. Le calcul prend un temps quadratique en la taille totale des modules : des secondes pour des milliers de clés, des minutes pour des dizaines de milliers. pepsi-keys-refresh.service l’exécute quotidiennement, après peer refresh et peer prune.

peer remove PEER-KEY-ID

Supprime une clé stockée. C’est aussi ainsi qu’un opérateur laisse passer la clé Autocrypt plus récente d’un correspondant que ACCEPT_ROTATION = expired a retenue (une ligne d’audit key.peer.rotate.held ; voir pepsi-stage-autocrypt-learn(1)) : l’ancienne ligne disparue, le prochain message portant la nouvelle clé la stocke comme une première clé.

95.1.50.1.4.3. Enregistrements des capacités S/MIME

Le fait que le client S/MIME d’un correspondant sache lire l”AuthEnvelopedData CMS (AES-256-GCM) est conservé par pair dans pepsi.smime_capability, parce qu’un certificat X.509 n’énonce aucune capacité de chiffrement de contenu qui lui soit propre. pepsi-stage-encrypt(1) et pepsi-stage-reencrypt(1) en tirent le choix du conteneur : sous la valeur par défaut [pepsi] CRYPTO_ALLOW_DOWNGRADE = negotiate, un destinataire consigné comme cbc reçoit de l”EnvelopedData AES-256-CBC, et tout autre destinataire — y compris un destinataire sans enregistrement — reçoit de l”AuthEnvelopedData. Les enregistrements proviennent de deux sources :

  • appris — pepsi-stage-autocrypt-learn(1) lit l’attribut SMIMECapabilities RFC 8551 du courrier signé d’un correspondant et le consigne pour le certificat qui a produit la signature (seulement lorsque cette signature se vérifie), de sorte qu’une déclaration ne décrit personne d’autre que le détenteur de la clé ;

  • configurés — avec les commandes ci-dessous, pour une adresse ou *@domain. Un enregistrement configuré l’emporte sur un enregistrement appris.

Thunderbird ne sait pas lire l”AuthEnvelopedData et affiche un message vide lorsqu’il en reçoit. Ses signatures n’annoncent aucun AES-GCM, de sorte qu’un correspondant Thunderbird qui a envoyé un message signé est consigné automatiquement. Celui qui n’a jamais envoyé de message signé reçoit, avec le premier message chiffré pour son certificat, un avis en clair à côté du texte chiffré lui demandant de signaler un message vide et de répondre de façon signée (pepsi-stage-encrypt(1), « L’avis du premier message ») ; peer capability set ADDRESS cbc règle la question aussitôt. L’avis est envoyé une fois par certificat, et la table le consigne aussi : une ligne notice porte l’empreinte et notice_sent_at mais aucune capacité. Un correspondant qui signe avec un certificat et chiffre vers un autre a aussi besoin d’un enregistrement configuré, puisqu’un enregistrement appris ne couvre que le certificat de signature. Les quatre commandes sont réservées à l’opérateur.

peer capability list [–address ADDRESS] [–json]

Liste les enregistrements, ou ceux qui concernent ADDRESS : son enregistrement configuré, l’enregistrement *@domain de son domaine, et les enregistrements appris et d’avis des certificats en cache pour elle. Un enregistrement appris ou d’avis montre les adresses dont les clés en cache sont ce certificat ; la colonne READS indique aead, cbc ou, pour une ligne d’avis, told.

peer capability set ADDRESS aead | cbc

Configure l’enregistrement pour ADDRESS (ou *@domain), en remplaçant tout enregistrement existant. Audité comme key.peer.capability.

peer capability unset ADDRESS

Retire l’enregistrement configuré ; un enregistrement appris, s’il y en a un, s’applique de nouveau. Audité.

peer capability forget FINGERPRINT

Retire l’enregistrement appris pour un certificat (SHA-256 hexadécimal, deux-points autorisés). Le message signé suivant de son détenteur le consigne de nouveau. Audité.

95.1.50.1.4.4. Commandes de la liste des clés compromises

Pepsi recherche dans pepsi.compromised_key chaque clé qu’il évalue : une clé vers laquelle chiffrer, une clé avec laquelle vérifier, une clé dans une chaîne S/MIME, et une clé avant que la découverte de clés ou un message ne la stocke. Une clé qui s’y trouve est refusée comme une clé inférieure à [pepsi] CRYPTO_MIN_RSA_BITS : n’importe qui peut signer avec elle et lire ce qui est chiffré pour elle. La table contient deux listes, distinguées par un nom de source :

  • la liste de blocage badkeys (https://badkeys.info) : chaque clé RSA et EC que le bogue OpenSSL de Debian (CVE-2008-0166) pouvait produire, les clés publiées dans des RFC, des suites de tests et de la documentation, et les clés extraites de micrologiciels et de paquets logiciels, sous forme d’empreintes SHA-256 tronquées de la valeur publique de chaque clé (aucun matériel de clé). Ses listes sources gardent les noms de badkeys (debianssl, forti, rfc, …). La liste ransomware de badkeys, des clés d’opérateurs de rançongiciels qu’aucun correspondant n’utilise, est laissée de côté ;

  • screen : les modules RSA que peer screen a factorisés ici.

La liste ne fait que croître. Une mise à jour ajoute ce qui est nouveau et ne retire rien, puisqu’une clé dont la moitié privée a été publiée une fois reste compromise. Une entrée qui s’avère erronée est écartée : elle ne refuse plus rien, et la mise à jour suivante ne la rajoute pas. Les quatre commandes sont réservées à l’opérateur.

blocklist update [–force]

Demande à [pepsi-keydiscovery] BADKEYS_URL/badkeysdata.json (par défaut https://update.badkeys.info/v0) si la liste a changé, en renvoyant l”ETag et le Last-Modified de la dernière exécution ; une liste inchangée coûte cette seule requête. Une nouvelle liste est téléchargée (environ 50 Mo en 2026), uniquement depuis l’arborescence de BADKEYS_URL, vérifiée contre le SHA-256 que nomment les métadonnées et quant à son ordre, et ses nouvelles entrées sont ajoutées en une seule transaction. Le premier import écrit environ trois millions de lignes (environ 240 Mo avec l’index) et prend moins d’une minute. Deux vérifications remplacent la signature que les métadonnées ne portent pas ; elles refusent la liste lorsqu’elle compte moins d’enregistrements que la précédente, ou lorsqu’elle ajouterait plus d’un quart de ce qui s’y trouve (au-delà de 50 000 entrées ; le premier import excepté). –force importe malgré tout une telle liste, et récupère à nouveau une liste inchangée. Chaque exécution, son issue (imported, unchanged, refused, failed) et ce qu’elle a ajouté depuis quelle liste source sont consignés dans pepsi.compromised_key_import. pepsi-keys-blocklist.timer l’exécute dix minutes après son démarrage puis quotidiennement ; systemctl mask --now pepsi-keys-blocklist.timer l’arrête (le Wants= de pepsi.target redémarre un timer simplement désactivé).

blocklist status [–json]

Quand la liste a été vérifiée pour la dernière fois et la date de la liste qu’elle contient, les entrées par liste source (et combien sont écartées), et les dix dernières exécutions avec ce que chacune a ajouté. pepsi-status(1) avertit lorsque la dernière vérification date de plus de trois jours ou que la dernière exécution a échoué ou a été refusée.

blocklist dismiss –import N | –list NAME

Met des entrées hors service : celles qu’a ajoutées une exécution (N d’après blocklist status), ou celles d’une liste source (un nom de liste badkeys, son numéro, ou screen). Audité (key.blocklist.dismiss). Une entrée écartée reste dans la table, de sorte qu’une mise à jour ne peut pas la rajouter.

blocklist restore –import N | –list NAME

Annule dismiss. Audité (key.blocklist.restore).

95.1.50.1.4.5. Liste des journaux Certificate Transparency

Pour chaque connexion cliente TLS que Pepsi vérifie contre les racines publiques, il confronte les Signed Certificate Timestamps du certificat du serveur à une liste de journaux Certificate Transparency, et il avertit d’un certificat qui n’a pas été journalisé ([pepsi] CT_CHECK, pepsi.conf(5)). La liste est un fichier public, [pepsi] CT_LOG_LIST (par défaut /var/lib/pepsi/ct-log-list.json), au format de la liste de journaux v3 de Google ; aucune base de données n’intervient. Les deux commandes sont réservées à l’opérateur.

ct-logs update [–force]

Récupère [pepsi] CT_LOG_LIST_URL (par défaut https://www.gstatic.com/ct/log_list/v3/log_list.json), en renvoyant l”ETag et le Last-Modified de la dernière exécution (conservés dans CT_LOG_LIST.meta), de sorte qu’une liste inchangée coûte une seule requête. Une nouvelle liste est analysée avant que quoi que ce soit ne soit écrit, refusée si elle nomme des journaux utilisables de moins de deux opérateurs ou si elle est plus ancienne que la liste en place, et remplace sinon le fichier de façon atomique (mode 0644). –force récupère à nouveau une liste inchangée et installe une liste plus ancienne. pepsi-keys-ct-logs.timer l’exécute cinq minutes après son démarrage puis quotidiennement ; systemctl mask --now pepsi-keys-ct-logs.timer l’arrête, et les certificats ne sont plus vérifiés une fois que la liste date de plus de 70 jours.

ct-logs status [–json]

Le chemin, la date, l’âge et le nombre de journaux de la liste, et si elle est trop ancienne pour être utilisée.

95.1.50.1.4.6. Commandes d’ancres de confiance

ca list [–json]

Liste les ancres de confiance avec leur identifiant, si elles sont activées, si elles se portent garantes d’un certificat feuille qui ne nomme aucune boîte aux lettres (NAMELESS), leur libellé, leur portée (SCOPE : les domaines, (constrained) pour une ancre sans portée dont le certificat porte nameConstraints, any sinon) et leur sujet ; puis un avertissement nommant chaque ancre activée qui se porte garante de tous les domaines de courrier. Le JSON porte permitted_domains et constrained.

ca add FILE [–label TEXT] [–accept-nameless]

Ajoute un certificat d’autorité (DER ou PEM ; - lit l’entrée standard) comme ancre de confiance. Un certificat sans basicConstraints CA:TRUE est refusé : aucune chaîne ne pourrait jamais s’y terminer. Idempotent sur le SHA-256 du certificat — ajouter deux fois la même ancre ne fait que mettre à jour l’étiquette. --accept-nameless active l’option ci-dessous sur une nouvelle ancre, --domain (répétable) sa portée (voir ca scope) ; la portée d’une ancre existante ne se modifie qu’avec ca scope.

ca scope CA-ID –domain DOMAIN… | –any

Limite les domaines de courrier pour lesquels on fait confiance à une ancre, ou (--any) lève la limite. Chaque DOMAIN se couvre lui-même et chacun de ses sous-domaines (example.org couvre alice@example.org et bob@sub.example.org, jamais example.net) ; il est stocké sous forme d’A-labels en minuscules, et un point initial est refusé. La portée est appliquée pendant la validation du chemin sous forme de contrainte de nom d’ancre de confiance RFC 5937 – un sous-arbre permis rfc822Name par domaine – à chaque boîte aux lettres (rfc822Name, SmtpUTF8Mailbox, emailAddress du sujet) de chaque certificat situé sous l’ancre et à l’adresse From: vérifiée, en plus de tout nameConstraints que porte le certificat de l’ancre lui-même (un nom doit satisfaire les deux). Un signataire hors de cette portée ne s’enchaîne pas jusqu’à cette ancre : sa signature se lit valid-untrusted à moins qu’une autre ancre ne se porte garante de lui. Une liste de révocation que l’ancre (ou un intermédiaire situé sous elle) a signée ne retire que les certificats situés dans sa portée. Une ancre ajoutée pour l’AC d’un partenaire doit porter les domaines de ce partenaire ; une ancre activée sans portée ni nameConstraints propres fait l’objet d’un avertissement de ca list, de pepsi-status(1) et de pepsi-setup check. Audité comme key.ca.scope.

ca accept-nameless CA-ID yes | no

Si un certificat feuille situé sous cette ancre qui ne nomme aucune boîte aux lettres — ni rfc822Name, ni SmtpUTF8Mailbox RFC 9598, ni emailAddress — peut encore rendre une signature valid pour le From: sous lequel elle est arrivée. Désactivé par défaut : un tel certificat ne contredit aucune ligne From:, de sorte que la liaison ne peut pas le faire échouer, mais il ne se porte garant d’aucune adresse non plus, et pepsi-stage-decrypt(1) rapporte donc une signature sous lui comme valid-untrusted (withheld=no-identity) plutôt que de laisser un seul certificat se vérifier comme n’importe quel expéditeur. Activez-le pour une AC dont le propre processus d’émission lie hors bande chaque certificat feuille à la boîte aux lettres de son titulaire. Audité comme key.ca.accept-nameless.

Une ancre est acceptée ici sur ses seules basicConstraints, mais la construction du chemin applique ses contraintes comme celles de toute autre AC (RFC 5937) : une ancre contrainte en noms ne se porte garante que des noms situés dans ses nameConstraints, une AC qui a déclaré pathlen:0 ne verra aucune sous-AC acceptée sous elle, et une requireExplicitPolicy ou une inhibitAnyPolicy qu’elle porte est respectée. Une chaîne qui en enfreint une échoue avec policy-rejected. Il en va de même d’une chaîne passant par une AC portant une extension critique que Pepsi ne sait pas du tout traiter (RFC 5280 §4.2) — une telle AC n’est jamais utilisée comme émetteur.

ca enable CA-ID, ca disable CA-ID

Remet une ancre au vérificateur, ou cesse de le faire tout en conservant la ligne pour mémoire.

ca remove CA-ID

Supprime une ancre.

Pepsi ne livre délibérément aucun jeu d’ancres par défaut. Une signature qui remonte jusqu’à une autorité que personne n’a choisie est rapportée comme non digne de confiance plutôt que mauvaise : un magasin vide se dégrade donc en « nous ne pouvons pas nous en porter garants » — et un opérateur qui ajoute une ancre prend une décision au lieu d’en hériter une.

95.1.50.1.4.7. Commandes de second facteur

Une adresse peut avoir un second facteur : un secret TOTP (RFC 6238, SHA-1, six chiffres, pas de 30 secondes) que son propriétaire conserve dans une application d’authentification. Dès qu’il existe, un appelant non privilégié (installation setuid) doit présenter un code en cours de validité pour chaque modification des identités de cette adresse – identity generate, import, revoke, forget-private, set-primary, publish, unpublish, delete – ainsi que pour identity export --private et identity csr, sous la forme de l’option –otp CODE du groupe identity (pepsi-keys identity --otp 123456 revoke 7). La propriété est vérifiée avant le code, de sorte qu’un utilisateur ne puisse pas accumuler des échecs contre l’enrôlement d’un autre. L’opérateur (root, pepsi-crypto, une installation non setuid) n’est jamais sollicité. Le même second facteur protège les commandes de clé par e-mail et la console web ; voir pepsi-stage-encrypt(1) et le chapitre du manuel consacré à la gestion des clés.

Un code n’est accepté qu’une fois (un rejeu dans ses propres 30 secondes est refusé), un pas de décalage d’horloge dans un sens ou dans l’autre est toléré, un code faux ou rejoué compte comme un échec et un code correct remet le compteur à zéro, et dix échecs consécutifs verrouillent le second facteur jusqu’à ce que l’opérateur le réinitialise.

otp status [ADDRESS] [–json]

Affiche l’enrôlement d’une adresse : quand elle a été enrôlée et utilisée pour la dernière fois, et les échecs consécutifs (ou LOCKED). L’opérateur peut omettre ADDRESS pour lister tous les enrôlements. N’affiche jamais de secret.

otp enroll ADDRESS [–otp CODE]

Crée un nouveau secret pour ADDRESS et l’imprime une seule fois, en base32 et sous forme d’URI otpauth:// (qrencode -t ansiutf8 en fait un code QR à scanner). Remplace un enrôlement existant, en repartant de zéro échec ; le propriétaire a besoin pour cela d’un code en cours de validité de l’ancien, l’opérateur non – c’est ainsi que l’opérateur remet un nouveau secret à un utilisateur verrouillé.

otp remove ADDRESS [–otp CODE]

Supprime le second facteur ; le propriétaire a besoin d’un code en cours de validité.

otp reset ADDRESS

Réservé à l’opérateur : supprime le second facteur quel que soit son état, ce qui déverrouille l’adresse. Son propriétaire s’enrôle de nouveau (par e-mail, ou avec otp enroll).

otp status –console LOGIN [–json], otp enroll –console LOGIN, otp reset –console LOGIN

Réservé à l’opérateur : la même chose pour le compte LOGIN de la console d’administration (un compte de POST /api/v1/accounts, non une adresse). Une fois inscrit, chaque connexion par mot de passe au compte (POST /api/v1/auth/login, le formulaire de connexion de la console) exige un code courant à côté du mot de passe, que pepsi-setup apply vérifie pour pepsi-httpd(1) dans une tâche confirm-login ; l’applicateur doit donc être installé. Le secret est conservé sous le sujet console LOGIN ; reset est la façon dont l’opérateur laisse revenir un administrateur dont le second facteur est verrouillé ou perdu.

Le secret est stocké enveloppé sous la clé de chiffrement de clés, comme une clé privée, dans une table que seul le rôle pepsi-crypto peut lire ; wrap rotate le réenveloppe aussi.

95.1.50.1.4.8. Commandes de la clé de chiffrement de clés

wrap rotate [–dry-run]

Réenveloppe chaque clé privée stockée, et chaque secret de second facteur, sous le [pepsi-crypto] KEY_WRAP_KEY_ID courant. La rotation est incrémentale par construction, car chaque ligne note la clé qui l’a scellée : configurez le nouveau secret comme KEY_WRAP_SECRET et gardez l’ancien à côté sous KEY_WRAP_SECRET_<OLD-ID>, faites pointer KEY_WRAP_KEY_ID vers le nouvel identifiant, et lancez ceci. Entre le changement de configuration et le balayage, le déploiement continue de fonctionner — le nouveau matériel est scellé sous la nouvelle clé, l’ancien s’ouvre toujours sous celle qui a été retirée — et ce n’est qu’ensuite que le secret retiré peut être supprimé.

Le même balayage ré-enveloppe une clé privée qui est déjà sous la clé courante mais au format d’enveloppement 0x01, dont les données associées ne lient pas l’empreinte de la clé (une telle clé s’ouvre encore, mais n’est jamais écrite ainsi) ; exécutez-le une fois sur une base de données qui en contient, même lorsque la clé de chiffrement de clés est inchangée.

Les lignes dont la clé de chiffrement de clés n’a aucun secret configuré sont signalées et laissées intactes plutôt que de faire échouer l’exécution ; de même pour les lignes réenveloppées en parallèle (chaque mise à jour est gardée sur l’ancien identifiant de clé et l’ancien blob, de sorte qu’un enveloppement plus récent ne soit jamais écrasé).

–dry-run

Liste ce qui serait réenveloppé, et ne change rien.

95.1.50.1.4.9. Publication DNS

dns ADDRESS

Imprime, au format de fichier de zone, les enregistrements DNS qui publient chaque identité publiée et active d”ADDRESS : un enregistrement OPENPGPKEY (RFC 7929) pour le matériel OpenPGP et un enregistrement SMIMEA (RFC 8162, sous la forme TLSA 3 0 0 — certificat délivré par le domaine, certificat complet, correspondance exacte) pour S/MIME. Les deux sont publiés sous un nom de propriétaire haché, l’hexadécimal des 28 premiers octets du SHA-256 de la partie locale. Le hachage ne cache pas l’adresse : dans une zone signée avec NSEC, les noms de propriétaire peuvent être listés en parcourant la zone, sous NSEC3 ils peuvent être retrouvés par une attaque par dictionnaire hors ligne, et dans les deux cas une table de parties locales courantes les retransforme en adresses. La sortie le dit dans un commentaire : la signature en ligne avec des enregistrements de couverture minimale (RFC 4470/7129) résiste au parcours, et une liste d’adresses qui doit rester privée se publie par WKD seulement.

Un enregistrement OPENPGPKEY porte la clé sans certifications de tiers, y compris lorsque l’identité stockée a été importée en en portant.

Ne publiez ceux-ci que dans une zone signée par DNSSEC, ce que la sortie répète en commentaire : un enregistrement de clé non signé est une clé fournie par quiconque peut répondre pour la zone, ce qui n’améliore en rien le fait de n’avoir aucune clé.

Le hachage du nom de propriétaire DNS distingue la casse (RFC 7929 §3), contrairement au hachage Web Key Directory du même local-part, qui met en minuscules. Les deux sont calculés par des fonctions différentes, à dessein.

pepsi-setup(1) imprime les mêmes enregistrements pour chaque identité publiée dans le cadre de sa sortie DNS, plafonnés à un nombre lisible ; cette commande est la façon d’obtenir une adresse précise dans un grand déploiement.

95.1.50.1.4.10. Commandes de PKI gérée

Avec une PKI gérée, une autorité de certification commerciale délivre un certificat S/MIME à chaque utilisateur d’un domaine, et personne n’a à porter à la main une demande de certificat à l’AC ni à en rapporter le certificat. Pepsi commande par l’API CertCentral Services de DigiCert, par défaut le produit Secure Email for Employee (secure_email_sponsor). Un tel certificat est validé par parrainage (sponsor-validated) : il nomme la personne (prénom et nom de famille) et l’adresse de courrier, et l’organisation à laquelle appartient le compte d’AC se porte garante de la personne et paie le certificat.

Pepsi engendre lui-même chaque clé et n’envoie à l’AC qu’une demande de certificat, si bien qu’aucune clé privée ne quitte l’hôte. Avant d’être installé, le certificat qui revient doit nommer l’adresse, autoriser la protection du courrier électronique, porter les usages de clé dont la commande a besoin et porter sur la clé propre de la commande. Il devient alors une identité S/MIME ordinaire (custody = local), et les certificats intermédiaires de l’AC sont stockés avec lui, afin que chaque signature qu’il produit les porte. Le chapitre du manuel sur la gestion des clés décrit l’ensemble du processus.

Chaque domaine géré a ses propres réglages et son propre compte d’AC, et rien n’est commandé pour un domaine tant qu’il n’est pas activé et que son identifiant n’est pas stocké. Les réglages, les utilisateurs et les commandes sont conservés dans la base de données (pepsi.mpki_domain, mpki_user et mpki_order) ; l’identifiant est un fichier (Fichiers). Chaque commande mpki est réservée à l’opérateur (root ou pepsi-crypto), car les réglages décident de ce qui est facturé à l’organisation et du nom que porte un certificat. Les commandes qui modifient des réglages, des utilisateurs, des commandes de certificats, l’identifiant ou les avis sont consignées dans le journal d’audit (mpki.domain.set, mpki.credential.set, mpki.credential.remove, mpki.user.add, mpki.user.set, mpki.user.delete, mpki.user.import, mpki.order.release, mpki.order.retry, mpki.order.cancel, mpki.notice.read).

mpki domain list [–json]

Une ligne par domaine géré : s’il est activé, son mode d’enrôlement et sa politique de noms d’en-tête, la fenêtre de renouvellement, un ou deux certificats, l’algorithme de clé, la limite quotidienne, et si son fichier d’identifiant est présent.

mpki domain show DOMAIN [–json]

Tous les réglages d’un domaine, le chemin de son fichier d’identifiant et si ce fichier existe, et qui a modifié les réglages en dernier.

mpki domain set DOMAIN [OPTIONS]

Crée les réglages d’un domaine ou les modifie. Une option omise garde sa valeur actuelle, ou sa valeur par défaut pour un nouveau domaine. Un nouveau domaine démarre désactivé. Lorsque la commande active un domaine qui n’a pas encore d’identifiant, elle le signale.

–enable, –disable

Active ou désactive la PKI gérée du domaine (désactivée par défaut). Tant qu’un domaine est désactivé, rien n’est commandé, renouvelé ni révoqué pour lui. Cela inclut les certificats des utilisateurs supprimés ou exclus entre-temps : ils sont révoqués une fois le domaine réactivé.

–api-url URL

L’URL de base de l’API de l’AC, par défaut https://www.digicert.com/services/v2. Elle doit être en https:// ; un simple http:// n’est accepté que pour localhost et 127.0.0.1, pour un substitut pendant les tests.

–organization-id ID, –any-organization

L’identifiant, chez l’AC, de l’organisation validée qui parraine les certificats. Sans lui (par défaut, ou après –any-organization), la seule organisation active du compte est utilisée, et un compte qui a plusieurs organisations refuse la commande et les liste.

–product NAME

Le nom du produit chez l’AC. Par défaut secure_email_sponsor.

–validity-years YEARS

La durée de validité à commander, de 1 à 3 ans (1 par défaut). Le produit peut en accepter moins.

–enrolment MODE

Qui reçoit un certificat. first-send (par défaut) : un utilisateur, dès qu’il a envoyé du courrier par Pepsi. all : chaque utilisateur de la liste. manual : seuls les utilisateurs qu’un administrateur sélectionne (--select yes). Dans tous les modes, un utilisateur dont la sélection est no n’en reçoit aucun.

–header-names POLICY

Ce qu’il advient d’un nom que Pepsi a tiré du nom affiché du premier message d’un utilisateur. approve (par défaut) : la commande attend qu’un administrateur confirme le nom. trust : il est commandé aussitôt. Un nom affiché est ce que l’expéditeur a tapé, quoi que ce soit, et l’organisation se porte garante du nom que porte le certificat : ne changez donc ce réglage que là où le nom affiché de chaque expéditeur est fixé par un administrateur.

–renew-days DAYS

Commande le remplacement ce nombre de jours avant l’expiration du certificat en cours, de 1 à 365. 90 par défaut.

–certificates N

one (par défaut) : un seul certificat pour la signature et le chiffrement. two : un certificat de signature et un certificat de chiffrement, commandés séparément. Un seul certificat exige une clé RSA.

–key-algorithm ALG

La clé engendrée pour chaque commande : rsa2048, rsa3072 (par défaut), rsa4096, p256 ou p384. Les courbes elliptiques exigent --certificates two.

–daily-limit N

Au plus ce nombre de nouveaux enrôlements du domaine partent vers l’AC sur toute période de 24 heures (20 par défaut). Une commande au-delà est retenue (daily-limit) et un administrateur en est informé ; 0 retient chaque nouvel enrôlement. Les renouvellements ne comptent pas et ne sont jamais retenus par la limite.

–notify ADDRESS, –no-notify

Envoie par courrier les avis du domaine à ADDRESS, ou cesse de les envoyer (par défaut : les avis sont seulement listés par mpki notices). Ce courrier exige aussi [pepsi-mpki] NOTIFY_STAGE (Configuration de la PKI gérée).

mpki domain check DOMAIN [–json]

Demande à l’AC si le domaine peut commander, sans rien commander : si l’identifiant est accepté, si le produit est disponible, quelle organisation parraine les certificats, et si le domaine est listé et validé dans le compte (l’AC valide le domaine de chaque commande). Chaque problème est affiché sur une ligne à part, et le programme se termine avec le code de sortie 1 lorsqu’il y en a un.

mpki credential set DOMAIN [–file FILE]

Stocke la clé d’API du domaine, lue dans FILE ou sur l’entrée standard, ce qui la tient à l’écart de l’historique du shell et de la liste des processus. Elle doit tenir en un seul mot : la clé d’API CertCentral, que Pepsi envoie dans l’en-tête X-DC-DEVKEY. La clé est écrite dans mpki-DOMAIN.secret dans [pepsi-mpki] CREDENTIAL_DIR avec le mode 0640, par un fichier temporaire et un renommage ; exécutée en tant que root, la commande donne le fichier au groupe pepsi-crypto.

mpki credential remove DOMAIN

Supprime le fichier d’identifiant. Les commandes en attente du domaine sont alors retenues (no-credential) jusqu’à ce qu’un identifiant soit de nouveau stocké.

mpki user list [–domain DOMAIN] [–deleted] [–json]

Une ligne par utilisateur : l’adresse, le nom, d’où vient le nom (header, ldap ou local ; un ? à la suite signifie que personne n’a encore confirmé le nom), la sélection, wanted lorsque l’utilisateur doit avoir un certificat, et la commande la plus récente avec son état et, pour une commande retenue, le motif. –deleted inclut les utilisateurs supprimés ; –json donne chaque utilisateur avec ses cinq commandes les plus récentes.

mpki user add ADDRESS –given-name NAME –surname NAME [–select SELECTION]

Crée un utilisateur sous un nom dont l’administrateur se porte garant (source local, confirmé), ou fait revenir un utilisateur supprimé. SELECTION vaut default (le mode d’enrôlement du domaine décide), yes (toujours enrôlé, en mode manual aussi) ou no (exclu). Un utilisateur existant garde sa sélection, sauf si –select en nomme une autre. Le domaine de l’adresse doit d’abord être configuré (mpki domain set).

mpki user set ADDRESS [–given-name NAME] [–surname NAME] [–confirm] [–select SELECTION]

Modifie un utilisateur. Un nouveau prénom ou nom de famille confirme le nom, puisque l’administrateur qui l’a tapé s’en porte garant ; –confirm approuve le nom tel qu’il est. L’un comme l’autre libère, à l’exécution suivante, une commande qui attend le nom. Un certificat déjà installé garde l’ancien nom jusqu’à son renouvellement. –select no exclut l’utilisateur : l’exécution suivante annule ses commandes en attente et révoque ses certificats installés, ici et auprès de l’AC.

mpki user delete ADDRESS

Supprime un utilisateur. L’exécution suivante révoque ses certificats. Son prochain message ne le recrée pas ; seul mpki user add le fait revenir. La ligne est conservée, marquée comme supprimée.

mpki user import FILE –ldif | –csv [OPTIONS]

Crée ou met à jour des utilisateurs à partir d’un export d’annuaire ; - lit l’entrée standard. Il n’y a pas de connexion LDAP : un annuaire parvient à Pepsi sous forme de fichier, comme la sortie de ldapsearch -LLL … mail givenName sn.

–ldif lit des enregistrements de contenu LDIF (RFC 2849) avec des valeurs simples et en base64, des lignes repliées et des commentaires. Les noms viennent de givenName et sn ou, là où l’un des deux manque, de cn, découpé comme un nom affiché. Une entrée qui a plusieurs valeurs de courrier donne un utilisateur par adresse. Un nom venant de l’annuaire compte comme confirmé (source ldap).

–csv lit un address,given name,surname par ligne. Les champs peuvent être entre guillemets doubles ("" vaut un guillemet), les lignes vides et celles qui commencent par # sont ignorées, et une première ligne dont le premier champ ne contient aucun @ est prise pour un en-tête. Les noms comptent comme saisis par un administrateur (source local).

L’import ne modifie jamais la sélection d’un utilisateur, et ne fait jamais revenir un utilisateur qu’un administrateur a supprimé ; il signale les deux cas. Un utilisateur connu dont le nom diffère, ou n’est pas encore confirmé, reçoit le nom du fichier, confirmé. Les adresses hors des domaines gérés sont signalées et ignorées. Un enregistrement sans nom complet crée un utilisateur dont la commande attend un nom (name-missing).

–domain DOMAIN

N’importe que les adresses de DOMAIN.

–mail-attribute ATTR, –given-name-attribute ATTR, –surname-attribute ATTR

Les attributs LDIF qui contiennent les adresses, le prénom et le nom de famille. Par défaut mail, givenName et sn.

–prune

Supprime aussi les utilisateurs de –domain venus d’un import d’annuaire (source ldap) que le fichier ne liste plus, ce qui révoque leurs certificats. Exige –domain et –ldif. La commande liste ces utilisateurs et demande d’abord confirmation ; –yes saute la question, et sans terminal ni –yes, rien du tout n’est importé.

–dry-run

Affiche ce qui changerait, et ne change rien.

–json

Affiche le plan et les décomptes en JSON.

La sortie a une ligne par adresse qui change : add, update (avec l’ancien nom), skip (supprimée ici, hors des domaines gérés, ou pas une adresse de courrier) et delete, puis les décomptes.

mpki order list [–domain DOMAIN] [–address ADDRESS] [–open] [–limit N] [–json]

Les commandes, les plus récentes d’abord, au plus N (50 par défaut) : l’identifiant, la date de création, l’adresse, le type (new, renew ou revoke), la finalité (sign, encrypt ou both), l’état, le motif d’une retenue, l’identifiant de commande chez l’AC et la dernière erreur. Une commande est queued (attend d’être soumise), held (attend un administrateur ou la disparition de sa cause), submitted (l’AC l’a), issued (téléchargée, en cours d’installation), installed ou revoked (terminée), failed (abandonnée, avec la raison) ou cancelled. –open ne liste que les commandes encore en cours : en file, retenues, soumises et délivrées.

mpki order release ORDER-ID

Laisse avancer une commande retenue ; l’exécution suivante la soumet. C’est ainsi qu’une commande franchit la limite quotidienne (daily-limit) et qu’elle reprend après l’ajout d’une licence au compte d’AC (no-licence) : ces deux retenues attendent un administrateur. Les retenues que l’exécution lève d’elle-même (name-missing, name-unconfirmed, no-credential) reviennent aussitôt tant que leur cause demeure.

mpki order retry ORDER-ID

Réessaie une commande échouée à l’exécution suivante, sans attendre un jour la commande de remplacement. Une commande que l’AC a et dont la clé est encore stockée est de nouveau suivie auprès de l’AC. Sinon, la commande est soumise à nouveau, comme nouvelle commande auprès de l’AC sur une nouvelle clé ; c’est le cas habituel, car une commande échouée abandonne sa clé. Une révocation échouée est envoyée de nouveau.

mpki order cancel ORDER-ID

Abandonne une commande en file, retenue, soumise ou échouée, et jette sa clé. Une commande qui avait atteint l’AC n’est annulée qu’ici, et le programme rappelle de l’annuler aussi dans le portail de l’AC. Tant que l’utilisateur doit encore avoir un certificat, l’exécution suivante crée une nouvelle commande ; pour arrêter définitivement, excluez l’utilisateur (mpki user set ADDRESS –select no). Un certificat installé n’est pas annulé mais révoqué, par la même exclusion.

mpki notices [–domain DOMAIN] [–unread] [–read ID… | –read-all] [–json]

Les avis destinés aux administrateurs, les plus récents d’abord (au plus 200) : l’heure, la gravité et une phrase, chacun marqué [unread] jusqu’à ce que quelqu’un le lise. Un avis est écrit lorsqu’une commande est soumise, installée, retenue (avec le motif et ce qu’il faut faire), réessayée pour la troisième fois, échouée ou révoquée, et lorsqu’une révocation attend une approbation auprès de l’AC. –read marque comme lus les avis donnés et –read-all chaque avis non lu (de –domain, s’il est donné) ; un avis marqué comme lu l’est pour chaque administrateur, y compris dans la page Avis de la console (voir pepsi-httpd(1)).

mpki run [–domain DOMAIN] [–json]

Une passe sur chaque domaine activé, ou sur –domain seulement. C’est ce que pepsi-keys-mpki.timer exécute toutes les cinq minutes. Sur un hôte sans domaine activé, la passe se réduit à une requête. Une passe a quatre étapes :

  1. Planifier. Chaque utilisateur qui doit avoir un certificat et n’en a aucun en cours de validité reçoit une commande new pour chaque finalité ; un certificat qui expire dans la fenêtre de renouvellement reçoit une commande renew. Une commande du même utilisateur et de la même finalité qui a échoué dans les dernières 24 heures retient la suivante, si bien qu’un échec est réessayé une fois par jour. Une nouvelle commande est créée retenue lorsque le nom manque ou n’est pas confirmé, ou lorsque la limite quotidienne est atteinte, et un avis dit pourquoi. Un utilisateur supprimé ou exclu voit ses commandes en attente annulées et ses certificats installés révoqués : ici aussitôt, et auprès de l’AC par une commande revoke. Un utilisateur qui n’est simplement plus sélectionné (en mode manual ou first-send) garde son certificat jusqu’à son expiration, et celui-ci n’est pas renouvelé.

  2. Libérer les commandes retenues dont la cause a disparu : un nom devenu complet et confirmé, ou un identifiant qui existe à présent.

  3. Traiter chaque commande arrivée à échéance. Pour une commande en file : engendrer la clé, la stocker enveloppée dans la ligne de la commande, puis envoyer la demande ; la commande porte pepsi-ORDER-ID comme référence dans le portail de l’AC. Interroger l’AC sur une commande soumise toutes les minutes au début, puis de moins en moins souvent jusqu’à une fois par heure. Télécharger un certificat délivré avec sa chaîne, le vérifier et l’installer ; les identités qu’il remplace (un certificat auto-signé, celui qu’un renouvellement remplace) sont retirées comme les retire une rotation de clés, afin que le courrier déjà chiffré vers elles s’ouvre toujours. Envoyer les révocations en file.

  4. Envoyer les avis de la passe à l’adresse de notification de chaque domaine.

L’échec d’une commande n’arrête pas la passe. Un échec temporaire (le réseau, un délai dépassé, une erreur de serveur chez l’AC) d’une commande que l’AC n’a pas encore est réessayé après 5 minutes, en doublant jusqu’à 6 heures, avec un avis à la troisième tentative ; la commande échoue après 40 tentatives, soit environ une semaine. Un refus de l’AC fait échouer une telle commande aussitôt, et un compte sans licence libre pour l’adresse la retient (no-licence). Une commande échouée est remplacée par une nouvelle un jour plus tard, ou réessayée à l’exécution suivante après mpki order retry. Une commande que l’AC a déjà n’est jamais abandonnée : une interrogation d’état ou un téléchargement qui échoue, refus compris (après le remplacement d’un identifiant, par exemple), est réessayé à au plus 40 minutes d’intervalle, et la commande garde sa clé. Seul l’état propre de la commande chez l’AC (rejetée, annulée, expirée ou révoquée) la fait échouer. Le programme affiche un résumé de la passe et se termine avec le code de sortie 1 lorsqu’une erreur s’est produite. Les passes ne se chevauchent jamais : une exécution qui démarre pendant qu’une autre est en cours le signale et ne fait rien.

95.1.50.1.5. Configuration du serveur de clés

La publication par le Web Key Directory n’a besoin d’aucune configuration : elle suit l’indicateur published de chaque identité et est servie par pepsi-httpd(1). La publication par serveur de clés, elle, en a besoin, parce qu’elle ne peut pas être défaite, et ses options vivent dans [pepsi-keys] :

VKS_PUBLISH (no par défaut)

Indique si les identités créées ou importées à la main démarrent avec leur téléversement vers le serveur de clés demandé, de sorte que identity publish –retry les téléverse et continue de réessayer jusqu’à ce que l’adresse soit vérifiée. Un téléversement peut être révoqué mais jamais retiré, la valeur par défaut reste donc une décision de l’opérateur. Elle ne conditionne pas la tâche de réessai, et ne s’applique jamais aux clés créées ou enregistrées automatiquement ; voir Les téléversements vers le serveur de clés sont demandés par identité. Lorsqu’elle est désactivée, identity publish –vks (ou la propre demande d’un utilisateur via la console web ou par courriel) reste disponible.

VKS_SERVER (par défaut : la première entrée de [pepsi-keydiscovery] VKS_SERVERS)

Où vont les téléversements ; https:// uniquement. Un serveur, non une liste : publier la même clé auprès de plusieurs multiplie un acte irréversible, et chacun doit ensuite être tenu à jour des révocations.

VKS_MAX_ATTEMPTS (5 par défaut), VKS_RETRY_INTERVAL (6 h par défaut), VKS_BATCH (50 par défaut)

Avec quelle insistance, à quelle fréquence et combien à la fois identity publish –retry essaie. Notez que les durées refusent les unités calendaires : 6 h s’analyse, 1 d non.

95.1.50.1.6. Configuration de la PKI gérée

Les réglages par domaine sont dans la base de données (mpki domain set). Ce que les commandes mpki lisent dans le fichier de configuration se trouve dans [pepsi-mpki], décrit dans pepsi.conf(5) ; chaque option a une valeur par défaut :

CREDENTIAL_DIR (par défaut : secrets.d à côté du fichier de configuration)

Où se trouvent les fichiers mpki-DOMAIN.secret.

TIMEOUT (60 s par défaut)

Le délai d’une requête à l’AC.

NOTIFY_STAGE (par défaut : aucune)

L’étape par laquelle le courrier d’avis entre dans le pipeline, par exemple l’étape qui signe le courrier sortant avec DKIM. Sans elle, aucun avis n’est envoyé par courrier.

NOTIFY_FROM (par défaut postmaster@DOMAIN)

Le From: d’un courrier d’avis.

95.1.50.1.7. Options globales

Ces options globales précèdent la sous-commande (un indicateur placé à la fin est rejeté).

-c FILE, –config FILE

Lit la configuration depuis FILE au lieu de parcourir les emplacements par défaut. Refusé aux appelants non privilégiés lorsque ce programme est installé setuid : la configuration nomme la connexion à la base de données, chaque chemin développé par ${…}, et la clé de chiffrement de clés elle-même.

-L LOGLEVEL, –log LOGLEVEL

Règle la verbosité de journalisation. LOGLEVEL est l’un de error, warn, info, debug ou trace (par défaut : [pepsi] LOG, sinon info).

-v, –verbose

Affiche les messages de journal de toutes les sources, y compris les bibliothèques tierces.

-h, –help

Affiche un résumé d’utilisation et quitte.

-V, –version

Affiche la version et quitte.

95.1.50.1.8. Code de sortie

0

Achèvement réussi. Une commande destructrice déclinée à son invite de confirmation sort également en 0, sans avoir rien changé.

1

Une erreur s’est produite : un fichier de configuration malformé, une combinaison d’options inadmissible, une adresse qui se résout vers le compte d’un autre utilisateur, du matériel de clé impossible à analyser, une clé de chiffrement de clés manquante ou qui n’ouvre pas une ligne, ou une connexion ou requête de base de données en échec. La raison est écrite dans le journal.

78

Le schéma de la base de données n’est pas celui qu’attend cette version (non installé, plus ancien, plus récent ou modifié) : exécutez schema de pepsi-setup(1).

95.1.50.1.9. Fichiers

Lorsque –config n’est pas fourni, le premier fichier existant de la liste suivante est utilisé :

  • $XDG_CONFIG_HOME/pepsi.conf

  • $HOME/.config/pepsi.conf

  • /etc/pepsi/pepsi.conf

  • /etc/pepsi.conf

secrets.d/pepsi-crypto.secret

La clé de chiffrement de clés, à côté du fichier de configuration et tirée dans la section [pepsi-crypto] par une directive @inline-secret@. Elle est tenue hors de la configuration lisible par tous parce que c’est l’unique secret qui ouvre chaque clé privée stockée ; pepsi-setup(1) lui donne le mode 0640 et la remet au compte pepsi-crypto à chaque exécution. Sauvegardez-la séparément — voir le chapitre Gestion des clés du manuel pour ce que coûte sa perte.

/run/pepsi-vmgenid-changed

Touché par la règle udev de Pepsi lorsque l’identifiant de génération de la machine virtuelle change (un clone, ou une restauration depuis un instantané). identity generate, otp enroll et wrap rotate ne regardent que sa date : dans les dix minutes suivant un changement, ils journalisent un avertissement nommant ce qu’ils génèrent, puisqu’un processus qui s’exécutait avant l’instantané peut répéter des nombres aléatoires. Voir le chapitre Exploitation du manuel, Cloned and restored virtual machines.

secrets.d/mpki-DOMAIN.secret

La clé d’API du compte d’AC d’un domaine géré, un fichier par domaine, dans [pepsi-mpki] CREDENTIAL_DIR. La première ligne qui n’est ni vide ni un commentaire # est la clé. mpki credential set l’écrit avec le mode 0640 et le groupe pepsi-crypto ; seul pepsi-keys la lit, et la clé ne va nulle part ailleurs qu’à l’AC. Quiconque détient le fichier peut commander des certificats que l’organisation paie, et les révoquer. Sauvegardez-le avec le reste de secrets.d.

Aucun autre fichier n’est lu ni écrit : tout le matériel de clé vit dans la base de données.

95.1.50.1.10. Exemples

Trouver les adresses servies dont le chiffrement est décidé par une clé fournie par quelqu’un d’autre, et faire d’une clé confirmée la clé propre de l’utilisateur (une clé de MUA : pas de –private)

pepsi-keys -c /etc/pepsi/pepsi.conf peer unclaimed
pepsi-keys -c /etc/pepsi/pepsi.conf peer show bob@example.org
gpg --export bob@example.org > bob.pgp    # the key bob confirmed to you
pepsi-keys -c /etc/pepsi/pepsi.conf identity import bob@example.org \
    --protocol openpgp --purpose both --public bob.pgp

Générer une identité OpenPGP et vérifier que GnuPG accepte la moitié publique

pepsi-keys -c /etc/pepsi/pepsi.conf identity generate alice@example.org \
    --protocol openpgp --name 'Alice Example'
pepsi-keys -c /etc/pepsi/pepsi.conf identity list --address alice@example.org
pepsi-keys -c /etc/pepsi/pepsi.conf identity export 1 | gpg --import

Générer la paire S/MIME, en imprimant une demande de certificat sur chaque clé pour une véritable autorité

pepsi-keys -c /etc/pepsi/pepsi.conf identity generate alice@example.org \
    --protocol smime --csr

Installer le certificat délivré par cette autorité, portant sur la clé déjà présente dans le magasin

pepsi-keys -c /etc/pepsi/pepsi.conf identity import alice@example.org \
    --protocol smime --purpose sign --public /tmp/alice-sign.pem --primary

Publier l’adresse dans le DNS (zone signée uniquement)

pepsi-keys -c /etc/pepsi/pepsi.conf dns alice@example.org >> example.org.zone

Retirer une clé de signature compromise, puis confirmer que la moitié privée a disparu

pepsi-keys -c /etc/pepsi/pepsi.conf identity revoke 1 --reason 'laptop stolen'
pepsi-keys -c /etc/pepsi/pepsi.conf identity show 1

Faire confiance à la main à la clé d’un correspondant et l’épingler contre une découverte ultérieure

pepsi-keys -c /etc/pepsi/pepsi.conf peer import bob@example.com \
    --protocol openpgp --file bob.pgp --pin

Consulter un correspondant avec chaque méthode activée et stocker le résultat

pepsi-keys -c /etc/pepsi/pepsi.conf peer refresh --address bob@example.com

Garder le cache honnête depuis une minuterie périodique : revalider ce qui est dû, puis jeter ce qui a vieilli

pepsi-keys -c /etc/pepsi/pepsi.conf peer refresh
pepsi-keys -c /etc/pepsi/pepsi.conf peer prune
pepsi-keys -c /etc/pepsi/pepsi.conf peer screen

Voir à quel point la liste des clés connues comme compromises est à jour, et mettre une liste source hors service (si ses entrées s’avéraient erronées)

pepsi-keys -c /etc/pepsi/pepsi.conf blocklist status
pepsi-keys -c /etc/pepsi/pepsi.conf blocklist dismiss --list forti

Ajouter une ancre de confiance S/MIME et voir ce qui est approuvé

pepsi-keys -c /etc/pepsi/pepsi.conf ca add /etc/ssl/certs/our-ca.pem --label 'Our CA'
pepsi-keys -c /etc/pepsi/pepsi.conf ca list

Faire confiance à l’AC d’un partenaire pour le seul domaine de ce partenaire

pepsi-keys -c /etc/pepsi/pepsi.conf ca add partner-ca.pem --label Partner --domain partner.example
pepsi-keys -c /etc/pepsi/pepsi.conf ca scope 2 --domain partner.example --domain partner.example.net

Voir ce que le profil de confidentialité persistante renouvellerait et détruirait aujourd’hui

pepsi-keys -c /etc/pepsi/pepsi.conf identity rotate-due --dry-run

Renouveler la clé de chiffrement de clés, en regardant d’abord

pepsi-keys -c /etc/pepsi/pepsi.conf wrap rotate --dry-run
pepsi-keys -c /etc/pepsi/pepsi.conf wrap rotate

Faire expirer tout ce qui a dépassé sa validité (depuis une minuterie périodique)

pepsi-keys -c /etc/pepsi/pepsi.conf identity retire

Publier une clé sur le serveur de clés, puis vérifier qu’elle est arrivée

pepsi-keys -c /etc/pepsi/pepsi.conf identity publish 1 --vks
pepsi-keys -c /etc/pepsi/pepsi.conf identity show 1

Mener à terme chaque vérification de serveur de clés en attente (ce qu’exécute le timer horaire)

pepsi-keys -c /etc/pepsi/pepsi.conf identity publish --retry

Cesser de publier une clé, et dire au monde que celle qui a été téléversée est morte

pepsi-keys -c /etc/pepsi/pepsi.conf identity unpublish 1
pepsi-keys -c /etc/pepsi/pepsi.conf identity revoke 1 --upload \
    --reason 'address closed'

Mettre en place une PKI gérée pour un domaine : la configurer, stocker la clé d’API du compte d’AC depuis l’entrée standard, et demander à l’AC si le domaine peut commander

pepsi-keys -c /etc/pepsi/pepsi.conf mpki domain set example.org \
    --enable --notify it@example.org
pepsi-keys -c /etc/pepsi/pepsi.conf mpki credential set example.org < api-key.txt
pepsi-keys -c /etc/pepsi/pepsi.conf mpki domain check example.org

Importer les utilisateurs depuis l’annuaire, en regardant d’abord

ldapsearch -LLL -H ldap://ldap.example.org -b ou=people,dc=example,dc=org \
    '(mail=*@example.org)' mail givenName sn > people.ldif
pepsi-keys -c /etc/pepsi/pepsi.conf mpki user import people.ldif --ldif \
    --domain example.org --dry-run
pepsi-keys -c /etc/pepsi/pepsi.conf mpki user import people.ldif --ldif \
    --domain example.org

Approuver un nom tiré du premier message d’un utilisateur, puis lancer une passe au lieu d’attendre le timer

pepsi-keys -c /etc/pepsi/pepsi.conf mpki user list --domain example.org
pepsi-keys -c /etc/pepsi/pepsi.conf mpki user set alice@example.org --confirm
pepsi-keys -c /etc/pepsi/pepsi.conf mpki run --domain example.org

Corriger un nom et l’approuver en une seule fois, ou refuser une adresse de rôle qui s’est enregistrée d’elle-même

pepsi-keys -c /etc/pepsi/pepsi.conf mpki user set bob@example.org \
    --given-name Robert --surname Example
pepsi-keys -c /etc/pepsi/pepsi.conf mpki user set noreply@example.org --select no

Voir ce qui attend, et laisser avancer une commande retenue par la limite quotidienne

pepsi-keys -c /etc/pepsi/pepsi.conf mpki notices --unread
pepsi-keys -c /etc/pepsi/pepsi.conf mpki order list --open
pepsi-keys -c /etc/pepsi/pepsi.conf mpki order release 17

95.1.50.1.11. Voir aussi

pepsi-keydisc(1), pepsi-httpd(1), pepsi-stage-vks-confirm(1), pepsi-setup(1), pepsi-config(1), pepsi-whitelist(1), pepsi-settings(1), pepsi.conf(5), pepsi.state(7)

Le chapitre Sécurité du manuel énonce les mécanismes sur lesquels repose ce programme (The private-key custody boundary, A second factor for key management, What an S/MIME trust anchor vouches for, Which S/MIME container a correspondent gets, A correspondent’s key changing, Certificates from a commercial CA) ; son chapitre Modèle de menace énonce ce qu’ils promettent (End-to-end encryption: two custody modes, Keys of correspondents, Somebody holding a copy of the database).

95.1.50.1.12. Bogues

Signalez les bogues au gestionnaire de tickets de Pepsi.