API d'automatisation codée cryptographique

API d'automatisation codée pour le package d'activités Cryptographie, couvrant le chiffrement symétrique, le hachage par clé et PGP.

UiPath.Cryptography.Activities

API de workflow codé pour le chiffrement et le déchiffrement symétriques, le hachage par clé et le chiffrement PGP, le déchiffrement, la signature, la signature en texte clair, la vérification et la génération de clés. Utilisez ces API lorsque vous créez des automatisations codées. Rendez-vous sur la page Automatisations codées pour en savoir plus sur les automatisations codées et sur leur conception via API.

• Accéder au service: cryptography (type ICryptographyService)
• Package requis: "UiPath.Cryptography.Activities": "*" dans les dépendances project.json .

Espaces de noms importés automatiquement

Ces espaces de noms sont automatiquement disponibles dans les workflows codés lorsque ce package est installé :

System
System.IO
System.Text
UiPath.Cryptography
UiPath.Cryptography.Activities
UiPath.Cryptography.Activities.API
UiPath.Cryptography.Enums

Vue d’ensemble du service

Le service cryptography expose toutes les opérations sous forme d'appels de méthode directs. Il n’y a aucune connexion, gestion ou étendue à ouvrir. Il est enregistré en tant que singleton sans état, de sorte que l'accesseur est partagé dans l'ensemble du workflow et que ses méthodes peuvent être appelées simultanément en toute sécurité. Appelez directement des méthodes sur l’accesseur du service:

var key = PasswordKey.FromPassword("mykey", Encoding.UTF8);
var ciphertext = cryptography.EncryptText("secret", EncryptionAlgorithm.AESGCM, SymmetricEncryptOptions.Classic(key));

Octets, Texte et Formulaires Fichier

Chaque opération logique expose trois formulaires d'entrée/sortie. Choisissez celui qui correspond aux données dont vous disposez déjà:

Formulaire	Suffixe	Entrée → Sortie	Quand l'utiliser
Octets	(base)	byte[] → byte[]	Données binaires ou déjà chargées.
Texte	...Text	string → string (Base64 ou ASCII protégé par ASCII)	Données entrant sous forme de texte.
Fichier	...File	chemin du fichier → chemin du fichier	Données qui résident sur le disque.

Documents de la clé

Les opérations symétriques et de hachage des clés basent le matériel sur l'un des deux sous-types CryptoKey concrètes. La classe que vous choisissez détermine les formats fil avec lesquels la clé peut être utilisée, et le système de type applique cela au moment de la compilation via les factures de format.

PasswordKey

Documents à extraire dans une clé de chiffrement. Utilisé avec les formats de fils Classic, Owasp2026 et OpenSslEnc .

Factures	Objectif
PasswordKey.FromPassword(string password, Encoding encoding)	Mot de passe ou phrase de passe en tant que string
PasswordKey.FromPassword(SecureString password, Encoding encoding)	Identique, provenant d'un magasin secret ou d'une entrée utilisateur.

PasswordKey stocke le mot de passe en interne sous la forme d'un SecureString (l'entreprise string copie les caractères d'entrée en un seul) et matérialise les octets de la clé de chiffrement juste à temps pour chaque opération. Les octets ne résident que sur le cadre de la pile de l'opération et ne sont jamais épinglés à l'instance PasswordKey ; les tampons intermédiaires sont mis à zéro après chaque majuscule.

PasswordKey est IDisposable: l'appel de Dispose() met à zéro le tampon protégé, et l'accès ultérieur à KeyBytes génère ObjectDisposedException. L'élimination est recommandée pour les workflows de longue durée.

RawKey

Une clé de chiffrement littérale de la longueur exacte requise de l'algorithme (par exemple, 32 octets pour AES-256). Utilisé avec le format de fil Raw . Aucun KDF n’est appliqué. RawKey est IDisposable: l'appel de Dispose() met à zéro les octets de clé conservés en place.

Factures	Objectif
RawKey.FromBytes(byte[] keyBytes)	Une clé déjà chargée en tant qu'octets.
RawKey.FromHex(string hex)	Une clé encodée en hexadécimal.
RawKey.FromBase64(string base64)	Une clé encodée en Base64.

La longueur de la clé n'est pas validée par les factures. Il est vérifié lorsque vous appelez la méthode de chiffrement ou de déchiffrement, et une longueur interdite pour l'algorithme choisi génère ArgumentException répertoriant les longueurs d'octets légales (par exemple, 16, 24 ou 32 pour AES). Créez la clé avec exactement la taille de clé requise par l'algorithme.

Les méthodes de hachage par clé acceptent l'un ou l'autre sous-type, car elles prennent CryptoKey directement et n'ont pas d'axe au format fil.

Options symétriques

SymmetricEncryptOptions et SymmetricDecryptOptions regroupent la clé, le format de fil de connexion et toutes les valeurs spécifiques au format (l'IU pour Raw, les itérations KDF pour Owasp2026 et OpenSslEnc). Créez-les via une machine de format. Le type-paramètre-clé de l'entreprise applique la paire clé-type et fil-format au moment de la compilation, de sorte qu'une valeur PasswordKey ne peut pas être transmise à Raw(...) et une RawKey ne peut pas être transmise à Classic(...).

Factures	Format	TypeClé	Remarques
SymmetricEncryptOptions.Classic(PasswordKey key, Encoding encoding = null)	Classic	PasswordKey	Par défaut. Format de fil figé à des fins de rétrocompatibilité.
SymmetricEncryptOptions.Owasp2026(PasswordKey key, int kdfIterations = 1_300_000, Encoding encoding = null)	Owasp2026	PasswordKey	Même mise en page que la version classique, avec PCompkD2-HMAC- SHA1 au nombre d'itérations recommandé par OWASP 2026.
SymmetricEncryptOptions.Raw(RawKey key, byte[] iv = null, Encoding encoding = null)	Raw	RawKey	Clé et IV fournis par l’appelant pour l’interopérabilité avec des tiers.
SymmetricEncryptOptions.OpenSslEnc(PasswordKey key, int kdfIterations = 600_000, Encoding encoding = null, AesKeySize aesKeySize = AesKeySize.Aes256)	OpenSslEnc	PasswordKey	openssl enc-compatible (extension Salted__ avec PCompilation aesKeySize sélectionne AES-128, -192 ou -256 pour correspondre au openssl enc -aes-N-cbc du pair.

Les factures SymmetricDecryptOptions prennent la même forme, sauf qu'il n'y a pas de IV du côté déchiffrement, car le IV est lu automatiquement à partir du flux de texte chiffré. Le paramètre facultatif encoding: définit l'encodage du texte sur les options (par défaut UTF-8) et n'est consulté que par EncryptText et DecryptText.

Un objet d'options construit est en lecture seule, mais inspectable: CryptoOptions expose les extracteurs Key, Format, KdfIterations et TextEncoding; SymmetricEncryptOptions expose en outre IV et AesKeySize; et SymmetricDecryptOptions expose AesKeySize.

IV et stratégie de veille

Toutes les méthodes de chiffrement symétriques sont non déterministes par défaut: un nouveau saut aléatoire de 8 octets (le cas échéant) et IV ou nonce sont générés à chaque appel et intégrés dans le flux de texte chiffré. Le chiffrement du même texte brut deux fois produit toujours un texte chiffré différent, et la méthode de déchiffrement correspondante reconstruit automatiquement le détail et le IV à partir du même flux.

• Les algorithmes de la famille CBC (AES, Rijndael, DES, TripleDES, RC2) utilisent le remplissage PKCS7, le mode CBC et un IV aléatoire.
• AESGCM est un chiffrement authentifié avec des données associées, avec une valeur nonce aléatoire 96 bits et une balise d'authentification 128 bits. Recommandé pour les nouveaux workflows.
• ChaCha20Poly1305 est une alternative AIEAD à AES-GCM.

Pour Raw, vous pouvez fournir un IV explicite via SymmetricEncryptOptions.Raw(key, iv). Transmettez null (la valeur par défaut) pour laisser le chiffrement en générer une.

Documents de la clé PGP

Les méthodes PGP prennent en charge des handles de clé fortement typés. Créez-les une fois et réutilisez-les entre les appels.

Factures	Objectif
PgpPublicKey.FromBytes(byte[] keyBytes)	Clé publique à partir d'octets en mémoire (masqués ASCII ou binaires).
PgpPublicKey.FromFilePath(string path)	Clé publique chargée à partir d'un fichier .asc ou .gpg .
PgpPrivateKey.FromBytes(byte[] keyBytes, string passphrase)	Clé privée et phrase de passe, liées l'une à l'autre.
PgpPrivateKey.FromBytes(byte[] keyBytes, SecureString passphrase)	Identique, avec une phrase de passe SecureString .
PgpPrivateKey.FromFilePath(string path, string passphrase)	Clé privée à partir d'un fichier.
PgpPrivateKey.FromFilePath(string path, SecureString passphrase)	Clé privée à partir d'un fichier, avec une phrase de passe SecureString .

Chaque gestion de clé expose également deux méthodes d'instance:

Membre	Objectif
byte[] ToBytes()	Renvoie une copie des octets de la clé tels qu'ils sont chargés: renforcée par ASCII si la clé a été créée à partir d'une entrée renforcée, binaire si chargée à partir du binaire. Les clés renvoyées par PgpGenerateKeys sont protégées par ASCII.
void Save(string filePath, bool overwrite = false)	Écrit la clé sur le disque. Génère InvalidOperationException si le fichier existe et que overwrite est false.

PgpKeyPair (renvoyé par PgpGenerateKeys, ou construit directement avec new PgpKeyPair(publicKey, privateKey)) contient une paire public/privé correspondante. Utilisez pair.PublicKey et pair.PrivateKey, ou déconstruisez avec var (pub, priv) = pair;. Maintenez avec pair.PublicKey.Save(path) et pair.PrivateKey.Save(path) lorsque vous avez besoin de fichiers sur le disque.

La transmission d’un PgpPrivateKey à une méthode de chiffrement implique la signature, et la transmission d’un PgpPublicKey à une méthode de déchiffrement implique la vérification de la signature. Les indicateurs bool sign ou bool verifySignature distincts ne sont pas utilisés.

PgpPrivateKey stocke sa phrase de passe en tant que SecureString pour la durée de vie de l'instance. Il est matérialisé sous la forme d'un string géré uniquement pendant la durée de chaque opération cryptographique, car la bibliothèque BeyondCastle sous-jacente nécessite un string simple. PgpPrivateKey est IDisposable: l'appel de Dispose() met à zéro le tampon protégé. PgpPublicKey ne contient aucun matériel secret et n’est pas IDisposable.

Relation avec les activités

L’API codée et les activités Cryptographie XAML s’exécutent sur le même cœur cryptographique de sorte qu’elles sont à une parité complète sur:

• Algorithme et algorithme de hachage par clé
• Formats de fils (Classic, Owasp2026, Raw, OpenSslEnc)
• IV, itérations KDF, taille de clé AES et options d’encodage
• Chaque opération PGP

Tout ce que vous pouvez calculer avec une activité, vous pouvez le calculer avec ce service. Les différences concernent la forme des entrées/sorties et le formulaire d’entrée de clé, et non la capacité.

L'API codée fait plus que les activités:

Capacité codée uniquement	Détail
Octets d'entrée/sortie à chaque opération	EncryptBytes / DecryptBytes, KeyedHashBytes, PgpEncryptBytes / PgpDecryptBytes, PgpSignBytes / PgpClearSignBytes, PgpVerifyBytes / PgpVerifyClearSignedBytes Aucune activité ne dispose d'un formulaire byte[] .
Clés byte[] brutes	RawKey.FromBytes(byte[]) pour le Raw symétrique et le hachage par clé. Les activités ne peuvent fournir que des clés brutes sous forme de chaînes hexadécimales ou Base64.
Élément de clé PGP en mémoire	PgpPublicKey.FromBytes et PgpPrivateKey.FromBytes vous permettent de fonctionner sans fichiers de clé sur disque. Les activités nécessitent des fichiers de clé.
Texte et octets - Signer/effacer/Vérifier	PgpSignText / PgpClearSignText, PgpVerifyText / PgpVerifyClearSignedText et leurs formulaires Octets. Les activités exposent uniquement la signature, l’effacement et la vérification basées sur des fichiers.
En mémoire PgpKeyPair	PgpGenerateKeys renvoie une paire de clés utilisable sans forcer la sortie du fichier.

Les activités font deux choses que l'API codée ne fait pas, aucune de ces capacités cryptographiques:

• La ressource UiPath gère (IResource / ILocalResource) en tant qu’entrées et sorties. L'API codée accepte les chemins d'accès aux fichiers string simples et byte[].
• Continuer En cas d'erreur, le comportement d'ingestion et de continuité. Dans un workflow codé, vous utilisez plutôt try/catch , car chaque méthode est générée en cas d'échec.

Remarque :

Les activités Texte divisent l'encodage de clé et l'encodage de texte brut en deux propriétés. Dans l'API codée, l'encodage du mot de passe est défini sur PasswordKey.FromPassword(..., encoding) et l'encodage du texte brut via le paramètre encoding: des options. Les deux axes restent contrôlés indépendamment.

Migration à partir de l'API codée précédente

L'interface API codée introduite dans la version précédente a été consolidée dans cette version. Les anciennes formes d'appel (séparer les surcharges de string / SecureString / byte[] avec un paramètre Encoding , plus une PgpGenerateKeys basée sur le chemin) sont remplacées par une seule forme basée sur des options par opération, de sorte que la clé L'appariement de types et fils-format est appliquée au moment de la compilation.

Il n'y a pas de [Obsolete] Shift: le code écrit sur l'API précédente doit être mis à jour pour être compilé sur ce package.

Avant	Après
EncryptBytes(input, algo, string key, Encoding enc)	EncryptBytes(input, algo, SymmetricEncryptOptions.Classic(PasswordKey.FromPassword(key, enc)))
EncryptBytes(input, algo, SecureString key, Encoding enc)	EncryptBytes(input, algo, SymmetricEncryptOptions.Classic(PasswordKey.FromPassword(key, enc)))
EncryptBytes(input, algo, byte[] keyBytes)	EncryptBytes(input, algo, SymmetricEncryptOptions.Raw(RawKey.FromBytes(keyBytes)))
EncryptText(input, algo, key, enc)	EncryptText(input, algo, SymmetricEncryptOptions.Classic(PasswordKey.FromPassword(key, enc), enc))
EncryptFile(in, out, algo, key, enc, overwrite)	EncryptFile(in, out, algo, SymmetricEncryptOptions.Classic(PasswordKey.FromPassword(key, enc)), overwrite)
DecryptBytes / DecryptText / DecryptFile	Même forme, avec SymmetricDecryptOptions.<Format>(...).
KeyedHashBytes(input, algo, string key, Encoding enc)	KeyedHashBytes(input, algo, PasswordKey.FromPassword(key, enc))
KeyedHashBytes(input, algo, byte[] keyBytes)	KeyedHashBytes(input, algo, RawKey.FromBytes(keyBytes))
KeyedHashText(input, algo, string key, Encoding enc)	KeyedHashText(input, algo, PasswordKey.FromPassword(key, enc), enc)
KeyedHashFile(inputPath, algo, string key, Encoding enc)	KeyedHashFile(inputPath, algo, PasswordKey.FromPassword(key, enc))
PgpGenerateKeys(publicKeyPath, privateKeyPath, userId, passphrase, keySize)	var pair = PgpGenerateKeys(userId, passphrase, keySize); pair.PublicKey.Save(publicKeyPath); pair.PrivateKey.Save(privateKeyPath);

Étant donné que chaque type de clé et d'options est nouveau, le code qui fait référence aux anciennes surcharges ne parvient pas à compiler plutôt que de récupérer silencieusement une surcharge différente. L'encodage de texte par défaut reste UTF-8, de sorte que le code qui s'appuie sur la valeur par défaut UTF-8 précédente ne nécessite aucun changement de comportement au-delà de la reformulation des options.

Chiffrement symétrique

byte[] EncryptBytes(byte[] input, EncryptionAlgorithm algorithm, SymmetricEncryptOptions options)

Chiffre les octets arbitraires. Le paramètre options porte le format de la clé et du fil de discussion. Renvoie le texte chiffré selon le format de fil choisi.

string EncryptText(string input, EncryptionAlgorithm algorithm, SymmetricEncryptOptions options)

Chiffre une chaîne et renvoie le résultat sous forme de texte chiffré en Base64. L'encodage du texte brut est lu à partir de options.TextEncoding, par défaut UTF-8.

void EncryptFile(string inputPath, string outputPath, EncryptionAlgorithm algorithm, SymmetricEncryptOptions options, bool overwrite = false)

Lit un fichier, le chiffre et écrit le résultat. Génère InvalidOperationException si outputPath existe et que overwrite est false.

Déchiffrement symétrique

byte[] DecryptBytes(byte[] input, EncryptionAlgorithm algorithm, SymmetricDecryptOptions options)

Décrypte le texte chiffré produit par EncryptBytes. options.Format doit correspondre au format utilisé au moment du chiffrement. Renvoie les octets en texte brut.

string DecryptText(string input, EncryptionAlgorithm algorithm, SymmetricDecryptOptions options)

Décrypte un texte chiffré en Base64 produit par EncryptText et renvoie le texte brut. L'encodage du texte brut est lu à partir de options.TextEncoding, doit correspondre à l'encodage utilisé au moment du chiffrement et sa valeur par défaut est UTF-8.

void DecryptFile(string inputPath, string outputPath, EncryptionAlgorithm algorithm, SymmetricDecryptOptions options, bool overwrite = false)

Lit un fichier chiffré et écrit le texte brut. Génère InvalidOperationException si outputPath existe et que overwrite est false.

Hachage des clés

Les méthodes de hachage par clé calculent un hachage HMAC (ou un hachage simple pour les algorithmes non HMAC) et renvoient le résultat sous la forme d'une chaîne hexadécimale en majuscules. L'opération est à sens unique et ne comporte pas d'inverse.

string KeyedHashBytes(byte[] input, KeyedHashAlgorithms algorithm, CryptoKey key)

string KeyedHashText(string input, KeyedHashAlgorithms algorithm, CryptoKey key, Encoding encoding = null)

string KeyedHashFile(string inputPath, KeyedHashAlgorithms algorithm, CryptoKey key)

Le paramètre facultatif encoding de KeyedHashText contrôle la façon dont la chaîne d'entrée est transcodée en octets avant le hachage, et sa valeur par défaut est UTF-8. KeyedHashBytes fonctionne sur les octets bruts, et KeyedHashFile hache le contenu du fichier octet par octet, donc ni n’a d’axe d’encodage.

Chiffrement PGP

Si un signer est fourni, la charge utile chiffrée est également signée avec cette clé privée.

byte[] PgpEncryptBytes(byte[] input, PgpPublicKey recipient, PgpPrivateKey signer = null)

string PgpEncryptText(string input, PgpPublicKey recipient, PgpPrivateKey signer = null)

void PgpEncryptFile(string inputPath, string outputPath, PgpPublicKey recipient, PgpPrivateKey signer = null, bool overwrite = false)

Décryptage PGP

Si une verifier est fournie, la signature intégrée est vérifiée lors du déchiffrement.

byte[] PgpDecryptBytes(byte[] input, PgpPrivateKey recipient, PgpPublicKey verifier = null)

string PgpDecryptText(string input, PgpPrivateKey recipient, PgpPublicKey verifier = null)

void PgpDecryptFile(string inputPath, string outputPath, PgpPrivateKey recipient, PgpPublicKey verifier = null, bool overwrite = false)

Signature PGP ( signature binaire)

Génère une charge utile signée en binaire. Vérifiez-le avec les méthodes PgpVerify* .

byte[] PgpSignBytes(byte[] input, PgpPrivateKey signer)

string PgpSignText(string input, PgpPrivateKey signer)

void PgpSignFile(string inputPath, string outputPath, PgpPrivateKey signer, bool overwrite = false)

Signature PGP en texte clair

Les signatures claires restent le contenu d’origine lisible par un humain avec la signature ajoutée. Vérifiez-les avec les méthodes PgpVerifyClearSigned* .

byte[] PgpClearSignBytes(byte[] input, PgpPrivateKey signer)

string PgpClearSignText(string input, PgpPrivateKey signer)

void PgpClearSignFile(string inputPath, string outputPath, PgpPrivateKey signer, bool overwrite = false)

Vérification PGP

Signatures binaires

Vérifiez les charges utiles produites par les méthodes PgpSign* (ou par PgpEncrypt* avec un signataire).

Method	Signature
Octets	bool PgpVerifyBytes(byte[] input, PgpPublicKey verifier)
Texte	bool PgpVerifyText(string input, PgpPublicKey verifier)
Fichier	bool PgpVerifyFile(string inputPath, PgpPublicKey verifier)

Renvoie true lorsque la signature est valide, et false dans le cas contraire.

Signatures en texte clair

Vérifiez les charges utiles produites par les PgpClearSign* méthodes.

Method	Signature
Octets	bool PgpVerifyClearSignedBytes(byte[] input, PgpPublicKey verifier)
Texte	bool PgpVerifyClearSignedText(string input, PgpPublicKey verifier)
Fichier	bool PgpVerifyClearSignedFile(string inputPath, PgpPublicKey verifier)

Clé publique bien formée

Confirme qu’une instance PgpPublicKey s’analyse comme une clé publique OpenPGP bien formée. Cela reflète le type de vérification Valider la clé publique de l'activité Vérifier PGP .

bool PgpVerifyPublicKey(PgpPublicKey key)

Renvoie true lorsque la clé est valide.

Génération de paires de clés PGP

Génère une paire de clés OpenPGP RSA en mémoire et renvoie les deux moitiés sous forme de PgpKeyPair correspondant. Persistez en appelant Save(path) sur chaque moitié.

PgpKeyPair PgpGenerateKeys(string userId, string passphrase, RsaKeySize keySize = RsaKeySize.Rsa4096)

PgpKeyPair PgpGenerateKeys(string userId, SecureString passphrase, RsaKeySize keySize = RsaKeySize.Rsa4096)

Paramètres :

• userId (string): l'ID d'utilisateur OpenPGP; généralement, une boîte aux lettres RFC 2822 telle que Alice Doe <[e-mail]>.
• passphrase : la phrase de passe qui protège la clé privée générée. Lié au fichier PgpPrivateKey renvoyé.
• keySize (RsaKeySize): la taille de la clé RSA. La valeur par défaut est Rsa4096. Rsa3072 et Rsa2048 sont acceptés pour l'interopérabilité avec les systèmes hérités.

Renvoie une PgpKeyPair exposant pair.PublicKey et pair.PrivateKey.

Enum référence

EncryptionAlgorithm

Utilisé par les méthodes de chiffrement et de déchiffrement symétriques.

Valeur (Value)	Remarques
AESGCM	AES-GCM avec une balise d’authentification 96 bits et 128 bits. AEAD. Recommandé pour les nouveaux workflows.
ChaCha20Poly1305	ChaCha20-Poly1305 AEDR. Non FIPS. Une alternative à AES-GCM.
AES	AES en mode CBC.
Rijndael	Rijndael en mode CBC. Obsolète et faible; éviter.
DES	DES en mode CBC. Obsolète et faible; éviter.
TripleDES	3DES en mode CBC. Obsolète et faible; éviter.
RC2	RC2 en mode CBC. Obsolète et faible; éviter.
PGP	Réservé. Utilisez plutôt les méthodes PgpEncrypt* et PgpDecrypt* dédiées.

SymmetricWireFormat

Utilisé par SymmetricEncryptOptions.Format et SymmetricDecryptOptions.Format.

Valeur (Value)	Remarques
Classic	Mise en page stable d'octets d'UiPath, PCompilation-HMAC- SHA1 à 10 000 itérations. Par défaut. Frozen à des fins de rétrocompatibilité.
Owasp2026	Mise en page classique avec le nombre d'itérations recommandé par OWASP (1 300 000). L'appelant peut le remplacer via kdfIterations.
Raw	IV ‖ ciphertext [‖ tag]. L’appelant fournit la clé littérale (et éventuellement l’IU). Pour l’interopérabilité avec des tiers.
OpenSslEnc	Salted__ ‖ salt(8) ‖ ciphertext [‖ tag], PComplete-HMAC- SHA256 à 600 000 itérations par défaut. Compatible avec openssl enc -pbkdf2.

KeyedHashAlgorithms

Utilisé par les méthodes de hachage par clé.

Valeur (Value)	Saisie de texte	Remarques
HMACSHA256	HMAC avec clé	Recommandé pour MAC et la vérification de l'intégrité.
HMACSHA384	HMAC avec clé
HMACSHA512	HMAC avec clé
SHA256	Hachage sans clé	La clé est ignorée; équivalent à un hachage SHA simple.
SHA384	Hachage sans clé	La clé est ignorée.
SHA512	Hachage sans clé	La clé est ignorée.
HMACSHA1	HMAC avec clé	Obsolète. SHA-1 est obsolète par NEST; préférez SHA256 ou une version supérieure.
HMACMD5	HMAC avec clé	Obsolète. AND 5 est interrompu; éviter pour toute utilisation sensible à la sécurité.
SHA1	Hachage sans clé	Obsolète. Les attaques par attaques sont documentées; ne pas utiliser.

RsaKeySize

Utilisé par PgpGenerateKeys.

Valeur (Value)	bits
Rsa2048	2048
Rsa3072	3072
Rsa4096	4096 (par défaut)

Modèles communs

Chiffrer et déchiffrer une chaîne avec AES-GCM (classique, par défaut)

[Workflow]
public void Execute()
{
    var key = PasswordKey.FromPassword("MySecretKey123!", Encoding.UTF8);

    var ciphertext = cryptography.EncryptText("Sensitive data", EncryptionAlgorithm.AESGCM, SymmetricEncryptOptions.Classic(key));
    Log($"Encrypted: {ciphertext}");

    var plaintext = cryptography.DecryptText(ciphertext, EncryptionAlgorithm.AESGCM, SymmetricDecryptOptions.Classic(key));
    Log($"Decrypted: {plaintext}");
}

Chiffrement avec une clé brute et IV fournie par l'appelant (interopérabilité tierce)

[Workflow]
public void Execute()
{
    // 32 bytes for AES-256
    byte[] rawKeyBytes = Convert.FromBase64String("your-base64-encoded-32-byte-key==");
    byte[] iv          = Convert.FromHexString("a3f1b2c4d5e6f70819a0b1c2d3e4f506");

    var key = RawKey.FromBytes(rawKeyBytes);

    byte[] cipher = cryptography.EncryptBytes(
        Encoding.UTF8.GetBytes("payload"),
        EncryptionAlgorithm.AESGCM,
        SymmetricEncryptOptions.Raw(key, iv));

    // Decrypt. The IV is read from the ciphertext stream prefix, so there is no need to pass it again.
    byte[] plain = cryptography.DecryptBytes(
        cipher,
        EncryptionAlgorithm.AESGCM,
        SymmetricDecryptOptions.Raw(key));
}

Décrypte un fichier produit par openssl enc

[Workflow]
public void Execute()
{
    // openssl enc -aes-256-cbc -pbkdf2 -iter 600000 -md sha256 -salt -k password -in plain.txt -out cipher.bin
    var key = PasswordKey.FromPassword("password", Encoding.UTF8);

    cryptography.DecryptFile(
        inputPath:  @"C:\Documents\cipher.bin",
        outputPath: @"C:\Documents\plain.txt",
        algorithm:  EncryptionAlgorithm.AES,
        options:    SymmetricDecryptOptions.OpenSslEnc(key),
        overwrite:  true);
}

Utiliser un nombre plus élevé d'itérations KDF (Owasp2026)

[Workflow]
public void Execute()
{
    var key = PasswordKey.FromPassword("MySecretKey", Encoding.UTF8);

    // Owasp2026(key) defaults to kdfIterations = 1_300_000 (the OWASP 2026 recommendation).
    var ciphertext = cryptography.EncryptBytes(
        Encoding.UTF8.GetBytes("payload"),
        EncryptionAlgorithm.AESGCM,
        SymmetricEncryptOptions.Owasp2026(key));

    // Decrypt must use the same iteration count. Owasp2026 does not store it in the wire format.
    byte[] plain = cryptography.DecryptBytes(
        ciphertext,
        EncryptionAlgorithm.AESGCM,
        SymmetricDecryptOptions.Owasp2026(key));
}

Calculer un HMAC- SHA256 pour la vérification de l’intégrité des données

[Workflow]
public void Execute()
{
    byte[] hmacKey = Convert.FromBase64String("your-base64-hmac-key==");
    var key = RawKey.FromBytes(hmacKey);

    // Keyed-hash methods take a CryptoKey directly. There is no options object, because there is no wire-format axis.
    var digest = cryptography.KeyedHashText("payload to verify", KeyedHashAlgorithms.HMACSHA256, key);
    Log($"HMAC-SHA256: {digest}");
}

Chiffrement et signature PGP, puis déchiffrement et vérification

[Workflow]
public void Execute()
{
    var recipientPublic = PgpPublicKey.FromFilePath(@"C:\Keys\recipient_public.asc");
    var senderPrivate   = PgpPrivateKey.FromFilePath(@"C:\Keys\sender_private.asc", "senderPassphrase");

    // Passing a signer to PgpEncrypt* implies sign-and-encrypt.
    byte[] encrypted = cryptography.PgpEncryptBytes(
        Encoding.UTF8.GetBytes("Signed and encrypted message"),
        recipientPublic,
        signer: senderPrivate);

    var recipientPrivate = PgpPrivateKey.FromFilePath(@"C:\Keys\recipient_private.asc", "recipientPassphrase");
    var senderPublic     = PgpPublicKey.FromFilePath(@"C:\Keys\sender_public.asc");

    // Passing a verifier to PgpDecrypt* implies verify-while-decrypting.
    byte[] decrypted = cryptography.PgpDecryptBytes(
        encrypted,
        recipientPrivate,
        verifier: senderPublic);

    Log(Encoding.UTF8.GetString(decrypted));
}

Générer une nouvelle paire de clés PGP

[Workflow]
public void Execute()
{
    PgpKeyPair pair = cryptography.PgpGenerateKeys(
        userId:     "Alice <[e-mail]>",
        passphrase: "StrongPassphrase!",
        keySize:    RsaKeySize.Rsa4096);

    pair.PublicKey.Save(@"C:\Keys\my_public.asc");
    pair.PrivateKey.Save(@"C:\Keys\my_private.asc");

    Log("Key pair generated.");
}

Valider une clé publique entrante avant de la stocker

[Workflow]
public void Execute()
{
    // Armored public key arriving as text from an HTTP response or config.
    string armoredPublicKey = LoadFromInbox();
    var candidate = PgpPublicKey.FromBytes(Encoding.UTF8.GetBytes(armoredPublicKey));

    if (!cryptography.PgpVerifyPublicKey(candidate))
    {
        throw new InvalidOperationException("Supplied content is not a valid OpenPGP public key.");
    }

    candidate.Save(@"C:\Keys\trusted_public.asc");
}