Kryptografie-codierte Automatisierungs-APIs

Codierte Automatisierungs-APIs für das Kryptographie-Aktivitätspaket, die symmetrische Verschlüsselung, Schlüssel-Hashing und PGP abdecken.

UiPath.Cryptography.Activities

Codierte Workflow-API für symmetrische Verschlüsselung und Entschlüsselung, Keyed Hashing und PGP-Verschlüsselung, Entschlüsselung, Signierung, Klarsignierung, Verifizierung und Schlüsselgenerierung. Verwenden Sie diese APIs, wenn Sie codierte Automatisierungen entwerfen. Unter Codierte Automatisierungen erfahren Sie mehr über codierte Automatisierungen und wie Sie sie mithilfe von APIs entwerfen.

• Dienstzugriff: cryptography (Typ ICryptographyService)
• Erforderliches Paket: "UiPath.Cryptography.Activities": "*" in den project.json -Abhängigkeiten.

Automatisch importierte Namensräume

Diese Namespaces sind automatisch in codierten Workflows verfügbar, wenn dieses Paket installiert wird:

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

Serviceübersicht

Der cryptography -Dienst stellt alle Vorgänge als direkte Methodenaufrufe bereit. Es ist keine Verbindung, kein Handle oder Scope zum Öffnen vorhanden. Sie wird als zustandslose Singleton registriert, sodass der Accessor für den gesamten Workflow gemeinsam genutzt wird und seine Methoden sicher gleichzeitig aufgerufen werden können. Aufrufmethoden für den Dienstzugriff direkt:

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

Byte-, Text- und Dateiformulare

Jede logische Operation macht drei Eingabe-/Ausgabeformulare verfügbar. Wählen Sie diejenige aus, die mit den Daten übereinstimmt, die Sie bereits haben:

Formular	Suffix	Eingabe → Ausgabe	Einsatzbereich
Bytes	(Basis)	byte[] → byte[]	Binäre oder bereits geladene Daten.
Text	...Text	string → string (Base64 oder ASCII-armored)	Daten, die als Text ankommen (HTTP, Konfiguration, Umgebung).
Datei	...File	Dateipfad → Dateipfad	Daten, die sich auf der Festplatte befinden.

Schlüsselelement

symmetrische Vorgänge und Keyed-Hash-Vorgänge verwenden das Schlüsselelement als einen von zwei konkreten CryptoKey -Untertypen. Die von Ihnen ausgewählte Klasse bestimmt, mit welchen Verbindungenformaten der Schlüssel verwendet werden kann, und das Typsystem erzwingt dies zur Kompilierungszeit über die Formatrichtlinien.

PasswordKey

Kennwortelement, das in einen Verschlüsselungsschlüssel PBKDF2-elastifiziert werden soll. Wird mit den Aderformaten Classic, Owasp2026 und OpenSslEnc verwendet.

Fabric	Zweck
PasswordKey.FromPassword(string password, Encoding encoding)	Kennwort oder Passphrase als string.
PasswordKey.FromPassword(SecureString password, Encoding encoding)	Dasselbe, aus einem geheimen Speicher oder einer Benutzereingabe.

PasswordKey speichert das Kennwort intern als SecureString (die string -Fabric kopiert die Eingabezeichen in eins) und formatiert die Verschlüsselungsschlüssel-Bytes Just-in-Time bei jedem Vorgang. Die Bytes befinden sich nur auf dem Stapelrahmen des Vorgangs und sind nie an die PasswordKey -Instanz angeheftet; Die Zwischenpuffer werden nach jeder Materialisierung auf Null gesetzt.

PasswordKey ist IDisposable: Durch Aufrufen von Dispose() wird der geschützte Puffer sofort auf Null gesetzt, und ein nachfolgender KeyBytes -Zugriff löst ObjectDisposedException aus. Das Verwerfen wird für langlebige Workflows empfohlen.

RawKey

Ein Literal-Verschlüsselungsschlüssel mit der genauen erforderlichen Länge des Algorithmus (z. B. 32 Byte für AES-256). Wird mit dem Verbindungenformat Raw verwendet. Es wird kein KDF angewendet. RawKey ist IDisposable: Durch Aufrufen von Dispose() werden die zurückgehaltenen Schlüsselbyte auf Null gesetzt.

Fabric	Zweck
RawKey.FromBytes(byte[] keyBytes)	Ein Schlüssel, der bereits als Byte geladen wurde.
RawKey.FromHex(string hex)	Ein als Hex codierter Schlüssel.
RawKey.FromBase64(string base64)	Ein Schlüssel, der als Base64 codiert ist.

Die Schlüssellänge wird von den Fabrics nicht validiert. Es wird aktiviert, wenn Sie die Verschlüsselungs- oder Entschlüsselungsmethode aufrufen, und eine unzulässige Länge für den ausgewählten Algorithmus löst ArgumentException mit den zulässigen Bytelängen aus (z. B. 16, 24 oder 32 für AES). Konfigurieren Sie den Schlüssel mit genau der für den Algorithmus erforderlichen Schlüsselgröße.

Keyed-Hash-Methoden akzeptieren beide Untertypen, da sie CryptoKey direkt nehmen und keine Wir-Format-Achse haben.

symmetrische Optionen

SymmetricEncryptOptions und SymmetricDecryptOptions bündeln den Schlüssel, das Webformat und alle formatspezifischen Werte (der IV für Raw die KDF-Iterationen für Owasp2026 und OpenSslEnc). Erstellen Sie sie über eine Format Fabric. Der Schlüssel-Parameter-Typ der Fabric erzwingt die Paarung von Schlüsselart und Wir-Format zur Kompilierungszeit, sodass ein PasswordKey nicht an Raw(...) und ein RawKey nicht an Classic(...) übergeben werden kann.

Fabric	Format	Tastentyp	Hinweise
SymmetricEncryptOptions.Classic(PasswordKey key, Encoding encoding = null)	Classic	PasswordKey	Standard. Gefiltertes Format für Rückkompatibilität (PBKDF2-HTAC-SHA1 bei 10.000 Iterationen).
SymmetricEncryptOptions.Owasp2026(PasswordKey key, int kdfIterations = 1_300_000, Encoding encoding = null)	Owasp2026	PasswordKey	Dasselbe Layout wie klassisch, mit PBKDF2-HTAC-SHA1 bei der empfohlenen Iterationsanzahl für 2026 von OWASP.
SymmetricEncryptOptions.Raw(RawKey key, byte[] iv = null, Encoding encoding = null)	Raw	RawKey	Vom Aufrufer bereitgestellter Schlüssel und IV für die Interoperabilität mit Drittanbietern.
SymmetricEncryptOptions.OpenSslEnc(PasswordKey key, int kdfIterations = 600_000, Encoding encoding = null, AesKeySize aesKeySize = AesKeySize.Aes256)	OpenSslEnc	PasswordKey	openssl enc-kompatibel (Salted__ Magie mit PBKDF2-HTAC-SHA256). aesKeySize wählt AES-128, -192 oder -256 entsprechend dem openssl enc -aes-N-cbc des Peer aus.

Die Faktoren haben die gleiche Form wie SymmetricDecryptOptions , mit der Ausnahme, dass auf der Entschlüsselungsseite kein InF vorhanden ist, da der IP automatisch aus dem Verschlüsselungstextstream gelesen wird. Der optionale encoding: Parameter legt die Textcodierung für die Optionen fest (Standardwert ist UTF-8) und wird nur von EncryptText und DecryptText verwendet.

Ein konstruiertes Optionsobjekt ist schreibgeschützt, aber nicht introbe Robot: CryptoOptions macht die Getter Key, Format, KdfIterations und TextEncoding verfügbar; SymmetricEncryptOptions macht zusätzlich IV und AesKeySize verfügbar; und SymmetricDecryptOptions macht AesKeySize verfügbar.

ID- und was-Strategie

Alle symmetrischen Verschlüsselungsmethoden sind standardmäßig nicht-deterministisch: Ein neues zufälliges 8-Byte-Salz (falls zutreffend) und ID oder Nonce werden bei jedem Aufruf generiert und in den Verschlüsselungstextstream eingebettet. Das zweimalige Verschlüsseln desselben Klartexts erzeugt immer unterschiedlichen Verschlüsselungstext, und die übereinstimmende Entschlüsselungsmethode rekonstruiert dasbereit und IV aus demselben Stream automatisch.

• Algorithmen der CBC-Familie (AES, Rijndael, DES, TripleDES, RC2) verwenden PKCS7-Abstand, CBC-Modus und eine zufällige IV.
• AESGCM ist eine authentifizierte Verschlüsselung mit zugehörigen Daten (AEAD) mit einer zufälligen 96-Bit-Nonce und einem 128-Bit-Authentifizierungs-Tag. Empfohlen für neue Workflows.
• ChaCha20Poly1305 ist eine AEAD-Alternative zu AES-GCM.

Für Raw können Sie eine explizite IV über SymmetricEncryptOptions.Raw(key, iv) angeben. Übergeben Sie null (Fabric Standard), damit die Verschlüsselung einen generiert.

PGP-Schlüsselteil

PGP-Methoden verwenden stark typisierte Schlüsselhandles. Erstellen Sie sie einmal und verwenden Sie sie für alle Aufrufe wieder.

Fabric	Zweck
PgpPublicKey.FromBytes(byte[] keyBytes)	Öffentlicher Schlüssel aus Bytes im Arbeitsspeicher (ASCII-armored oder binär).
PgpPublicKey.FromFilePath(string path)	Öffentlicher Schlüssel, der aus einer .asc oder .gpg -Datei geladen wurde.
PgpPrivateKey.FromBytes(byte[] keyBytes, string passphrase)	Privater Schlüssel und Passphrase, miteinander verbunden.
PgpPrivateKey.FromBytes(byte[] keyBytes, SecureString passphrase)	Dasselbe, mit einer SecureString -Passphrase.
PgpPrivateKey.FromFilePath(string path, string passphrase)	Privater Schlüssel aus einer Datei.
PgpPrivateKey.FromFilePath(string path, SecureString passphrase)	Privater Schlüssel aus einer Datei mit einer SecureString -Passphrase.

Jedes Schlüsselhandle macht auch zwei Instanzmethoden verfügbar:

Mitglied	Zweck
byte[] ToBytes()	Gibt eine Kopie der Schlüsselbytes zurück, wenn sie geladen wurde: ASCII-armored, wenn der Schlüssel aus der geschützen Eingabe erstellt wurde, binär, wenn er aus binär geladen wurde. Von PgpGenerateKeys zurückgegebene Schlüssel sind ASCII-armored.
void Save(string filePath, bool overwrite = false)	Schreibt den Schlüssel auf den Datenträger. Löst InvalidOperationException aus, wenn die Datei vorhanden ist und overwrite ist false.

PgpKeyPair (zurückgegeben von PgpGenerateKeys oder direkt mit new PgpKeyPair(publicKey, privateKey) erstellt) enthält ein abgeglichenes öffentliches/privates Paar. Verwenden Sie pair.PublicKey und pair.PrivateKey oder dekonstruieren Sie mit var (pub, priv) = pair;. Behalten Sie pair.PublicKey.Save(path) und pair.PrivateKey.Save(path) bei, wenn Sie Dateien auf dem Datenträger benötigen.

Das Übergeben eines PgpPrivateKey an eine Verschlüsselungsmethode impliziert eine Signatur und die Übergabe eines PgpPublicKey an eine Entschlüsselungsmethode impliziert eine Überprüfung der Signatur. Separate bool sign oder bool verifySignature -Flags werden nicht verwendet.

PgpPrivateKey speichert seine Passphrase als SecureString für die Lebensdauer der Instanz. Er wird nur für die Dauer jedes kryptografischen Vorgangs in einen verwalteten string Materialzustand, da die zugrunde liegende Automation Suite-Bibliothek ein einfaches string erfordert. PgpPrivateKey ist IDisposable: Durch Aufrufen von Dispose() wird der geschützte Puffer schnell auf Null gesetzt. PgpPublicKey enthält kein geheimes Material und ist nicht IDisposable.

Beziehung zu den Aktivitäten

Die codierte API und die Kryptographie-XAML-Aktivitäten werden auf demselben kryptografischen Kern ausgeführt, sodass sie auf folgende Weise vollständig parisch sind:

• Algorithmen und Keyed-Hash-Algorithmen
• Nachrichtenformate (Classic, Owasp2026, Raw, OpenSslEnc)
• IV, KDF-Iterationen, AES-Schlüsselgröße und Codierungsoptionen
• Jeder PGP-Vorgang

Alles, was Sie mit einer Aktivität berechnen können, können Sie mit diesem Dienst berechnen. Die Unterschiede bestehen in der Eingabe-/Ausgabe-Form und im Schlüssel-Eingabeformular, nicht in der Funktionalität.

Die codierte API führt mehr als die Aktivitäten aus:

Nur codierte Funktion	Detail
Byte-Eingabe/Ausgabe bei jedem Vorgang	EncryptBytes / DecryptBytes, KeyedHashBytes, PgpEncryptBytes / PgpDecryptBytes, PgpSignBytes / PgpClearSignBytes, PgpVerifyBytes / PgpVerifyClearSignedBytes. Keine Aktivität hat ein byte[] -Formular.
Unformatierte byte[] Schlüssel	RawKey.FromBytes(byte[]) für symmetrische Raw und Verschlüsselungs-Hash. Aktivitäten können Rohschlüssel nur als Hex- oder Base64-Strings bereitstellen.
PGP-Schlüssel innerhalb des Arbeitsspeichers	PgpPublicKey.FromBytes und PgpPrivateKey.FromBytes können Sie ohne Schlüsseldateien auf der Festplatte arbeiten. Die Aktivitäten erfordern Schlüsseldateien.
Text und Bytes signieren/löschen/verifizieren	PgpSignText / PgpClearSignText, PgpVerifyText / PgpVerifyClearSignedText und ihre Byte-Formulare. Die Aktivitäten machen nur dateibasierte Signierungen, Clearsigns und Verifizierungen verfügbar.
In Arbeitsspeicher PgpKeyPair	PgpGenerateKeys Gibt ein verwendbares Schlüsselpaar zurück, ohne die Dateiausgabe zu erzwingen.

Die Aktivitäten führen zwei Dinge aus, die die codierte API nicht ausführt, von denen keines eine kryptografische Funktion ist:

• UiPath-Ressourcen behandelt (IResource / ILocalResource) als Eingaben und Ausgaben. Die codierte API verwendet einfache string Dateipfade und byte[].
• Bei Fehler fortfahren. In einem codierten Workflow verwenden Sie stattdessen das normale try/catch , da jede Methode einen Fehler auslöst.

Hinweis:

Die Text-Aktivitäten teilen die Schlüsselcodierung und die Klartextcodierung in zwei Eigenschaften auf. In der codierten API wird die Kennwortcodierung auf PasswordKey.FromPassword(..., encoding) und die Nur-Text-Codierung durch den Optionsparameter encoding: festgelegt. Beide Achsen bleiben unabhängig steuerbar.

Migration von der vorherigen codierten API

Die in der vorherigen Version eingeführte codierte API-Oberfläche wurde in dieser Version konsolidiert. Die alten Aufrufstrukturen (separate string / SecureString / byte[] Schlüsselüberladungen mit einem Encoding Parameter sowie ein pfadbasiertes PgpGenerateKeys) werden durch eine einzelne Optionsbasierte Form pro Vorgang, also den Schlüssel, ersetzt Die Paarung für "-art" und "leiten" wird zur Kompilierungszeit erzwungen.

Es gibt keine [Obsolete] -Shikons: Code, der gegen die vorherige API geschrieben wurde, muss aktualisiert werden, um mit diesem Paket zu kompilieren.

Vor	Nach
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	Die gleiche Form mit 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);

Da jeder Schlüssel- und Optionstyp neu ist, kann Code, der auf die alten Überladungen verweist, nicht kompiliert werden, anstatt im Hintergrund eine andere Überladung aufzunehmen. Die standardmäßige Textcodierung bleibt UTF-8, sodass Code, der auf dem vorherigen UTF-8-Standard basiert, keine Verhaltensänderung über die Optionen Refactor hinaus erfordert.

symmetrische Verschlüsselung

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

Verschlüsselt beliebige Bytes. Der Parameter options hat das Schlüssel- und Nachrichtenformat. Gibt den Verschlüsselungstext für das ausgewählte Authentifizierungsformat zurück.

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

Verschlüsselt eine Zeichenfolge und gibt das Ergebnis als Base64-codierten Verschlüsselungstext zurück. Die Klartextcodierung wird von options.TextEncoding gelesen und standardmäßig ist UTF-8.

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

Liest eine Datei, verschlüsselt sie und schreibt das Ergebnis. Löst InvalidOperationException aus, wenn outputPath vorhanden ist und overwrite false ist.

Balancerte Entschlüsselung

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

Entschlüsselt den von EncryptBytes erzeugten Verschlüsselungstext. options.Format muss mit dem Format übereinstimmen, das zum Zeitpunkt der Verschlüsselung verwendet wird. Gibt die Klartext-Bytes zurück.

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

Entschlüsselt einen Base64-codierten Verschlüsselungstext, der von EncryptText erzeugt wurde, und gibt den Klartext zurück. Die Klartextcodierung wird von options.TextEncoding gelesen, muss mit der Codierung übereinstimmen, die zum Zeitpunkt der Verschlüsselung verwendet wird, und die Standardeinstellung ist UTF-8.

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

Liest eine verschlüsselte Datei und schreibt den Klartext. Löst InvalidOperationException aus, wenn outputPath vorhanden ist und overwrite false ist.

Schlüssel-Hashing

Keyed-Hash-Methoden berechnen einen HTAC (oder einen einfachen Hash für Nicht-HTML-Algorithmen) und geben das Ergebnis als Hex-Zeichenfolge in Großbuchstaben zurück. Der Vorgang ist unidirektional und hat keine Inversion.

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)

Der optionale Parameter encoding für KeyedHashText steuert, wie die Eingabezeichenfolge vor dem Hashing in Bytes transcodiert wird, und verwendet standardmäßig UTF-8. KeyedHashBytes arbeitet mit unformatierten Bytes und KeyedHashFile hashen die Dateiinhalte Byte für Byte, sodass keine von beiden eine Codierungsachse hat.

PGP-Verschlüsselung

Wenn ein signer angegeben wird, wird die verschlüsselte Nutzlast auch mit diesem privaten Schlüssel signiert.

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)

PGP-Entschlüsselung

Wenn eine verifier angegeben wird, wird die eingebettete Signatur während der Entschlüsselung überprüft.

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)

PGP-Signatur (binäre Signatur)

Erstellt eine binär signierte Nutzlast. Überprüfen Sie es mit den PgpVerify* -Methoden.

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

string PgpSignText(string input, PgpPrivateKey signer)

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

Klare PGP-Signatur

Klare Signaturen halten den ursprünglichen Inhalt für Menschen lesbar, wobei die Signatur angehängt wird. Überprüfen Sie sie mit den PgpVerifyClearSigned* -Methoden.

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

string PgpClearSignText(string input, PgpPrivateKey signer)

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

PGP-Verifizierung

Binäre Signaturen

Überprüfen Sie Nutzlasten, die von den PgpSign* -Methoden (oder von PgpEncrypt* mit einem Unterzeichner) erstellt wurden.

Method	Signatur
Bytes	bool PgpVerifyBytes(byte[] input, PgpPublicKey verifier)
Text	bool PgpVerifyText(string input, PgpPublicKey verifier)
Datei	bool PgpVerifyFile(string inputPath, PgpPublicKey verifier)

Gibt true zurück, wenn die Signatur gültig ist, andernfalls false .

Klare Signaturen

Überprüfen Sie die von den PgpClearSign* -Methoden erzeugten Nutzlasten.

Method	Signatur
Bytes	bool PgpVerifyClearSignedBytes(byte[] input, PgpPublicKey verifier)
Text	bool PgpVerifyClearSignedText(string input, PgpPublicKey verifier)
Datei	bool PgpVerifyClearSignedFile(string inputPath, PgpPublicKey verifier)

Gutformatierung des öffentlichen Schlüssels

Bestätigt, dass eine PgpPublicKey -Instanz als gut formatierter öffentlicher OpenPGP-Schlüssel geparst wird. Dies spiegelt den Verifizierungstyp Validieren des öffentlichen Schlüssels der Aktivität PGP Verify wider.

bool PgpVerifyPublicKey(PgpPublicKey key)

Gibt true zurück, wenn der Schlüssel gültig ist.

Generierung von PGP-Schlüsselpaaren

Generiert ein OpenPGP-RSA-Schlüsselpaar im Speicher und gibt beide Hälften als übereinstimmendes PgpKeyPair zurück. Behalten Sie bei, indem Sie Save(path) für jede Hälfte aufrufen.

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

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

Parameter:

• userId (string) – Die OpenPGP-Benutzer-ID; konventionell ein RFC 2822-Postfach wie Alice Doe <[e-mail]>.
• passphrase – Die Passphrase, die den generierten privaten Schlüssel schützt. An die zurückgegebene PgpPrivateKey gebunden.
• keySize (RsaKeySize) – Die Größe des RSA-Schlüssels. Die Standardeinstellung ist Rsa4096. Rsa3072 und Rsa2048 werden für die Interoperabilität mit Legacy-Systemen akzeptiert.

Gibt PgpKeyPair zurück, das pair.PublicKey und pair.PrivateKey verfügbar macht.

Aufzählungsreferenz

EncryptionAlgorithm

Wird von den symmetrischen Verschlüsselungs- und Entschlüsselungsmethoden verwendet.

Wert	Hinweise
AESGCM	AES-GCM mit einer 96-Bit-Nonce und einem 128-Bit-Authentifizierungs-Tag. AAAD. Empfohlen für neue Workflows.
ChaCha20Poly1305	finden Nicht-FIPS. Eine Alternative zu AES-GCM.
AES	AES im CBC-Modus.
Rijndael	Rijndael im CBC-Modus. Veraltet und schwach; vermeiden.
DES	DES im CBC-Modus. Veraltet und schwach; vermeiden.
TripleDES	3DES im CBC-Modus. Veraltet und schwach; vermeiden.
RC2	RC2 im CBC-Modus. Veraltet und schwach; vermeiden.
PGP	Reserviert. Verwenden Sie stattdessen die dedizierten Methoden PgpEncrypt* und PgpDecrypt* .

SymmetricWireFormat

Wird von SymmetricEncryptOptions.Format und SymmetricDecryptOptions.Format verwendet.

Wert	Hinweise
Classic	Das byte-stabile Layout von UiPath, PBKDF2-HTAC-SHA1, bei 10.000 Iterationen. Standard. Eingefroren für Rückkompatibilität.
Owasp2026	Klassisches Layout mit der von OWASP empfohlenen Iterationsanzahl (1.300.000). Der Aufrufer kann dies durch kdfIterations überschreiben.
Raw	IV ‖ ciphertext [‖ tag]. Der Aufrufer liefert den Literalschlüssel (und optional den IV). Für Interoperabilität mit Drittanbietern.
OpenSslEnc	Salted__ ‖ salt(8) ‖ ciphertext [‖ tag], PBKDF2-HTAC-SHA256 bei 600.000 Iterationen standardmäßig. Kompatibel mit openssl enc -pbkdf2.

KeyedHashAlgorithms

Wird von den Keyed-Hash-Methoden verwendet.

Wert	Typ	Hinweise
HMACSHA256	HTAC mit Schlüssel	Empfohlen für die Überprüfung von Compliance- und Integritätsanforderungen.
HMACSHA384	HTAC mit Schlüssel
HMACSHA512	HTAC mit Schlüssel
SHA256	Hash ohne Schlüssel	Der Schlüssel wird ignoriert; entspricht einem einfachen SHA-Hash.
SHA384	Hash ohne Schlüssel	Der Schlüssel wird ignoriert.
SHA512	Hash ohne Schlüssel	Der Schlüssel wird ignoriert.
HMACSHA1	HTAC mit Schlüssel	Veraltet SHA-1 wird von NIST veraltet; Bevorzugen Sie SHA256 oder höher.
HMACMD5	HTAC mit Schlüssel	Veraltet AMD5 ist kaputt; für jede sicherheitsrelevante Verwendung zu vermeiden.
SHA1	Hash ohne Schlüssel	Veraltet Konflikt jedoch werden demonstriert; Nicht verwenden.

RsaKeySize

Wird von PgpGenerateKeys verwendet.

Wert	Bits
Rsa2048	2048
Rsa3072	3072
Rsa4096	4096 (Standard)

Häufige Muster

Verschlüsseln und Entschlüsseln eines Strings mit AES-GCM (klassisch, Standard)

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

Mit einem vom Aufrufer bereitgestellten Rohschlüssel und IV (Interoperabilität von Drittanbietern) verschlüsseln

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

Entschlüsselt eine Datei, die von erstellt wurde 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);
}

Stärkere KDF-Iterationsanzahl verwenden (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));
}

Berechnen Sie einen HTAC-SHA256 für die Überprüfung der Datenintegrität

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

PGP verschlüsseln und signieren, dann entschlüsseln und überprüfen

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

Generieren Sie ein neues PGP-Schlüsselpaar

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

Validieren Sie einen eingehenden öffentlichen Schlüssel, bevor Sie ihn speichern

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