---
product: Chilkat
product_version: 11.7.0
language: c
language_label: C
class: Crypt2
license: bundle
deprecated: false
reference_html: https://www.chilkatsoft.com/refdoc/c_CkCrypt2Ref.html
---
# Chilkat Crypt2 — C — v11.7.0

> Chilkat 11.7.0 · language=c · class=Crypt2
> Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0/<lang>/classes/Crypt2.md`.
> Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/c/guide.md`.

## Purpose

**Encrypt, decrypt, hash, sign, verify, encode, and authenticate data.**

`Chilkat.Crypt2` is a broad cryptographic utility class for applications that need symmetric encryption, decryption, hashing, HMACs, key derivation, random data generation, one-time passwords, binary encoding, PKCS#7/CMS signatures, CAdES options, and certificate-based public-key encryption and decryption. It works with strings, files, byte data, `BinData`, and `StringBuilder` objects, making it useful for both small in-memory operations and file-based cryptographic workflows.

**Encryption and decryption**

Encrypt and decrypt strings, files, byte arrays, and Chilkat buffer objects using configurable algorithms, modes, keys, IVs, padding, and encodings.

**Hashes and HMACs**

Compute message digests and keyed message authentication codes for text, files, byte data, and in-memory buffers.

**PKCS#7 / CMS signatures**

Create and verify signed data, detached signatures, opaque signatures, and certificate-based signature formats used in many security workflows.

**CAdES support**

Use CAdES-related options when advanced CMS signature profiles are required for compliance or interoperability.

**Key and random utilities**

Derive keys, generate random bytes, create one-time passwords, and prepare keying material for cryptographic operations.

**Encoding and data conversion**

Encode and decode binary data using formats such as Base64, hex, URL encoding, and other supported binary encodings.

**Common pattern:** Choose the cryptographic operation, set the algorithm and related options, provide keys, certificates, passwords, IVs, or encoding settings as needed, then call the method matching the data form: string, file, bytes, `BinData`, or `StringBuilder`. Check `LastErrorText` when diagnosing algorithm, key, certificate, signature, or encoding issues.

For an extended overview, see [Crypt2 Class Overview](https://www.chilkatsoft.com/crypt2_class_overview.asp).

## Object creation, unlocking and error handling

**Create/Dispose**

```c
HCkCrypt2 instance = CkCrypt2_Create();
// ...
CkCrypt2_Dispose(instance);
```

`HCkCrypt2 CkCrypt2_Create(void);`

Creates an instance of the HCkCrypt2 object and returns a handle ("void \*" pointer). The handle is passed in the 1st argument for the functions listed on this page.

`void CkCrypt2_Dispose(HCkCrypt2 handle);`

Objects created by calling CkCrypt2_Create must be freed by calling this method. A memory leak occurs if a handle is not disposed by calling this function. Also, any handle returned by a Chilkat "C" function must also be freed by the application by calling the appropriate Dispose method, such as CkCrypt2_Dispose.

Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in C.

## Members common to every Chilkat class

Documented once per language in `common-members.md`; listed here so this page is self-contained.

| Property | Signature | Access | Meaning |
|---|---|---|---|
| `DebugLogFilePath` | `void CkCrypt2_getDebugLogFilePath(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putDebugLogFilePath(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_debugLogFilePath(HCkCrypt2 cHandle);` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. |
| `LastErrorHtml` | `void CkCrypt2_getLastErrorHtml(HCkCrypt2 cHandle, HCkString retval); const char *CkCrypt2_lastErrorHtml(HCkCrypt2 cHandle);` | read-only | Provides HTML-formatted information about the last called method or property. |
| `LastErrorText` | `void CkCrypt2_getLastErrorText(HCkCrypt2 cHandle, HCkString retval); const char *CkCrypt2_lastErrorText(HCkCrypt2 cHandle);` | read-only | Provides plain text information about the last called method or property. |
| `LastErrorXml` | `void CkCrypt2_getLastErrorXml(HCkCrypt2 cHandle, HCkString retval); const char *CkCrypt2_lastErrorXml(HCkCrypt2 cHandle);` | read-only | Provides XML-formatted information about the last called method or property. |
| `LastMethodSuccess` | `BOOL CkCrypt2_getLastMethodSuccess(HCkCrypt2 cHandle); void CkCrypt2_putLastMethodSuccess(HCkCrypt2 cHandle, BOOL newVal);` | read/write | Indicates the success or failure of the most recent method call: `TRUE` means success, `FALSE` means failure. |
| `Utf8` | `BOOL CkCrypt2_getUtf8(HCkCrypt2 cHandle); void CkCrypt2_putUtf8(HCkCrypt2 cHandle, BOOL newVal);` | read/write | When set to `TRUE`, all `const char *` arguments and return values are interpreted as UTF-8 strings. |
| `VerboseLogging` | `BOOL CkCrypt2_getVerboseLogging(HCkCrypt2 cHandle); void CkCrypt2_putVerboseLogging(HCkCrypt2 cHandle, BOOL newVal);` | read/write | If set to `TRUE`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. |
| `Version` | `void CkCrypt2_getVersion(HCkCrypt2 cHandle, HCkString retval); const char *CkCrypt2_version(HCkCrypt2 cHandle);` | read-only | Version of the component/library, such as "10.1.0" |

## Member index

| Member | Kind | Signature |
|---|---|---|
| `AbortCurrent` | property, read/write | `BOOL CkCrypt2_getAbortCurrent(HCkCrypt2 cHandle); void CkCrypt2_putAbortCurrent(HCkCrypt2 cHandle, BOOL newVal);` |
| `BCryptWorkFactor` | property, read/write | `int CkCrypt2_getBCryptWorkFactor(HCkCrypt2 cHandle); void CkCrypt2_putBCryptWorkFactor(HCkCrypt2 cHandle, int newVal);` |
| `BlockSize` | property, read-only | `int CkCrypt2_getBlockSize(HCkCrypt2 cHandle);` |
| `CadesEnabled` | property, read/write | `BOOL CkCrypt2_getCadesEnabled(HCkCrypt2 cHandle); void CkCrypt2_putCadesEnabled(HCkCrypt2 cHandle, BOOL newVal);` |
| `CadesSigPolicyHash` | property, read/write | `void CkCrypt2_getCadesSigPolicyHash(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putCadesSigPolicyHash(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_cadesSigPolicyHash(HCkCrypt2 cHandle);` |
| `CadesSigPolicyId` | property, read/write | `void CkCrypt2_getCadesSigPolicyId(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putCadesSigPolicyId(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_cadesSigPolicyId(HCkCrypt2 cHandle);` |
| `CadesSigPolicyUri` | property, read/write | `void CkCrypt2_getCadesSigPolicyUri(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putCadesSigPolicyUri(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_cadesSigPolicyUri(HCkCrypt2 cHandle);` |
| `Charset` | property, read/write | `void CkCrypt2_getCharset(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putCharset(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_charset(HCkCrypt2 cHandle);` |
| `CipherMode` | property, read/write | `void CkCrypt2_getCipherMode(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putCipherMode(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_cipherMode(HCkCrypt2 cHandle);` |
| `CmsOptions` | property, read/write | `void CkCrypt2_getCmsOptions(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putCmsOptions(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_cmsOptions(HCkCrypt2 cHandle);` |
| `CryptAlgorithm` | property, read/write | `void CkCrypt2_getCryptAlgorithm(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putCryptAlgorithm(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_cryptAlgorithm(HCkCrypt2 cHandle);` |
| `EncodingMode` | property, read/write | `void CkCrypt2_getEncodingMode(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putEncodingMode(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_encodingMode(HCkCrypt2 cHandle);` |
| `FirstChunk` | property, read/write | `BOOL CkCrypt2_getFirstChunk(HCkCrypt2 cHandle); void CkCrypt2_putFirstChunk(HCkCrypt2 cHandle, BOOL newVal);` |
| `HashAlgorithm` | property, read/write | `void CkCrypt2_getHashAlgorithm(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putHashAlgorithm(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_hashAlgorithm(HCkCrypt2 cHandle);` |
| `HavalRounds` | property, read/write | `int CkCrypt2_getHavalRounds(HCkCrypt2 cHandle); void CkCrypt2_putHavalRounds(HCkCrypt2 cHandle, int newVal);` |
| `HeartbeatMs` | property, read/write | `int CkCrypt2_getHeartbeatMs(HCkCrypt2 cHandle); void CkCrypt2_putHeartbeatMs(HCkCrypt2 cHandle, int newVal);` |
| `IncludeCertChain` | property, read/write | `BOOL CkCrypt2_getIncludeCertChain(HCkCrypt2 cHandle); void CkCrypt2_putIncludeCertChain(HCkCrypt2 cHandle, BOOL newVal);` |
| `InitialCount` | property, read/write | `int CkCrypt2_getInitialCount(HCkCrypt2 cHandle); void CkCrypt2_putInitialCount(HCkCrypt2 cHandle, int newVal);` |
| `IterationCount` | property, read/write | `int CkCrypt2_getIterationCount(HCkCrypt2 cHandle); void CkCrypt2_putIterationCount(HCkCrypt2 cHandle, int newVal);` |
| `KeyLength` | property, read/write | `int CkCrypt2_getKeyLength(HCkCrypt2 cHandle); void CkCrypt2_putKeyLength(HCkCrypt2 cHandle, int newVal);` |
| `LastChunk` | property, read/write | `BOOL CkCrypt2_getLastChunk(HCkCrypt2 cHandle); void CkCrypt2_putLastChunk(HCkCrypt2 cHandle, BOOL newVal);` |
| `MacAlgorithm` | property, read/write | `void CkCrypt2_getMacAlgorithm(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putMacAlgorithm(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_macAlgorithm(HCkCrypt2 cHandle);` |
| `NumSignerCerts` | property, read-only | `int CkCrypt2_getNumSignerCerts(HCkCrypt2 cHandle);` |
| `OaepHash` | property, read/write | `void CkCrypt2_getOaepHash(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putOaepHash(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_oaepHash(HCkCrypt2 cHandle);` |
| `OaepMgfHash` | property, read/write | `void CkCrypt2_getOaepMgfHash(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putOaepMgfHash(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_oaepMgfHash(HCkCrypt2 cHandle);` |
| `OaepPadding` | property, read/write | `BOOL CkCrypt2_getOaepPadding(HCkCrypt2 cHandle); void CkCrypt2_putOaepPadding(HCkCrypt2 cHandle, BOOL newVal);` |
| `PaddingScheme` | property, read/write | `int CkCrypt2_getPaddingScheme(HCkCrypt2 cHandle); void CkCrypt2_putPaddingScheme(HCkCrypt2 cHandle, int newVal);` |
| `PbesAlgorithm` | property, read/write | `void CkCrypt2_getPbesAlgorithm(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putPbesAlgorithm(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_pbesAlgorithm(HCkCrypt2 cHandle);` |
| `PbesPassword` | property, read/write | `void CkCrypt2_getPbesPassword(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putPbesPassword(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_pbesPassword(HCkCrypt2 cHandle);` |
| `Pkcs7CryptAlg` | property, read/write | `void CkCrypt2_getPkcs7CryptAlg(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putPkcs7CryptAlg(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_pkcs7CryptAlg(HCkCrypt2 cHandle);` |
| `Rc2EffectiveKeyLength` | property, read/write | `int CkCrypt2_getRc2EffectiveKeyLength(HCkCrypt2 cHandle); void CkCrypt2_putRc2EffectiveKeyLength(HCkCrypt2 cHandle, int newVal);` |
| `SigningAlg` | property, read/write | `void CkCrypt2_getSigningAlg(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putSigningAlg(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_signingAlg(HCkCrypt2 cHandle);` |
| `SigningAttributes` | property, read/write | `void CkCrypt2_getSigningAttributes(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putSigningAttributes(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_signingAttributes(HCkCrypt2 cHandle);` |
| `UncommonOptions` | property, read/write | `void CkCrypt2_getUncommonOptions(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putUncommonOptions(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_uncommonOptions(HCkCrypt2 cHandle);` |
| `UuFilename` | property, read/write | `void CkCrypt2_getUuFilename(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putUuFilename(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_uuFilename(HCkCrypt2 cHandle);` |
| `UuMode` | property, read/write | `void CkCrypt2_getUuMode(HCkCrypt2 cHandle, HCkString retval); void CkCrypt2_putUuMode(HCkCrypt2 cHandle, const char *newVal); const char *CkCrypt2_uuMode(HCkCrypt2 cHandle);` |
| `AddEncryptCert` | method | `void CkCrypt2_AddEncryptCert(HCkCrypt2 cHandle, HCkCert cert);` |
| `AddPfxSourceBd` | method | `BOOL CkCrypt2_AddPfxSourceBd(HCkCrypt2 cHandle, HCkBinData bd, const char *password);` |
| `AddPfxSourceFile` | method | `BOOL CkCrypt2_AddPfxSourceFile(HCkCrypt2 cHandle, const char *pfxFilePath, const char *pfxPassword);` |
| `AddSigningCert` | method | `BOOL CkCrypt2_AddSigningCert(HCkCrypt2 cHandle, HCkCert cert);` |
| `AesKeyUnwrap` | method | `BOOL CkCrypt2_AesKeyUnwrap(HCkCrypt2 cHandle, const char *kek, const char *wrappedKeyData, const char *encoding, HCkString outStr); const char *CkCrypt2_aesKeyUnwrap(HCkCrypt2 cHandle, const char *kek, const char *wrappedKeyData, const char *encoding);` |
| `AesKeyUnwrapWithPadding` | method | `BOOL CkCrypt2_AesKeyUnwrapWithPadding(HCkCrypt2 cHandle, const char *kek, const char *wrappedKeyData, const char *encoding, HCkString outStr); const char *CkCrypt2_aesKeyUnwrapWithPadding(HCkCrypt2 cHandle, const char *kek, const char *wrappedKeyData, const char *encoding);` |
| `AesKeyWrap` | method | `BOOL CkCrypt2_AesKeyWrap(HCkCrypt2 cHandle, const char *kek, const char *keyData, const char *encoding, HCkString outStr); const char *CkCrypt2_aesKeyWrap(HCkCrypt2 cHandle, const char *kek, const char *keyData, const char *encoding);` |
| `AesKeyWrapWithPadding` | method | `BOOL CkCrypt2_AesKeyWrapWithPadding(HCkCrypt2 cHandle, const char *kek, const char *keyData, const char *encoding, HCkString outStr); const char *CkCrypt2_aesKeyWrapWithPadding(HCkCrypt2 cHandle, const char *kek, const char *keyData, const char *encoding);` |
| `Argon2DeriveKey` | method | `BOOL CkCrypt2_Argon2DeriveKey(HCkCrypt2 cHandle, const char *password, const char *json, HCkBinData bdKey);` |
| `Argon2HashPassword` | method | `BOOL CkCrypt2_Argon2HashPassword(HCkCrypt2 cHandle, const char *password, const char *json, HCkString phcHash); const char *CkCrypt2_argon2HashPassword(HCkCrypt2 cHandle, const char *password, const char *json);` |
| `Argon2VerifyPassword` | method | `int CkCrypt2_Argon2VerifyPassword(HCkCrypt2 cHandle, const char *password, const char *json, const char *phcHash);` |
| `BCryptHash` | method | `BOOL CkCrypt2_BCryptHash(HCkCrypt2 cHandle, const char *password, HCkString outStr); const char *CkCrypt2_bCryptHash(HCkCrypt2 cHandle, const char *password);` |
| `BCryptVerify` | method | `BOOL CkCrypt2_BCryptVerify(HCkCrypt2 cHandle, const char *password, const char *bcryptHash);` |
| `CkDecryptFile` | method | `BOOL CkCrypt2_CkDecryptFile(HCkCrypt2 cHandle, const char *srcFile, const char *destFile);` |
| `CkEncryptFile` | method | `BOOL CkCrypt2_CkEncryptFile(HCkCrypt2 cHandle, const char *srcFile, const char *destFile);` |
| `ClearEncryptCerts` | method | `void CkCrypt2_ClearEncryptCerts(HCkCrypt2 cHandle);` |
| `ClearSigningCerts` | method | `void CkCrypt2_ClearSigningCerts(HCkCrypt2 cHandle);` |
| `CoSign` | method | `BOOL CkCrypt2_CoSign(HCkCrypt2 cHandle, HCkBinData bdIn, HCkCert cert, HCkBinData bdOut);` |
| `CrcBd` | method | `unsigned long CkCrypt2_CrcBd(HCkCrypt2 cHandle, const char *crcAlg, HCkBinData bd);` |
| `CrcFile` | method | `unsigned long CkCrypt2_CrcFile(HCkCrypt2 cHandle, const char *crcAlg, const char *path);` |
| `CreateP7M` | method | `BOOL CkCrypt2_CreateP7M(HCkCrypt2 cHandle, const char *inFilename, const char *p7mPath);` |
| `CreateP7S` | method | `BOOL CkCrypt2_CreateP7S(HCkCrypt2 cHandle, const char *inFilename, const char *p7sPath);` |
| `DecodeString` | method | `BOOL CkCrypt2_DecodeString(HCkCrypt2 cHandle, const char *inStr, const char *charset, const char *encoding, HCkString outStr); const char *CkCrypt2_decodeString(HCkCrypt2 cHandle, const char *inStr, const char *charset, const char *encoding);` |
| `DecryptBd` | method | `BOOL CkCrypt2_DecryptBd(HCkCrypt2 cHandle, HCkBinData bd);` |
| `DecryptEncoded` | method | `BOOL CkCrypt2_DecryptEncoded(HCkCrypt2 cHandle, const char *encodedEncryptedData, HCkString outStr); const char *CkCrypt2_decryptEncoded(HCkCrypt2 cHandle, const char *encodedEncryptedData);` |
| `DecryptSb` | method | `BOOL CkCrypt2_DecryptSb(HCkCrypt2 cHandle, HCkBinData bdIn, HCkStringBuilder sbOut);` |
| `DecryptSecureENC` | method | `BOOL CkCrypt2_DecryptSecureENC(HCkCrypt2 cHandle, const char *cipherText, HCkSecureString secureStr);` |
| `DecryptStringENC` | method | `BOOL CkCrypt2_DecryptStringENC(HCkCrypt2 cHandle, const char *str, HCkString outStr); const char *CkCrypt2_decryptStringENC(HCkCrypt2 cHandle, const char *str);` |
| `EncodeBytes` | method | `BOOL CkCrypt2_EncodeBytes(HCkCrypt2 cHandle, const unsigned char *pByteData, unsigned long szByteData, const char *encoding, HCkString outStr); const char *CkCrypt2_encodeBytes(HCkCrypt2 cHandle, const unsigned char *pByteData, unsigned long szByteData, const char *encoding);` |
| `EncodeInt` | method | `BOOL CkCrypt2_EncodeInt(HCkCrypt2 cHandle, int value, int numBytes, BOOL littleEndian, const char *encoding, HCkString outStr); const char *CkCrypt2_encodeInt(HCkCrypt2 cHandle, int value, int numBytes, BOOL littleEndian, const char *encoding);` |
| `EncodeString` | method | `BOOL CkCrypt2_EncodeString(HCkCrypt2 cHandle, const char *strToEncode, const char *charsetName, const char *toEncodingName, HCkString outStr); const char *CkCrypt2_encodeString(HCkCrypt2 cHandle, const char *strToEncode, const char *charsetName, const char *toEncodingName);` |
| `EncryptBd` | method | `BOOL CkCrypt2_EncryptBd(HCkCrypt2 cHandle, HCkBinData bd);` |
| `EncryptEncoded` | method | `BOOL CkCrypt2_EncryptEncoded(HCkCrypt2 cHandle, const char *str, HCkString outStr); const char *CkCrypt2_encryptEncoded(HCkCrypt2 cHandle, const char *str);` |
| `EncryptSb` | method | `BOOL CkCrypt2_EncryptSb(HCkCrypt2 cHandle, HCkStringBuilder sbIn, HCkBinData bdOut);` |
| `EncryptSecureENC` | method | `BOOL CkCrypt2_EncryptSecureENC(HCkCrypt2 cHandle, HCkSecureString secureStr, HCkString outStr); const char *CkCrypt2_encryptSecureENC(HCkCrypt2 cHandle, HCkSecureString secureStr);` |
| `EncryptStringENC` | method | `BOOL CkCrypt2_EncryptStringENC(HCkCrypt2 cHandle, const char *str, HCkString outStr); const char *CkCrypt2_encryptStringENC(HCkCrypt2 cHandle, const char *str);` |
| `GenerateUuid` | method | `BOOL CkCrypt2_GenerateUuid(HCkCrypt2 cHandle, HCkString outStr); const char *CkCrypt2_generateUuid(HCkCrypt2 cHandle);` |
| `GenRandomBytesENC` | method | `BOOL CkCrypt2_GenRandomBytesENC(HCkCrypt2 cHandle, int numBytes, HCkString outStr); const char *CkCrypt2_genRandomBytesENC(HCkCrypt2 cHandle, int numBytes);` |
| `GetEncodedAuthTag` | method | `BOOL CkCrypt2_GetEncodedAuthTag(HCkCrypt2 cHandle, const char *encoding, HCkString outStr); const char *CkCrypt2_getEncodedAuthTag(HCkCrypt2 cHandle, const char *encoding);` |
| `GetEncodedIV` | method | `BOOL CkCrypt2_GetEncodedIV(HCkCrypt2 cHandle, const char *encoding, HCkString outIV); const char *CkCrypt2_getEncodedIV(HCkCrypt2 cHandle, const char *encoding);` |
| `GetLastJsonData` | method | `void CkCrypt2_GetLastJsonData(HCkCrypt2 cHandle, HCkJsonObject json);` |
| `GetSignatureSigningTimeStr` | method | `BOOL CkCrypt2_GetSignatureSigningTimeStr(HCkCrypt2 cHandle, int index, HCkString outStr); const char *CkCrypt2_getSignatureSigningTimeStr(HCkCrypt2 cHandle, int index);` |
| `GetSignedAttributes` | method | `BOOL CkCrypt2_GetSignedAttributes(HCkCrypt2 cHandle, int signerIndex, HCkBinData pkcs7Der, HCkStringBuilder sbJson);` |
| `HashBdENC` | method | `BOOL CkCrypt2_HashBdENC(HCkCrypt2 cHandle, HCkBinData bd, HCkString outStr); const char *CkCrypt2_hashBdENC(HCkCrypt2 cHandle, HCkBinData bd);` |
| `HashBeginBytes2` | method | `BOOL CkCrypt2_HashBeginBytes2(HCkCrypt2 cHandle, const unsigned char *pByteData, unsigned long szByteData);` |
| `HashBeginString` | method | `BOOL CkCrypt2_HashBeginString(HCkCrypt2 cHandle, const char *strData);` |
| `HashChunkBd` | method | `BOOL CkCrypt2_HashChunkBd(HCkCrypt2 cHandle, BOOL firstChunk, HCkBinData bd);` |
| `HashFileENC` | method | `BOOL CkCrypt2_HashFileENC(HCkCrypt2 cHandle, const char *path, HCkString outStr); const char *CkCrypt2_hashFileENC(HCkCrypt2 cHandle, const char *path);` |
| `HashFinalENC` | method | `BOOL CkCrypt2_HashFinalENC(HCkCrypt2 cHandle, HCkString outStr); const char *CkCrypt2_hashFinalENC(HCkCrypt2 cHandle);` |
| `HashMoreBytes2` | method | `BOOL CkCrypt2_HashMoreBytes2(HCkCrypt2 cHandle, const unsigned char *pByteData, unsigned long szByteData);` |
| `HashMoreString` | method | `BOOL CkCrypt2_HashMoreString(HCkCrypt2 cHandle, const char *strData);` |
| `HashStringENC` | method | `BOOL CkCrypt2_HashStringENC(HCkCrypt2 cHandle, const char *str, HCkString outStr); const char *CkCrypt2_hashStringENC(HCkCrypt2 cHandle, const char *str);` |
| `HasSignatureSigningTime` | method | `BOOL CkCrypt2_HasSignatureSigningTime(HCkCrypt2 cHandle, int index);` |
| `Hotp` | method | `BOOL CkCrypt2_Hotp(HCkCrypt2 cHandle, const char *secret, const char *secretEnc, const char *counterHex, int numDigits, int truncOffset, const char *hashAlg, HCkString outStr); const char *CkCrypt2_hotp(HCkCrypt2 cHandle, const char *secret, const char *secretEnc, const char *counterHex, int numDigits, int truncOffset, const char *hashAlg);` |
| `LastDecryptCert` | method | `BOOL CkCrypt2_LastDecryptCert(HCkCrypt2 cHandle, HCkCert cert);` |
| `LastSignerCert` | method | `BOOL CkCrypt2_LastSignerCert(HCkCrypt2 cHandle, int index, HCkCert cert);` |
| `LoadTaskCaller` | method | `BOOL CkCrypt2_LoadTaskCaller(HCkCrypt2 cHandle, HCkTask task);` |
| `MacBdENC` | method | `BOOL CkCrypt2_MacBdENC(HCkCrypt2 cHandle, HCkBinData bd, HCkString outStr); const char *CkCrypt2_macBdENC(HCkCrypt2 cHandle, HCkBinData bd);` |
| `MacStringENC` | method | `BOOL CkCrypt2_MacStringENC(HCkCrypt2 cHandle, const char *inText, HCkString outStr); const char *CkCrypt2_macStringENC(HCkCrypt2 cHandle, const char *inText);` |
| `MySqlAesDecrypt` | method | `BOOL CkCrypt2_MySqlAesDecrypt(HCkCrypt2 cHandle, const char *strEncryptedHex, const char *strPassword, HCkString outStr); const char *CkCrypt2_mySqlAesDecrypt(HCkCrypt2 cHandle, const char *strEncryptedHex, const char *strPassword);` |
| `MySqlAesEncrypt` | method | `BOOL CkCrypt2_MySqlAesEncrypt(HCkCrypt2 cHandle, const char *strData, const char *strPassword, HCkString outStr); const char *CkCrypt2_mySqlAesEncrypt(HCkCrypt2 cHandle, const char *strData, const char *strPassword);` |
| `OpaqueSignBd` | method | `BOOL CkCrypt2_OpaqueSignBd(HCkCrypt2 cHandle, HCkBinData bd);` |
| `OpaqueSignStringENC` | method | `BOOL CkCrypt2_OpaqueSignStringENC(HCkCrypt2 cHandle, const char *str, HCkString outStr); const char *CkCrypt2_opaqueSignStringENC(HCkCrypt2 cHandle, const char *str);` |
| `OpaqueVerifyBd` | method | `BOOL CkCrypt2_OpaqueVerifyBd(HCkCrypt2 cHandle, HCkBinData bd);` |
| `OpaqueVerifyStringENC` | method | `BOOL CkCrypt2_OpaqueVerifyStringENC(HCkCrypt2 cHandle, const char *p7m, HCkString outOriginal); const char *CkCrypt2_opaqueVerifyStringENC(HCkCrypt2 cHandle, const char *p7m);` |
| `Pbkdf1` | method | `BOOL CkCrypt2_Pbkdf1(HCkCrypt2 cHandle, const char *password, const char *charset, const char *hashAlg, const char *salt, int iterationCount, int outputKeyBitLen, const char *encoding, HCkString outStr); const char *CkCrypt2_pbkdf1(HCkCrypt2 cHandle, const char *password, const char *charset, const char *hashAlg, const char *salt, int iterationCount, int outputKeyBitLen, const char *encoding);` |
| `Pbkdf2` | method | `BOOL CkCrypt2_Pbkdf2(HCkCrypt2 cHandle, const char *password, const char *charset, const char *hashAlg, const char *salt, int iterationCount, int outputKeyBitLen, const char *encoding, HCkString outStr); const char *CkCrypt2_pbkdf2(HCkCrypt2 cHandle, const char *password, const char *charset, const char *hashAlg, const char *salt, int iterationCount, int outputKeyBitLen, const char *encoding);` |
| `RandomizeIV` | method | `void CkCrypt2_RandomizeIV(HCkCrypt2 cHandle);` |
| `ReEncode` | method | `BOOL CkCrypt2_ReEncode(HCkCrypt2 cHandle, const char *encodedData, const char *fromEncoding, const char *toEncoding, HCkString outStr); const char *CkCrypt2_reEncode(HCkCrypt2 cHandle, const char *encodedData, const char *fromEncoding, const char *toEncoding);` |
| `SetDecryptCert` | method | `BOOL CkCrypt2_SetDecryptCert(HCkCrypt2 cHandle, HCkCert cert);` |
| `SetDecryptCert2` | method | `BOOL CkCrypt2_SetDecryptCert2(HCkCrypt2 cHandle, HCkCert cert, HCkPrivateKey key);` |
| `SetEncodedAad` | method | `BOOL CkCrypt2_SetEncodedAad(HCkCrypt2 cHandle, const char *aadStr, const char *encoding);` |
| `SetEncodedAuthTag` | method | `BOOL CkCrypt2_SetEncodedAuthTag(HCkCrypt2 cHandle, const char *authTagStr, const char *encoding);` |
| `SetEncodedIV` | method | `void CkCrypt2_SetEncodedIV(HCkCrypt2 cHandle, const char *ivStr, const char *encoding);` |
| `SetEncodedKey` | method | `void CkCrypt2_SetEncodedKey(HCkCrypt2 cHandle, const char *keyStr, const char *encoding);` |
| `SetEncodedSalt` | method | `void CkCrypt2_SetEncodedSalt(HCkCrypt2 cHandle, const char *saltStr, const char *encoding);` |
| `SetEncryptCert` | method | `BOOL CkCrypt2_SetEncryptCert(HCkCrypt2 cHandle, HCkCert cert);` |
| `SetIV` | method | `void CkCrypt2_SetIV(HCkCrypt2 cHandle, const unsigned char *pByteData, unsigned long szByteData);` |
| `SetMacKeyEncoded` | method | `BOOL CkCrypt2_SetMacKeyEncoded(HCkCrypt2 cHandle, const char *key, const char *encoding);` |
| `SetMacKeyString` | method | `BOOL CkCrypt2_SetMacKeyString(HCkCrypt2 cHandle, const char *key);` |
| `SetSecretKey` | method | `void CkCrypt2_SetSecretKey(HCkCrypt2 cHandle, const unsigned char *pByteData, unsigned long szByteData);` |
| `SetSigningCert` | method | `BOOL CkCrypt2_SetSigningCert(HCkCrypt2 cHandle, HCkCert cert);` |
| `SetSigningCert2` | method | `BOOL CkCrypt2_SetSigningCert2(HCkCrypt2 cHandle, HCkCert cert, HCkPrivateKey privateKey);` |
| `SetTsaHttpObj` | method | `void CkCrypt2_SetTsaHttpObj(HCkCrypt2 cHandle, HCkHttp http);` |
| `SetVerifyCert` | method | `BOOL CkCrypt2_SetVerifyCert(HCkCrypt2 cHandle, HCkCert cert);` |
| `SignBdENC` | method | `BOOL CkCrypt2_SignBdENC(HCkCrypt2 cHandle, HCkBinData dataToSign, HCkString outStr); const char *CkCrypt2_signBdENC(HCkCrypt2 cHandle, HCkBinData dataToSign);` |
| `SignHashENC` | method | `BOOL CkCrypt2_SignHashENC(HCkCrypt2 cHandle, const char *encodedHash, const char *hashAlg, const char *hashEncoding, HCkString outStr); const char *CkCrypt2_signHashENC(HCkCrypt2 cHandle, const char *encodedHash, const char *hashAlg, const char *hashEncoding);` |
| `SignSbENC` | method | `BOOL CkCrypt2_SignSbENC(HCkCrypt2 cHandle, HCkStringBuilder sb, HCkString outStr); const char *CkCrypt2_signSbENC(HCkCrypt2 cHandle, HCkStringBuilder sb);` |
| `SignStringENC` | method | `BOOL CkCrypt2_SignStringENC(HCkCrypt2 cHandle, const char *str, HCkString outStr); const char *CkCrypt2_signStringENC(HCkCrypt2 cHandle, const char *str);` |
| `Totp` | method | `BOOL CkCrypt2_Totp(HCkCrypt2 cHandle, const char *secret, const char *secretEnc, const char *t0, const char *tNow, int tStep, int numDigits, int truncOffset, const char *hashAlg, HCkString outStr); const char *CkCrypt2_totp(HCkCrypt2 cHandle, const char *secret, const char *secretEnc, const char *t0, const char *tNow, int tStep, int numDigits, int truncOffset, const char *hashAlg);` |
| `UseCertVault` | method | `BOOL CkCrypt2_UseCertVault(HCkCrypt2 cHandle, HCkXmlCertVault vault);` |
| `VerifyBdENC` | method | `BOOL CkCrypt2_VerifyBdENC(HCkCrypt2 cHandle, HCkBinData data, const char *encodedSig);` |
| `VerifyP7M` | method | `BOOL CkCrypt2_VerifyP7M(HCkCrypt2 cHandle, const char *p7mPath, const char *destPath);` |
| `VerifyP7S` | method | `BOOL CkCrypt2_VerifyP7S(HCkCrypt2 cHandle, const char *originalDataPath, const char *p7sPath);` |
| `VerifySbENC` | method | `BOOL CkCrypt2_VerifySbENC(HCkCrypt2 cHandle, HCkStringBuilder sb, const char *encodedSig);` |
| `VerifyStringENC` | method | `BOOL CkCrypt2_VerifyStringENC(HCkCrypt2 cHandle, const char *str, const char *encodedSig);` |
| `XtsSetDataUnitNumber` | method | `void CkCrypt2_XtsSetDataUnitNumber(HCkCrypt2 cHandle, unsigned long loUint32, unsigned long hiUint32);` |
| `XtsSetEncodedTweakKey` | method | `void CkCrypt2_XtsSetEncodedTweakKey(HCkCrypt2 cHandle, const char *key, const char *encoding);` |
| `XtsSetEncodedTweakValue` | method | `void CkCrypt2_XtsSetEncodedTweakValue(HCkCrypt2 cHandle, const char *tweak, const char *encoding);` |

Deprecated members are listed at the end of this file with their replacements; do not use them in new code.

## Properties

### Crypt2.AbortCurrent

`Chilkat 11.7.0 · c · Crypt2 · AbortCurrent · property · read/write · since 9.5.0.58`

```c
BOOL CkCrypt2_getAbortCurrent(HCkCrypt2 cHandle);
void CkCrypt2_putAbortCurrent(HCkCrypt2 cHandle, BOOL newVal);
```

Setting this property to `TRUE` will abort the current method, but only for those methods having an `Async` alternative. The property automatically resets to `FALSE` at the start of each method and after an abort. Both synchronous and asynchronous methods can be aborted; synchronous methods require setting this property from another thread.

### Crypt2.BCryptWorkFactor

`Chilkat 11.7.0 · c · Crypt2 · BCryptWorkFactor · property · read/write · since 9.5.0.65`

```c
int CkCrypt2_getBCryptWorkFactor(HCkCrypt2 cHandle);
void CkCrypt2_putBCryptWorkFactor(HCkCrypt2 cHandle, int newVal);
```

The BCrypt work factor determines the computational cost of `BCryptHash` and `BCryptVerify` . It represents the base-2 logarithm of the number of hashing rounds. For instance, a work factor of 12 corresponds to 2^12 hashing rounds. This cost factor is designed to make computations challenging enough to deter brute-force attacks. The work factor must be set between 4 and 31, inclusive, with a `default value of 10`.

### Crypt2.BlockSize

`Chilkat 11.7.0 · c · Crypt2 · BlockSize · property · read-only`

```c
int CkCrypt2_getBlockSize(HCkCrypt2 cHandle);
```

This property indicates the block size in bytes for the chosen encryption algorithm. For instance, if the `CryptAlgorithm` is set to `AES`, the BlockSize is automatically set to 16 bytes. In contrast, the block size for the `ChaCha20` streaming algorithm is 1 byte.

### Crypt2.CadesEnabled

`Chilkat 11.7.0 · c · Crypt2 · CadesEnabled · property · read/write`

```c
BOOL CkCrypt2_getCadesEnabled(HCkCrypt2 cHandle);
void CkCrypt2_putCadesEnabled(HCkCrypt2 cHandle, BOOL newVal);
```

**Full documentation for this property (same in every language):** [Explaining CAdES-BES Signatures](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/explaining_cades_bes.md)

This property applies to all `PKCS7` signature creation methods. When set to `TRUE`, it ensures the inclusion of required attributes (such as `content-type`, `message-digest`, and `signing-certificate-v2`) to qualify the signature as at least a `CAdES-BES` signature. By default, this property is set to `FALSE`.

### Crypt2.CadesSigPolicyHash

`Chilkat 11.7.0 · c · Crypt2 · CadesSigPolicyHash · property · read/write`

```c
void CkCrypt2_getCadesSigPolicyHash(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putCadesSigPolicyHash(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_cadesSigPolicyHash(HCkCrypt2 cHandle);
```

**Full documentation for this property (same in every language):** [CAdES Signature Policy - Meaning and Purpose](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/cades_signature_policy.md)

This property is for PKCS7 CMS signatures that wish to include CAdES `signature policy attributes`. Set it to the `base64`-encoded hash of the policy document at the `CadesSigPolicyUri` using either `SHA256` or `SHA1`.

See also:

- [Online Tool to Hash a Document at a URL](https://tools.chilkat.io/hashFileAtUrl.cshtml)

### Crypt2.CadesSigPolicyId

`Chilkat 11.7.0 · c · Crypt2 · CadesSigPolicyId · property · read/write`

```c
void CkCrypt2_getCadesSigPolicyId(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putCadesSigPolicyId(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_cadesSigPolicyId(HCkCrypt2 cHandle);
```

**Full documentation for this property (same in every language):** [CAdES Signature Policy - Meaning and Purpose](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/cades_signature_policy.md)

This property is for PKCS7 CMS signatures that wish to include CAdES `signature policy attributes`. The `CAdES Signature Policy ID` is an object identifier (`OID`) included in a CAdES signature that specifies the exact signature policy the signer followed. It is the OID associated with the policy URL. An example OID would look like this: `2.16.840.1.101.3.2.1.48.1`

An application that wishes to include signature policy attributes should set all three properties: `CadesSigPolicyHash` , `CadesSigPolicyUri` , and `CadesSigPolicyId` .

### Crypt2.CadesSigPolicyUri

`Chilkat 11.7.0 · c · Crypt2 · CadesSigPolicyUri · property · read/write`

```c
void CkCrypt2_getCadesSigPolicyUri(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putCadesSigPolicyUri(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_cadesSigPolicyUri(HCkCrypt2 cHandle);
```

**Full documentation for this property (same in every language):** [CAdES Signature Policy - Meaning and Purpose](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/cades_signature_policy.md)

This property is for PKCS7 CMS signatures that wish to include CAdES `signature policy attributes`. The `signature policy URI` in a `CAdES` digital signature is a link that points to a document describing the rules and conditions under which the signature was created. Typically the Signature Policy URI in a CAdES signature points to a `.der` file, not a PDF or human-readable document. For example: `http://example.com/policies/my-policy.der`

### Crypt2.Charset

`Chilkat 11.7.0 · c · Crypt2 · Charset · property · read/write`

```c
void CkCrypt2_getCharset(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putCharset(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_charset(HCkCrypt2 cHandle);
```

**Full documentation for this property (same in every language):** [Charset Matters when Encrypting Text](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/charset_matters_when_encrypting_text.md) · [Charset Matters when Hashing Text](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/hashing_text.md) · [Character Encodings (Charsets) Supported by Chilkat](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/charsets_supported_by_chilkat.md) · [ANSI Charset Explained](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/ansi_charset_explained.md)

This property specifies the character encoding used to represent text as bytes for encryption and hashing. By default, it uses the computer's `ANSI` charset, such as `Windows-1252` for locales like the United States, United Kingdom, Western Europe, Australia, and New Zealand.

Most applications are **advised to set this property** to `UTF-8`. Chilkat plans to change its default to UTF-8 in a future major version to align with current standards. The current default of ANSI stems from a time when UTF-8 was not widely adopted.

### Crypt2.CipherMode

`Chilkat 11.7.0 · c · Crypt2 · CipherMode · property · read/write`

```c
void CkCrypt2_getCipherMode(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putCipherMode(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_cipherMode(HCkCrypt2 cHandle);
```

**Full documentation for this property (same in every language):** [More About Block Encryption Cipher Modes](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/block_encryption_cipher_modes.md)

Sets the `cipher mode` for **block encryption algorithms** (AES, Blowfish,TwoFish, DES, 3DES, RC2). Possible values are `CBC` (the default) , `ECB`, `CTR`, `OFB`, `GCM`, and `CFB`. These acronyms have the following meanings:

- `CBC`: Cipher Block Chaining,
- `ECB`: Electronic CookBook
- `CTR`: Counter Mode
- `CFB`: Cipher Feedback
- `OFB`: Output Feedback
- `GCM`: Galois/Counter Mode
- `XTS`: AES-XTS (starting in Chilkat v9.5.0.91, only works with AES encryption)

The `GCM` (Galois/Counter Mode) is available with any cipher having a 16-byte block size, such as AES. The CFB, OFB, CTR, and GCM modes convert block ciphers into stream ciphers. In these modes of operation, the `PaddingScheme` property is unused because no padding occurs.

**Starting in v9.5.0.91** Chilkat supports `AES-XTS` mode. XTS mode additionally uses a tweak key and tweak value, which are set via the `XtsSetEncodedTweakKey`, `XtsSetEncodedTweakValue`, and `XtsSetDataUnitNumber`. (The latter two functions provide alternative means of setting the tweak value.) Chilkat fully supports AES-XTS mode with `ciphertext-stealing`, which means it will correctly encrypt/decrypt data with size not divisible by the block size (i.e. divisible by 16 bytes).

### Crypt2.CmsOptions

`Chilkat 11.7.0 · c · Crypt2 · CmsOptions · property · read/write · since 9.5.0.78`

```c
void CkCrypt2_getCmsOptions(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putCmsOptions(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_cmsOptions(HCkCrypt2 cHandle);
```

**Full documentation for this property (same in every language):** [Algorithm Identifier ASN.1 Structure](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/algorithm_identifier_asn1.md) · [CMS (PKCS7) signed-data Constructed Octets](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/cms_signed_data_constructed_octets.md) · [Egypt ITIDA CMS Signatures with JSON Canonicalization](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/egypt_itida_cms_signatures.md)

A JSON string to manage additional CMS (PKCS7) signature and validation options. Possible options are:

- boolean `OmitAlgorithmIdNull`: Set this JSON member to `true` to omit the explicit NULL within an AlgorithmIdentifier ASN.1 within the PKCS7. This should almost never be used, but helps for rare cases where a validator dislikes the explicit NULL being present.
- boolean `ValidateTimestampTokens`: Tells Chilkat to also validate the timestamp tokens when validating a signature that includes a timestamp.
- boolean `ConstructedOctets`: When set to `true`, tells Chilkat to use the `ASN.1 constructed octets` format for the data contained in the CMS (PKCS7) signed-data.
- boolean `CanonicalizeITIDA`: This applies to `Egypt ITIDA`, which requires signed documents in a CAdES-BES CMS format, using ITIDA’s JSON canonicalization (for JSON payloads), with only the Base64‑encoded signature attached - not the original data itself. When set to `true`, Chilkat will `automatically do the special ITIDA JSON canonicalization`.

### Crypt2.CryptAlgorithm

`Chilkat 11.7.0 · c · Crypt2 · CryptAlgorithm · property · read/write`

```c
void CkCrypt2_getCryptAlgorithm(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putCryptAlgorithm(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_cryptAlgorithm(HCkCrypt2 cHandle);
```

**Full documentation for this property (same in every language):** [Explaining PBES2 Encryption](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/explaining_pbes2_encryption.md)

Selects the encryption algorithm for encrypting and decrypting. Possible values are:

| Algorithm | Type | Symmetric? | Key Size(s) | Block/Stream | Mode of Operation | Notes |
| --- | --- | --- | --- | --- | --- | --- |
| `aes` | Block cipher | ✔ Yes | 128, 192, 256 bits | Block (128-bit) | CBC, CTR, GCM, etc. | Widely used, FIPS-approved |
| `pki` (Public-Key Encryption) | Asymmetric | ✗ No | 1024–4096+ bits | N/A | N/A | Used for key exchange, not bulk data |
| `chacha20` | Stream cipher | ✔ Yes | 256 bits | Stream | N/A | High speed, secure, designed for simplicity |
| `des` | Block cipher | ✔ Yes | 56 bits | Block (64-bit) | ECB, CBC, etc. | Deprecated, insecure |
| `3des` | Block cipher | ✔ Yes | 112 or 168 bits | Block (64-bit) | ECB, CBC, etc. | Legacy use, weak by modern standards |
| `rc2` | Block cipher | ✔ Yes | 40–128 bits (variable) | Block (64-bit) | ECB, CBC, etc. | Obsolete, variable strength |
| `blowfish2` (Blowfish) | Block cipher | ✔ Yes | 32–448 bits (variable) | Block (64-bit) | ECB, CBC, etc. | Fast, but 64-bit block size is a limitation |
| `twofish` | Block cipher | ✔ Yes | Up to 256 bits | Block (128-bit) | ECB, CBC, etc. | AES finalist, secure and flexible |
| `pbes1` | Key derivation | ✔ Yes | Based on underlying cipher | Block (varies) | PKCS#5 v1.5 | Obsolete, uses DES/RC2 |
| `pbes2` | Key derivation | ✔ Yes | Based on underlying cipher | Block (varies) | PKCS#5 v2.0 | Modern, supports AES, SHA, etc. |
| `arc4` (RC4) | Stream cipher | ✔ Yes | 40–2048 bits (variable) | Stream | N/A | Deprecated, insecure due to biases |

See also:

- [Explaining PCKS7/CMS Encryption vs RSA Encryption](https://cknotes.com/pkcs7-cms-encryption-vs-rsa-encryption/)

### Crypt2.EncodingMode

`Chilkat 11.7.0 · c · Crypt2 · EncodingMode · property · read/write`

```c
void CkCrypt2_getEncodingMode(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putEncodingMode(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_encodingMode(HCkCrypt2 cHandle);
```

**Full documentation for this property (same in every language):** [Binary Encodings Supported by Chilkat](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

The EncodingMode property specifies the `binary encoding` format (e.g., `base64`, `hex`, `base58`, `base64url`) used by functions ending in `"ENC"`, like `EncryptStringENC` and `DecryptStringENC`. For encryption functions, EncodingMode determines the encoding of the output. For decryption functions, it specifies the encoding of the input data.

A `list of supported binary encodings` is available at the link below.

The default value is `base64`

### Crypt2.FirstChunk

`Chilkat 11.7.0 · c · Crypt2 · FirstChunk · property · read/write`

```c
BOOL CkCrypt2_getFirstChunk(HCkCrypt2 cHandle);
void CkCrypt2_putFirstChunk(HCkCrypt2 cHandle, BOOL newVal);
```

Using the `FirstChunk` and `LastChunk` properties is the way to do streaming encryption or decryption with Chilkat.

By default, both FirstChunk and LastChunk are set to `TRUE`, indicating that the data passed to the encryption or decryption method is the full amount. To process data in multiple chunks, adjust these settings as follows:

1\. For the first chunk, set FirstChunk = `TRUE` and LastChunk = `FALSE`.  
2\. For intermediate chunks, set both FirstChunk = `FALSE` and LastChunk = `FALSE`.  
3\. For the final chunk, set FirstChunk = `FALSE` and LastChunk = `TRUE`.

You can feed data chunks of any size, regardless of the encryption algorithm's block size (e.g., 16 bytes for AES). Chilkat will handle buffering and, upon receiving the final chunk, pad the output to the appropriate block size according to the selected `PaddingScheme`.

### Crypt2.HashAlgorithm

`Chilkat 11.7.0 · c · Crypt2 · HashAlgorithm · property · read/write`

```c
void CkCrypt2_getHashAlgorithm(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putHashAlgorithm(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_hashAlgorithm(HCkCrypt2 cHandle);
```

Selects the hash algorithm used by methods that create hashes. The valid choices are `sha256`, `sha384`, `sha512`, `sha3-224`, `sha3-256`, `sha3-384`, `sha3-512`, `sha1`, `md2`, `md5`, `haval`, `ripemd128`, `ripemd160`,`ripemd256`, or `ripemd320`.

(Chilkat supports `SHA-2` because it includes the SHA-256, SHA-384, and SHA-512 hash functions.)

**The default value is `sha256`.**

Note: The HAVAL hash algorithm is affected by two other properties: `HavalRounds` and `KeyLength` .

- The HavalRounds may have values of 3, 4, or 5.
- For HAVAL hashing, the KeyLength can be 128, 160, 192, 224, or 256.

### Crypt2.HavalRounds

`Chilkat 11.7.0 · c · Crypt2 · HavalRounds · property · read/write`

```c
int CkCrypt2_getHavalRounds(HCkCrypt2 cHandle);
void CkCrypt2_putHavalRounds(HCkCrypt2 cHandle, int newVal);
```

Applies to the HAVAL hash algorithm only and must be set to the integer value 3, 4, or 5. The default value is 3.

### Crypt2.HeartbeatMs

`Chilkat 11.7.0 · c · Crypt2 · HeartbeatMs · property · read/write`

```c
int CkCrypt2_getHeartbeatMs(HCkCrypt2 cHandle);
void CkCrypt2_putHeartbeatMs(HCkCrypt2 cHandle, int newVal);
```

**Full documentation for this property (same in every language):** [Event Callback Examples](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/event_callback_examples.md)

The interval in milliseconds between each `AbortCheck` event callback, which enables an application to abort certain method calls before they complete. **By default, HeartbeatMs is set to** `0`**, meaning no AbortCheck event callbacks will trigger.** Methods with event callbacks include: `CkDecryptFile` , `CkEncryptFile` , `HashFile` , and `HashFileENC` .

### Crypt2.IncludeCertChain

`Chilkat 11.7.0 · c · Crypt2 · IncludeCertChain · property · read/write`

```c
BOOL CkCrypt2_getIncludeCertChain(HCkCrypt2 cHandle);
void CkCrypt2_putIncludeCertChain(HCkCrypt2 cHandle, BOOL newVal);
```

This applies only to creating digital signatures. By default (`TRUE`), any additional certificates in the authentication chain are included in the PKCS7 digital signature.

### Crypt2.InitialCount

`Chilkat 11.7.0 · c · Crypt2 · InitialCount · property · read/write · since 9.5.0.55`

```c
int CkCrypt2_getInitialCount(HCkCrypt2 cHandle);
void CkCrypt2_putInitialCount(HCkCrypt2 cHandle, int newVal);
```

The initial counter for the `ChaCha20` encryption algorithm, which has a default value of 0, is pre-agreed by both the encryptor and decryptor.

### Crypt2.IterationCount

`Chilkat 11.7.0 · c · Crypt2 · IterationCount · property · read/write`

```c
int CkCrypt2_getIterationCount(HCkCrypt2 cHandle);
void CkCrypt2_putIterationCount(HCkCrypt2 cHandle, int newVal);
```

The iteration count in password-based encryption (PBE) establishes the computational difficulty for encryption and decryption, thereby enhancing resistance to exhaustive search attacks. The default iteration count is `1024`, which is considered low, so it is recommended that applications increase this number when using `pbes2` encryption.

**PBES2 Iteration Count Recommendation**s

Aim for a **100–200 ms** derive time on your target hardware.

- Server/Desktop: `100000 – 1000000+`
- Mobile/Embedded: `50000 - 100000`

Benchmark annually and increase iterations as hardware improves.

### Crypt2.KeyLength

`Chilkat 11.7.0 · c · Crypt2 · KeyLength · property · read/write`

```c
int CkCrypt2_getKeyLength(HCkCrypt2 cHandle);
void CkCrypt2_putKeyLength(HCkCrypt2 cHandle, int newVal);
```

The key length `in bits` for symmetric encryption algorithms. The default value is `256`.

### Crypt2.LastChunk

`Chilkat 11.7.0 · c · Crypt2 · LastChunk · property · read/write`

```c
BOOL CkCrypt2_getLastChunk(HCkCrypt2 cHandle);
void CkCrypt2_putLastChunk(HCkCrypt2 cHandle, BOOL newVal);
```

See the documentation for the `FirstChunk` property.

### Crypt2.MacAlgorithm

`Chilkat 11.7.0 · c · Crypt2 · MacAlgorithm · property · read/write · since 9.5.0.55`

```c
void CkCrypt2_getMacAlgorithm(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putMacAlgorithm(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_macAlgorithm(HCkCrypt2 cHandle);
```

Selects the MAC algorithm to be used for any of the Mac methods, such as MacStringENC, MacBytes, etc. The default value is `hmac`. Possible values are `hmac` and `poly1305`.

### Crypt2.NumSignerCerts

`Chilkat 11.7.0 · c · Crypt2 · NumSignerCerts · property · read-only`

```c
int CkCrypt2_getNumSignerCerts(HCkCrypt2 cHandle);
```

This property is set upon verifying a digital signature and indicates the number of signer certificates. You can retrieve each signing certificate using the `LastSignerCert` method with an index ranging from `0` to `NumSignerCerts`-1.

### Crypt2.OaepHash

`Chilkat 11.7.0 · c · Crypt2 · OaepHash · property · read/write · since 9.5.0.67`

```c
void CkCrypt2_getOaepHash(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putOaepHash(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_oaepHash(HCkCrypt2 cHandle);
```

Selects the hash algorithm for use within OAEP padding when encrypting using `pki` with RSAES-OAEP. The valid choices are `sha1`, `sha256`, `sha384`, `sha512`,

The default value is `sha256`

### Crypt2.OaepMgfHash

`Chilkat 11.7.0 · c · Crypt2 · OaepMgfHash · property · read/write · since 9.5.0.71`

```c
void CkCrypt2_getOaepMgfHash(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putOaepMgfHash(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_oaepMgfHash(HCkCrypt2 cHandle);
```

Selects the MGF hash algorithm for use within OAEP padding when encrypting using `pki` with RSAES-OAEP. The valid choices are `sha1`, `sha256`, `sha384`, `sha512`, The default is `sha256`.

### Crypt2.OaepPadding

`Chilkat 11.7.0 · c · Crypt2 · OaepPadding · property · read/write · since 9.5.0.67`

```c
BOOL CkCrypt2_getOaepPadding(HCkCrypt2 cHandle);
void CkCrypt2_putOaepPadding(HCkCrypt2 cHandle, BOOL newVal);
```

Selects the RSA encryption scheme when encrypting using `pki` (with a certificate and private key). The default value is `FALSE`, which selects RSAES_PKCS1-V1_5. If set to `TRUE`, then RSAES_OAEP is used.

### Crypt2.PaddingScheme

`Chilkat 11.7.0 · c · Crypt2 · PaddingScheme · property · read/write`

```c
int CkCrypt2_getPaddingScheme(HCkCrypt2 cHandle);
void CkCrypt2_putPaddingScheme(HCkCrypt2 cHandle, int newVal);
```

**Full documentation for this property (same in every language):** [Debugging Symmetric Encryption such as AES](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/tweet_debug_symmetric_encryption_aes.md)

This property defines the padding scheme Chilkat uses for adding padding to input data during encryption and removing it during decryption. It is applicable only to symmetric block ciphers, such as AES, Blowfish, and Twofish, which require input sizes matching their exact block size. Padding ensures the last block is completely filled.

The possible values are:

0. **PKCS#5/PKCS#7 (RFC 1423)** `default`  
   *Each pad byte = number of padding bytes.*

   Block size: 8  
   Data: "HELLO" (5 bytes)  
   Padding: 0x03 0x03 0x03

1. **FIPS 81**  
   *Last byte = count; others = random.*

   Block size: 8  
   Data: "HELLO"  
   Padding: 0xA4 0x2F 0x9C 0x03

2. **Random**  
   *All pad bytes random; decryptor must know original length.*

   Block size: 8  
   Data: "HELLO"  
   Padding: 0x7D 0x20 0xCB 0x81

3. **Null (0x00)**  
   *Pad with zeros; no padding if already exact.*

   Block size: 8  
   Data: "HEL" (3 bytes)  
   Padding: 0x00 0x00 0x00 0x00 0x00

4. **Space (0x20)**  
   *Pad with spaces; no padding if already exact.*

   Block size: 8  
   Data: "HEL" (3 bytes)  
   Padding: 0x20 0x20 0x20 0x20 0x20

### Crypt2.PbesAlgorithm

`Chilkat 11.7.0 · c · Crypt2 · PbesAlgorithm · property · read/write`

```c
void CkCrypt2_getPbesAlgorithm(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putPbesAlgorithm(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_pbesAlgorithm(HCkCrypt2 cHandle);
```

If the `CryptAlgorithm` property is set to `pbes1` or `pbes2`, this property defines the symmetric encryption algorithm to be used for password-based encryption (PBE). The default is `"des"`. Applications should set this property equal to `"aes"`.

### Crypt2.PbesPassword

`Chilkat 11.7.0 · c · Crypt2 · PbesPassword · property · read/write`

```c
void CkCrypt2_getPbesPassword(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putPbesPassword(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_pbesPassword(HCkCrypt2 cHandle);
```

The password to be used when the `CryptAlgorithm` is `"pbes1"` or `"pbes2"`.

### Crypt2.Pkcs7CryptAlg

`Chilkat 11.7.0 · c · Crypt2 · Pkcs7CryptAlg · property · read/write`

```c
void CkCrypt2_getPkcs7CryptAlg(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putPkcs7CryptAlg(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_pkcs7CryptAlg(HCkCrypt2 cHandle);
```

This property determines the underlying symmetric encryption algorithm when the `CryptAlgorithm` property is set to `pki` for selecting PKCS7 public-key encryption.

The default is `aes`.

### Crypt2.Rc2EffectiveKeyLength

`Chilkat 11.7.0 · c · Crypt2 · Rc2EffectiveKeyLength · property · read/write`

```c
int CkCrypt2_getRc2EffectiveKeyLength(HCkCrypt2 cHandle);
void CkCrypt2_putRc2EffectiveKeyLength(HCkCrypt2 cHandle, int newVal);
```

The effective key length (in bits) for the `RC2` encryption algorithm. When using RC2, set both the `KeyLength` and Rc2EffectiveKeyLength properties to values between 8 and 1024, inclusive. The default setting for both is 128.

The default value is `128`

RC2 is an old symmetric encryption algorithm, now considered insecure due to its small key size and vulnerability to cryptanalysis. Modern algorithms like AES are recommended instead.

### Crypt2.SigningAlg

`Chilkat 11.7.0 · c · Crypt2 · SigningAlg · property · read/write · since 9.5.0.67`

```c
void CkCrypt2_getSigningAlg(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putSigningAlg(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_signingAlg(HCkCrypt2 cHandle);
```

This property applies when creating RSA signatures.

It defines the `RSA signature scheme`. The default is `PKCS1-v1_5`. You can change it to `RSASSA-PSS` (or `pss`) to use the RSASSA-PSS signature scheme.

1. **PKCS#1 v1.5**  
   *Older, deterministic scheme.*  
   \- Simple padding.  
   \- Vulnerable to certain attacks if not used carefully.  
   \- Still widely used for compatibility.
2. **RSASSA-PSS**  
   *Newer, probabilistic scheme (recommended by modern standards).*  
   \- Adds random salt for each signature.  
   \- More secure against chosen-plaintext and padding oracle attacks.  
   \- Recommended by modern standards like PKCS#1 v2.1 and FIPS.

### Crypt2.SigningAttributes

`Chilkat 11.7.0 · c · Crypt2 · SigningAttributes · property · read/write · since 9.5.0.75`

```c
void CkCrypt2_getSigningAttributes(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putSigningAttributes(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_signingAttributes(HCkCrypt2 cHandle);
```

Contains JSON to specify the authenticated (signed) attributes or unauthenticated (unsigned) attributes that are to be included in CMS signatures. The default value is:

```
{
    "contentType": true,
    "signingTime": true,
    "messageDigest": true
}
```

### Crypt2.UncommonOptions

`Chilkat 11.7.0 · c · Crypt2 · UncommonOptions · property · read/write · since 9.5.0.83`

```c
void CkCrypt2_getUncommonOptions(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putUncommonOptions(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_uncommonOptions(HCkCrypt2 cHandle);
```

This is a catch-all property to be used for uncommon needs. This property defaults to the empty string and should typically remain empty.

Can be set to a list of the following comma separated keywords:

- `UseConstructedOctets` - Introduced in v9.5.0.83. When creating opaque CMS signatures (signatures that embed the data being signed), will use the `constructed octets` form of the ASN.1 that holds the data. This is to satify some validators that are brittle/fragile/picky and require a particular format, such as for the ICP-Brazil Digital Signature Standard.

### Crypt2.UuFilename

`Chilkat 11.7.0 · c · Crypt2 · UuFilename · property · read/write`

```c
void CkCrypt2_getUuFilename(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putUuFilename(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_uuFilename(HCkCrypt2 cHandle);
```

When UU encoding, this is the filename to be embedded in UU encoded output. The default is `file.dat`. When UU decoding, this is the filename found in the UU encoded input.

### Crypt2.UuMode

`Chilkat 11.7.0 · c · Crypt2 · UuMode · property · read/write`

```c
void CkCrypt2_getUuMode(HCkCrypt2 cHandle, HCkString retval);
void CkCrypt2_putUuMode(HCkCrypt2 cHandle, const char *newVal);
const char *CkCrypt2_uuMode(HCkCrypt2 cHandle);
```

When UU encoding, this is the file permissions mode to be embedded in UU encoded output. The default is `644`. When UU decoding, this property is set to the mode found in the UU encoded input.

## Methods

### Crypt2.AddEncryptCert

`Chilkat 11.7.0 · c · Crypt2 · AddEncryptCert · method`

```c
void CkCrypt2_AddEncryptCert(HCkCrypt2 cHandle, HCkCert cert);
```

**Full documentation for this method (same in every language):** [Public Key Encryption to Multiple Recipients](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/public_key_encryption_to_multiple_recipients.md) · [Explaining PKCS#7 Enveloped Data](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/pkcs7_enveloped_data.md)

Adds a certificate for public-key encryption. To enable public-key encryption with digital certificates, set the `CryptAlgorithm` property to `pki`. Call `AddEncryptCert` separately for each certificate you wish to use for encryption.

Any of the `Encrypt*` methods will do `RSA public-key encryption` when the `CryptAlgorithm` is set to the keyword `pki`. The output is a `PKCS#7 enveloped-data` secure container.

### Crypt2.AddPfxSourceBd

`Chilkat 11.7.0 · c · Crypt2 · AddPfxSourceBd · method · since 11.0.0`

```c
BOOL CkCrypt2_AddPfxSourceBd(HCkCrypt2 cHandle, HCkBinData bd, const char *password);
```

Adds a `PFX` file to the object's list of sources for locating certificates and private keys during public-key decryption or signing. To add multiple PFX sources, call this method multiple times. `bd` should contain the bytes of a PFX file (also known as `PKCS12` or `.p12`).

**Note:** Information about the certificate(s) needed for `public-key decryption` are included in the `PKCS#7 enveloped-data`. Chilkat will automatically find a usable certificate and private key from sources like Windows certificate stores, the Apple keychain, or other sources provided by the application.

Returns TRUE for success, FALSE for failure.

### Crypt2.AddPfxSourceFile

`Chilkat 11.7.0 · c · Crypt2 · AddPfxSourceFile · method`

```c
BOOL CkCrypt2_AddPfxSourceFile(HCkCrypt2 cHandle, const char *pfxFilePath, const char *pfxPassword);
```

Adds a `PFX` file to the object's list of sources for locating certificates and private keys during public-key decryption or signing. To add multiple PFX sources, call this method multiple times.

**Note:** Information about the certificate(s) needed for `public-key decryption` are included in the `PKCS#7 enveloped-data`. Chilkat will automatically find a usable certificate and private key from sources like Windows certificate stores, the Apple keychain, or other sources provided by the application.

Returns TRUE for success, FALSE for failure.

### Crypt2.AddSigningCert

`Chilkat 11.7.0 · c · Crypt2 · AddSigningCert · method · since 9.5.0.83`

```c
BOOL CkCrypt2_AddSigningCert(HCkCrypt2 cHandle, HCkCert cert);
```

**Full documentation for this method (same in every language):** [PKCS#7 signed-data with Multiple Signers](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/pkcs7_multiple_signers.md)

Call this method once per certificate to add `multiple certificates for signing`. If signing with a single certificate, then the `SetSigningCert` or `SetSigningCert2` methods can be used instead.

Returns TRUE for success, FALSE for failure.

### Crypt2.AesKeyUnwrap

`Chilkat 11.7.0 · c · Crypt2 · AesKeyUnwrap · method · since 9.5.0.66`

```c
BOOL CkCrypt2_AesKeyUnwrap(HCkCrypt2 cHandle, const char *kek, const char *wrappedKeyData, const char *encoding, HCkString outStr);
const char *CkCrypt2_aesKeyUnwrap(HCkCrypt2 cHandle, const char *kek, const char *wrappedKeyData, const char *encoding);
```

**Full documentation for this method (same in every language):** [Explaining AES Key Wrap With Padding vs Without Padding](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/aes_key_wrap_with_padding_vs_no_padding.md)

Implements the `AES Key Wrap Algorithm` (RFC 3394) for unwrapping. The `kek` is the `Key Encryption Key` (the AES key used to unwrap the `wrappedKeyData`). The arguments and return value are binary encoded strings using the encoding specified by `encoding` (which can be `base64`, `hex`, `base64url`, etc.) The full list of supported encodings is available at the link below.

The `kek` should be an `AES key` of `16 bytes`, `24 bytes`, or `32 bytes` (i.e. 128-bits, 192- bits, or 256-bits). For example, if passed as a hex string, then the `kek` should be 32 chars in length, 48 chars, or 64 chars (because each byte is represented as 2 chars in hex).

The `wrappedKeyData` contains the data to be unwrapped. The result, if decoded, is 8 bytes less than the wrapped key data. For example, if a 256-bit AES key (32 bytes) is wrapped, the size of the wrapped key data is 40 bytes. Unwrapping restores it to the original 32 bytes.

Returns TRUE for success, FALSE for failure.

### Crypt2.AesKeyUnwrapWithPadding

`Chilkat 11.7.0 · c · Crypt2 · AesKeyUnwrapWithPadding · method · since 9.5.0.96`

```c
BOOL CkCrypt2_AesKeyUnwrapWithPadding(HCkCrypt2 cHandle, const char *kek, const char *wrappedKeyData, const char *encoding, HCkString outStr);
const char *CkCrypt2_aesKeyUnwrapWithPadding(HCkCrypt2 cHandle, const char *kek, const char *wrappedKeyData, const char *encoding);
```

**Full documentation for this method (same in every language):** [Explaining AES Key Wrap With Padding vs Without Padding](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/aes_key_wrap_with_padding_vs_no_padding.md)

Implements the `AES Key Wrap with Padding Algorithm` (RFC 5649) for unwrapping. The `kek` is the `Key Encryption Key` (the AES key used to unwrap the `wrappedKeyData`). The arguments and return value are binary encoded strings using the encoding specified by `encoding` (which can be `base64`, `hex`, `base64url`, etc.)

The `kek` should be an `AES key` of `16 bytes`, `24 bytes`, or `32 bytes` (i.e. 128-bits, 192- bits, or 256-bits). For example, if passed as a hex string, then the `kek` should be 32 chars in length, 48 chars, or 64 chars (because each byte is represented as 2 chars in hex).

The `wrappedKeyData` contains the data to be unwrapped.

The unwrapped key is returned as an encoded string (using the encoding specified in `encoding`).

Returns TRUE for success, FALSE for failure.

### Crypt2.AesKeyWrap

`Chilkat 11.7.0 · c · Crypt2 · AesKeyWrap · method · since 9.5.0.66`

```c
BOOL CkCrypt2_AesKeyWrap(HCkCrypt2 cHandle, const char *kek, const char *keyData, const char *encoding, HCkString outStr);
const char *CkCrypt2_aesKeyWrap(HCkCrypt2 cHandle, const char *kek, const char *keyData, const char *encoding);
```

**Full documentation for this method (same in every language):** [Explaining AES Key Wrap With Padding vs Without Padding](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/aes_key_wrap_with_padding_vs_no_padding.md)

Implements the `AES Key Wrap Algorithm` (RFC 3394). The `kek` is the `Key Encryption Key` (the AES key used to encrypt the `keyData`). The arguments and return value are binary encoded strings using the encoding specified by `encoding` (which can be `base64`, `hex`, `base64url`, etc.) The full list of supported encodings is available at the link below.

The `kek` should be an `AES key` of `16 bytes`, `24 bytes`, or `32 bytes` (i.e. 128-bits, 192- bits, or 256-bits). For example, if passed as a hex string, then the `kek` should be 32 chars in length, 48 chars, or 64 chars (because each byte is represented as 2 chars in hex).

The `keyData` contains the data to be key wrapped. It must be a multiple of 64-bits in length. In other words, if the `keyData` is decoded to binary, it should be a number of bytes that is a multiple of 8.

The return string, if decoded to binary bytes, is equal to the size of the key data + 8 additional bytes.

Returns TRUE for success, FALSE for failure.

### Crypt2.AesKeyWrapWithPadding

`Chilkat 11.7.0 · c · Crypt2 · AesKeyWrapWithPadding · method · since 9.5.0.96`

```c
BOOL CkCrypt2_AesKeyWrapWithPadding(HCkCrypt2 cHandle, const char *kek, const char *keyData, const char *encoding, HCkString outStr);
const char *CkCrypt2_aesKeyWrapWithPadding(HCkCrypt2 cHandle, const char *kek, const char *keyData, const char *encoding);
```

**Full documentation for this method (same in every language):** [Explaining AES Key Wrap With Padding vs Without Padding](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/aes_key_wrap_with_padding_vs_no_padding.md)

Implements the `AES Key Wrap with Padding Algorithm` (RFC 5649). The `kek` is the `Key Encryption Key` (the AES key used to encrypt the `keyData`). The arguments and return value are binary encoded strings using the encoding specified by `encoding` (which can be `base64`, `hex`, `base64url`, etc.)

The `kek` should be an `AES key` of `16 bytes`, `24 bytes`, or `32 bytes` (i.e. 128-bits, 192- bits, or 256-bits). For example, if passed as a hex string, then the `kek` should be 32 chars in length, 48 chars, or 64 chars (because each byte is represented as 2 chars in hex).

The `keyData` contains the data to be key wrapped.

Returns the wrapped key using the encoding specified in `encoding`.

Returns TRUE for success, FALSE for failure.

### Crypt2.Argon2DeriveKey

`Chilkat 11.7.0 · c · Crypt2 · Argon2DeriveKey · method · since 11.6.0`

```c
BOOL CkCrypt2_Argon2DeriveKey(HCkCrypt2 cHandle, const char *password, const char *json, HCkBinData bdKey);
```

Derives a key from a password using **Argon2**, the memory-hard key derivation function specified in RFC 9106. Argon2 is deliberately expensive in both CPU time and memory, which is what makes a brute-force search of the password space costly.

`password` is the password. `json` is a JSON string containing the Argon2 options (described below). The derived key is returned in `bdKey`, which is cleared before the derived key is stored in it.

A `salt` member is **required** in `json`. There is no default, because a key derivation salt is chosen and stored by the application. Use `GenRandomBytesENC` to generate one.

Every other member is optional. Passing an empty string for `json` is the same as passing `{}` and would fail only because no salt was given.

The JSON is validated strictly before it is used, so malformed JSON is rejected rather than partially applied. It must be a single JSON object, and every member value must be a simple value (string, number, `true`, `false` or `null`) -- no Argon2 member takes an object or an array. Member names are matched exactly, and any member not listed below is an **error** rather than something ignored. A member given twice, or a member given together with its short alias, is also an error, because which one would win is ambiguous. All of this is deliberate. A misspelled name such as `iteration`, a miscapitalized one such as `memoryCostKB`, or a single missing comma would otherwise be discarded in silence and the default used in its place. For a cost parameter that is a silent downgrade, and it produces a hash that looks perfectly valid, so nothing downstream would catch it. The specific problem is reported in the `LastErrorText`.

- `variant` - `argon2id` (the default), `argon2i`, or `argon2d`. Use `argon2id` unless there is a specific reason not to: it combines Argon2i's resistance to side-channel attacks with Argon2d's resistance to time-memory tradeoff attacks.
- `version` - `19` (the default, 0x13) or `16` (0x10). Only set `16` to reproduce a hash made by an old implementation.
- `iterations` - the number of passes over memory, called `t` in RFC 9106. Must be at least 1. Defaults to `3`.
- `memoryCostKb` - the amount of memory used, in KB, called `m` in RFC 9106. Must be at least 8 times `parallelism`. Defaults to `65536` (64 MB). This is the parameter that does the most to make an attack expensive.
- `parallelism` - the number of lanes, called `p` in RFC 9106. Defaults to `1`. Changing it changes the derived key. Chilkat computes all lanes on the calling thread, so raising it does not make the computation faster.
- `keyLen` - the length of the derived key in bytes. Must be between 4 and 1048576. Defaults to `32`.
- `salt` - the salt, which must be at least 8 bytes. 16 random bytes is the usual choice.
- `secret` - the optional secret value `K` of RFC 9106, often called a `pepper`: a key held by the application and **not** stored alongside the hash, so that a stolen database of hashes cannot be attacked without it.
- `ad` - the optional associated data `X` of RFC 9106: additional non-secret data bound into the derivation.
- `encoding` - how the `salt`, `secret` and `ad` members are encoded. Defaults to `base64`. May be any encoding Chilkat supports, such as `hex`, or `utf-8` to use the characters of the member itself as the bytes.
- `saltEncoding`, `secretEncoding`, `adEncoding` - override `encoding` for one member.
- `passwordCharset` - the character encoding the password is converted to before use. Defaults to `utf-8`. If set to `hex` or `base64`, `password` is instead treated as encoded binary and decoded, exactly as for the charset argument of `Pbkdf2`.
- `maxMemoryKb` - refuses to allocate more than this many KB. This is not an Argon2 parameter; it is a guard so that an unreasonable `memoryCostKb` cannot exhaust memory. Defaults to `2097152` (2 GB).

The short names used in RFC 9106 and in PHC hash strings are accepted as aliases: `t` for `iterations`, `m` for `memoryCostKb`, `p` for `parallelism`, and `v` for `version`. This means the parameters of an existing hash string such as `$argon2id$v=19$m=65536,t=3,p=1$...` can be transcribed directly.

For example, to derive a 32-byte key:

`{ "iterations": 3, "memoryCostKb": 65536, "parallelism": 1, "keyLen": 32, "salt": "cmFuZG9tc2FsdDEyMzQ=" }`

To hash a password for storage, use `Argon2HashPassword` instead, which generates a random salt and returns a self-describing string.

Returns TRUE for success, FALSE for failure.

### Crypt2.Argon2HashPassword

`Chilkat 11.7.0 · c · Crypt2 · Argon2HashPassword · method · since 11.6.0`

```c
BOOL CkCrypt2_Argon2HashPassword(HCkCrypt2 cHandle, const char *password, const char *json, HCkString phcHash);
const char *CkCrypt2_argon2HashPassword(HCkCrypt2 cHandle, const char *password, const char *json);
```

Hashes a password using **Argon2** (RFC 9106) and returns the result as a PHC format string, such as

`$argon2id$v=19$m=65536,t=3,p=1$c29tZXJhbmRvbXNhbHQ$3fJ7v1qKcVJ0lHqXjBQZ8mYm3sNTfSPRt0bqDl9kEyM`

The string records the variant, version, memory cost, iterations, parallelism, salt and hash, so it is everything needed to verify the password later with `Argon2VerifyPassword`. Store the whole string.

`password` is the password. `json` is a JSON string containing the Argon2 options, which are the same members documented for `Argon2DeriveKey`, with one difference: **the salt is optional here**. As with all of the Argon2 methods, an unrecognized member name is an error. When no `salt` member is present, a cryptographically random salt is generated for this hash, which is what should normally happen. A `saltLen` member (default `16`, allowed range 8 to 1024) sets how many random bytes to generate.

Passing an empty string for `json` uses all defaults: Argon2id, version 19, 3 iterations, 64 MB of memory, 1 lane, a 32-byte hash and a 16-byte random salt.

Note that if a `secret` (pepper) or `ad` is used, it is **not** stored in the returned string. The same value must be supplied to `Argon2VerifyPassword` for the password to verify.

Returns TRUE for success, FALSE for failure.

### Crypt2.Argon2VerifyPassword

`Chilkat 11.7.0 · c · Crypt2 · Argon2VerifyPassword · method · since 11.6.0`

```c
int CkCrypt2_Argon2VerifyPassword(HCkCrypt2 cHandle, const char *password, const char *json, const char *phcHash);
```

Verifies `password` against a PHC format Argon2 hash string previously produced by `Argon2HashPassword` (or by any other RFC 9106 implementation).

Returns one of three values:

- `1` - the password matched.
- `0` - the password did not match.
- `-1` - the verification could not be performed at all: `phcHash` was not a valid Argon2 hash string, its parameters were out of range, or an internal failure occurred. The reason is written to the `LastErrorText`.

Test for a match with `== 1`, never for `!= 0`, so that an unusable hash string is not mistaken for a successful login.

The variant, version, memory cost, iterations, parallelism, salt and hash length are all read from `phcHash`, so none of the Argon2 cost options need to be supplied. Pass an empty string for `json` unless the hash was created with a `secret` (pepper) or `ad`, in which case `json` must contain the same values that were used to create it. Only the `secret`, `ad`, `encoding`, `passwordCharset` and `maxMemoryKb` members of `json` are used; everything else is ignored. The other documented members are still accepted here, so that one JSON string can be shared between hashing and verifying, but an unrecognized member name is an error.

A return of `0` and a return of `-1` call for different handling. `0` is a normal failed login attempt. `-1` means the stored hash itself is unusable, which is a data or configuration problem rather than a bad password, and is worth logging or alerting on separately.

The `maxMemoryKb` member is worth setting when the hash strings come from an untrusted source. The memory cost is taken from `phcHash`, so a hash claiming an enormous `m` would otherwise cause a very large allocation. It defaults to 2 GB and is checked before any memory is allocated.

### Crypt2.BCryptHash

`Chilkat 11.7.0 · c · Crypt2 · BCryptHash · method · since 9.5.0.65`

```c
BOOL CkCrypt2_BCryptHash(HCkCrypt2 cHandle, const char *password, HCkString outStr);
const char *CkCrypt2_bCryptHash(HCkCrypt2 cHandle, const char *password);
```

Computes and returns a bcrypt hash of the `password`. The number of rounds of hashing is determined by the `BCryptWorkFactor` property.

Starting in v9.5.0.76, if the `password` is prefixed with `$2b$` then the output will use the $2b version of bcrypt. For example, to create a `$2b$` bcrypt has for the password `secret`, pass in the string `$2b$secret` for `password`.

Returns TRUE for success, FALSE for failure.

### Crypt2.BCryptVerify

`Chilkat 11.7.0 · c · Crypt2 · BCryptVerify · method · since 9.5.0.65`

```c
BOOL CkCrypt2_BCryptVerify(HCkCrypt2 cHandle, const char *password, const char *bcryptHash);
```

Verifies the `password` against a previously computed BCrypt hash. Returns `TRUE` if the password matches the `bcryptHash`. Returns `FALSE` if the password does not match.

Returns TRUE for success, FALSE for failure.

### Crypt2.CkDecryptFile

`Chilkat 11.7.0 · c · Crypt2 · CkDecryptFile · method`

```c
BOOL CkCrypt2_CkDecryptFile(HCkCrypt2 cHandle, const char *srcFile, const char *destFile);
```

File-to-file decryption that supports files of any size by using internal streaming mode.

Returns TRUE for success, FALSE for failure.

Async variant: `CkDecryptFileAsync` — same arguments, returns a `Task` (see Async variants below).

### Crypt2.CkEncryptFile

`Chilkat 11.7.0 · c · Crypt2 · CkEncryptFile · method`

```c
BOOL CkCrypt2_CkEncryptFile(HCkCrypt2 cHandle, const char *srcFile, const char *destFile);
```

Encrypts a file to another file using streaming mode, allowing files of virtually any size to be processed without loading the entire file into memory. The exception is when the `CryptAlgorithm` property is set to `"pki"`, in which case the entire input file must reside in memory because public-key encryption is performed in-memory rather than as a streaming operation.

Returns TRUE for success, FALSE for failure.

Async variant: `CkEncryptFileAsync` — same arguments, returns a `Task` (see Async variants below).

### Crypt2.ClearEncryptCerts

`Chilkat 11.7.0 · c · Crypt2 · ClearEncryptCerts · method`

```c
void CkCrypt2_ClearEncryptCerts(HCkCrypt2 cHandle);
```

Clears the internal list of digital certificates to be used for public-key encryption.

### Crypt2.ClearSigningCerts

`Chilkat 11.7.0 · c · Crypt2 · ClearSigningCerts · method · since 9.5.0.83`

```c
void CkCrypt2_ClearSigningCerts(HCkCrypt2 cHandle);
```

Clears the set of certificates to be used in signing.

### Crypt2.CoSign

`Chilkat 11.7.0 · c · Crypt2 · CoSign · method · since 9.5.0.89`

```c
BOOL CkCrypt2_CoSign(HCkCrypt2 cHandle, HCkBinData bdIn, HCkCert cert, HCkBinData bdOut);
```

Co-sign's an existing CMS signature. `bdIn` contains the existing CMS signature. If successful, `cert` is the output co-signed CMS signature.

Returns TRUE for success, FALSE for failure.

### Crypt2.CrcBd

`Chilkat 11.7.0 · c · Crypt2 · CrcBd · method · since 11.0.0`

```c
unsigned long CkCrypt2_CrcBd(HCkCrypt2 cHandle, const char *crcAlg, HCkBinData bd);
```

Computes a CRC for data contained in `crcAlg`, which can be either `crc-32` used in the Zip file format, or `crc8` for the CRC8 algorithm.

### Crypt2.CrcFile

`Chilkat 11.7.0 · c · Crypt2 · CrcFile · method · since 9.5.0.38`

```c
unsigned long CkCrypt2_CrcFile(HCkCrypt2 cHandle, const char *crcAlg, const char *path);
```

Calculates the CRC for a file's contents using the CRC algorithm specified by `crcAlg`. Possible algorithms are:

- `crc-32` - This is the CRC used in the Zip file format.
- `crc8`

Async variant: `CrcFileAsync` — same arguments, returns a `Task` (see Async variants below).

### Crypt2.CreateP7M

`Chilkat 11.7.0 · c · Crypt2 · CreateP7M · method`

```c
BOOL CkCrypt2_CreateP7M(HCkCrypt2 cHandle, const char *inFilename, const char *p7mPath);
```

**Full documentation for this method (same in every language):** [What is an Enveloping PKCS7 CMS Signature?](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/explain_pkcs7_enveloping_cms_signature.md) · [.p7s vs .p7m](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/p7s_vs_p7m.md)

Signs the contents of `inFilename` and writes the enveloping (i.e. opaque) `PKCS7` signature (`.p7m`) to `p7mPath`.

In a **PKCS#7/CMS signature**, the signer computes a **cryptographic hash** (e.g. SHA-256) of the data, then uses their **private key** to sign that hash.

The signature = `Sign( Hash(data) )`

This signed hash is what gets stored in the signature file. For enveloping/opaque signatures, the signed data is also stored in the signature file.

Set the `HashAlgorithm` property to specify the hash algorithmg. The valid options are `sha256`, `sha1`, `sha384`, and `sha512`.

Returns TRUE for success, FALSE for failure.

Async variant: `CreateP7MAsync` — same arguments, returns a `Task` (see Async variants below).

See also:

- [Online Tool to Examine a .p7m and Generate Code that Duplicates the .p7m](https://tools.chilkat.io/generateP7M)

### Crypt2.CreateP7S

`Chilkat 11.7.0 · c · Crypt2 · CreateP7S · method`

```c
BOOL CkCrypt2_CreateP7S(HCkCrypt2 cHandle, const char *inFilename, const char *p7sPath);
```

**Full documentation for this method (same in every language):** [What is a Detached PKCS7 CMS Signature?](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/explain_pkcs7_detached_cms_signature.md)

Signs the contents of `inFilename` and writes the detached `PKCS7` signature (`.p7s`) to `p7sPath`.

In a **PKCS#7/CMS detached signature**, the signer computes a **cryptographic hash** (e.g. SHA-256) of the data, then uses their **private key** to sign that hash.

The signature = `Sign( Hash(data) )`

This signed hash is what gets stored in the signature file.

Set the `HashAlgorithm` property to specify the hash algorithmg. The valid options are `sha256`, `sha1`, `sha384`, and `sha512`.

Returns TRUE for success, FALSE for failure.

Async variant: `CreateP7SAsync` — same arguments, returns a `Task` (see Async variants below).

### Crypt2.DecodeString

`Chilkat 11.7.0 · c · Crypt2 · DecodeString · method`

```c
BOOL CkCrypt2_DecodeString(HCkCrypt2 cHandle, const char *inStr, const char *charset, const char *encoding, HCkString outStr);
const char *CkCrypt2_decodeString(HCkCrypt2 cHandle, const char *inStr, const char *charset, const char *encoding);
```

Decodes from an encoding back to the original string. The `encoding` can be set to any of the following strings: `base64`, `hex`, `quoted-printable`, `url`, `base32`, `Q`, `B`, `url_rc1738`, `url_rfc2396`, `url_rfc3986`, `url_oauth`, `uu`, `modBase64`, or `html` (for HTML entity encoding).

Returns TRUE for success, FALSE for failure.

### Crypt2.DecryptBd

`Chilkat 11.7.0 · c · Crypt2 · DecryptBd · method · since 9.5.0.67`

```c
BOOL CkCrypt2_DecryptBd(HCkCrypt2 cHandle, HCkBinData bd);
```

Decrypts the contents of `bd`. This method can do either `symmetric key decryption` or `CMS public key decryption` (e.g., `PKCS#7 EnvelopedData`).

Before calling this method for `symmetric key decryption` (e.g., `AES`, `ChaCha20`, `Blowfish`, etc.), ensure the following setup:

1. Define the encryption algorithm using the `CryptAlgorithm` property.
2. Specify the encryption key length with the `KeyLength` property.
3. Establish the cipher mode through the `CipherMode` property.
4. Use the `SetEncodedIV` method to set the IV, if needed by the cipher mode.
5. Set the encryption key with the `SetEncodedKey` method.
6. Ensure the `PaddingScheme` property matches the encryptor's value.

When calling this method for `public key decryption` (i.e. decrypting a `PKCS7 CMS message`), the following setup is required:

1. The `CryptAlgorithm` property should be set to the string `"pki"`.
2. Optionally specify the certificate to be used for decryption by calling `SetDecryptCert`. If SetDecryptCert is not called, then Chilkat will automatically search certificate sources (`Windows certificate stores`, `Apple keychain`, etc.) for the required certificate.

Returns TRUE for success, FALSE for failure.

### Crypt2.DecryptEncoded

`Chilkat 11.7.0 · c · Crypt2 · DecryptEncoded · method`

```c
BOOL CkCrypt2_DecryptEncoded(HCkCrypt2 cHandle, const char *encodedEncryptedData, HCkString outStr);
const char *CkCrypt2_decryptEncoded(HCkCrypt2 cHandle, const char *encodedEncryptedData);
```

Decrypts encoded encrypted data, and returns the decrypted data as a binary encoded string. For example:

**Input** → **Decode** `EncodingMode` → **Decrypt** → **Encode** `EncodingMode` → **Output**

The encoding (e.g. `base64`, `hex`, etc.) is determined by the `EncodingMode` property.

This method supports `symmetric key` and `public key` decryption. For more information on **properties that affect decryption**, such as `CryptAlgorithm`, `CipherMode`, etc., refer to the `DecryptBd` method documentation.

Returns TRUE for success, FALSE for failure.

### Crypt2.DecryptSb

`Chilkat 11.7.0 · c · Crypt2 · DecryptSb · method · since 9.5.0.67`

```c
BOOL CkCrypt2_DecryptSb(HCkCrypt2 cHandle, HCkBinData bdIn, HCkStringBuilder sbOut);
```

**Full documentation for this method (same in every language):** [Importance of Charset when Encrypting or Decrypting Text](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/charset_matters_when_encrypting_text.md)

This function is intended for use when the **expected decrypted output is text**. It decrypts the contents of `bdIn` and appends the resulting string to `sbOut`. Ensure that the `Charset` property, such as `utf-8,` matches the one used during encryption to interpret the decrypted bytes correctly as characters.

**Input** → **Decrypt** → **Interpret Bytes according to** `Charset` → **Append to StringBuilder**

This method supports `symmetric key` and `public key` decryption. For more information on **properties that affect decryption**, such as `CryptAlgorithm`, `CipherMode`, etc., refer to the `DecryptBd` method documentation.

Returns TRUE for success, FALSE for failure.

### Crypt2.DecryptSecureENC

`Chilkat 11.7.0 · c · Crypt2 · DecryptSecureENC · method · since 9.5.0.71`

```c
BOOL CkCrypt2_DecryptSecureENC(HCkCrypt2 cHandle, const char *cipherText, HCkSecureString secureStr);
```

This function is intended for use when the **expected decrypted output is text**. It decrypts binary encoded encrypted bytes passed in `cipherText` and appends the resulting string to `secureStr`. Ensure that the `Charset` property, such as `utf-8,` matches the one used during encryption to interpret the decrypted bytes correctly as characters.

**Input** → **Decode using** `EncodingMode` → **Decrypt** → **Interpret Bytes according to** `Charset` → **Append to Secure String**

The encoding (e.g. `base64`, `hex`, etc.) is determined by the `EncodingMode` property.

This method supports `symmetric key` and `public key` decryption. For more information on **properties that affect decryption**, such as `CryptAlgorithm`, `CipherMode`, etc., refer to the `DecryptBd` method documentation.

Returns TRUE for success, FALSE for failure.

### Crypt2.DecryptStringENC

`Chilkat 11.7.0 · c · Crypt2 · DecryptStringENC · method`

```c
BOOL CkCrypt2_DecryptStringENC(HCkCrypt2 cHandle, const char *str, HCkString outStr);
const char *CkCrypt2_decryptStringENC(HCkCrypt2 cHandle, const char *str);
```

**Full documentation for this method (same in every language):** [Explaining the Importance of the Charset](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/charset_matters_when_encrypting_text.md) · [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

This function is intended for use when the **expected decrypted output is text**. It decrypts binary encoded encrypted bytes passed in `str` and appends the resulting string to ARG2. Ensure that the `Charset` property, such as `utf-8,` matches the one used during encryption to interpret the decrypted bytes correctly as characters.

**Input** → **Decode using** `EncodingMode` → **Decrypt** → **Interpret Bytes according to** `Charset` → **Output**

The encoding (e.g. `base64`, `hex`, etc.) is determined by the `EncodingMode` property.

This method supports `symmetric key` and `public key` decryption. For more information on **properties that affect decryption**, such as `CryptAlgorithm`, `CipherMode`, etc., refer to the `DecryptBd` method documentation.

Returns TRUE for success, FALSE for failure.

### Crypt2.EncodeBytes

`Chilkat 11.7.0 · c · Crypt2 · EncodeBytes · method`

```c
BOOL CkCrypt2_EncodeBytes(HCkCrypt2 cHandle, const unsigned char *pByteData, unsigned long szByteData, const char *encoding, HCkString outStr);
const char *CkCrypt2_encodeBytes(HCkCrypt2 cHandle, const unsigned char *pByteData, unsigned long szByteData, const char *encoding);
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Encode binary data to base64, hex, quoted-printable, or URL-encoding. The `encoding` can be set to any of the following strings: `base64`, `hex`, `quoted-printable`, `url`, `base32`, `Q`, `B`, `url_rc1738`, `url_rfc2396`, `url_rfc3986`, `url_oauth`, `uu`, `modBase64`, or `html` (for HTML entity encoding).

The `pByteData` points to the bytes to be encoded. The `szByteData` specifies the number of bytes to encode.

Returns TRUE for success, FALSE for failure.

### Crypt2.EncodeInt

`Chilkat 11.7.0 · c · Crypt2 · EncodeInt · method · since 9.5.0.77`

```c
BOOL CkCrypt2_EncodeInt(HCkCrypt2 cHandle, int value, int numBytes, BOOL littleEndian, const char *encoding, HCkString outStr);
const char *CkCrypt2_encodeInt(HCkCrypt2 cHandle, int value, int numBytes, BOOL littleEndian, const char *encoding);
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Encodes an integer to N bytes and returns in the specified encoding. If `littleEndian` is `TRUE`, then `little-endian` byte ordering is used. Otherwise `big-endian` byte order is used.

Returns TRUE for success, FALSE for failure.

### Crypt2.EncodeString

`Chilkat 11.7.0 · c · Crypt2 · EncodeString · method`

```c
BOOL CkCrypt2_EncodeString(HCkCrypt2 cHandle, const char *strToEncode, const char *charsetName, const char *toEncodingName, HCkString outStr);
const char *CkCrypt2_encodeString(HCkCrypt2 cHandle, const char *strToEncode, const char *charsetName, const char *toEncodingName);
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md) · [Charset Supported by Chilkat](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/charsets_supported_by_chilkat.md)

Binary encodes a string. The `toEncodingName` can be set to **any of the binary encodings supported by Chilkat**, such as `base64`, `hex`, etc. (see the link below for the full list of encodings). The `charsetName`, such as `"utf-8"`, determines the bytes that are encoded.

The `toEncodingName` can also be set to the value `html` for HTML entity encoding.

Returns TRUE for success, FALSE for failure.

### Crypt2.EncryptBd

`Chilkat 11.7.0 · c · Crypt2 · EncryptBd · method · since 9.5.0.67`

```c
BOOL CkCrypt2_EncryptBd(HCkCrypt2 cHandle, HCkBinData bd);
```

Encrypts the contents of `bd`. This method can do either `symmetric key encryption` or `CMS public key encryption` (e.g., `PKCS#7 EnvelopedData`).

Before calling this method for `symmetric key encryption` (e.g., `AES`, `ChaCha20`, `Blowfish`, etc.), ensure the following setup:

1. Define the encryption algorithm using the `CryptAlgorithm` property.
2. Specify the encryption key length with the `KeyLength` property.
3. Establish the cipher mode through the `CipherMode` property.
4. Use the `SetEncodedIV` method to set the IV, if needed by the cipher mode.
5. Set the encryption key with the `SetEncodedKey` method.
6. Set the `PaddingScheme` property if needing something different than the default.

When calling this method for `public key encryption` (i.e. creating a `PKCS7 CMS message`), the following setup is required:

1. The `CryptAlgorithm` property should be set to the string `"pki"`.
2. To specify the encryption certificate, use `SetEncryptCert`. For multiple certificates, call `AddEncryptCert` for each one.

Returns TRUE for success, FALSE for failure.

### Crypt2.EncryptEncoded

`Chilkat 11.7.0 · c · Crypt2 · EncryptEncoded · method`

```c
BOOL CkCrypt2_EncryptEncoded(HCkCrypt2 cHandle, const char *str, HCkString outStr);
const char *CkCrypt2_encryptEncoded(HCkCrypt2 cHandle, const char *str);
```

Encrypts binary-encoded data and returns it as a binary-encoded string. For example:

**Input** → **Decode** `EncodingMode` → **Encrypt** → **Encode** `EncodingMode` → **Output**

The encoding (e.g. `base64`, `hex`, etc.) is determined by the `EncodingMode` property.

This method supports `symmetric key` and `public key` decryption. For more information on **properties that affect decryption**, such as `CryptAlgorithm`, `CipherMode`, etc., refer to the `method documentation.`

Returns TRUE for success, FALSE for failure.

### Crypt2.EncryptSb

`Chilkat 11.7.0 · c · Crypt2 · EncryptSb · method · since 9.5.0.67`

```c
BOOL CkCrypt2_EncryptSb(HCkCrypt2 cHandle, HCkStringBuilder sbIn, HCkBinData bdOut);
```

**Full documentation for this method (same in every language):** [Importance of Charset when Encrypting or Decrypting Text](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/charset_matters_when_encrypting_text.md)

Encrypts text and appends the encrypted bytes in `bdOut`. The `Charset` property, such as `utf-8`, determines the actual bytes that are encrypted.

`StringBuilder` → **Get bytes according to** `Charset` → **Encrypt** → **Append to** `BinData`

This method supports `symmetric key` and `public key` encryption. For more information on **properties that affect encryption**, such as `CryptAlgorithm`, `CipherMode`, etc., refer to the `EncryptBd` method documentation.

Returns TRUE for success, FALSE for failure.

### Crypt2.EncryptSecureENC

`Chilkat 11.7.0 · c · Crypt2 · EncryptSecureENC · method · since 9.5.0.71`

```c
BOOL CkCrypt2_EncryptSecureENC(HCkCrypt2 cHandle, HCkSecureString secureStr, HCkString outStr);
const char *CkCrypt2_encryptSecureENC(HCkCrypt2 cHandle, HCkSecureString secureStr);
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md) · [Importance of Charset when Encrypting or Decrypting Text](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/charset_matters_when_encrypting_text.md)

Encrypts the secure string and returns the encrypted bytes as a binary encoded string. The `Charset` property determines the actual bytes that are encrypted.

`SecureString` → **Get bytes according to** `Charset` → **Encrypt** → **Encode using** `EncodingMode` → **Output**

The encoding (e.g. `base64`, `hex`, etc.) is determined by the `EncodingMode` property.

This method supports `symmetric key` and `public key` encryption. For more information on **properties that affect encryption**, such as `CryptAlgorithm`, `CipherMode`, etc., refer to the `EncryptBd` method documentation.

Returns TRUE for success, FALSE for failure.

### Crypt2.EncryptStringENC

`Chilkat 11.7.0 · c · Crypt2 · EncryptStringENC · method`

```c
BOOL CkCrypt2_EncryptStringENC(HCkCrypt2 cHandle, const char *str, HCkString outStr);
const char *CkCrypt2_encryptStringENC(HCkCrypt2 cHandle, const char *str);
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md) · [Importance of Charset when Encrypting or Decrypting Text](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/charset_matters_when_encrypting_text.md)

Encrypts the `str` and returns the encrypted bytes as a binary encoded string. The `Charset` property determines the actual bytes that are encrypted.

**Input** → **Get bytes according to** `Charset` → **Encrypt** → **Encode using** `EncodingMode` → **Output**

The encoding (e.g. `base64`, `hex`, etc.) is determined by the `EncodingMode` property.

This method supports `symmetric key` and `public key` encryption. For more information on **properties that affect encryption**, such as `CryptAlgorithm`, `CipherMode`, etc., refer to the `EncryptBd` method documentation.

Returns TRUE for success, FALSE for failure.

### Crypt2.GenerateUuid

`Chilkat 11.7.0 · c · Crypt2 · GenerateUuid · method · since 9.5.0.55`

```c
BOOL CkCrypt2_GenerateUuid(HCkCrypt2 cHandle, HCkString outStr);
const char *CkCrypt2_generateUuid(HCkCrypt2 cHandle);
```

Generates a random UUID string having standard UUID format, such as `de305d54-75b4-431b-adb2-eb6b9e546014`.

Note: This generates a `version 4 UUID` using random byte values. See RFC 4122.

Returns TRUE for success, FALSE for failure.

### Crypt2.GenRandomBytesENC

`Chilkat 11.7.0 · c · Crypt2 · GenRandomBytesENC · method`

```c
BOOL CkCrypt2_GenRandomBytesENC(HCkCrypt2 cHandle, int numBytes, HCkString outStr);
const char *CkCrypt2_genRandomBytesENC(HCkCrypt2 cHandle, int numBytes);
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Generates `numBytes` random bytes and returns them as an encoded string. The encoding format (e.g., base64, hex) is determined by the `EncodingMode` property. It utilizes the `Fortuna` cryptographically secure random number generator, auto-seeded by an OS-dependent secure entropy source.

Returns TRUE for success, FALSE for failure.

### Crypt2.GetEncodedAuthTag

`Chilkat 11.7.0 · c · Crypt2 · GetEncodedAuthTag · method · since 9.5.0.55`

```c
BOOL CkCrypt2_GetEncodedAuthTag(HCkCrypt2 cHandle, const char *encoding, HCkString outStr);
const char *CkCrypt2_getEncodedAuthTag(HCkCrypt2 cHandle, const char *encoding);
```

**Full documentation for this method (same in every language):** [Explaining the AES-GCM Authentication Tag](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/gcm_authentication_tag.md) · [AES-GCM Overview](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/aes_gcm_overview.md) · [Explaining Authenticated Encryption, such as AES-GCM](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/authenticated_encryption_gcm.md)

When encrypting in `GCM` mode, Chilkat generates the `GCM authentication tag`. The application can then use this method to retrieve the tag, which should be sent to the decrypting party along with the encrypted data. For further details on GCM authenticated encryption, please refer to the web pages linked below.

Returns TRUE for success, FALSE for failure.

### Crypt2.GetEncodedIV

`Chilkat 11.7.0 · c · Crypt2 · GetEncodedIV · method`

```c
BOOL CkCrypt2_GetEncodedIV(HCkCrypt2 cHandle, const char *encoding, HCkString outIV);
const char *CkCrypt2_getEncodedIV(HCkCrypt2 cHandle, const char *encoding);
```

This method retrieves the IV set by the application during the last call to `SetEncodedIV` or `RandomizeIV`.

Returns TRUE for success, FALSE for failure.

### Crypt2.GetLastJsonData

`Chilkat 11.7.0 · c · Crypt2 · GetLastJsonData · method · since 11.0.0`

```c
void CkCrypt2_GetLastJsonData(HCkCrypt2 cHandle, HCkJsonObject json);
```

Offers details on the last method executed. While many methods provide no information, some do through GetLastJsonData. For instance, after invoking a signature verification method, GetLastJsonData will return JSON detailing the algorithms used.

### Crypt2.GetSignatureSigningTimeStr

`Chilkat 11.7.0 · c · Crypt2 · GetSignatureSigningTimeStr · method`

```c
BOOL CkCrypt2_GetSignatureSigningTimeStr(HCkCrypt2 cHandle, int index, HCkString outStr);
const char *CkCrypt2_getSignatureSigningTimeStr(HCkCrypt2 cHandle, int index);
```

This method retrieves the signing time of the Nth certificate in a digital signature after verification. The signing time for the first certificate is at index 0. The `NumSignerCerts` property indicates the total number of signing certificates, although typically only one is used. Note: Before accessing the signing time, use the `HasSignatureSigningTime` method to verify its availability, and skip indices lacking a signing time. The signing time is returned in `RFC822 string format`.

Returns TRUE for success, FALSE for failure.

See also:

- [Explaining the Signing Time Authenticated Attribute in PKCS7 Signatures](https://cknotes.com/explaining-the-signingtime-authenticated-attribute-in-pkcs7-signatures/)

### Crypt2.GetSignedAttributes

`Chilkat 11.7.0 · c · Crypt2 · GetSignedAttributes · method · since 9.5.0.75`

```c
BOOL CkCrypt2_GetSignedAttributes(HCkCrypt2 cHandle, int signerIndex, HCkBinData pkcs7Der, HCkStringBuilder sbJson);
```

Extracts the signed (authenticated) attributes for the Nth signer, where `signerIndex` is typically 0, as most signatures have only one signer. Provide the binary PKCS7 in `pkcs7Der`. If successful, `sbJson` will hold the signed attributes in JSON format.

Sample JSON output:

```
{
  "signedAttributes": [
    {
      "oid": "1.2.840.113549.1.9.3",
      "name": "Content Type"
    },
    {
      "oid": "1.2.840.113549.1.9.5",
      "name": "Signing Time"
    },
    {
      "oid": "1.2.840.113549.1.9.4"
      "name": "Message Digest"
    },
    {
      "oid": "1.2.840.113549.1.9.16.2.47",
      "name": "Signing Certificate V2"
    }
  ]
}
```

Returns TRUE for success, FALSE for failure.

### Crypt2.HashBdENC

`Chilkat 11.7.0 · c · Crypt2 · HashBdENC · method · since 9.5.0.66`

```c
BOOL CkCrypt2_HashBdENC(HCkCrypt2 cHandle, HCkBinData bd, HCkString outStr);
const char *CkCrypt2_hashBdENC(HCkCrypt2 cHandle, HCkBinData bd);
```

**Full documentation for this method (same in every language):** [Binary Encodings Supported by Chilkat](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Hashes the bytes in `bd` and returns the hash as a binary-encoded string. The hash algorithm is determined by the `HashAlgorithm` property, while the encoding is specified by the `EncodingMode` property. Encoding options include `base64`, `hex`, `base64url`, or others listed at the link below.

Returns TRUE for success, FALSE for failure.

### Crypt2.HashBeginBytes2

`Chilkat 11.7.0 · c · Crypt2 · HashBeginBytes2 · method · since 9.5.0.82`

```c
BOOL CkCrypt2_HashBeginBytes2(HCkCrypt2 cHandle, const unsigned char *pByteData, unsigned long szByteData);
```

To hash binary data in chunks, start by hashing the first chunk using this method. For additional chunks, use the `HashMoreBytes` method as needed. Complete the process with `HashFinal` or `HashFinalENC` to obtain the hash result. The hash algorithm used is determined by the `HashAlgorithm` property setting.

Returns TRUE for success, FALSE for failure.

### Crypt2.HashBeginString

`Chilkat 11.7.0 · c · Crypt2 · HashBeginString · method`

```c
BOOL CkCrypt2_HashBeginString(HCkCrypt2 cHandle, const char *strData);
```

**Full documentation for this method (same in every language):** [Importance of Charset when Hashing Text](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/hashing_text.md)

To hash a large amount of text, start by processing the first chunk using this method. For subsequent chunks, use the `HashMoreString` method as needed. Conclude by calling `HashFinalENC` to obtain the final result. The hash algorithm is determined by the `HashAlgorithm` property setting.

Returns TRUE for success, FALSE for failure.

### Crypt2.HashChunkBd

`Chilkat 11.7.0 · c · Crypt2 · HashChunkBd · method · since 11.1.0`

```c
BOOL CkCrypt2_HashChunkBd(HCkCrypt2 cHandle, BOOL firstChunk, HCkBinData bd);
```

Start or continue hashing data in chunks. Set `firstChunk` to `TRUE` for the first chunk, and `FALSE` for subsequent chunks. Finish by calling `HashFinalENC` to obtain the result. The hash algorithm used is determined by the `HashAlgorithm` property.

Returns TRUE for success, FALSE for failure.

### Crypt2.HashFileENC

`Chilkat 11.7.0 · c · Crypt2 · HashFileENC · method`

```c
BOOL CkCrypt2_HashFileENC(HCkCrypt2 cHandle, const char *path, HCkString outStr);
const char *CkCrypt2_hashFileENC(HCkCrypt2 cHandle, const char *path);
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Hashes a file and returns the hash as an encoded string.

The hash algorithm is specified by the `HashAlgorithm` property, The encoding is controlled by the `EncodingMode` property, which can be set to `base64`, `hex`, `base64url`, or any of the encodings listed at the link below.

Any size file is supported because the file is hashed internally in streaming mode (keeping memory usage low and constant).

Returns TRUE for success, FALSE for failure.

Async variant: `HashFileENCAsync` — same arguments, returns a `Task` (see Async variants below).

### Crypt2.HashFinalENC

`Chilkat 11.7.0 · c · Crypt2 · HashFinalENC · method`

```c
BOOL CkCrypt2_HashFinalENC(HCkCrypt2 cHandle, HCkString outStr);
const char *CkCrypt2_hashFinalENC(HCkCrypt2 cHandle);
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Finalizes a multi-step hash computation and returns the hash bytes encoded according to the `EncodingMode` property setting.

Returns TRUE for success, FALSE for failure.

### Crypt2.HashMoreBytes2

`Chilkat 11.7.0 · c · Crypt2 · HashMoreBytes2 · method · since 9.5.0.82`

```c
BOOL CkCrypt2_HashMoreBytes2(HCkCrypt2 cHandle, const unsigned char *pByteData, unsigned long szByteData);
```

The same as HashMoreBytes except the binary data is passed via a pointer and length.

Returns TRUE for success, FALSE for failure.

### Crypt2.HashMoreString

`Chilkat 11.7.0 · c · Crypt2 · HashMoreString · method`

```c
BOOL CkCrypt2_HashMoreString(HCkCrypt2 cHandle, const char *strData);
```

Adds more text to the hash currently under computation. (See `HashBeginString`)

Returns TRUE for success, FALSE for failure.

### Crypt2.HashStringENC

`Chilkat 11.7.0 · c · Crypt2 · HashStringENC · method`

```c
BOOL CkCrypt2_HashStringENC(HCkCrypt2 cHandle, const char *str, HCkString outStr);
const char *CkCrypt2_hashStringENC(HCkCrypt2 cHandle, const char *str);
```

**Full documentation for this method (same in every language):** [Importance of Charset when Hashing Text](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/hashing_text.md) · [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Hashes the `str` and returns the hash as a binary encoded string. The `Charset` property determines the actual bytes that are hashed.

**Input** → **Get bytes according to** `Charset` → **Hash** → **Encode using** `EncodingMode` → **Output**

The encoding (e.g. `base64`, `hex`, etc.) is determined by the `EncodingMode` property.

The hash algorithm is determined by the `HashAlgorithm` property.

Returns TRUE for success, FALSE for failure.

### Crypt2.HasSignatureSigningTime

`Chilkat 11.7.0 · c · Crypt2 · HasSignatureSigningTime · method`

```c
BOOL CkCrypt2_HasSignatureSigningTime(HCkCrypt2 cHandle, int index);
```

After verifying a digital signature with a signature verification method, you can call this method. It returns `TRUE` if the signing time for the Nth certificate is available and can be accessed using the `GetSignatureSigningTimeStr` method.

### Crypt2.Hotp

`Chilkat 11.7.0 · c · Crypt2 · Hotp · method · since 9.5.0.77`

```c
BOOL CkCrypt2_Hotp(HCkCrypt2 cHandle, const char *secret, const char *secretEnc, const char *counterHex, int numDigits, int truncOffset, const char *hashAlg, HCkString outStr);
const char *CkCrypt2_hotp(HCkCrypt2 cHandle, const char *secret, const char *secretEnc, const char *counterHex, int numDigits, int truncOffset, const char *hashAlg);
```

Implements RFC 4226: HOTP: An HMAC-Based One-Time Password Algorithm. The arguments to this method are:

- `secret`: The shared secret in an enocded representation such as base64, hex, ascii, etc.
- `secretEnc`: The encoding of the shared secret, such as `base64`
- `counterHex`: The 8-byte counter in hexidecimal format.
- `numDigits`: The number of decimal digits to return.
- `truncOffset`: Normally set this to -1 for dynamic truncation. Otherwise can be set in the range 0..15.
- `hashAlg`: Normally set to `sha1`. Can be set to other hash algorithms such as `sha256`, `sha512`, etc.

Returns TRUE for success, FALSE for failure.

### Crypt2.LastDecryptCert

`Chilkat 11.7.0 · c · Crypt2 · LastDecryptCert · method · since 11.0.0`

```c
BOOL CkCrypt2_LastDecryptCert(HCkCrypt2 cHandle, HCkCert cert);
```

Returns in `cert` the last certificate used for public-key decryption.

Returns TRUE for success, FALSE for failure.

### Crypt2.LastSignerCert

`Chilkat 11.7.0 · c · Crypt2 · LastSignerCert · method · since 11.0.0`

```c
BOOL CkCrypt2_LastSignerCert(HCkCrypt2 cHandle, int index, HCkCert cert);
```

Retrieves the Nth certificate used for signing in `cert`, where the first certificate is at index 0. Use this method **after verifying a digital signature** to access the signer certificates. The `NumSignerCerts` property indicates the total number of signing certificates. Usually, only one certificate is used when creating a digital signature.

Returns TRUE for success, FALSE for failure.

### Crypt2.LoadTaskCaller

`Chilkat 11.7.0 · c · Crypt2 · LoadTaskCaller · method · since 9.5.0.80`

```c
BOOL CkCrypt2_LoadTaskCaller(HCkCrypt2 cHandle, HCkTask task);
```

Loads the caller of the task's async method.

Returns TRUE for success, FALSE for failure.

### Crypt2.MacBdENC

`Chilkat 11.7.0 · c · Crypt2 · MacBdENC · method · since 9.5.0.66`

```c
BOOL CkCrypt2_MacBdENC(HCkCrypt2 cHandle, HCkBinData bd, HCkString outStr);
const char *CkCrypt2_macBdENC(HCkCrypt2 cHandle, HCkBinData bd);
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Generates a **Message Authentication Code** (MAC) for the bytes in `bd` using the algorithm defined by the `MacAlgorithm` property. The resulting MAC is encoded into a string based on the `EncodingMode` property (e.g., `base64` or `hex`). The `HashAlgorithm` property determines the internal hash function. Before generating the MAC, specify the secret key using `SetMacKeyEncoded` .

Returns TRUE for success, FALSE for failure.

### Crypt2.MacStringENC

`Chilkat 11.7.0 · c · Crypt2 · MacStringENC · method · since 9.5.0.55`

```c
BOOL CkCrypt2_MacStringENC(HCkCrypt2 cHandle, const char *inText, HCkString outStr);
const char *CkCrypt2_macStringENC(HCkCrypt2 cHandle, const char *inText);
```

**Full documentation for this method (same in every language):** [Importance of Charset when Hashing Text](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/hashing_text.md) · [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Computes a Message Authentication Code (MAC) and returns it as a binary encoded string. The MAC algorithm is defined by the `MacAlgorithm` property. The `Charset` property determines the actual bytes that are hashed.

**Input** → **Get bytes according to** `Charset` → **MAC** → **Encode using** `EncodingMode` → **Output**

The encoding (e.g. `base64`, `hex`, etc.) is determined by the `EncodingMode` property.

The hash algorithm is determined by the `HashAlgorithm` property. The secret key must be set beforehand by calling `SetMacKeyEncoded` .

Returns TRUE for success, FALSE for failure.

### Crypt2.MySqlAesDecrypt

`Chilkat 11.7.0 · c · Crypt2 · MySqlAesDecrypt · method`

```c
BOOL CkCrypt2_MySqlAesDecrypt(HCkCrypt2 cHandle, const char *strEncryptedHex, const char *strPassword, HCkString outStr);
const char *CkCrypt2_mySqlAesDecrypt(HCkCrypt2 cHandle, const char *strEncryptedHex, const char *strPassword);
```

Matches `MySQL`'s `AES_DECRYPT` function. `strEncryptedHex` is a hex-encoded AES-encrypted string, and the return value is the original unencrypted string.

Returns TRUE for success, FALSE for failure.

### Crypt2.MySqlAesEncrypt

`Chilkat 11.7.0 · c · Crypt2 · MySqlAesEncrypt · method`

```c
BOOL CkCrypt2_MySqlAesEncrypt(HCkCrypt2 cHandle, const char *strData, const char *strPassword, HCkString outStr);
const char *CkCrypt2_mySqlAesEncrypt(HCkCrypt2 cHandle, const char *strData, const char *strPassword);
```

This function replicates `MySQL`'s `AES_ENCRYPT`, returning the encrypted data as a hex-encoded string. In MySQL, this is done using: `HEX(AES_ENCRYPT('The quick brown fox jumps over the lazy dog', 'password'))`.

Returns TRUE for success, FALSE for failure.

### Crypt2.OpaqueSignBd

`Chilkat 11.7.0 · c · Crypt2 · OpaqueSignBd · method · since 9.5.0.67`

```c
BOOL CkCrypt2_OpaqueSignBd(HCkCrypt2 cHandle, HCkBinData bd);
```

**Full documentation for this method (same in every language):** [About PKCS#7 signed-data Format](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/pkcs7_signed-data.md)

Digitally signs the contents of `bd`. If successful, the contents of `bd` are replaced with the `PKCS#7 signed-data`, which embeds the original data within the signature. Ensure a certificate is set using `SetSigningCert` before invoking this method. The `HashAlgorithm` property specifies the hash algorithm for creating the data's hash during signing.

Returns TRUE for success, FALSE for failure.

Async variant: `OpaqueSignBdAsync` — same arguments, returns a `Task` (see Async variants below).

### Crypt2.OpaqueSignStringENC

`Chilkat 11.7.0 · c · Crypt2 · OpaqueSignStringENC · method`

```c
BOOL CkCrypt2_OpaqueSignStringENC(HCkCrypt2 cHandle, const char *str, HCkString outStr);
const char *CkCrypt2_opaqueSignStringENC(HCkCrypt2 cHandle, const char *str);
```

**Full documentation for this method (same in every language):** [About PKCS#7 signed-data Format](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/pkcs7_signed-data.md) · [Why Charset Matters in Digital Signatures](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/charset_matters_in_digital_signatures.md) · [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Digitally signs a string and returns `PKCS#7 signed-data` as a `binary encoded string`. The `EncodingMode` property determines the binary encoding, such as `base64`, `hex`, `hex_lower`, `base64_mime`, etc. The `Charset` property determines the actual bytes that are hashed and signed. The `HashAlgorithm` property specifies the hash algorithm for creating the data's hash during signing.

Returns TRUE for success, FALSE for failure.

Async variant: `OpaqueSignStringENCAsync` — same arguments, returns a `Task` (see Async variants below).

### Crypt2.OpaqueVerifyBd

`Chilkat 11.7.0 · c · Crypt2 · OpaqueVerifyBd · method · since 9.5.0.67`

```c
BOOL CkCrypt2_OpaqueVerifyBd(HCkCrypt2 cHandle, HCkBinData bd);
```

**Full documentation for this method (same in every language):** [About PKCS#7 signed-data Format](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/pkcs7_signed-data.md)

The method performs in-place verification of the `PKCS#7 signed-data` content of `bd`. If the signature is successfully verified, the content of `bd` is replaced with the original data, and the method returns `TRUE`. If verification fails, `bd` remains unchanged, and the method returns `FALSE`. Afterwards, you can retrieve signer certificates by using the `NumSignerCerts` property and the `LastSignerCert` method.

Returns TRUE for success, FALSE for failure.

### Crypt2.OpaqueVerifyStringENC

`Chilkat 11.7.0 · c · Crypt2 · OpaqueVerifyStringENC · method`

```c
BOOL CkCrypt2_OpaqueVerifyStringENC(HCkCrypt2 cHandle, const char *p7m, HCkString outOriginal);
const char *CkCrypt2_opaqueVerifyStringENC(HCkCrypt2 cHandle, const char *p7m);
```

**Full documentation for this method (same in every language):** [About PKCS#7 signed-data Format](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/pkcs7_signed-data.md) · [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md) · [Why Charset Matters in Digital Signatures](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/charset_matters_in_digital_signatures.md)

This function verifies a `PKCS#7 signed-data` binary-encoded signature and returns the original text data. The `EncodingMode` property determines how `p7m` is decoded to bytes. If the signature does not verify successfully, it returns an empty string. The `Charset` property specifies how the original data bytes are converted to characters. You can obtain signer certificates using the `NumSignerCerts` property and the `LastSignerCert` method.

Returns TRUE for success, FALSE for failure.

### Crypt2.Pbkdf1

`Chilkat 11.7.0 · c · Crypt2 · Pbkdf1 · method`

```c
BOOL CkCrypt2_Pbkdf1(HCkCrypt2 cHandle, const char *password, const char *charset, const char *hashAlg, const char *salt, int iterationCount, int outputKeyBitLen, const char *encoding, HCkString outStr);
const char *CkCrypt2_pbkdf1(HCkCrypt2 cHandle, const char *password, const char *charset, const char *hashAlg, const char *salt, int iterationCount, int outputKeyBitLen, const char *encoding);
```

**Full documentation for this method (same in every language):** [More About PBKDF1](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/pbkdf1.md)

This function implements the `PBKDF1` (Password-Based Key Derivation Function #1) algorithm. Follow these guidelines to use it:

1. **`password`** (the password) is first converted using the character encoding specified by **`charset`** before being processed by the key derivation function.
2. **`hashAlg`** specifies the hash function to use, such as `md5`, `sha1`, or `md2`.
3. **`salt`** represents the salt, which should be random data of at least 8 bytes (64 bits). You can use the `GenRandomBytesENC` method to generate this.
4. **`iterationCount`** sets the iteration count, which must be a minimum of 1000.
5. **`outputKeyBitLen`** determines the length (in bits) of the derived key.
6. **`encoding`** defines the output encoding format, such as `base64` or `hex`, and also the expected encoding of **`salt`** (the salt).

The function returns the derived key.

Note: If `charset` is specified as hex or base64, the password (`password`) will be treated as binary data encoded in that format. It will be decoded into binary form and used directly as such.

Returns TRUE for success, FALSE for failure.

### Crypt2.Pbkdf2

`Chilkat 11.7.0 · c · Crypt2 · Pbkdf2 · method`

```c
BOOL CkCrypt2_Pbkdf2(HCkCrypt2 cHandle, const char *password, const char *charset, const char *hashAlg, const char *salt, int iterationCount, int outputKeyBitLen, const char *encoding, HCkString outStr);
const char *CkCrypt2_pbkdf2(HCkCrypt2 cHandle, const char *password, const char *charset, const char *hashAlg, const char *salt, int iterationCount, int outputKeyBitLen, const char *encoding);
```

**Full documentation for this method (same in every language):** [More about PBKDF2 Key Derivation](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/key_derivation_pbkdf2.md)

Implements the `PBKDF2` algorithm as follows:

1. Convert `password` to the character encoding specified by `charset` before using it in the key derivation function.
2. `hashAlg` specifies the hash algorithm. Options include `sha256`, `sha384`, `sha512`, `md5`, `sha1`, `md2`, or any algorithm listed in the HashAlgorithm property.
3. Provide a random `salt` value that is at least 8 bytes (64 bits) long. Use methods like `GenRandomBytesENC` to generate this salt value.
4. Ensure `iterationCount` is 1000 or greater.
5. Control the length of the derived key output using `outputKeyBitLen`.
6. Set `encoding` to specify the encoding format for the output and the expected encoding for `salt`. Options include `base64` and `hex`.

The derived key is the output of this process. Internally, PBKDF2 uses a pseudorandom function (PRF), specifically a keyed HMAC. The hash algorithm chosen with `hashAlg` dictates this PRF; for example, `SHA256` uses HMAC-SHA256, while `SHA1` uses HMAC-SHA1.

Note: If `charset` is `hex` or `base64`, `password` is treated as binary data. It will be decoded and used directly as a binary password. `SHA256` uses HMAC-SHA256, while `SHA1` uses HMAC-SHA1.

PBKDF1 and PBKDF2 are both key derivation functions used to strengthen passwords for cryptographic purposes, but PBKDF2 is the improved version.

- **PBKDF1**: Older and limited - it can only generate small keys (up to the hash function’s output size), making it less flexible and secure.
- **PBKDF2**: More advanced - it can generate longer keys, is more resistant to attacks, and is widely recommended for modern security needs.

In short, `PBKDF2` is stronger and more versatile than `PBKDF1`.

Returns TRUE for success, FALSE for failure.

### Crypt2.RandomizeIV

`Chilkat 11.7.0 · c · Crypt2 · RandomizeIV · method`

```c
void CkCrypt2_RandomizeIV(HCkCrypt2 cHandle);
```

Sets the initialization vector (IV) to a random value. The `CryptAlgorithm` property should be set prior to calling this method.

A **random IV** is used in symmetric encryption (like AES-CBC or AES-GCM) to ensure that encrypting the same plaintext with the same key produces **different ciphertext each time**. This prevents attackers from recognizing patterns in encrypted data and strengthens security.

**Why use a random IV?**

- It ensures **semantic security** (i.e. same plaintext never results in same ciphertext).
- Prevents replay and pattern attacks.
- Especially important in modes like **CBC** and **GCM**.

**How is the IV sent to the decrypting party?**

The IV is **not secret**, but it must be **available** for decryption. Common methods:

- **Prepended** to the ciphertext (e.g., `IV || ciphertext`)
- **Sent in a separate field** (e.g., JSON field, HTTP header)
- **Concatenated and encoded** (e.g., base64 of IV + ciphertext)

At the receiving side, the decryptor **extracts the IV** and uses it with the shared key to decrypt the ciphertext correctly.

### Crypt2.ReEncode

`Chilkat 11.7.0 · c · Crypt2 · ReEncode · method`

```c
BOOL CkCrypt2_ReEncode(HCkCrypt2 cHandle, const char *encodedData, const char *fromEncoding, const char *toEncoding, HCkString outStr);
const char *CkCrypt2_reEncode(HCkCrypt2 cHandle, const char *encodedData, const char *fromEncoding, const char *toEncoding);
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

This method converts between different encodings, such as from `base64` to `hex`. Each argument can be **any binary encoding supported by Chilkat**.

Returns TRUE for success, FALSE for failure.

### Crypt2.SetDecryptCert

`Chilkat 11.7.0 · c · Crypt2 · SetDecryptCert · method`

```c
BOOL CkCrypt2_SetDecryptCert(HCkCrypt2 cHandle, HCkCert cert);
```

**Full documentation for this method (same in every language):** [Certificates and Private Keys (Files and Sources)](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/certificates_and_private_keys.md)

Sets the digital certificate for decryption when the `CryptAlgorithm` property is set to `"pki"`. This method requires that the certificate has a private key.

Returns TRUE for success, FALSE for failure.

### Crypt2.SetDecryptCert2

`Chilkat 11.7.0 · c · Crypt2 · SetDecryptCert2 · method`

```c
BOOL CkCrypt2_SetDecryptCert2(HCkCrypt2 cHandle, HCkCert cert, HCkPrivateKey key);
```

Sets the digital certificate and associated private key for decryption when the `CryptAlgorithm` property is set to `"pki"`. The private key must be the one that matches the certificate's public key.

Returns TRUE for success, FALSE for failure.

### Crypt2.SetEncodedAad

`Chilkat 11.7.0 · c · Crypt2 · SetEncodedAad · method · since 9.5.0.55`

```c
BOOL CkCrypt2_SetEncodedAad(HCkCrypt2 cHandle, const char *aadStr, const char *encoding);
```

Sets the optional authenticated additional data (`AAD`) for AES encryption in `GCM` mode. The data is provided as a binary-encoded string using the specified `encoding`, and any binary encoding supported by Chilkat can be used.

In GCM (Galois/Counter Mode) encryption, AAD (Additional Authenticated Data) is optional input that is not encrypted but is authenticated along with the ciphertext. It's used to verify integrity of associated data like headers or metadata. If AAD is modified, decryption will fail due to authentication tag mismatch.

Returns TRUE for success, FALSE for failure.

### Crypt2.SetEncodedAuthTag

`Chilkat 11.7.0 · c · Crypt2 · SetEncodedAuthTag · method · since 9.5.0.55`

```c
BOOL CkCrypt2_SetEncodedAuthTag(HCkCrypt2 cHandle, const char *authTagStr, const char *encoding);
```

**Full documentation for this method (same in every language):** [Explaining the AES-GCM Authentication Tag](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/gcm_authentication_tag.md) · [AES-GCM Overview](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/aes_gcm_overview.md) · [Explaining Authenticated Encryption, such as AES-GCM](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/authenticated_encryption_gcm.md)

In GCM mode, the authentication tag is a short value (e.g. 16 bytes) **generated during encryption** that ensures the integrity and authenticity of both the ciphertext and any AAD. It must be verified during decryption to confirm the data hasn't been altered.

When decrypting AES-GCM, applications must call this method to provide the expected authentication tag.

To prevent Chilkat from checking the authentication tag after decryption, you can set the authentication tag to the special `hex` value `FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF` (16 bytes of 0xFF).

Returns TRUE for success, FALSE for failure.

### Crypt2.SetEncodedIV

`Chilkat 11.7.0 · c · Crypt2 · SetEncodedIV · method`

```c
void CkCrypt2_SetEncodedIV(HCkCrypt2 cHandle, const char *ivStr, const char *encoding);
```

**Full documentation for this method (same in every language):** [IV Length and Algorithm Block Size](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/symmetric_encrpytion_iv_and_algorithm_block_size.md) · [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Sets the initialization vector used in **symmetric encrpytion** (`AES`, `Blowfish`, etc.) from a binary-encoded string using any Chilkat-supported encoding method (e.g., `base64`, `hex`).

An **Initialization Vector (IV)** is a random or unique value used in symmetric encryption to ensure that encrypting the same plaintext multiple times produces different ciphertexts. It prevents pattern leakage.

**Cipher Modes That Require an IV:**

- `CBC` (Cipher Block Chaining)
- `CFB` (Cipher Feedback)
- `OFB` (Output Feedback)
- `CTR` (Counter Mode)
- `GCM` (Galois/Counter Mode)

**ECB (Electronic Codebook)** does \*not\* use an IV, which makes it less secure.

### Crypt2.SetEncodedKey

`Chilkat 11.7.0 · c · Crypt2 · SetEncodedKey · method`

```c
void CkCrypt2_SetEncodedKey(HCkCrypt2 cHandle, const char *keyStr, const char *encoding);
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Sets the encryption key used in **symmetric encryption** (`AES`, `Blowfish`, etc.) from a binary-encoded string using any Chilkat-supported encoding method (e.g., `base64`, `hex`).

The key must have a byte size equal to the `KeyLength` property. For instance, a KeyLength of `128 bits` requires a `16-byte` key, and a KeyLength of `256 bits` requires a `32-byte` key.

### Crypt2.SetEncodedSalt

`Chilkat 11.7.0 · c · Crypt2 · SetEncodedSalt · method`

```c
void CkCrypt2_SetEncodedSalt(HCkCrypt2 cHandle, const char *saltStr, const char *encoding);
```

**Full documentation for this method (same in every language):** [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md) · [Explaining PBES2 Encryption](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/explaining_pbes2_encryption.md)

Sets the `pbes2` or `pbes1` salt bytes from a binary-encoded string using any Chilkat-supported encoding method (e.g., `base64`, `hex`).

This salt is used for encryption and decryption when the `CryptAlgorithm` property is set to `pbes1` or `pbes2`. Note: This does not apply to the `Pbkdf1` or `Pbkdf2` methods, where the salt is provided as a function argument.

### Crypt2.SetEncryptCert

`Chilkat 11.7.0 · c · Crypt2 · SetEncryptCert · method`

```c
BOOL CkCrypt2_SetEncryptCert(HCkCrypt2 cHandle, HCkCert cert);
```

Instructs the encryption library to use a specified digital certificate for public-key encryption. To encrypt using multiple certificates, call `AddEncryptCert` for each one. This action is equivalent to calling `ClearEncryptCerts` before `AddEncryptCert` .

Returns TRUE for success, FALSE for failure.

### Crypt2.SetIV

`Chilkat 11.7.0 · c · Crypt2 · SetIV · method`

```c
void CkCrypt2_SetIV(HCkCrypt2 cHandle, const unsigned char *pByteData, unsigned long szByteData);
```

**Full documentation for this method (same in every language):** [IV Length and Algorithm Block Size](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/symmetric_encrpytion_iv_and_algorithm_block_size.md)

Sets the initialization vector (IV) for a symmetric encryption algorithm like AES.

### Crypt2.SetMacKeyEncoded

`Chilkat 11.7.0 · c · Crypt2 · SetMacKeyEncoded · method · since 9.5.0.55`

```c
BOOL CkCrypt2_SetMacKeyEncoded(HCkCrypt2 cHandle, const char *key, const char *encoding);
```

**Full documentation for this method (same in every language):** [MAC Key Ambiguity](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/mac_key_ambiguity.md) · [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Sets the MAC key from a binary-encoded string using any Chilkat-supported encoding method (e.g., `base64`, `hex`).

Returns TRUE for success, FALSE for failure.

### Crypt2.SetMacKeyString

`Chilkat 11.7.0 · c · Crypt2 · SetMacKeyString · method · since 9.5.0.55`

```c
BOOL CkCrypt2_SetMacKeyString(HCkCrypt2 cHandle, const char *key);
```

**Full documentation for this method (same in every language):** [Mac Key Ambiguity](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/mac_key_ambiguity.md)

Sets the MAC key from a string. The `Charset` property determines the actual bytes used for the MAC key.

Returns TRUE for success, FALSE for failure.

### Crypt2.SetSecretKey

`Chilkat 11.7.0 · c · Crypt2 · SetSecretKey · method`

```c
void CkCrypt2_SetSecretKey(HCkCrypt2 cHandle, const unsigned char *pByteData, unsigned long szByteData);
```

Sets the encryption key used in **symmetric encrpytion** (`AES`, `Blowfish`, etc.).

The key must have a byte size equal to the `KeyLength` property. For instance, a KeyLength of `128 bits` requires a `16-byte` key, and a KeyLength of `256 bits` requires a `32-byte` key.

### Crypt2.SetSigningCert

`Chilkat 11.7.0 · c · Crypt2 · SetSigningCert · method`

```c
BOOL CkCrypt2_SetSigningCert(HCkCrypt2 cHandle, HCkCert cert);
```

Sets the digital certificate to be used for signing. Signing requires that the certificate has a private key.

Returns TRUE for success, FALSE for failure.

### Crypt2.SetSigningCert2

`Chilkat 11.7.0 · c · Crypt2 · SetSigningCert2 · method`

```c
BOOL CkCrypt2_SetSigningCert2(HCkCrypt2 cHandle, HCkCert cert, HCkPrivateKey privateKey);
```

Sets the digital certificate and associated private key for signing. The private key must be the one that matches the certificate's public key.

Returns TRUE for success, FALSE for failure.

### Crypt2.SetTsaHttpObj

`Chilkat 11.7.0 · c · Crypt2 · SetTsaHttpObj · method`

```c
void CkCrypt2_SetTsaHttpObj(HCkCrypt2 cHandle, HCkHttp http);
```

If timestamp server communications are needed for signing and special Internet settings like a proxy server are necessary, this method can provide an Http object configured with these settings.

### Crypt2.SetVerifyCert

`Chilkat 11.7.0 · c · Crypt2 · SetVerifyCert · method`

```c
BOOL CkCrypt2_SetVerifyCert(HCkCrypt2 cHandle, HCkCert cert);
```

Assigns the digital certificate for signature verification. Typically, a PKCS7 (CMS) signature includes the signing certificate information, making it **unnecessary to call this method explicitly**. This is only required in rare instances.

Returns TRUE for success, FALSE for failure.

### Crypt2.SignBdENC

`Chilkat 11.7.0 · c · Crypt2 · SignBdENC · method · since 9.5.0.67`

```c
BOOL CkCrypt2_SignBdENC(HCkCrypt2 cHandle, HCkBinData dataToSign, HCkString outStr);
const char *CkCrypt2_signBdENC(HCkCrypt2 cHandle, HCkBinData dataToSign);
```

**Full documentation for this method (same in every language):** [About PKCS#7 signed-data Format](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/pkcs7_signed-data.md) · [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Digitally signs the content in `dataToSign` and returns a `detached` signature (`PKCS#7 signed-data`) as a binary-encoded string. The `EncodingMode` property determines the binary-encoding. Possible encodings include `base64`, `base64_mime`, `hex`, and `hex_lower`. The `HashAlgorithm` property specifies the hash algorithm for creating the data's hash during signing.

Returns TRUE for success, FALSE for failure.

Async variant: `SignBdENCAsync` — same arguments, returns a `Task` (see Async variants below).

### Crypt2.SignHashENC

`Chilkat 11.7.0 · c · Crypt2 · SignHashENC · method · since 9.5.0.90`

```c
BOOL CkCrypt2_SignHashENC(HCkCrypt2 cHandle, const char *encodedHash, const char *hashAlg, const char *hashEncoding, HCkString outStr);
const char *CkCrypt2_signHashENC(HCkCrypt2 cHandle, const char *encodedHash, const char *hashAlg, const char *hashEncoding);
```

**Full documentation for this method (same in every language):** [About PKCS#7 signed-data Format](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/pkcs7_signed-data.md) · [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md) · [Digital Signatures Actually Sign the Hash of the Data](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/digital_signatures_sign_the_hash.md)

Digitally signs a pre-computed hash and returns a `detached` signature (`PKCS#7 signed-data`) as a binary-encoded string. The `EncodingMode` property determines the binary-encoding. Possible encodings include `base64`, `base64_mime`, `hex`, and `hex_lower`

`encodedHash` is a binary-encoded hash to be signed, with its encoding format specified by `hashEncoding` (e.g., `base64`, `hex`). `hashAlg` specifies the hash algorithm (e.g., `sha256`, `sha1`, `sha512`) used for `encodedHash`.

Returns TRUE for success, FALSE for failure.

Async variant: `SignHashENCAsync` — same arguments, returns a `Task` (see Async variants below).

### Crypt2.SignSbENC

`Chilkat 11.7.0 · c · Crypt2 · SignSbENC · method · since 9.5.0.67`

```c
BOOL CkCrypt2_SignSbENC(HCkCrypt2 cHandle, HCkStringBuilder sb, HCkString outStr);
const char *CkCrypt2_signSbENC(HCkCrypt2 cHandle, HCkStringBuilder sb);
```

**Full documentation for this method (same in every language):** [About PKCS#7 signed-data Format](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/pkcs7_signed-data.md) · [Why Charset Matters in Digital Signatures](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/charset_matters_in_digital_signatures.md) · [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Digitally signs the text contained in `sb` and returns a `detached` signature (`PKCS#7 signed-data`) as a binary-encoded string. The `EncodingMode` property determines the binary-encoding. Possible encodings include `base64`, `base64_mime`, `hex`, and `hex_lower`. The `HashAlgorithm` property specifies the hash algorithm for creating the data's hash during signing. The `Charset` property determines the actual bytes that are hashed and signed.

Returns TRUE for success, FALSE for failure.

Async variant: `SignSbENCAsync` — same arguments, returns a `Task` (see Async variants below).

### Crypt2.SignStringENC

`Chilkat 11.7.0 · c · Crypt2 · SignStringENC · method`

```c
BOOL CkCrypt2_SignStringENC(HCkCrypt2 cHandle, const char *str, HCkString outStr);
const char *CkCrypt2_signStringENC(HCkCrypt2 cHandle, const char *str);
```

**Full documentation for this method (same in every language):** [About PKCS#7 signed-data Format](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/pkcs7_signed-data.md) · [Why Charset Matters in Digital Signatures](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/charset_matters_in_digital_signatures.md) · [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Digitally signs a string and returns a `detached` signature (`PKCS#7 signed-data`) as a binary-encoded string. The `EncodingMode` property determines the binary-encoding. Possible encodings include `base64`, `base64_mime`, `hex`, and `hex_lower`. The `HashAlgorithm` property specifies the hash algorithm for creating the data's hash during signing. The `Charset` property determines the actual bytes that are hashed and signed.

Returns TRUE for success, FALSE for failure.

Async variant: `SignStringENCAsync` — same arguments, returns a `Task` (see Async variants below).

### Crypt2.Totp

`Chilkat 11.7.0 · c · Crypt2 · Totp · method · since 9.5.0.77`

```c
BOOL CkCrypt2_Totp(HCkCrypt2 cHandle, const char *secret, const char *secretEnc, const char *t0, const char *tNow, int tStep, int numDigits, int truncOffset, const char *hashAlg, HCkString outStr);
const char *CkCrypt2_totp(HCkCrypt2 cHandle, const char *secret, const char *secretEnc, const char *t0, const char *tNow, int tStep, int numDigits, int truncOffset, const char *hashAlg);
```

Implements RFC 6238: TOTP: Time-Based One-Time Password Algorithm. The arguments to this method are:

- `secret`: The shared secret in an enocded representation such as base64, hex, ascii, etc.
- `secretEnc`: The encoding of the shared secret, such as `base64`
- `t0`: The Unix time to start counting time steps. It is a number in decimal string form. A Unix time is the number of seconds elapsed since midnight UTC of January 1, 1970. `0` is a typical value used for this argument.
- `tNow`: The current Unix time in decimal string form. To use the current system date/time, pass an empty string for this argument.
- `tStep`: The time step in seconds. A typical value is 30. Note: Both client and server must pre-agree on the secret, the t0, and the tStep.
- `numDigits`: The number of decimal digits to return.
- `truncOffset`: Normally set this to -1 for dynamic truncation. Otherwise can be set in the range 0..15.
- `hashAlg`: Normally set to `sha1`. Can be set to other hash algorithms such as `sha256`, `sha512`, etc.

Returns TRUE for success, FALSE for failure.

### Crypt2.UseCertVault

`Chilkat 11.7.0 · c · Crypt2 · UseCertVault · method · since 9.5.0.40`

```c
BOOL CkCrypt2_UseCertVault(HCkCrypt2 cHandle, HCkXmlCertVault vault);
```

Adds an XML certificate vault to the object's internal list of sources to be searched for certificates and private keys when encrypting/decrypting or signing/verifying. Unlike the AddPfxSourceData and AddPfxSourceFile methods, only a single XML certificate vault can be used. If UseCertVault is called multiple times, only the last certificate vault will be used, as each call to UseCertVault will replace the certificate vault provided in previous calls.

Returns TRUE for success, FALSE for failure.

### Crypt2.VerifyBdENC

`Chilkat 11.7.0 · c · Crypt2 · VerifyBdENC · method · since 9.5.0.67`

```c
BOOL CkCrypt2_VerifyBdENC(HCkCrypt2 cHandle, HCkBinData data, const char *encodedSig);
```

**Full documentation for this method (same in every language):** [About PKCS#7 signed-data Format](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/pkcs7_signed-data.md) · [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Verifies a `detached digital signature` against the original data contained in `data`. Returns `TRUE` if the signature is verified. The `encodedSig` holds a binary-encoded `PKCS#7 signed-data` detached signature. The type of binary encoding, such as `base64,` `hex,` or `base64_mime,` is determined by the `EncodingMode` property.

Afterwards, you can retrieve signer certificates by using the `NumSignerCerts` property and the `LastSignerCert` method.

Returns TRUE for success, FALSE for failure.

### Crypt2.VerifyP7M

`Chilkat 11.7.0 · c · Crypt2 · VerifyP7M · method`

```c
BOOL CkCrypt2_VerifyP7M(HCkCrypt2 cHandle, const char *p7mPath, const char *destPath);
```

**Full documentation for this method (same in every language):** [About PKCS#7 signed-data Format](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/pkcs7_signed-data.md)

Verifies an `opaque digital signature` contained in a `.p7m` file and extracts the original data to `destPath`. Returns `TRUE` if the .p7m is validated and the original data was extracted. Otherwise returns `FALSE`.

Afterwards, you can retrieve signer certificates by using the `NumSignerCerts` property and the `LastSignerCert` method.

Returns TRUE for success, FALSE for failure.

### Crypt2.VerifyP7S

`Chilkat 11.7.0 · c · Crypt2 · VerifyP7S · method`

```c
BOOL CkCrypt2_VerifyP7S(HCkCrypt2 cHandle, const char *originalDataPath, const char *p7sPath);
```

**Full documentation for this method (same in every language):** [About PKCS#7 signed-data Format](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/pkcs7_signed-data.md)

Verifies a `detached digital signature` contained in a `.p7s` file against the original data contained in `originalDataPath`. Returns `TRUE` if the signature is verified.

Afterwards, you can retrieve signer certificates by using the `NumSignerCerts` property and the `LastSignerCert` method.

Returns TRUE for success, FALSE for failure.

### Crypt2.VerifySbENC

`Chilkat 11.7.0 · c · Crypt2 · VerifySbENC · method · since 9.5.0.67`

```c
BOOL CkCrypt2_VerifySbENC(HCkCrypt2 cHandle, HCkStringBuilder sb, const char *encodedSig);
```

**Full documentation for this method (same in every language):** [About PKCS#7 signed-data Format](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/pkcs7_signed-data.md) · [Why Charset Matters in Digital Signatures](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/charset_matters_in_digital_signatures.md) · [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Verifies a `detached digital signature` against the original text contained in `sb`. Returns `TRUE` if the signature is verified. The `encodedSig` holds a binary-encoded `PKCS#7 signed-data` detached signature. The type of binary encoding, such as `base64,` `hex,` or `base64_mime,` is determined by the `EncodingMode` property. The `Charset` property determines how the text in `sb` is converted to bytes for signature validation.

Afterwards, you can retrieve signer certificates by using the `NumSignerCerts` property and the `LastSignerCert` method.

Returns TRUE for success, FALSE for failure.

### Crypt2.VerifyStringENC

`Chilkat 11.7.0 · c · Crypt2 · VerifyStringENC · method`

```c
BOOL CkCrypt2_VerifyStringENC(HCkCrypt2 cHandle, const char *str, const char *encodedSig);
```

**Full documentation for this method (same in every language):** [About PKCS#7 signed-data Format](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/pkcs7_signed-data.md) · [Why Charset Matters in Digital Signatures](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/charset_matters_in_digital_signatures.md) · [Supported Binary Encodings](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Verifies a `detached digital signature` against the original text in `str`. Returns `TRUE` if the signature is verified. The `encodedSig` holds a binary-encoded `PKCS#7 signed-data` detached signature. The type of binary encoding, such as `base64,` `hex,` or `base64_mime,` is determined by the `EncodingMode` property. The `Charset` property determines how the text in `str` is converted to bytes for signature validation.

Afterwards, you can retrieve signer certificates by using the `NumSignerCerts` property and the `LastSignerCert` method.

Returns TRUE for success, FALSE for failure.

### Crypt2.XtsSetDataUnitNumber

`Chilkat 11.7.0 · c · Crypt2 · XtsSetDataUnitNumber · method · since 9.5.0.91`

```c
void CkCrypt2_XtsSetDataUnitNumber(HCkCrypt2 cHandle, unsigned long loUint32, unsigned long hiUint32);
```

Sets the XTS-AES mode data unit number. The data unit number is a 64-bit unsigned integer. It is passed in as two 32-bit unsigned integers representing the high and low 32-bits.

Setting the data unit number is one way of setting the tweak value. The tweak value is 16 bytes in length and can alternatively be set by calling XtsSetEncodedTweakValue.

This method sets the tweak value such that the first 8 bytes are composed of the little-endian 64-bit data unit number, followed by 8 zero bytes.

(Unfortunately, Chilkat cannot use 64-bit integers in method arguments because many older programming environments, such as ActiveX, do not support it. Chilkat must present an identical and uniform API across all programming languages.)

### Crypt2.XtsSetEncodedTweakKey

`Chilkat 11.7.0 · c · Crypt2 · XtsSetEncodedTweakKey · method · since 9.5.0.91`

```c
void CkCrypt2_XtsSetEncodedTweakKey(HCkCrypt2 cHandle, const char *key, const char *encoding);
```

Sets the XTS-AES mode tweak key from an encoded string. The encoding argument can be set to any of the following strings: `base64`, `hex`, `quoted-printable`, `ascii`, or `url`. The tweak key should be equal in size to the encryption key. For example, to do 256-bit AES-XTS, the encryption key is 256-bits, and the tweak key is also 256-bits.

### Crypt2.XtsSetEncodedTweakValue

`Chilkat 11.7.0 · c · Crypt2 · XtsSetEncodedTweakValue · method · since 9.5.0.91`

```c
void CkCrypt2_XtsSetEncodedTweakValue(HCkCrypt2 cHandle, const char *tweak, const char *encoding);
```

Sets the XTS-AES mode tweak value from an encoded string. The encoding argument can be set to any of the following strings: `base64`, `hex`, `quoted-printable`, `ascii`, or `url`.

The tweak value must be 16 bytes in length. An application can set the initial tweak value by calling this method, or by calling XtsSetDataUnitNumber (but not both).

## Events and callbacks

This binding delivers progress information through callbacks (AbortCheck, PercentDone, ProgressInfo, TaskCompleted) rather than events. See `guide.md` for how to attach them in C.

## Async variants

Each returns a `Task` instead of the result and takes the same arguments as the synchronous method; run the task, wait for `Finished`, then read the result from the task. No new Async methods are added from 11.7.0 on.

```c
HCkTask CkCrypt2_CkDecryptFileAsync(HCkCrypt2 cHandle, const char *srcFile, const char *destFile);
HCkTask CkCrypt2_CkEncryptFileAsync(HCkCrypt2 cHandle, const char *srcFile, const char *destFile);
HCkTask CkCrypt2_CrcFileAsync(HCkCrypt2 cHandle, const char *crcAlg, const char *path);
HCkTask CkCrypt2_CreateP7MAsync(HCkCrypt2 cHandle, const char *inFilename, const char *p7mPath);
HCkTask CkCrypt2_CreateP7SAsync(HCkCrypt2 cHandle, const char *inFilename, const char *p7sPath);
HCkTask CkCrypt2_HashFileENCAsync(HCkCrypt2 cHandle, const char *path);
HCkTask CkCrypt2_OpaqueSignBdAsync(HCkCrypt2 cHandle, HCkBinData bd);
HCkTask CkCrypt2_OpaqueSignStringENCAsync(HCkCrypt2 cHandle, const char *str);
HCkTask CkCrypt2_SignBdENCAsync(HCkCrypt2 cHandle, HCkBinData dataToSign);
HCkTask CkCrypt2_SignHashENCAsync(HCkCrypt2 cHandle, const char *encodedHash, const char *hashAlg, const char *hashEncoding);
HCkTask CkCrypt2_SignSbENCAsync(HCkCrypt2 cHandle, HCkStringBuilder sb);
HCkTask CkCrypt2_SignStringENCAsync(HCkCrypt2 cHandle, const char *str);
```

## Deprecated members — do not use in new code

| Member | Kind | Deprecated in | Use instead |
|---|---|---|---|
| `AddPfxSourceData` | method | before 11.6.1 | — |
| `CrcBytes` | method | before 11.6.1 | — |
| `CreateDetachedSignature` | method | before 11.6.1 | `CreateP7S` |
| `Decode` | method | before 11.6.1 | — |
| `DecryptBytes` | method | before 11.6.1 | — |
| `DecryptBytes2` | method | before 11.6.1 | — |
| `DecryptBytesENC` | method | before 11.6.1 | — |
| `DecryptStream` | method | before 11.6.1 | — |
| `DecryptString` | method | before 11.6.1 | — |
| `Encode` | method | before 11.6.1 | — |
| `EncryptBytes` | method | before 11.6.1 | — |
| `EncryptBytes2` | method | before 11.6.1 | — |
| `EncryptBytesENC` | method | before 11.6.1 | — |
| `EncryptStream` | method | before 11.6.1 | — |
| `EncryptString` | method | before 11.6.1 | — |
| `GenEncodedSecretKey` | method | before 11.6.1 | — |
| `GenerateSecretKey` | method | before 11.6.1 | `Pbkdf2` |
| `GetDecryptCert` | method | before 11.6.1 | — |
| `GetEncodedAad` | method | before 11.6.1 | — |
| `GetEncodedKey` | method | before 11.6.1 | — |
| `GetEncodedSalt` | method | before 11.6.1 | — |
| `GetSignerCert` | method | before 11.6.1 | — |
| `GetSignerCertChain` | method | before 11.6.1 | — |
| `HashBeginBytes` | method | before 11.6.1 | — |
| `HashBytes` | method | before 11.6.1 | — |
| `HashBytes2` | method | before 11.6.1 | — |
| `HashBytesENC` | method | before 11.6.1 | — |
| `HashFile` | method | before 11.6.1 | `HashFileENC` |
| `HashFinal` | method | before 11.6.1 | `HashFinalENC` |
| `HashMoreBytes` | method | before 11.6.1 | — |
| `HashString` | method | before 11.6.1 | `HashStringENC` |
| `LastJsonData` | method | before 11.6.1 | `GetLastJsonData` |
| `MacBytes` | method | before 11.6.1 | `MacBdENC` |
| `MacBytes2` | method | before 11.6.1 | — |
| `MacBytesENC` | method | before 11.6.1 | `MacBdENC` |
| `MacString` | method | before 11.6.1 | `MacStringENC` |
| `OpaqueSignBytes` | method | before 11.6.1 | `OpaqueSignBd` |
| `OpaqueSignBytes2` | method | before 11.6.1 | — |
| `OpaqueSignBytesENC` | method | before 11.6.1 | — |
| `OpaqueSignString` | method | before 11.6.1 | — |
| `OpaqueVerifyBytes` | method | before 11.6.1 | — |
| `OpaqueVerifyBytes2` | method | before 11.6.1 | — |
| `OpaqueVerifyBytesENC` | method | before 11.6.1 | — |
| `OpaqueVerifyString` | method | before 11.6.1 | — |
| `RandomizeKey` | method | before 11.6.1 | `GenRandomBytesENC` |
| `SetMacKeyBytes` | method | before 11.6.1 | `SetMacKeyEncoded` |
| `SetSecretKeyViaPassword` | method | before 11.6.1 | `Pbkdf2` |
| `SignBytes` | method | before 11.6.1 | — |
| `SignBytes2` | method | before 11.6.1 | — |
| `SignBytesENC` | method | before 11.6.1 | — |
| `SignString` | method | before 11.6.1 | — |
| `VerifyBytes` | method | before 11.6.1 | — |
| `VerifyBytesENC` | method | before 11.6.1 | — |
| `VerifyDetachedSignature` | method | before 11.6.1 | `VerifyP7S` |
| `VerifyString` | method | before 11.6.1 | — |

## Related classes

[`BinData`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/c/classes/BinData.md), [`Cert`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/c/classes/Cert.md), [`Http`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/c/classes/Http.md), [`JsonObject`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/c/classes/JsonObject.md), [`PrivateKey`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/c/classes/PrivateKey.md), [`SecureString`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/c/classes/SecureString.md), [`StringBuilder`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/c/classes/StringBuilder.md), [`Task`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/c/classes/Task.md), [`XmlCertVault`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/c/classes/XmlCertVault.md)

