APIs de automação codificadas com criptografia

APIs de automação codificadas para o pacote de atividades de Criptografia, cobrindo criptografia simétrica, hash com chave e PGP.

UiPath.Cryptography.Activities

API de fluxo de trabalho codificada para criptografia e descriptografia simétrica, hash com chave e criptografia PGP, descriptografia, assinatura, assinatura sem criptografia, verificação e geração de chave. Use essas APIs ao projetar automações codificadas. Visite Automações codificadas para saber mais sobre automações codificadas e como projetá-las usando APIs.

• Acessador de serviço: cryptography (tipo ICryptographyService)
• Pacote obrigatório: "UiPath.Cryptography.Activities": "*" nas dependências project.json .

Namespaces importados automaticamente

Esses namespaces estão automaticamente disponíveis em fluxos de trabalho codificados quando esse pacote é instalado:

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

Visão geral do serviço

O serviço expõe cryptography as operações como chamadas de método diretas. Não há conexão, identificador ou escopo para abrir. Ele é registrado como um unificado sem estado, então o acessador é compartilhado no fluxo de trabalho e seus métodos são seguros para serem chamados simultaneamente. Chame métodos no acessador de serviço diretamente:

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

Bytes, Texto e Formulários de arquivo

Cada operação lógica expõe três formulários de entrada/saída. Escolha uma que corresponda aos dados que você já tem:

Formulário	Sufixo	Entrada → Saída	Quando usar
Bytes	(base)	byte[] → byte[]	Dados binários ou já carregados.
Texto	...Text	string → string (Base64 ou ASCII- Importado)	Dados que chegam como texto (HTTP, configuração, ambiente).
de transações	...File	caminho do arquivo → caminho do arquivo	Dados que residem no disco.

Material da chave

Operações simétricas e keyed-Hash aceitam o material da chave como um dos dois subtipos CryptoKey validação. A classe que você escolher determina em quais formatos de conexão a chave pode ser usada e o sistema de tipos impõe isso no tempo de compilação por meio de fábricas de formatos.

PasswordKey

Material de senha a ser esticado em RBKF2 em uma chave de cifra. Usado com os formatos de conexão Classic, Owasp2026 e OpenSslEnc .

Matriz	Finalidade
PasswordKey.FromPassword(string password, Encoding encoding)	Senha ou frase secreta como um string.
PasswordKey.FromPassword(SecureString password, Encoding encoding)	Mesmo, proveniente de um armazenamento secreto ou entrada do usuário.

PasswordKey a senha internamente como um SecureString (a fábrica de string copia os caracteres de entrada em um) e materializa os bytes da chave de cifra just-in-time em cada operação. Os bytes residem apenas no quadro de pilha da operação e nunca são fixados na instância PasswordKey ; os buffers intermediários são zerados após cada materialização.

PasswordKey é IDisposable: chamar Dispose() zera prontamente o buffer protegido e o acesso KeyBytes subsequente gera ObjectDisposedException. O descarte é recomendado para fluxos de trabalho de longa duração.

RawKey

Uma chave de cifra literal do comprimento necessário exato do algoritmo (por exemplo, 32 bytes para AES-256). Usado com o formato de conexão Raw . Nenhum KPF é aplicado. RawKey é IDisposable: chamar Dispose() zera os bytes de chave mantidos no local.

Matriz	Finalidade
RawKey.FromBytes(byte[] keyBytes)	Uma chave já carregada em bytes.
RawKey.FromHex(string hex)	Uma chave codificada como hexadecimal.
RawKey.FromBase64(string base64)	Uma chave codificada como Base64.

O tamanho da chave não é validado pelas fábricas. Ele é verificado quando você chama o método de criptografia ou descriptografia, e um comprimento inválido para o algoritmo escolhido gera ArgumentException listando os comprimentos de bytes legais (por exemplo, 16, 24 ou 32 para AES). Construa a chave com exatamente o tamanho de chave necessário do algoritmo.

Os métodos de hash com chave aceitam qualquer um dos subtipos, porque aceitam CryptoKey diretamente e não têm eixo com formato de conexão.

Opções simétricas

SymmetricEncryptOptions e SymmetricDecryptOptions agrupam a chave, o formato de conexão e quaisquer valores específicos do formato (o IV para Raw, as iterações KPD para Owasp2026 e OpenSslEnc). Construa-os por meio de uma fábrica de formatos. O tipo de parâmetro-chave da UiPath Assistant impõe o emparelhamento do tipo de chave e do formato do conector no tempo de compilação, portanto, um PasswordKey não pode ser passado para Raw(...) e um RawKey não pode ser passado para Classic(...).

Matriz	Format	TipoDeChave	Observações
SymmetricEncryptOptions.Classic(PasswordKey key, Encoding encoding = null)	Classic	PasswordKey	Padrão. Formato de conexão congelante para compatibilidade retroativa (SBKF2-HTAC-SHA1 em 10.000 iterações).
SymmetricEncryptOptions.Owasp2026(PasswordKey key, int kdfIterations = 1_300_000, Encoding encoding = null)	Owasp2026	PasswordKey	Mesmo layout que o Clássico, com RBKF2-HTAC-SHA1 na contagem de iterações recomendada do OWASP 2026.
SymmetricEncryptOptions.Raw(RawKey key, byte[] iv = null, Encoding encoding = null)	Raw	RawKey	Chave fornecida pelo chamador e IV, para interoperabilidade de terceiros.
SymmetricEncryptOptions.OpenSslEnc(PasswordKey key, int kdfIterations = 600_000, Encoding encoding = null, AesKeySize aesKeySize = AesKeySize.Aes256)	OpenSslEnc	PasswordKey	openssl enc-compatível (Salted__ com BBKF2-HTAC-SHA256). aesKeySize seleciona AES-128, -192 ou -256 para corresponder ao openssl enc -aes-N-cbc dos pares.

As famílias SymmetricDecryptOptions assumem a mesma forma, exceto que não há nenhum VM no lado de descriptografia porque o VM é lido automaticamente a partir do fluxo de texto cifrado. O parâmetro encoding: opcional define a codificação de texto nas opções (padrão para UTF-8) e é consultado apenas por EncryptText e DecryptText.

Um objeto de opções construído é somente leitura, mas introexplorável: CryptoOptions expõe os getters Key, Format, KdfIterations e TextEncoding; SymmetricEncryptOptions também expõe IV e AesKeySize; e SymmetricDecryptOptions expõe AesKeySize.

IV e estratégia de Sal

Todos os métodos de criptografia simétrica são não determinísticos por padrão: um novo sal aleatório de 8 bytes (quando aplicável) e IV ou nonce são gerados em cada chamada e incorporados no fluxo de texto cifrado. A criptografia do mesmo texto simples duas vezes sempre produz textos cifrados diferentes, e o método de descriptografia de correspondência reconstrui o sales e o VM do mesmo stream automaticamente.

• Algoritmos da família CBC (AES, Rijndael, DES, TripleDES, RC2) usam preenchimento PKCS7, modo CBC e um IV aleatório.
• é a Criptografia AESGCM com Dados Associados (AEAD), com um nonce aleatório de 96 bits e uma tag de autenticação de 128 bits. Recomendado para novos fluxos de trabalho.
• ChaCha20Poly1305 é uma alternativa AEAD ao AES-GCM.

Para Raw, você pode fornecer um IV explícito por meio de SymmetricEncryptOptions.Raw(key, iv). Passe null (o padrão de fábrica) para permitir que a cifra gere um.

Material da chave PGP

Os métodos PGP usam identificadores de chave com estrutura de dados rigorosa. Construa-os uma vez e reutilize-os em chamadas.

Matriz	Finalidade
PgpPublicKey.FromBytes(byte[] keyBytes)	Chave pública de bytes na memória (ASCII ou binária).
PgpPublicKey.FromFilePath(string path)	Chave pública carregada de um arquivo .asc ou .gpg .
PgpPrivateKey.FromBytes(byte[] keyBytes, string passphrase)	Chave privada e frase secreta, vinculadas.
PgpPrivateKey.FromBytes(byte[] keyBytes, SecureString passphrase)	O mesmo, com uma frase secreta SecureString .
PgpPrivateKey.FromFilePath(string path, string passphrase)	Chave privada de um arquivo.
PgpPrivateKey.FromFilePath(string path, SecureString passphrase)	Chave privada de um arquivo, com uma frase secreta SecureString .

Cada identificador de chave também expõe dois métodos de instância:

Membro	Finalidade
byte[] ToBytes()	Retorna uma cópia dos bytes da chave conforme carregado: ASCII com acesso se a chave tiver sido criada a partir de uma entrada chaveada, binário se carregado a partir de binário. As chaves retornadas por PgpGenerateKeys são protegidas por ASCII.
void Save(string filePath, bool overwrite = false)	Grava a chave no disco. Gera InvalidOperationException se o arquivo existir e overwrite for false.

PgpKeyPair (retornado por PgpGenerateKeys ou construído diretamente com new PgpKeyPair(publicKey, privateKey)) contém um par público/privado correspondente. Use pair.PublicKey e pair.PrivateKey ou desconstrua com var (pub, priv) = pair;. Persiste com pair.PublicKey.Save(path) e pair.PrivateKey.Save(path) quando você precisar de arquivos no disco.

Passar um PgpPrivateKey para um método de criptografia implica assinatura, e passar um PgpPublicKey para um método de descriptografia implica a verificação de assinatura. Os sinalizadores bool sign ou bool verifySignature separados não são usados.

PgpPrivateKey sua frase secreta como um SecureString para o tempo de vida da instância. Ele é materializado para um string gerenciado apenas para a duração de cada operação criptográfica, porque a biblioteca BoncyCastle subjacente requer um string simples. PgpPrivateKey é IDisposable: chamar Dispose() zera prontamente o buffer protegido. PgpPublicKey não tem nenhum material secreto e não é IDisposable.

Relacionamento com as atividades

A API codificada e as atividades Criptografia XAML são executadas no mesmo núcleo criptográfico, portanto, estão em paridade completa em:

• Algoritmos e algoritmos de hash com chave
• Formatos de conexão (Classic, Owasp2026, Raw, OpenSslEnc)
• IV, iterações KPD, tamanho da chave AES e opções de codificação
• Cada operação PGP

Qualquer coisa que você possa computar com uma atividade, você pode computar com este serviço. As diferenças são sobre o formato de entrada/saída e o formulário de entrada da chave, não sobre a capacidade.

A API codificada faz mais do que as atividades:

Recurso somente codificado	Detalhe
Entrada/saída de bytes em cada operação	EncryptBytes / DecryptBytes, KeyedHashBytes, PgpEncryptBytes / PgpDecryptBytes, PgpSignBytes / PgpClearSignBytes, PgpVerifyBytes / PgpVerifyClearSignedBytes. Nenhuma atividade tem um formulário byte[] .
Chaves byte[] brutas	RawKey.FromBytes(byte[]) para hash Raw e com chave. As atividades só podem fornecer chaves brutas como strings hexadecimais ou Base64.
Material da chave PGP na memória	PgpPublicKey.FromBytes e PgpPrivateKey.FromBytes que você opere sem arquivos de chave no disco. As atividades exigem arquivos de chave.
Text e Bytes assinam / Clear Sign / Verificam	PgpSignText / PgpClearSignText, PgpVerifyText / PgpVerifyClearSignedText e seus formulários de Bytes. As atividades expõem apenas Sign, ClearSign e Verify baseados em arquivos.
Na memória PgpKeyPair	PgpGenerateKeys retorna um par de chaves utilizável sem forçar a saída do arquivo.

As atividades fazem duas coisas que a API codificada não faz, nenhuma das quais é um recurso criptográfico:

• Identificadores de recursos da UiPath (IResource / ILocalResource) como entradas e saídas. A API codificada segue caminhos de arquivos string simples e byte[].
• Continuar com erro no comportamento de ingerir e continuar. Em um fluxo de trabalho codificado, você usa try/catch comuns, porque todo método gera falha.

Observação:

As atividades Text dividem a codificação de chave e a codificação de texto simples em duas propriedades. Na API codificada, a codificação de senha é definida em PasswordKey.FromPassword(..., encoding) e a codificação de texto simples por meio do parâmetro de opções encoding: . Ambos os eixos permanecem verificáveis de forma independente.

Migração da API codificada anteriormente

A superfície de API codificada introduzida na versão anterior foi consolidada nesta versão. As formas de chamada antigas (sobrecargas de teclas string / SecureString / byte[] separadas com um parâmetro Encoding , mais um PgpGenerateKeys baseado em caminho) são substituídas por um único formato baseado em opções por operação, então a chave O emparelhamento -type e wire-format é imposto no tempo de compilação.

Não há correções [Obsolete] : o código escrito na API anterior deve ser atualizado para compilar com este pacote.

Before	Depois
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	Mesma forma, com 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);

Como cada tipo de chave e opções é novo, o código que faz referência às sobrecargas antigas falha ao compilar em vez de detectar silenciosamente uma sobrecarga diferente. A codificação de texto padrão permanece UTF-8, portanto, o código que dependia do padrão UTF-8 anterior não precisa de alteração comportamental além da reformulação das opções.

Criptografia simétrica

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

Criptografa bytes arbitrários. O parâmetro options carrega o formato de chave e conexão. Retorna o texto cifrado pelo formato de conexão escolhido.

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

Criptografa uma string e retorna o resultado como texto cifrado codificado em Base64. A codificação de texto simples é lida a partir de options.TextEncoding, com padrão para UTF-8.

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

Lê um arquivo, o criptografa e grava o resultado. Gera InvalidOperationException se outputPath existir e overwrite for false.

Descriptografia simétrica

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

Descriptografa o texto criptografado produzido por EncryptBytes. options.Format deve corresponder ao formato usado no momento da criptografia. Retorna os bytes de texto simples.

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

Descriptografa um texto cifrado codificado em Base64 produzido por EncryptText e retorna o texto simples. A codificação de texto simples é lida a partir de options.TextEncoding, deve corresponder à codificação usada no momento da criptografia e tem como padrão UTF-8.

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

Lê um arquivo criptografado e grava o texto simples. Gera InvalidOperationException se outputPath existir e overwrite for false.

Hash com chave

Os métodos Keyed-Hash calculam um HMAC (ou um hash simples para algoritmos não HMAC) e retornam o resultado como uma string hexadecimal maiúscula. A operação é unidirecional e não tem 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)

O parâmetro opcional em encoding controla como a string de entrada é transcodificada para bytes antes KeyedHashText hash e assume como padrão UTF-8. KeyedHashBytes opera em bytes brutos e KeyedHashFile faz hash do conteúdo do arquivo byte a byte, portanto, nenhum dos dois tem um eixo de codificação.

Criptografia PGP

Se um signer for fornecido, a carga útil criptografada também será assinada com essa chave 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)

Descriptografia PGP

Se um verifier for fornecido, a assinatura incorporada será verificada durante a descriptografia.

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)

Assinatura PGP (assinatura binária)

Produz uma carga com assinatura em formato binário. Verifique-o com PgpVerify* métodos.

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

string PgpSignText(string input, PgpPrivateKey signer)

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

Assinatura sem criptografia de PGP

As assinaturas sem criptografia mantêm o conteúdo original legível por humanos com a assinatura anexada. Verifique-os com PgpVerifyClearSigned* métodos.

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

string PgpClearSignText(string input, PgpPrivateKey signer)

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

Verificação de PGP

Assinaturas binárias

Verifique as cargas produzidas pelos métodos PgpSign* (ou por PgpEncrypt* com um signatário).

Método	Assinatura
Bytes	bool PgpVerifyBytes(byte[] input, PgpPublicKey verifier)
Texto	bool PgpVerifyText(string input, PgpPublicKey verifier)
de transações	bool PgpVerifyFile(string inputPath, PgpPublicKey verifier)

Retorna true quando a assinatura é válida, e false caso contrário.

Assinaturas sem criptografia

Verifique as cargas produzidas pelos PgpClearSign* .

Método	Assinatura
Bytes	bool PgpVerifyClearSignedBytes(byte[] input, PgpPublicKey verifier)
Texto	bool PgpVerifyClearSignedText(string input, PgpPublicKey verifier)
de transações	bool PgpVerifyClearSignedFile(string inputPath, PgpPublicKey verifier)

Boa formatação da chave pública

Confirma que uma instância PgpPublicKey é analisada como uma chave pública OpenPGP bem formatada. Isso espelha o tipo de verificação Validate Public Key da atividade PGP Verify .

bool PgpVerifyPublicKey(PgpPublicKey key)

Retorna true quando a chave é válida.

Geração de pares de chaves PGP

Gera um par de chaves RSA OpenPGP na memória e retorna ambas as partes como um PgpKeyPair correspondente. Persiste chamando Save(path) em cada metade.

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

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

Parâmetros:

• userId (string) - O ID de usuário do OpenPGP; condicionalmente, uma caixa de correio RFC 2822, como Alice Doe <[e-mail]>.
• passphrase - A frase secreta que protege a chave privada gerada. Vinculado ao PgpPrivateKey retornado.
• keySize (RsaKeySize) - O tamanho da chave RSA. O padrão é Rsa4096. Rsa3072 e Rsa2048 são aceitos para interoperabilidade com sistemas legados.

Retorna um PgpKeyPair expondo pair.PublicKey e pair.PrivateKey.

Referência enumerada

EncryptionAlgorithm

Usado pelos métodos simétricos de criptografar e descriptografar.

Valor	Observações
AESGCM	AES-GCM com um nonce de 96 bits e uma tag de autenticação de 128 bits. AAD. Recomendado para novos fluxos de trabalho.
ChaCha20Poly1305	ChaCha20-Poly1305 AAD. Não FIPS. Uma alternativa ao AES-GCM.
AES	AES no modo CBC.
Rijndael	Rijndael no modo CBC. Obsoleto e fraco; evitar.
DES	DES no modo CBC. Obsoleto e fraco; evitar.
TripleDES	3DES no modo CBC. Obsoleto e fraco; evitar.
RC2	RC2 no modo CBC. Obsoleto e fraco; evitar.
PGP	Reservado. Use os métodos dedicados PgpEncrypt* e PgpDecrypt* em vez disso.

SymmetricWireFormat

Usado por SymmetricEncryptOptions.Format e SymmetricDecryptOptions.Format.

Valor	Observações
Classic	O layout estável de bytes da UiPath, RBKF2-HTAC-SHA1 em 10.000 iterações. Padrão. Convidado para compatibilidade com versões anteriores.
Owasp2026	Layout clássico com a contagem de iterações recomendada pelo OWASP (1.300.000). O chamador pode substituí-lo por meio kdfIterations.
Raw	IV ‖ ciphertext [‖ tag]. O chamador fornece a chave literal (e, opcionalmente, o VM). Para interoperabilidade de terceiros.
OpenSslEnc	Salted__ ‖ salt(8) ‖ ciphertext [‖ tag], RBKPD2-HTAC-SHA256 em 600.000 iterações por padrão. Compatível com openssl enc -pbkdf2.

KeyedHashAlgorithms

Usado pelos métodos keyed-Hash.

Valor	Tipo	Observações
HMACSHA256	HMAC com chave	Recomendado para verificação de MAC e integridade.
HMACSHA384	HMAC com chave
HMACSHA512	HMAC com chave
SHA256	Hash não chaveado	A chave é ignorada; equivalente a um hash SHA simples.
SHA384	Hash não chaveado	A chave é ignorada.
SHA512	Hash não chaveado	A chave é ignorada.
HMACSHA1	HMAC com chave	Obsoleto. SHA-1 está obsoleto pelo NIST; prefira SHA256 ou superior.
HMACMD5	HMAC com chave	Obsoleto. SDK5 está quebrado; evitar para qualquer uso confidencial.
SHA1	Hash não chaveado	Obsoleto. Os ataques de colagem são demonstrados; não use.

RsaKeySize

Usado por PgpGenerateKeys.

Valor	bits
Rsa2048	2048
Rsa3072	3072
Rsa4096	4096 (padrão)

Padrões comuns

Criptografe e descriptografe uma string com AES-GCM (Clássico, o padrão)

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

Criptografar com uma chave bruta fornecida pelo chamador e IV (interoperabilidade de terceiros)

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

Descriptografar um arquivo produzido 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);
}

Use uma contagem de iterações de KPD mais forte (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));
}

Calcule um HMAC-SHA256 para verificação de integridade de dados

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

O PGP criptografa e assina, depois descriptografa e verifica

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

Gere um novo par de chaves 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 uma chave pública de entrada antes de armazená-la

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