API de automatización codificadas de criptografía

API de automatización codificadas para el paquete de actividades de criptografía, que cubren el cifrado simétrico, el hash con clave y PGP.

UiPath.Cryptography.Activities

API de flujo de trabajo codificado para cifrado y descifrado simétrico, hash con clave y cifrado PGP, descifrado, firma, firma clara, verificación y generación de claves. Utiliza estas API al diseñar automatizaciones codificadas. Consulta Automatizaciones codificadas para obtener más información sobre las automatizaciones codificadas y cómo diseñarlas utilizando las API.

• Descriptor de acceso de servicio: cryptography (tipo ICryptographyService)
• Paquete requerido: "UiPath.Cryptography.Activities": "*" en las dependencias project.json .

Espacios de nombres importados automáticamente

Estos espacios de nombres están disponibles automáticamente en los flujos de trabajo codificados cuando se instala este paquete:

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

Descripción general del servicio

El servicio cryptography expone todas las operaciones como llamadas directas a métodos. No hay conexión, manipulador o ámbito para abrir. Se registra como singleton sin estado, por lo que el descriptor de acceso se comparte en todo el flujo de trabajo y sus métodos son seguros para llamar de forma simultánea. Llamar a métodos en el descriptor de acceso de servicio directamente:

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

Formularios de bytes, texto y archivo

Cada operación lógica expone tres formularios de entrada/salida. Elige el que coincida con los datos que ya tienes:

Formulario	Sufijo	Entrada → Salida	Cuándo usarlo
Bytes	(base)	byte[] → byte[]	Datos binarios o ya cargados.
Texto	...Text	string → string (Base64 o ASCII blindado)	Datos que llegan como texto (HTTP, configuración, entorno).
Archivo	...File	ruta del archivo → ruta del archivo	Datos que residen en el disco.

Material clave

Las operaciones simétricas y hash con clave toman el material clave como uno de dos subtipos CryptoKey concretos. La clase que elijas determina con qué formatos de conexión se puede utilizar la clave, y el sistema de tipos lo aplica en tiempo de compilación a través de las fábricas de formatos.

PasswordKey

Material de la contraseña que se ampliará con PBKDF2 en una clave de cifrado. Se utiliza con los formatos de conexión Classic, Owasp2026 y OpenSslEnc .

Fábrica	Propósito
PasswordKey.FromPassword(string password, Encoding encoding)	Contraseña o frase de contraseña como string.
PasswordKey.FromPassword(SecureString password, Encoding encoding)	Lo mismo, procedente de un almacén de secretos o de una entrada de usuario.

PasswordKey almacena la contraseña internamente como SecureString (la fábrica string copia los caracteres de entrada en uno) y materializa los bytes de clave de cifrado justo a tiempo en cada operación. Los bytes solo se encuentran en el marco de la pila de la operación y nunca se anclan a la instancia PasswordKey ; los búferes intermedios se ponen a cero después de cada materialización.

PasswordKey es IDisposable: llamar a Dispose() ansiosamente pone a cero el búfer protegido, y el acceso KeyBytes posterior arroja ObjectDisposedException. Se recomienda desechar para flujos de trabajo de larga duración.

RawKey

Una clave de cifrado literal de la longitud exacta requerida por el algoritmo (por ejemplo, 32 bytes para AES-256). Se utiliza con el formato de conexión Raw . No se aplica ningún KDF. RawKey es IDisposable: llamar a Dispose() pone a cero los bytes de clave retenidos en su lugar.

Fábrica	Propósito
RawKey.FromBytes(byte[] keyBytes)	Una clave ya cargada en bytes.
RawKey.FromHex(string hex)	Una clave codificada como hexadecimal.
RawKey.FromBase64(string base64)	Una clave codificada como Base64.

Las fábricas no validan la longitud de la clave. Se comprueba cuando llamas al método de cifrado o descifrado, y una longitud no válida para el algoritmo elegido arroja ArgumentException enumerando las longitudes de bytes legales (por ejemplo, 16, 24 o 32 para AES). Construye la clave con exactamente el tamaño de clave requerido por el algoritmo.

Los métodos hash con clave aceptan cualquier subtipo, porque toman CryptoKey directamente y no tienen eje de formato de conexión.

Opciones simétricas

SymmetricEncryptOptions y SymmetricDecryptOptions agrupan la clave, el formato de conexión y cualquier valor específico del formato (el IV para Raw, las iteraciones KDF para Owasp2026 y OpenSslEnc). Constrúyelos a través de una fábrica de formatos. El tipo de parámetro de clave de la fábrica aplica el emparejamiento de tipo de clave y formato de conexión en tiempo de compilación, por lo que no se puede pasar un PasswordKey a Raw(...) y un RawKey a Classic(...).

Fábrica	Formato	TipodeClave	Notas
SymmetricEncryptOptions.Classic(PasswordKey key, Encoding encoding = null)	Classic	PasswordKey	Predeterminado. Formato de conexión congelada para compatibilidad con versiones anteriores (PBKDF2-HMAC-SHA1 a 10 000 iteraciones).
SymmetricEncryptOptions.Owasp2026(PasswordKey key, int kdfIterations = 1_300_000, Encoding encoding = null)	Owasp2026	PasswordKey	Mismo diseño que Clásico, con PBKDF2-HMAC-SHA1 en el recuento de iteraciones recomendado de OWASP para 2026.
SymmetricEncryptOptions.Raw(RawKey key, byte[] iv = null, Encoding encoding = null)	Raw	RawKey	Clave y IV proporcionados por la persona que llama, para la interoperabilidad de terceros.
SymmetricEncryptOptions.OpenSslEnc(PasswordKey key, int kdfIterations = 600_000, Encoding encoding = null, AesKeySize aesKeySize = AesKeySize.Aes256)	OpenSslEnc	PasswordKey	openssl enc-compatible (Salted__ mágico con PBKDF2-HMAC-SHA256). aesKeySize selecciona AES-128, -192 o -256 para que coincida con el openssl enc -aes-N-cbc del par.

Las fábricas SymmetricDecryptOptions toman la misma forma, excepto que no hay IV en el lado de descifrado porque el IV se lee automáticamente desde el flujo de texto cifrado. El parámetro opcional encoding: establece la codificación del texto en las opciones (predeterminado en UTF-8) y solo es consultado por EncryptText y DecryptText.

Un objeto de opciones construido es de solo lectura pero introspectable: CryptoOptions expone los captadores Key, Format, KdfIterations y TextEncoding; SymmetricEncryptOptions expone además IV y AesKeySize; y SymmetricDecryptOptions expone AesKeySize.

Estrategia IV y sal

Todos los métodos de cifrado simétricos son no deterministas de forma predeterminada: se genera un nuevo salt aleatorio de 8 bytes (cuando corresponda) y un IV o nonce en cada llamada y se incrustan en el flujo de texto cifrado. Cifrar el mismo texto sin formato dos veces siempre produce un texto cifrado diferente, y el método de descifrado coincidente reconstruye el salt y el IV a partir del mismo flujo automáticamente.

• Los algoritmos de la familia CBC (AES, Rijndael, DES, TripleDES, RC2) utilizan relleno PKCS7, modo CBC y un IV aleatorio.
• AESGCM es cifrado autenticado con datos asociados (AEAD), con un nonce aleatorio de 96 bits y una etiqueta de autenticación de 128 bits. Recomendado para nuevos flujos de trabajo.
• ChaCha20Poly1305 es una alternativa AEAD a AES-GCM.

Para Raw, puedes proporcionar un IV explícito a SymmetricEncryptOptions.Raw(key, iv). Introduce null (el valor predeterminado de fábrica) para que el cifrado genere uno.

Material de clave PGP

Los métodos PGP toman identificadores de clave fuertemente tipados. Constrúyalos una vez y reutilícelos en todas las llamadas.

Fábrica	Propósito
PgpPublicKey.FromBytes(byte[] keyBytes)	Clave pública de bytes en memoria (ASCII blindado o binario).
PgpPublicKey.FromFilePath(string path)	Clave pública cargada desde un archivo .asc o .gpg .
PgpPrivateKey.FromBytes(byte[] keyBytes, string passphrase)	Clave privada y contraseña, vinculadas entre sí.
PgpPrivateKey.FromBytes(byte[] keyBytes, SecureString passphrase)	Lo mismo, con una contraseña SecureString .
PgpPrivateKey.FromFilePath(string path, string passphrase)	Clave privada de un archivo.
PgpPrivateKey.FromFilePath(string path, SecureString passphrase)	Clave privada de un archivo, con una contraseña SecureString .

Cada identificador de clave también expone dos métodos de instancia:

Miembro	Propósito
byte[] ToBytes()	Devuelve una copia de los bytes de la clave tal como están cargados: ASCII blindado si la clave se creó a partir de una entrada blindada, binario si se cargó desde binario. Las claves devueltas por PgpGenerateKeys están blindadas con ASCII.
void Save(string filePath, bool overwrite = false)	Escribe la clave en el disco. Lanza InvalidOperationException si el archivo existe y overwrite es false.

PgpKeyPair (devuelto por PgpGenerateKeys, o construido directamente con new PgpKeyPair(publicKey, privateKey)) contiene un par público/privado coincidente. Usa pair.PublicKey y pair.PrivateKey o deconstruye con var (pub, priv) = pair;. Persiste con pair.PublicKey.Save(path) y pair.PrivateKey.Save(path) cuando necesites archivos en el disco.

Pasar un PgpPrivateKey a un método de cifrado implica firmar, y pasar un PgpPublicKey a un método de descifrado implica la verificación de la firma. No se utilizan marcadores bool sign o bool verifySignature independientes.

PgpPrivateKey almacena su contraseña como SecureString durante la vida útil de la instancia. Se materializa en un string administrado solo durante la duración de cada operación criptográfica, porque la biblioteca subyacente de BouncyCastle requiere un string simple. PgpPrivateKey es IDisposable: llamar a Dispose() ansiosamente pone a cero el búfer protegido. PgpPublicKey no contiene material secreto y no es IDisposable.

Relación con las actividades

La API codificada y las actividades XAML de criptografía se ejecutan en el mismo núcleo criptográfico, por lo que tienen paridad completa en:

• Algoritmos y algoritmos hash con clave
• Formatos de conexión (Classic, Owasp2026, Raw, OpenSslEnc)
• IV, iteraciones de KDF, tamaño de clave AES y opciones de codificación
• Cada operación PGP

Cualquier cosa que puedas calcular con una actividad, puedes calcularla con este servicio. Las diferencias son sobre la forma de entrada/salida y la forma de entrada de clave, no sobre la capacidad.

La API codificada hace más que las actividades:

Capacidad solo codificada	Detalles
Bytes de entrada/salida en cada operación	EncryptBytes / DecryptBytes, KeyedHashBytes, PgpEncryptBytes / PgpDecryptBytes, PgpSignBytes / PgpClearSignBytes, PgpVerifyBytes / PgpVerifyClearSignedBytes. Ninguna actividad tiene un formulario byte[] .
Claves byte[] sin procesar	RawKey.FromBytes(byte[]) para simétrico Raw y hash con clave. Las actividades solo pueden proporcionar claves sin formato como cadenas hexadecimales o Base64.
Material de clave PGP en memoria	PgpPublicKey.FromBytes y PgpPrivateKey.FromBytes te permiten operar sin archivos clave en el disco. Las actividades requieren archivos clave.
Firmar/verificar/verificar texto y bytes	PgpSignText / PgpClearSignText, PgpVerifyText / PgpVerifyClearSignedText y sus formularios de Bytes. Las actividades exponen solo la firma basada en archivos, la firma clara y la verificación.
En memoria PgpKeyPair	PgpGenerateKeys devuelve un par de claves utilizables sin forzar la salida del archivo.

Las actividades hacen dos cosas que la API codificada no hace, ninguna de las cuales es una capacidad criptográfica:

• Los identificadores de recursos de UiPath (IResource / ILocalResource) como entradas y salidas. La API codificada toma rutas de archivo string simples y byte[].
• Comportamiento de tragar y continuar de Continuar en caso de error . En un flujo de trabajo codificado, utilizas ordinario try/catch en su lugar, porque cada método se produce en caso de fallo.

Nota:

Las actividades de Texto dividen la codificación de clave y la codificación de texto sin formato en dos propiedades. En la API codificada, la codificación de la contraseña se establece en PasswordKey.FromPassword(..., encoding) y la codificación de texto sin formato a través del parámetro de opciones encoding: . Ambos ejes siguen siendo controlables de forma independiente.

Migrar desde la API codificada anterior

La superficie de API codificada introducida en la versión anterior se ha consolidado en esta versión. Las antiguas formas de llamada (sobrecargas de clave string / SecureString / byte[] independientes con un parámetro Encoding , más una PgpGenerateKeys basada en la ruta) se reemplazan por una única forma basada en opciones por operación, por lo que la clave El emparejamiento de tipo y formato de conexión se aplica en tiempo de compilación.

No hay correcciones [Obsolete] : el código escrito en la API anterior debe actualizarse para compilar en este paquete.

Antes	Despué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	Misma forma, con 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);

Debido a que cada tipo de clave y opción es nuevo, el código que hace referencia a las sobrecargas antiguas no se compila en lugar de recoger silenciosamente una sobrecarga diferente. La codificación de texto predeterminada sigue siendo UTF-8, por lo que el código que se basaba en el valor predeterminado UTF-8 anterior no necesita cambios de comportamiento más allá de las opciones de refactorización.

Cifrado simétrico

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

Cifra bytes arbitrarios. El parámetro options lleva el formato de clave y conexión. Devuelve el texto cifrado según el formato de conexión elegido.

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

Cifra una cadena y devuelve el resultado como texto cifrado codificado en Base64. La codificación de texto sin formato se lee desde options.TextEncoding y el valor predeterminado es UTF-8.

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

Lee un archivo, lo cifra y escribe el resultado. Lanza InvalidOperationException si outputPath existe y overwrite es false.

Descifrado simétrico

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

Descifra el texto cifrado producido por EncryptBytes. options.Format debe coincidir con el formato utilizado en el momento del cifrado. Devuelve los bytes de texto sin formato.

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

Descifra un texto cifrado codificado en Base64 producido por EncryptText y devuelve el texto sin formato. La codificación de texto sin formato se lee desde options.TextEncoding, debe coincidir con la codificación utilizada en el momento del cifrado y el valor predeterminado es UTF-8.

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

Lee un archivo cifrado y escribe el texto sin formato. Lanza InvalidOperationException si outputPath existe y overwrite es false.

Hash con clave

Los métodos hash con clave calculan un HMAC (o un hash simple para algoritmos no HMAC) y devuelven el resultado como una cadena hexadecimal en mayúsculas. La operación es unidireccional y no tiene inversa.

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)

El parámetro opcional encoding en KeyedHashText controla cómo se transcodifica la cadena de entrada a bytes antes del hash, y el valor predeterminado es UTF-8. KeyedHashBytes opera en bytes sin procesar, y KeyedHashFile aplica hash al contenido del archivo byte por byte, por lo que ninguno tiene un eje de codificación.

Cifrado PGP

Si se proporciona un signer , la carga útil cifrada también se firma con esa clave privada.

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)

Descifrado PGP

Si se proporciona un verifier , la firma incrustada se verifica durante el descifrado.

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)

Firma PGP (firma binaria)

Produce una carga útil firmada de forma binaria. Verifícalo con los métodos PgpVerify* .

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

string PgpSignText(string input, PgpPrivateKey signer)

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

Firma clara de PGP

Las firmas claras mantienen el contenido original legible por humanos con la firma adjunta. Verifícalos con los métodos PgpVerifyClearSigned* .

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

string PgpClearSignText(string input, PgpPrivateKey signer)

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

Verificación PGP

Firmas binarias

Verifica las cargas útiles producidas por los métodos PgpSign* (o por PgpEncrypt* con un firmante).

Método	Firma
Bytes	bool PgpVerifyBytes(byte[] input, PgpPublicKey verifier)
Texto	bool PgpVerifyText(string input, PgpPublicKey verifier)
Archivo	bool PgpVerifyFile(string inputPath, PgpPublicKey verifier)

Devuelve true cuando la firma es válida y false en caso contrario.

Firmas claras

Verifica las cargas útiles producidas por los métodos PgpClearSign* .

Método	Firma
Bytes	bool PgpVerifyClearSignedBytes(byte[] input, PgpPublicKey verifier)
Texto	bool PgpVerifyClearSignedText(string input, PgpPublicKey verifier)
Archivo	bool PgpVerifyClearSignedFile(string inputPath, PgpPublicKey verifier)

Bien formada de clave pública

Confirma que una instancia PgpPublicKey se analiza como una clave pública OpenPGP bien formada. Esto refleja el tipo de verificación Validar clave pública de la actividad PGP Verify .

bool PgpVerifyPublicKey(PgpPublicKey key)

Devuelve true cuando la clave es válida.

Generación de pares de claves PGP

Genera un par de claves OpenPGP RSA en la memoria y devuelve ambas mitades como PgpKeyPair coincidentes. Persiste llamando Save(path) en cada mitad.

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

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

Parámetros:

• userId (string): el ID de usuario de OpenPGP; convencionalmente un buzón RFC 2822 como Alice Doe <[e-mail]>.
• passphrase : la contraseña que protege la clave privada generada. Vinculado al PgpPrivateKey devuelto.
• keySize (RsaKeySize): el tamaño de la clave RSA. El valor predeterminado es Rsa4096. Rsa3072 y Rsa2048 se aceptan para la interoperabilidad con sistemas heredados.

Devuelve un PgpKeyPair que expone pair.PublicKey y pair.PrivateKey.

Referencia de enumeración

EncryptionAlgorithm

Utilizado por los métodos de cifrado y descifrado simétricos.

Valor	Notas
AESGCM	AES-GCM con un nonce de 96 bits y una etiqueta de autenticación de 128 bits. AEAD. Recomendado para nuevos flujos de trabajo.
ChaCha20Poly1305	ChaCha20-Poly1305 AEAD. No FIPS. Una alternativa a AES-GCM.
AES	AES en modo CBC.
Rijndael	Rijndael en modo CBC. Obsoleto y débil; evitar.
DES	DES en modo CBC. Obsoleto y débil; evitar.
TripleDES	3DES en modo CBC. Obsoleto y débil; evitar.
RC2	RC2 en modo CBC. Obsoleto y débil; evitar.
PGP	Reservado. Utiliza los métodos dedicados PgpEncrypt* y PgpDecrypt* en su lugar.

SymmetricWireFormat

Utilizado por SymmetricEncryptOptions.Format y SymmetricDecryptOptions.Format.

Valor	Notas
Classic	Diseño estable en bytes de UiPath, PBKDF2-HMAC-SHA1 a 10 000 iteraciones. Predeterminado. Congelado para compatibilidad con versiones anteriores.
Owasp2026	Diseño clásico con el recuento de iteraciones recomendado por OWASP (1 300 000). La persona que llama puede anularlo a través de kdfIterations.
Raw	IV ‖ ciphertext [‖ tag]. La persona que llama proporciona la clave literal (y, opcionalmente, el IV). Para la interoperabilidad de terceros.
OpenSslEnc	Salted__ ‖ salt(8) ‖ ciphertext [‖ tag], PBKDF2-HMAC-SHA256 a 600 000 iteraciones de forma predeterminada. Compatible con openssl enc -pbkdf2.

KeyedHashAlgorithms

Utilizado por los métodos hash con clave.

Valor	Tipo	Notas
HMACSHA256	HMAC con clave	Recomendado para MAC y verificación de integridad.
HMACSHA384	HMAC con clave
HMACSHA512	HMAC con clave
SHA256	Hash no clave	La clave se ignora; equivalente a un hash SHA simple.
SHA384	Hash no clave	La clave se ignora.
SHA512	Hash no clave	La clave se ignora.
HMACSHA1	HMAC con clave	Obsoleto. SHA-1 está obsoleto por NIST; prefiere SHA256 o superior.
HMACMD5	HMAC con clave	Obsoleto. MD5 está roto; evitar para cualquier uso sensible a la seguridad.
SHA1	Hash no clave	Obsoleto. Se demuestran los ataques de colisión; no utilizar.

RsaKeySize

Utilizado por PgpGenerateKeys.

Valor	bits
Rsa2048	2048
Rsa3072	3072
Rsa4096	4096 (predeterminado)

Patrones comunes

Cifrar y descifrar una cadena con AES-GCM (clásico, el valor predeterminado)

[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}");
}

Cifrar con una clave sin procesar proporcionada por la persona que llama e IV (interoperabilidad de terceros)

[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));
}

Descifrar un archivo producido por 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);
}

Utilice un recuento de iteraciones de KDF más fuerte (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));
}

Calcular un HMAC-SHA256 para la verificación de la integridad de los datos

[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}");
}

Cifrar y firmar PGP, luego descifrar y verificar

[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));
}

Generar un nuevo par de claves 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.");
}

Validar una clave pública entrante antes de almacenarla

[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");
}