CkCrypt2 Ruby Programming
Reference Documentation

CkCrypt2

Chilkat encryption component.

Object Creation

obj = Chilkat::CkCrypt2.new()

Properties

# Returns an integer value
get_BlockSize( )

The block-size (in bytes) of the selected encryption algorithm. For example, if the CryptAlgorithm property is set to "aes", the BlockSize property is automatically set to 16. The block-size for the ARC4 streaming encryption algorithm is 1.

# Returns a boolean value
get_CadesEnabled( )

# newVal is a boolean (input)
put_CadesEnabled( newVal )

To be documented soon...

# str is a CkString object (output)
get_CadesSigPolicyHash( str )

# newVal is a string (input)
put_CadesSigPolicyHash( newVal )

To be documented soon...

# str is a CkString object (output)
get_CadesSigPolicyId( str )

# newVal is a string (input)
put_CadesSigPolicyId( newVal )

To be documented soon...

# str is a CkString object (output)
get_CadesSigPolicyUri( str )

# newVal is a string (input)
put_CadesSigPolicyUri( newVal )

To be documented soon...

# out is a CkString object (output)
get_Charset( out )

# str is a string (input)
put_Charset( str )

Controls the character encoding of the text encrypted, signed, hashed or compressed. This property is relevant wherever strings are used as inputs or outputs.

When working with strings, it is important to know the exact bytes that are being encrypted/hashed/signed/compressed. This is critical when interoperating with other systems. If your application is sending an encrypted string to another system that will decrypt it, you will need to know the encoding of the string that is expected on the receiving end (after decryption). If you pass Unicode data (2 byte per character) to the encryptor, subsequent decryption will reproduce the original Unicode. However, it may be that your program works with Unicode strings, but the recipient of the encrypted data works with iso-8859-1 strings. In such a case, setting the Charset property to "iso-8859-1" causes the character data to be automatically converted to the Charset before being encrypted (or compressed, or hashed, or signed). The set of valid charsets is listed below:

ANSI
us-ascii
unicode
unicodefffe
iso-8859-1
iso-8859-2
iso-8859-3
iso-8859-4
iso-8859-5
iso-8859-6
iso-8859-7
iso-8859-8
iso-8859-9
iso-8859-13
iso-8859-15
windows-874
windows-1250
windows-1251
windows-1252
windows-1253
windows-1254
windows-1255
windows-1256
windows-1257
windows-1258
utf-7
utf-8
utf-32
utf-32be
shift_jis
gb2312
ks_c_5601-1987
big5
iso-2022-jp
iso-2022-kr
euc-jp
euc-kr
macintosh
x-mac-japanese
x-mac-chinesetrad
x-mac-korean
x-mac-arabic
x-mac-hebrew
x-mac-greek
x-mac-cyrillic
x-mac-chinesesimp
x-mac-romanian
x-mac-ukrainian
x-mac-thai
x-mac-ce
x-mac-icelandic
x-mac-turkish
x-mac-croatian
asmo-708
dos-720
dos-862
ibm037
ibm437
ibm500
ibm737
ibm775
ibm850
ibm852
ibm855
ibm857
ibm00858
ibm860
ibm861
ibm863
ibm864
ibm865
cp866
ibm869
ibm870
cp875
koi8-r
koi8-u

# out is a CkString object (output)
get_CipherMode( out )

# newVal is a string (input)
put_CipherMode( newVal )

Controls the cipher mode for Rijndael and Twofish encryption. Possible values are "CBC" (the default) and "ECB".

CBC is an acronym for Cipher Block Chaining, ECB is an acronym for Electronic CookBook.

# out is a CkString object (output)
get_CompressionAlgorithm( out )

# alg is a string (input)
put_CompressionAlgorithm( alg )

Selects the compression algorithm to be used for the various compress and inflate methods. Currently, the only valid setting is "BZIP2".

# out is a CkString object (output)
get_CryptAlgorithm( out )

# str is a string (input)
put_CryptAlgorithm( str )

Selects the encryption algorithm for encrypting and decrypting. Possible values are: "pki", "aes", "rijndael", "blowfish", "blowfish2", "des", "3des", "rc2", "arc4", "twofish", "pbes1" and "pbes2". The "pki" encryption algorithm isn't a specific algorithm, but instead tells the component to encrypt/decrypt using public-key encryption with digital certificates. The other choices, rijndael, blowfish, and twofish, are symmetric encryption algorithms that do not involve digital certificates and public/private keys.

The original Chilkat implementation of Blowfish has a 4321 byte-swapping issue (the results are 4321 byte-swapped). The new implementation ("blowfish2") does not byte swap. This should be used for compatibility with other Blowfish software.

Password-based encryption (PBE) is selected by setting this property to "pbes1" or "pbes2". Password-based encryption is defined in the PKCS5 Password-Based Cryptography Standard at http://www.rsa.com/rsalabs/node.asp?id=2127. If PBE is used, the underlying encryption algorithm is specified by the PbesAlgorithm property. The underlying encryption (PbesAlgorithm) for PBES1 is limited to 56-bit DES or 64-bit RC2.

# out is a CkString object (output)
get_EncodingMode( out )

# str is a string (input)
put_EncodingMode( str )

Controls the encoding of binary data to a printable string for many methods. The valid modes are "Base64", "Base32", "UU", "QP" (for quoted-printable), "URL" (for url-encoding), and "Hex".

# Returns a boolean value
get_FirstChunk( )

# b is a boolean (input)
put_FirstChunk( b )

Chilkat Crypt2 provides the ability to feed the encryption/decryption methods with chunks of data. This allows a large amount of data, or a data stream, to be fed piecemeal for encrypting or decrypting. It applies to all symmetric algorithms currently supported (AES, Blowfish, Twofish, 3DES, RC2, DES, ARC4), and all algorithms supported in the future.

The default value for both FirstChunk and LastChunk is true — meaning that when you call an Encrypt* or Decrypt* method, it is both the first and last chunk (i.e. it’s the entire amount of data to be encrypted or decrypted).

If you wish to feed the data piecemeal, do this:

1. Set FirstChunk = true, LastChunk = false for the first chunk of data.
2. For all “middle” chunks (i.e. all chunks except for the final chunk) set FirstChunk = false and LastChunk = false.
3. For the final chunk, set FirstChunk = false and LastChunk = true

You don’t need to worry about feeding data according to the block size of the encryption algorithm. For example, AES has a block size of 16 bytes. You may feed data in chunks of any size. The Chilkat Crypt2 component will buffer the data. When the final chunk is passed, the output is padded to the algorithm’s block size according to the PaddingScheme.

more info about FirstChunk/LastChunk

# out is a CkString object (output)
get_HashAlgorithm( out )

# str is a string (input)
put_HashAlgorithm( str )

Selects the hash algorithm used by methods that create hashes. The valid choices are "sha1", "sha256", "sha384", "sha512", "md2", "md5", "haval", "ripemd128", "ripemd160","ripemd256", or "ripemd320".

# Returns an integer value
get_HavalRounds( )

# newVal is an integer (input)
put_HavalRounds( 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.

# bData is a CkByteData object (output)
get_IV( bData )

# bData is a CkByteData object (input)
put_IV( bData )

The initialization vector to be used with symmetric encryption algorithms (Rijndael, Blowfish, Twofish). If left unset, no initialization vector is used.

# Returns a boolean value
get_IncludeCertChain( )

# newVal is a boolean (input)
put_IncludeCertChain( newVal )

Only applies when creating digital signatures. If true (the default), then additional certificates (if any) in the chain of authentication are included in the PKCS7 digital signature.

# Returns an integer value
get_IterationCount( )

# newVal is an integer (input)
put_IterationCount( newVal )

Iteration count to be used with password-based encryption (PBE). Password-based encryption is defined in the PKCS5 Password-Based Cryptography Standard at http://www.rsa.com/rsalabs/node.asp?id=2127

The purpose of the iteration count is to increase the computation required to encrypt and decrypt. A larger iteration count makes cracking via exhaustive search more difficult. The default value is 1024.

# Returns an integer value
get_KeyLength( )

# newVal is an integer (input)
put_KeyLength( newVal )

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

# Returns a boolean value
get_LastChunk( )

# b is a boolean (input)
put_LastChunk( b )

(See the description for the FirstChunk property.)

# str is a CkString object (output)
LastErrorHtml( str )

Error information in HTML format for the last method called.

# str is a CkString object (output)
LastErrorText( str )

Error information in plain-text format for the last method called.

# str is a CkString object (output)
LastErrorXml( str )

Error information in XML format for the last method called.

# Returns an integer value
get_NumSignerCerts( )

This property is set when a digital signature is verified. It contains the number of signer certificates. Each signing certificate can be retrieved by calling the GetSignerCert method, passing an index from 0 to NumSignerCerts-1.

# Returns an integer value
get_PaddingScheme( )

# newVal is an integer (input)
put_PaddingScheme( newVal )

The padding scheme used by block encryption algorithms such as AES (Rijndael), Blowfish, Twofish, RC2, DES, 3DES, etc. Block encryption algorithms pad encrypted data to a multiple of algorithm's block size. The default value of this property is 0.

Possible values are:

0 = RFC 1423 padding scheme: Each padding byte is set to the number of padding bytes. If the data is already a multiple of algorithm's block size bytes, an extra block is appended each having a value equal to the block size. (for example, if the algorithm's block size is 16, then 16 bytes having the value 0x10 are added.). (This is also known as PKCS5 padding: PKCS #5 padding string consists of a sequence of bytes, each of which is equal to the total number of padding bytes added. )

1 = FIPS81 (Federal Information Processing Standards 81) where the last byte contains the number of padding bytes, including itself, and the other padding bytes are set to random values.

2 = Each padding byte is set to a random value. The decryptor must know how many bytes are in the original unencrypted data.

3 = Pad with NULLs. (If already a multiple of the algorithm's block size, no padding is added).

4 = Pad with SPACE chars(0x20). (If already a multiple of algorithm's block size, no padding is added).

# str is a CkString object (output)
get_PbesAlgorithm( str )

# newVal is a string (input)
put_PbesAlgorithm( newVal )

If the CryptAlgorithm property is set to "pbes1" or "pbes2", this property specifies the underlying encryption algorithm to be used with password-based encryption (PBE). Password-based encryption is defined in the PKCS5 Password-Based Cryptography Standard at http://www.rsa.com/rsalabs/node.asp?id=2127

# str is a CkString object (output)
get_PbesPassword( str )

# newVal is a string (input)
put_PbesPassword( newVal )

The password to be used with password-based encryption (PBE). Password-based encryption is defined in the PKCS5 Password-Based Cryptography Standard at http://www.rsa.com/rsalabs/node.asp?id=2127

# str is a CkString object (output)
get_Pkcs7CryptAlg( str )

# newVal is a string (input)
put_Pkcs7CryptAlg( newVal )

When the CryptAlgorithm property is "PKI" to select PKCS7 public-key encryption, this selects the underlying symmetric encryption algorithm. Possible values are: "aes", "des", "3des", and "rc2".

# Returns an integer value
get_Rc2EffectiveKeyLength( )

# newVal is an integer (input)
put_Rc2EffectiveKeyLength( newVal )

The effective key length (in bits) for the RC2 encryption algorithm. When RC2 is used, both the KeyLength and Rc2EffectiveKeyLength properties should be set. For RC2, both should be between 8 and 1024 (inclusive).

# data is a CkByteData object (output)
get_Salt( data )

# data is a CkByteData object (output)
put_Salt( data )

The salt to be used with password-based encryption (PBE). Password-based encryption is defined in the PKCS5 Password-Based Cryptography Standard at http://www.rsa.com/rsalabs/node.asp?id=2127

# bData is a CkByteData object (output)
get_SecretKey( bData )

# bData is a CkByteData object (input)
put_SecretKey( bData )

The binary secret key used for symmetric encryption (Rijndael, Blowfish, Twofish). The secret key must be identical for decryption to succeed. The length in bytes of the SecretKey must equal the KeyLength/8.

# Returns a boolean value
get_Utf8( )

# b is a boolean (input)
put_Utf8( b )

When set to true, all "const char *" arguments are expected to be utf-8 strings. If set to false, the "const char *" arguments are expected to be ANSI strings.

# str is a CkString object (output)
get_UuFilename( str )

# newVal is a string (input)
put_UuFilename( newVal )

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.

UU Encoding and Decoding

# str is a CkString object (output)
get_UuMode( str )

# newVal is a string (input)
put_UuMode( newVal )

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.

# Returns a boolean value
get_VerboseLogging( )

# newVal is a boolean (input)
put_VerboseLogging( newVal )

Set to true to make the contents of the LastErrorText, LastErrorHtml, and LastErrorXml properties more verbose. The default value is false. Make sure to turn off verbose logging when not debugging, as verbose logging can affect performance.

# out is a CkString object (output)
get_Version( out )

The version of the component, such as "4.0.0".

Methods

AddEncryptCert( cert )

Adds a certificate to be used for public-key encryption. (To use public-key encryption with digital certificates, set the CryptAlgorithm property = "pki".) To encrypt with more than one certificate, call AddEncryptCert once per certificate.

# pfxBytes is a CkByteData object (output)
# pfxPassword is a string (input)
# Returns a boolean value
AddPfxSourceData( pfxBytes, pfxPassword )

Adds a PFX to the object's internal list of sources to be searched for certificates and private keys when decrypting. Multiple PFX sources can be added by calling this method once for each. (On the Windows operating system, the registry-based certificate stores are also automatically searched, so it is commonly not required to explicitly add PFX sources.)

The pfxBytes contains the bytes of a PFX file (also known as PKCS12 or .p12).

Returns true for success, false for failure.

# pfxFilePath is a string (input)
# pfxPassword is a string (input)
# Returns a boolean value
AddPfxSourceFile( pfxFilePath, pfxPassword )

Adds a PFX file to the object's internal list of sources to be searched for certificates and private keys when decrypting. Multiple PFX files can be added by calling this method once for each. (On the Windows operating system, the registry-based certificate stores are also automatically searched, so it is commonly not required to explicitly add PFX sources.)

The pfxFilePath contains the bytes of a PFX file (also known as PKCS12 or .p12).

Returns true for success, false for failure.

# inData is a CkByteData object (output)
# charset is a string (input)
# outStr is a CkString object (output)
# Returns a boolean value
BytesToString( inData, charset, outStr )

Utility method to convert bytes to a string -- interpreting the bytes according to the charset specified.

Returns true for success, false for failure.

# inFile is a string (input)
# outFile is a string (input)
# Returns a boolean value
CkDecryptFile( inFile, outFile )

File-to-file decryption. There is no limit to the size of the file that can be decrypted because the component will operate in streaming mode internally.

Returns true for success, false for failure.

# inFile is a string (input)
# outFile is a string (input)
# Returns a boolean value
CkEncryptFile( inFile, outFile )

File-to-file encryption. There is no limit to the size of the file that can be encrypted because the component will operate in streaming mode internally.

Returns true for success, false for failure.

ClearEncryptCerts( )

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

# bData is a CkByteData object (input)
# out is a CkByteData object (output)
# Returns a boolean value
CompressBytes( bData, out )

Memory-to-memory compression. Compresses a byte array and returns a byte array of compressed data. The compression algorithm specified by the CompressionAlgorithm property is used. Currently, the only choice is "BZIP2".

# bData is a CkByteData object (input)
# out is a CkString object (output)
# Returns a boolean value
CompressBytesENC( bData, out )

Same as CompressBytes, except an encoded string is returned. The encoding is controlled by the EncodingMode property, which can be set to "Base64", "QP" (for quoted-printable), or "Hex".

Returns true for success, false for failure.

# str is a string (input)
# out is a CkByteData object (output)
# Returns a boolean value
CompressString( str, out )

Compresses a string and returns a byte array of the compressed data. For languages such as C#, VB.NET, Visual Basic 6, etc. the string input argument is Unicode. The Charset property controls the conversion of the Unicode string to a multibyte string before compression is applied. For example, if Charset is set to "iso-8859-1", then the input string argument is first converted from Unicode (2 bytes per char) to iso-8859-1 (1 byte per char) before compressing according to the CompressionAlgorithm property ("BZIP2"). If the Charset property is set to "unicode", then no character encoding conversion will happen, and the full Unicode string is compressed.

# str is a string (input)
# out is a CkString object (output)
# Returns a boolean value
CompressStringENC( str, out )

Compresses a string and returns an encoded string of the compressed data. For languages such as C#, VB.NET, Visual Basic 6, etc. the string input argument is Unicode. The Charset property controls the conversion of the Unicode string to a multibyte string before compression is applied. For example, if Charset is set to "iso-8859-1", then the input string argument is first converted from Unicode (2 bytes per char) to iso-8859-1 (1 byte per char) before compressing according to the CompressionAlgorithm property ("BZIP2"). If the Charset property is set to "unicode", then no character encoding conversion will happen, and the full Unicode string is compressed.

Compressed data is typically binary data which is not a printable string. This method encodes the output compressed data to a printable string according to the EncodingMode property, which can be set to "Base64", "QP" (for quoted-printable), or "Hex".

Returns true for success, false for failure.

# inFilePath is a string (input)
# outSigFilePath is a string (input)
# Returns a boolean value
CreateDetachedSignature( inFilePath, outSigFilePath )

Digitally signs a file and writes the digital signature to a separate output file (a PKCS#7 signature file). The input file (inFilePath) is unmodified. A certificate for signing must be specified by calling SetSigningCert or SetSigningCert2 prior to calling this method.

This method is equivalent to CreateP7S. The CreateP7S method was added to clarify the format of the signature file that is created.

Returns true for success, false for failure.

# inFilename is a string (input)
# p7mFilename is a string (input)
# Returns a boolean value
CreateP7M( inFilename, p7mFilename )

Digitally signs a file and creates a .p7m (PKCS #7 Message) file that contains both the signature and original file content. The input file (ARG1) is unmodified. A certificate for signing must be specified by calling SetSigningCert or SetSigningCert2 prior to calling this method.

Returns true for success, false for failure.

# inFilename is a string (input)
# outP7sFilename is a string (input)
# Returns a boolean value
CreateP7S( inFilename, outP7sFilename )

Digitally signs a file and creates a .p7s (PKCS #7 Signature) signature file. The input file (inFilename) is unmodified. The output file ( outP7sFilename) contains only the signature and not the original data. A certificate for signing must be specified by calling SetSigningCert or SetSigningCert2 prior to calling this method.

Returns true for success, false for failure.

# str is a string (input)
# encoding is a string (input)
# bData is a CkByteData object (output)
Decode( str, encoding, bData )

Decode binary data from an encoded string. The ARG3 can be any of the following: "base64", "base32", "hex", "url", "html", "uu", "modbase64", or "quoted-printable".

# inStr is a string (input)
# charset is a string (input)
# encoding is a string (input)
# outStr is a CkString object (output)
# Returns a boolean value
DecodeString( inStr, charset, encoding, outStr )

Decodes from an encoding back to the original string. The encoding can be any of the following: "base64", "base32", "hex", "url", "html", "uu", "modbase64", or "quoted-printable".

Returns true for success, false for failure.

# bData is a CkByteData object (input)
# out is a CkByteData object (output)
# Returns a boolean value
DecryptBytes( bData, out )

Decrypts a byte array and returns the unencrypted byte array. The property settings used when encrypting the data must match the settings when decrypting. Specifically, the CryptAlgorithm, CipherMode, PaddingScheme, KeyLength, IV, and SecretKey properties must match.

# str is a string (input)
# out is a CkByteData object (output)
# Returns a boolean value
DecryptBytesENC( str, out )

Decrypts string-encoded encrypted data and returns the unencrypted byte array. Data encrypted with EncryptBytesENC can be decrypted with this method. The property settings used when encrypting the data must match the settings when decrypting. Specifically, the EncodingMode, CryptAlgorithm, CipherMode, PaddingScheme, KeyLength, IV, and SecretKey properties must match.

# encodedEncryptedData is a string (input)
# outStr is a CkString object (output)
# Returns a boolean value
DecryptEncoded( encodedEncryptedData, outStr )

Encrypted data is passed to this method as an encoded string (base64, hex, etc.). This method first decodes the input data according to the EncodingMode property setting. It then decrypts and re-encodes using the EncodingMode setting, and returns the decrypted data in encoded string form.

Returns true for success, false for failure.

# bData is a CkByteData object (input)
# out is a CkString object (output)
# Returns a boolean value
DecryptString( bData, out )

The reverse of EncryptString.

Decrypts encrypted byte data and returns the original string. The property settings used when encrypting the string must match the settings when decrypting. Specifically, the Charset, CryptAlgorithm, CipherMode, PaddingScheme, KeyLength, IV, and SecretKey properties must match.

Returns true for success, false for failure.

# str is a string (input)
# out is a CkString object (output)
# Returns a boolean value
DecryptStringENC( str, out )

The reverse of EncryptStringENC.

Decrypts string-encoded encrypted data and returns the original string. The property settings used when encrypting the string must match the settings when decrypting. Specifically, the Charset, EncodingMode, CryptAlgorithm, CipherMode, PaddingScheme, KeyLength, IV, and SecretKey properties must match.

Returns true for success, false for failure.

# bData is a CkByteData object (input)
# encoding is a string (input)
# str is a CkString object (output)
Encode( bData, encoding, str )

Encode binary data to base64, hex, quoted-printable, or URL-encoding. The encoding argument can be set to any of the following strings: "base64", "hex", "quoted-printable", or "url".

Returns true for success, false for failure.

# strToEncode is a string (input)
# charsetName is a string (input)
# toEncodingName is a string (input)
# outStr is a CkString object (output)
# Returns a boolean value
EncodeString( strToEncode, charsetName, toEncodingName, outStr )

Encode a string to base64, hex, quoted-printable, or URL-encoding. charsetName may be set to any of the following strings: "base64", "hex", "quoted-printable", or "url". The toEncodingName is important, and usually you'll want to specify "ansi". For example, if the string "ABC" is to be encoded to "hex" using ANSI, the result will be "414243". However, if "unicode" is used, the result is "410042004300".

Returns true for success, false for failure.

# bData is a CkByteData object (input)
# out is a CkByteData object (output)
# Returns a boolean value
EncryptBytes( bData, out )

Encrypts a byte array. The minimal set of properties that should be set before encrypting are: CryptAlgorithm, SecretKey. Other properties that control encryption are: CipherMode, PaddingScheme, KeyLength, IV. When decrypting, all property settings must match otherwise garbled data is returned.

# bData is a CkByteData object (input)
# out is a CkString object (output)
# Returns a boolean value
EncryptBytesENC( bData, out )

Encrypts a byte array and returns the encrypted data as an encoded (printable) string. The minimal set of properties that should be set before encrypting are: CryptAlgorithm, SecretKey, EncodingMode. Other properties that control encryption are: CipherMode, PaddingScheme, KeyLength, IV. When decrypting, all property settings must match otherwise garbled data is returned. The encoding of the string that is returned is controlled by the EncodingMode property, which can be set to "Base64", "QP", or "Hex".

Returns true for success, false for failure.

# str is a string (input)
# outStr is a CkString object (output)
# Returns a boolean value
EncryptEncoded( str, outStr )

The input string is first decoded according to the encoding algorithm specified by the EncodingMode property (such as base64, hex, etc.) It is then encrypted according to the encryption algorithm specified by CryptAlgorithm. The resulting encrypted data is encoded (using EncodingMode) and returned.

Returns true for success, false for failure.

# str is a string (input)
# out is a CkByteData object (output)
# Returns a boolean value
EncryptString( str, out )

Encrypts a string and returns the encrypted data as a byte array. The minimal set of properties that should be set before encrypting are: CryptAlgorithm, SecretKey, Charset. Other properties that control encryption are: CipherMode, PaddingScheme, KeyLength, IV. When decrypting, all property settings must match otherwise garbled data is returned. The Charset property controls the exact bytes that get encrypted. Languages such as VB.NET, C#, and Visual Basic work with Unicode strings, thus the input string is Unicode. If Unicode is to be encrypted (i.e. 2 bytes per character) then set the Charset property to "Unicode". To implicitly convert the string to another charset before the encryption is applied, set the Charset property to something else, such as "iso-8859-1", "Shift_JIS", "big5", "windows-1252", etc. The complete list of possible charsets is listed here:

us-ascii
unicode
unicodefffe
iso-8859-1
iso-8859-2
iso-8859-3
iso-8859-4
iso-8859-5
iso-8859-6
iso-8859-7
iso-8859-8
iso-8859-9
iso-8859-13
iso-8859-15
windows-874
windows-1250
windows-1251
windows-1252
windows-1253
windows-1254
windows-1255
windows-1256
windows-1257
windows-1258
utf-7
utf-8
utf-32
utf-32be
shift_jis
gb2312
ks_c_5601-1987
big5
iso-2022-jp
iso-2022-kr
euc-jp
euc-kr
macintosh
x-mac-japanese
x-mac-chinesetrad
x-mac-korean
x-mac-arabic
x-mac-hebrew
x-mac-greek
x-mac-cyrillic
x-mac-chinesesimp
x-mac-romanian
x-mac-ukrainian
x-mac-thai
x-mac-ce
x-mac-icelandic
x-mac-turkish
x-mac-croatian
asmo-708
dos-720
dos-862
ibm037
ibm437
ibm500
ibm737
ibm775
ibm850
ibm852
ibm855
ibm857
ibm00858
ibm860
ibm861
ibm863
ibm864
ibm865
cp866
ibm869
ibm870
cp875
koi8-r
koi8-u

# str is a string (input)
# out is a CkString object (output)
# Returns a boolean value
EncryptStringENC( str, out )

Encrypts a string and returns the encrypted data as an encoded (printable) string. The minimal set of properties that should be set before encrypting are: CryptAlgorithm, SecretKey, Charset, and EncodingMode. Other properties that control encryption are: CipherMode, PaddingScheme, KeyLength, IV. When decrypting (with DecryptStringENC), all property settings must match otherwise garbled data is returned. The Charset property controls the exact bytes that get encrypted. Languages such as VB.NET, C#, and Visual Basic work with Unicode strings, thus the input string is Unicode. If Unicode is to be encrypted (i.e. 2 bytes per character) then set the Charset property to "Unicode". To implicitly convert the string to another charset before the encryption is applied, set the Charset property to something else, such as "iso-8859-1", "Shift_JIS", "big5", "windows-1252", etc. (Refer to EncryptString for the complete list of charsets.)

The EncodingMode property controls the encoding of the string that is returned. It can be set to "Base64", "QP", or "Hex".

Returns true for success, false for failure.

# password is a string (input)
# encoding is a string (input)
# outStr is a CkString object (output)
GenEncodedSecretKey( password, encoding, outStr )

Identical to the GenerateSecretKey method, except it returns the binary secret key as a string encoded according to encoding, which may be "base64", "hex", "url", etc. Please see the documentation for GenerateSecretKey for more information.

Returns true for success, false for failure.

# numBytes is an integer (input)
# outStr is a CkString object (output)
# Returns a boolean value
GenRandomBytesENC( numBytes, outStr )

Generates numBytes random bytes and returns them as an encoded string. The encoding, such as base64, hex, etc. is controlled by the EncodingMode property.

Returns true for success, false for failure.

# password is a string (input)
# out is a CkByteData object (output)
GenerateSecretKey( password, out )

Hashes a string to a byte array that has the same number of bits as the current value of the KeyLength property. For example, if KeyLength is equal to 128 bits, then a 16-byte array is returned. This can be used to set the SecretKey property. In order to decrypt, the SecretKey must match exactly. To use "password-based" encryption, the password is passed to this method to generate a binary secret key that can then be assigned to the SecretKey property.

IMPORTANT: If you are trying to decrypt something encrypted by another party such that the other party provided you with the secret key, DO NOT use this method. This method is for transforming an arbitrary-length password into a binary secret key of the proper length. Please see this Chilkat blog post: Getting Started with AES Decryption

# encoding is a string (input)
# strIV is a CkString object (output)
GetEncodedIV( encoding, strIV )

Returns the initialization vector as an encoded string. The encoding argument can be set to any of the following strings: "base64", "hex", "quoted-printable", or "url".

Returns true for success, false for failure.

# encoding is a string (input)
# strKey is a CkString object (output)
GetEncodedKey( encoding, strKey )

Returns the secret key as an encoded string. The encoding argument can be set to any of the following strings: "base64", "hex", "quoted-printable", or "url".

Returns true for success, false for failure.

# encoding is a string (input)
# outStr is a CkString object (output)
GetEncodedSalt( encoding, outStr )

Returns the password-based encryption (PBE) salt bytes as an encoded string. The encoding argument can be set to any of the following strings: "base64", "hex", "quoted-printable", or "url".

Returns true for success, false for failure.

# Returns a CkCert object
GetLastCert( )

Returns the last certificate used when decrypting data or verifying a signature. This is only valid when public-key encryption is used, and does not apply to symmetric algorithms such as Rijndael, Blowfish, or Twofish.

# index is an integer (input)
# outSysTime is a SYSTEMTIME object (output)
# Returns a boolean value
GetSignatureSigningTime( index, outSysTime )

To be documented soon...

# index is an integer (input)
# Returns a CkCert object
GetSignerCert( index )

This method can be called after a digital signature is verified to retrieve the certificate(s) used for signing. The 1st certificate is at index 0. The NumSignerCerts property contains the total number of signing certificates. (Typically, a single certificate is used in creating a digital signature.)

# index is an integer (input)
# Returns a boolean value
HasSignatureSigningTime( index )

To be documented soon...

# data is a CkByteData object (output)
# Returns a boolean value
HashBeginBytes( data )

Begin hashing a byte stream. Call this method to hash the 1st chunk. Additional chunks are hashed by calling HashMoreBytes 0 or more times followed by a final call to HashFinal (or HashFinalENC) to retrieve the result. The hash algorithm is selected by the HashAlgorithm property setting.

# strData is a string (input)
# Returns a boolean value
HashBeginString( strData )

Begin hashing a text stream. Call this method to hash the 1st chunk. Additional chunks are hashed by calling HashMoreString 0 or more times followed by a final call to HashFinal (or HashFinalENC) to retrieve the result. The hash algorithm is selected by the HashAlgorithm property setting.

# bData is a CkByteData object (input)
# out is a CkByteData object (output)
# Returns a boolean value
HashBytes( bData, out )

Hashes a byte array. The hash algorithm to be used is controlled by the HashAlgorithm property, which can be set to "sha1", "sha384", "sha512", "md2", "md5", "haval", "ripemd128", "ripemd160","ripemd256", or "ripemd320".

The HAVAL hash algorithm is affected by two other properties: HavalRounds and KeyLength. The HavalRounds may have values of 3, 4, or 5. The KeyLength may have values of 128, 160, 192, 224, or 256.

# bData is a CkByteData object (input)
# out is a CkString object (output)
# Returns a boolean value
HashBytesENC( bData, out )

Hashes a byte array and returns an encoded (printable) string of the binary hash. The hash algorithm to be used is controlled by the HashAlgorithm property, which can be set to "sha1", "sha384", "sha512", "md2", "md5", or "haval". The encoding is controlled by the EncodingMode property, which can be set to "Base64", "QP", or "Hex".

Returns true for success, false for failure.

# filename is a string (input)
# out is a CkByteData object (output)
# Returns a boolean value
HashFile( filename, out )

Hashes a file. The hash algorithm to be used is controlled by the HashAlgorithm property, which can be set to "sha1", "sha384", "sha512", "md2", "md5", "haval", "ripemd128", "ripemd160","ripemd256", or "ripemd320". The function returns the hash bytes. Any size file is supported because the file is hashed internally in streaming mode.

The HAVAL hash algorithm is affected by two other properties: HavalRounds and KeyLength. The HavalRounds may have values of 3, 4, or 5. The KeyLength may have values of 128, 160, 192, 224, or 256.

# filename is a string (input)
# out is a CkString object (output)
# Returns a boolean value
HashFileENC( filename, out )

Hashes a file. The hash algorithm to be used is controlled by the HashAlgorithm property, which can be set to "sha1", "sha384", "sha512", "md2", "md5", or "haval". The function returns the hash as a string encoded according to the EncodingMode property. Any size file is supported because the file is hashed internally in streaming mode.

Returns true for success, false for failure.

# outBytes is a CkByteData object (output)
# Returns a boolean value
HashFinal( outBytes )

Finalizes a multi-step hash computation and returns the hash bytes.

# outStr is a CkString object (output)
# Returns a boolean value
HashFinalENC( outStr )

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.

# data is a CkByteData object (output)
# Returns a boolean value
HashMoreBytes( data )

Adds more bytes to the hash currently under computation. (See HashBeginBytes)

# strData is a string (input)
# Returns a boolean value
HashMoreString( strData )

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

# str is a string (input)
# out is a CkByteData object (output)
# Returns a boolean value
HashString( str, out )

Hashes a string and returns a binary hash. The hash algorithm to be used is controlled by the HashAlgorithm property, which can be set to "sha1", "sha384", "sha512", "md2", "md5", "haval", "ripemd128", "ripemd160","ripemd256", or "ripemd320".

The Charset property controls the character encoding of the string that is hashed. Languages such as VB.NET, C#, and Visual Basic work with Unicode strings. If it is desired to hash Unicode directly (2 bytes/char) then set the Charset property to "Unicode". To implicitly convert to another charset before hashing, set the Charset property to the desired charset. For example, if Charset is set to "iso-8859-1", the input string is first implicitly converted to iso-8859-1 (1 byte per character) before hashing. The full list fo supported charsets is listed in the EncryptString method description.

# str is a string (input)
# out is a CkString object (output)
# Returns a boolean value
HashStringENC( str, out )

Hashes a string and returns an encoded (printable) string of the binary hash. The hash algorithm to be used is controlled by the HashAlgorithm property, which can be set to "sha1", "sha384", "sha512", "md2", "md5", "haval", "ripemd128", "ripemd160","ripemd256", or "ripemd320".

The Charset property controls the character encoding of the string that is hashed. Languages such as VB.NET, C#, and Visual Basic work with Unicode strings. If it is desired to hash Unicode directly (2 bytes/char) then set the Charset property to "Unicode". To implicitly convert to another charset before hashing, set the Charset property to the desired charset. For example, if Charset is set to "iso-8859-1", the input string is first implicitly converted to iso-8859-1 (1 byte per character) before hashing. The full list of supported charsets is listed in the EncryptString method description.
The encoding of the output string is controlled by the EncodingMode property, which can be set to "Base64", "QP", or "Hex".

The HAVAL hash algorithm is affected by two other properties: HavalRounds and KeyLength. The HavalRounds may have values of 3, 4, or 5. The KeyLength may have values of 128, 160, 192, 224, or 256.

Returns true for success, false for failure.

# inBytes is a CkByteData object (input)
# hmacOut is a CkByteData object (output)
HmacBytes( inBytes, hmacOut )

Computes a keyed-Hash Message Authentication Code (HMAC or KHMAC), which is a type of message authentication code (MAC) calculated using a specific algorithm involving a cryptographic hash function in combination with a secret key. As with any MAC, it may be used to simultaneously verify both the data integrity and the authenticity of a message. Any iterative cryptographic hash function, such as MD5 or SHA-1, may be used in the calculation of an HMAC; the resulting MAC algorithm is termed HMAC-MD5 or HMAC-SHA-1 accordingly. The cryptographic strength of the HMAC depends upon the cryptographic strength of the underlying hash function, on the size and quality of the key and the size of the hash output length in bits.

The secret key is set by calling one of these methods prior to calling this method: SetHmacKeyBytes, SetHmacKeyEncoded, or SetHmacKeyString.

The hash algorithm is specified by the HashAlgorithm property.

# inBytes is a CkByteData object (input)
# encodedHmacOut is a CkString object (output)
HmacBytesENC( inBytes, encodedHmacOut )

Computes an HMAC using a secret key and hash algorithm. The result is encoded to a string using the encoding (base64, hex, etc.) specified by the EncodingMode property.

The secret key is set by calling one of these methods prior to calling this method: SetHmacKeyBytes, SetHmacKeyEncoded, or SetHmacKeyString.

The hash algorithm is specified by the HashAlgorithm property.

Returns true for success, false for failure.

# inText is a string (input)
# hmacOut is a CkByteData object (output)
HmacString( inText, hmacOut )

Computes an HMAC using a secret key and hash algorithm.

The secret key is set by calling one of these methods prior to calling this method: SetHmacKeyBytes, SetHmacKeyEncoded, or SetHmacKeyString.

The hash algorithm is specified by the HashAlgorithm property.

# inText is a string (input)
# encodedHmacOut is a CkString object (output)
HmacStringENC( inText, encodedHmacOut )

Computes an HMAC using a secret key and hash algorithm. The result is encoded to a string using the encoding (base64, hex, etc.) specified by the EncodingMode property.

The secret key is set by calling one of these methods prior to calling this method: SetHmacKeyBytes, SetHmacKeyEncoded, or SetHmacKeyString.

The hash algorithm is specified by the HashAlgorithm property.

Returns true for success, false for failure.

# bData is a CkByteData object (input)
# out is a CkByteData object (output)
# Returns a boolean value
InflateBytes( bData, out )

The opposite of CompressBytes.

# str is a string (input)
# out is a CkByteData object (output)
# Returns a boolean value
InflateBytesENC( str, out )

The opposite of CompressBytesENC. The EncodingMode and CompressionAlgorithm properties should match what was used when compressing.

# bData is a CkByteData object (input)
# out is a CkString object (output)
# Returns a boolean value
InflateString( bData, out )

The opposite of CompressString. The Charset and CompressionAlgorithm properties should match what was used when compressing.

Returns true for success, false for failure.

# str is a string (input)
# out is a CkString object (output)
# Returns a boolean value
InflateStringENC( str, out )

The opposite of CompressStringENC. The Charset, EncodingMode, and CompressionAlgorithm properties should match what was used when compressing.

Returns true for success, false for failure.

# Returns a boolean value
IsUnlocked( )

Returns true if the component is unlocked.

# strEncryptedHex is a string (input)
# strPassword is a string (input)
# outStr is a CkString object (output)
# Returns a boolean value
MySqlAesDecrypt( strEncryptedHex, strPassword, outStr )

Matches MySQL's AES_DECRYPT function. strEncryptedHex is a hex-encoded string of the AES encrypted data. The return value is the original unencrypted string.

Returns true for success, false for failure.

# strData is a string (input)
# strPassword is a string (input)
# outStr is a CkString object (output)
# Returns a boolean value
MySqlAesEncrypt( strData, strPassword, outStr )

Matches MySQL's AES_ENCRYPT function. The return value is a hex-encoded string of the encrypted data. The equivalent call in MySQL would look like this: HEX(AES_ENCRYPT('The quick brown fox jumps over the lazy dog','password'))

Returns true for success, false for failure.

Match MySQL AES_ENCRYPT Function

# bData is a CkByteData object (input)
# out is a CkByteData object (output)
# Returns a boolean value
OpaqueSignBytes( bData, out )

Digitally signs a byte array and returns the opaque digital signature. A certificate must be set by calling SetSigningCert prior to calling this method.

# bData is a CkByteData object (input)
# out is a CkString object (output)
# Returns a boolean value
OpaqueSignBytesENC( bData, out )

Digitally signs a byte array and returns the opaque digital signature encoded as a printable string. A certificate must be set by calling SetSigningCert prior to calling this method. The EncodingMode property controls the output encoding, which can be "Base64", "QP", or "Hex".

Returns true for success, false for failure.

# str is a string (input)
# out is a CkByteData object (output)
# Returns a boolean value
OpaqueSignString( str, out )

Digitally signs a string and returns the opaque digital signature. A certificate must be set by calling SetSigningCert prior to calling this method. The Charset property controls the character encoding of the string that is signed. (Languages such as VB.NET, C#, and Visual Basic work with Unicode strings.) To sign Unicode data (2 bytes per char), set the Charset property to "Unicode". To implicitly convert the string to a mutlibyte charset such as "iso-8859-1", "Shift_JIS", "utf-8", or something else, then set the Charset property to the name of the charset before signing. The complete list of charsets is listed in the EncryptString method description.

# str is a string (input)
# out is a CkString object (output)
# Returns a boolean value
OpaqueSignStringENC( str, out )

Digitally signs a string and returns the opaque digital signature as an encoded string. A certificate must be set by calling SetSigningCert prior to calling this method. The Charset property controls the character encoding of the string that is signed. (Languages such as VB.NET, C#, and Visual Basic work with Unicode strings.) To sign Unicode data (2 bytes per char), set the Charset property to "Unicode". To implicitly convert the string to a mutlibyte charset such as "iso-8859-1", "Shift_JIS", "utf-8", or something else, then set the Charset property to the name of the charset before signing. The complete list of charsets is listed in the EncryptString method description.

The encoding of the output string is controlled by the EncodingMode property, which can be set to "Base64", "QP", or "Hex".

Returns true for success, false for failure.

# p7s is a CkByteData object (input)
# original is a CkByteData object (output)
# Returns a boolean value
OpaqueVerifyBytes( p7s, original )

Verifies an opaque signature and returns the original data. If the signature verification fails, the returned data will be 0 bytes in length.

# p7s is a string (input)
# original is a CkByteData object (output)
# Returns a boolean value
OpaqueVerifyBytesENC( p7s, original )

Verifies an opaque signature (encoded in string form) and returns the original data. If the signature verification fails, the returned data will be 0 bytes in length.

# p7s is a CkByteData object (input)
# original is a CkString object (output)
# Returns a boolean value
OpaqueVerifyString( p7s, original )

Verifies an opaque signature and returns the original string. If the signature verification fails, the returned string will be 0 characters in length.

Returns true for success, false for failure.

# p7s is a string (input)
# original is a CkString object (output)
# Returns a boolean value
OpaqueVerifyStringENC( p7s, original )

Verifies an opaque signature (encoded in string form) and returns the original data string. If the signature verification fails, the returned string will be 0 characters in length.

Returns true for success, false for failure.

# password is a string (input)
# charset is a string (input)
# hashAlg is a string (input)
# salt is a string (input)
# iterationCount is an integer (input)
# outputKeyBitLen is an integer (input)
# encoding is a string (input)
# outStr is a CkString object (output)
# Returns a boolean value
Pbkdf1( password, charset, hashAlg, salt, iterationCount, outputKeyBitLen, encoding, outStr )

Implements the PBKDF1 algorithm (Password Based Key Derivation Function #1). The password is converted to the character encoding represented by charset before being passed (internally) to the key derivation function. The hashAlg may be "md5", "sha1", "md2", etc. The salt should be random data at least 8 bytes (64 bits) in length. (The GenRandomBytesENC method is good for generating a random salt value.) The iterationCount should be no less than 1000. The length (in bits) of the derived key output by this method is controlled by outputKeyBitLen. The encoding argument may be "base64", "hex", etc. It controls the encoding of the output, and the expected encoding of the salt. The derived key is returned.

Returns true for success, false for failure.

# password is a string (input)
# charset is a string (input)
# hashAlg is a string (input)
# salt is a string (input)
# iterationCount is an integer (input)
# outputKeyBitLen is an integer (input)
# encoding is a string (input)
# outStr is a CkString object (output)
# Returns a boolean value
Pbkdf2( password, charset, hashAlg, salt, iterationCount, outputKeyBitLen, encoding, outStr )

Implements the PBKDF2 algorithm (Password Based Key Derivation Function #2). The password is converted to the character encoding represented by charset before being passed (internally) to the key derivation function. The hashAlg may be "md5", "sha1", "md2", etc. The salt should be random data at least 8 bytes (64 bits) in length. (The GenRandomBytesENC method is good for generating a random salt value.) The iterationCount should be no less than 1000. The length (in bits) of the derived key output by this method is controlled by outputKeyBitLen. The encoding argument may be "base64", "hex", etc. It controls the encoding of the output, and the expected encoding of the salt. The derived key is returned.

Returns true for success, false for failure.

RandomizeIV( )

Sets the initialization vector to a random value.

RandomizeKey( )

Sets the secret key to a random value.

# encodedData is a string (input)
# fromEncoding is a string (input)
# toEncoding is a string (input)
# outStr is a CkString object (output)
# Returns a boolean value
ReEncode( encodedData, fromEncoding, toEncoding, outStr )

Provides a means for converting from one encoding to another (such as base64 to hex). This is helpful for programming environments where byte arrays are a real pain-in-the-***. The fromEncoding and toEncoding may be "base64", "hex", "quoted-printable" (or "qp"), or "url".

Returns true for success, false for failure.

# filename is a string (input)
# outBytes is a CkByteData object (output)
# Returns a boolean value
ReadFile( filename, outBytes )

Convenience method to read an entire file and return as a byte array.

# filename is a string (input)
# Returns a boolean value
SaveLastError( filename )

Saves the last error information to an XML formatted file.

# csp is a CkCSP object (input)
# Returns a boolean value
SetCSP( csp )

(Only applies to the Microsoft Windows OS) Sets the Cryptographic Service Provider (CSP) to be used for PKI public-key encryption / signing, or public-key decryption / signature verification.

This is not commonly used becaues the default Microsoft CSP is typically appropriate. One instance where SetCSP is necessary is when using the Crypto-Pro CSP for the GOST R 34.10-2001 and GOST R 34.10-94 providers.

# Returns a boolean value
SetDecryptCert( cert )

Sets the digital certificate to be used for decryption when the CryptAlgorithm property is set to "PKI". A private key is required for decryption. Because this method only specifies the certificate, a prerequisite is that the certificate w/ private key must have been pre-installed on the computer. Private keys are stored in the Windows Protected Store (either a user account specific store, or the system-wide store). The Chilkat component will automatically locate and find the certificate's corresponding private key from the protected store when decrypting.

Returns true for success, false for failure.

# Returns a boolean value
SetDecryptCert2( cert, key )

Sets the digital certificate to be used for decryption when the CryptAlgorithm property is set to "PKI". The private key is supplied in the 2nd argument to this method, so there is no requirement that the certificate be pre-installed on a computer before decrypting (if this method is called).

Returns true for success, false for failure.

# ivStr is a string (input)
# encoding is a string (input)
SetEncodedIV( ivStr, encoding )

Sets the initialization vector from an encoded string. The encoding argument can be set to any of the following strings: "base64", "hex", "quoted-printable", "ascii", or "url".

# keyStr is a string (input)
# encoding is a string (input)
SetEncodedKey( keyStr, encoding )

Sets the secret key from an encoded string. The encoding argument can be set to any of the following strings: "base64", "hex", "quoted-printable", "ascii", or "url".

# saltStr is a string (input)
# encoding is a string (input)
SetEncodedSalt( saltStr, encoding )

Sets the password-based encryption (PBE) salt bytes from an encoded string. The encoding argument can be set to any of the following strings: "base64", "hex", "quoted-printable", "ascii", or "url".

# cert is a CkCert object (input)
SetEncryptCert( cert )

Tells the encryption library to use a specific digital certificate for public-key encryption. To encrypt with multiple certificates, call AddEncryptCert once for each certificate. (Calling this method is the equivalent of calling ClearEncryptCerts followed by AddEncryptCert.)

# keyBytes is a CkByteData object (input)
SetHmacKeyBytes( keyBytes )

Sets the secret key to be used for one of the HMAC methods.

# key is a string (input)
# encoding is a string (input)
SetHmacKeyEncoded( key, encoding )

Sets the secret key to be used for one of the HMAC methods. The encoding can be set to any of the following strings: "base64", "hex", "quoted-printable", or "url".

# key is a string (input)
SetHmacKeyString( key )

Sets the secret key to be used for one of the HMAC methods.

# ivData is a string (input)
# numBytes is an integer (input)
SetIV( ivData, numBytes )

Sets the initialization vector for a symmetric encryption algorithm (such as AES, BlowFish, TwoFish, DES, etc.). IV's are used in CBC mode (Cipher-Block-Chaining), but are not used in ECB mode (Electronic Cookbook). The length of the IV should equal the block size of the algorithm. (It is not equal to the key length). For AES and TwoFish, the block size (and thus IV size) is always 16 bytes. For Blowfish it's 8 bytes. For DES and 3DES it's 8 bytes.

# keyData is a string (input)
# numBytes is an integer (input)
SetSecretKey( keyData, numBytes )

To be documented soon.

# password is a string (input)
SetSecretKeyViaPassword( password )

Accepts a password string and (internally) generates a binary secret key of the appropriate bit length and sets the SecretKey property. This method should only be used if you are using Chilkat for both encryption and decryption because the password-to-secret-key algorithm would need to be identical for the decryption to match the encryption.

# cert is a CkCert object (input)
SetSigningCert( cert )

Tells the encryption library to use a specific digital certificate for digital signature creation.

# Returns a boolean value
SetSigningCert2( cert, key )

To be documented soon.

Returns true for success, false for failure.

# cert is a CkCert object (input)
SetVerifyCert( cert )

Sets the digital certificate to be used in verifying a signature.

# bData is a CkByteData object (input)
# out is a CkByteData object (output)
# Returns a boolean value
SignBytes( bData, out )

Digitally signs a byte array and returns the detached digital signature. A certificate must be set by calling SetSigningCert prior to calling this method.

# bData is a CkByteData object (input)
# out is a CkString object (output)
# Returns a boolean value
SignBytesENC( bData, out )

Digitally signs a byte array and returns the detached digital signature encoded as a printable string. A certificate must be set by calling SetSigningCert prior to calling this method. The EncodingMode property controls the output encoding, which can be "Base64", "QP", or "Hex".

Returns true for success, false for failure.

# str is a string (input)
# out is a CkByteData object (output)
# Returns a boolean value
SignString( str, out )

Digitally signs a string and returns the detached digital signature. A certificate must be set by calling SetSigningCert prior to calling this method. The Charset property controls the character encoding of the string that is signed. (Languages such as VB.NET, C#, and Visual Basic work with Unicode strings.) To sign Unicode data (2 bytes per char), set the Charset property to "Unicode". To implicitly convert the string to a mutlibyte charset such as "iso-8859-1", "Shift_JIS", "utf-8", or something else, then set the Charset property to the name of the charset before signing. The complete list of charsets is listed in the EncryptString method description.

# str is a string (input)
# out is a CkString object (output)
# Returns a boolean value
SignStringENC( str, out )

Digitally signs a string and returns the PKCS7 detached digital signature as an encoded string. A certificate must be set by calling SetSigningCert prior to calling this method. The Charset property controls the character encoding of the string that is signed. (Languages such as VB.NET, C#, and Visual Basic work with Unicode strings.) To sign Unicode data (2 bytes per char), set the Charset property to "Unicode". To implicitly convert the string to a mutlibyte charset such as "iso-8859-1", "Shift_JIS", "utf-8", or something else, then set the Charset property to the name of the charset before signing. The complete list of charsets is listed in the EncryptString method description.

The encoding of the output string is controlled by the EncodingMode property, which can be set to "Base64", "QP", or "Hex".

Returns true for success, false for failure.

# inStr is a string (input)
# charset is a string (input)
# outBytes is a CkByteData object (output)
# Returns a boolean value
StringToBytes( inStr, charset, outBytes )

Convert a string to a byte array where the characters are encoded according to the charset specified.

# inStr is a string (input)
# ending is a string (input)
# outStr is a CkString object (output)
TrimEndingWith( inStr, ending, outStr )

Trim a string ending with a specific substring until the string no longer ends with that substring.

Returns true for success, false for failure.

# unlockCode is a string (input)
# Returns a boolean value
UnlockComponent( unlockCode )

Unlocks the component. This must be called once prior to calling any other method.

# bData1 is a CkByteData object (input)
# sigData is a CkByteData object (input)
# Returns a boolean value
VerifyBytes( bData1, sigData )

Verifies a byte array against a digital signature and returns true if the byte array is unaltered.

# bData is a CkByteData object (input)
# encodedSig is a string (input)
# Returns a boolean value
VerifyBytesENC( bData, encodedSig )

Verifies a byte array against a string-encoded digital signature and returns true if the byte array is unaltered. This method can be used to verify a signature produced by SignBytesENC. The EncodingMode property must be set prior to calling to match the encoding of the digital signature string ("Base64", "QP", or "Hex").

# inFilename is a string (input)
# p7sFilename is a string (input)
# Returns a boolean value
VerifyDetachedSignature( inFilename, p7sFilename )

Verifies a .p7s (PKCS #7 Signature) against the original file (or exact copy of it). If the inFilename has not been modified, the return value is true, otherwise it is false. This method is equivalent to VerifyP7S.

# p7mFilename is a string (input)
# outFilename is a string (input)
# Returns a boolean value
VerifyP7M( p7mFilename, outFilename )

Verifies a .p7m file and extracts the original file from the .p7m. Returns true if the signature is valid and the contents are unchanged. Otherwise returns false.

Extract a File from a .p7m (PKCS7 Signed-Data)

# inFilename is a string (input)
# p7sFilename is a string (input)
# Returns a boolean value
VerifyP7S( inFilename, p7sFilename )

Verifies a .p7s (PKCS #7 Signature) against the original file (or exact copy of it). If the inFilename has not been modified, the return value is true, otherwise it is false.

# str is a string (input)
# sigData is a CkByteData object (input)
# Returns a boolean value
VerifyString( str, sigData )

Verifies a string against a binary digital signature and returns true if the string is unaltered. This method can be used to verify a signature produced by SignString. The Charset property must be set to the charset that was used when creating the signature.

# str is a string (input)
# encodedSig is a string (input)
# Returns a boolean value
VerifyStringENC( str, encodedSig )

Verifies a string against a string-encoded digital signature and returns true if the string is unaltered. This method can be used to verify a signature produced by SignStringENC. The Charset and EncodingMode properties must be set to the same values that were used when creating the signature.

# filename is a string (input)
# fileData is a CkByteData object (output)
# Returns a boolean value
WriteFile( filename, fileData )

Convenience method to write an entire byte array to a file.

# inData is a CkByteData object (output)
# charset is a string (input)
# Returns a string
bytesToString( inData, charset )

Utility method to convert bytes to a string -- interpreting the bytes according to the charset specified.

Returns a null on failure

# Returns a string
cadesSigPolicyHash( )

To be documented soon...

# Returns a string
cadesSigPolicyId( )

To be documented soon...

# Returns a string
cadesSigPolicyUri( )

To be documented soon...

# Returns a string
charset( )

Controls the character encoding of the text encrypted, signed, hashed or compressed. This property is relevant wherever strings are used as inputs or outputs.

When working with strings, it is important to know the exact bytes that are being encrypted/hashed/signed/compressed. This is critical when interoperating with other systems. If your application is sending an encrypted string to another system that will decrypt it, you will need to know the encoding of the string that is expected on the receiving end (after decryption). If you pass Unicode data (2 byte per character) to the encryptor, subsequent decryption will reproduce the original Unicode. However, it may be that your program works with Unicode strings, but the recipient of the encrypted data works with iso-8859-1 strings. In such a case, setting the Charset property to "iso-8859-1" causes the character data to be automatically converted to the Charset before being encrypted (or compressed, or hashed, or signed). The set of valid charsets is listed below:

ANSI
us-ascii
unicode
unicodefffe
iso-8859-1
iso-8859-2
iso-8859-3
iso-8859-4
iso-8859-5
iso-8859-6
iso-8859-7
iso-8859-8
iso-8859-9
iso-8859-13
iso-8859-15
windows-874
windows-1250
windows-1251
windows-1252
windows-1253
windows-1254
windows-1255
windows-1256
windows-1257
windows-1258
utf-7
utf-8
utf-32
utf-32be
shift_jis
gb2312
ks_c_5601-1987
big5
iso-2022-jp
iso-2022-kr
euc-jp
euc-kr
macintosh
x-mac-japanese
x-mac-chinesetrad
x-mac-korean
x-mac-arabic
x-mac-hebrew
x-mac-greek
x-mac-cyrillic
x-mac-chinesesimp
x-mac-romanian
x-mac-ukrainian
x-mac-thai
x-mac-ce
x-mac-icelandic
x-mac-turkish
x-mac-croatian
asmo-708
dos-720
dos-862
ibm037
ibm437
ibm500
ibm737
ibm775
ibm850
ibm852
ibm855
ibm857
ibm00858
ibm860
ibm861
ibm863
ibm864
ibm865
cp866
ibm869
ibm870
cp875
koi8-r
koi8-u

Returns a null on failure

# Returns a string
cipherMode( )

Controls the cipher mode for Rijndael and Twofish encryption. Possible values are "CBC" (the default) and "ECB".

CBC is an acronym for Cipher Block Chaining, ECB is an acronym for Electronic CookBook.

Returns a null on failure

# bData is a CkByteData object (input)
# Returns a string
compressBytesENC( bData )

Same as CompressBytes, except an encoded string is returned. The encoding is controlled by the EncodingMode property, which can be set to "Base64", "QP" (for quoted-printable), or "Hex".

Returns a null on failure

# str is a string (input)
# Returns a string
compressStringENC( str )

Compresses a string and returns an encoded string of the compressed data. For languages such as C#, VB.NET, Visual Basic 6, etc. the string input argument is Unicode. The Charset property controls the conversion of the Unicode string to a multibyte string before compression is applied. For example, if Charset is set to "iso-8859-1", then the input string argument is first converted from Unicode (2 bytes per char) to iso-8859-1 (1 byte per char) before compressing according to the CompressionAlgorithm property ("BZIP2"). If the Charset property is set to "unicode", then no character encoding conversion will happen, and the full Unicode string is compressed.

Compressed data is typically binary data which is not a printable string. This method encodes the output compressed data to a printable string according to the EncodingMode property, which can be set to "Base64", "QP" (for quoted-printable), or "Hex".

Returns a null on failure

# Returns a string
compressionAlgorithm( )

Selects the compression algorithm to be used for the various compress and inflate methods. Currently, the only valid setting is "BZIP2".

Returns a null on failure

# Returns a string
cryptAlgorithm( )

Selects the encryption algorithm for encrypting and decrypting. Possible values are: "pki", "aes", "rijndael", "blowfish", "blowfish2", "des", "3des", "rc2", "arc4", "twofish", "pbes1" and "pbes2". The "pki" encryption algorithm isn't a specific algorithm, but instead tells the component to encrypt/decrypt using public-key encryption with digital certificates. The other choices, rijndael, blowfish, and twofish, are symmetric encryption algorithms that do not involve digital certificates and public/private keys.

The original Chilkat implementation of Blowfish has a 4321 byte-swapping issue (the results are 4321 byte-swapped). The new implementation ("blowfish2") does not byte swap. This should be used for compatibility with other Blowfish software.

Password-based encryption (PBE) is selected by setting this property to "pbes1" or "pbes2". Password-based encryption is defined in the PKCS5 Password-Based Cryptography Standard at http://www.rsa.com/rsalabs/node.asp?id=2127. If PBE is used, the underlying encryption algorithm is specified by the PbesAlgorithm property. The underlying encryption (PbesAlgorithm) for PBES1 is limited to 56-bit DES or 64-bit RC2.

Returns a null on failure

# inStr is a string (input)
# charset is a string (input)
# encoding is a string (input)
# Returns a string
decodeString( inStr, charset, encoding )

Decodes from an encoding back to the original string. The encoding can be any of the following: "base64", "base32", "hex", "url", "html", "uu", "modbase64", or "quoted-printable".

Returns a null on failure

# encodedEncryptedData is a string (input)
# Returns a string
decryptEncoded( encodedEncryptedData )

Encrypted data is passed to this method as an encoded string (base64, hex, etc.). This method first decodes the input data according to the EncodingMode property setting. It then decrypts and re-encodes using the EncodingMode setting, and returns the decrypted data in encoded string form.

Returns a null on failure

# bData is a CkByteData object (input)
# Returns a string
decryptString( bData )

The reverse of EncryptString.

Decrypts encrypted byte data and returns the original string. The property settings used when encrypting the string must match the settings when decrypting. Specifically, the Charset, CryptAlgorithm, CipherMode, PaddingScheme, KeyLength, IV, and SecretKey properties must match.

Returns a null on failure

# str is a string (input)
# Returns a string
decryptStringENC( str )

The reverse of EncryptStringENC.

Decrypts string-encoded encrypted data and returns the original string. The property settings used when encrypting the string must match the settings when decrypting. Specifically, the Charset, EncodingMode, CryptAlgorithm, CipherMode, PaddingScheme, KeyLength, IV, and SecretKey properties must match.

Returns a null on failure

# bData is a CkByteData object (input)
# encoding is a string (input)
# Returns a string
encode( bData, encoding )

Encode binary data to base64, hex, quoted-printable, or URL-encoding. The encoding argument can be set to any of the following strings: "base64", "hex", "quoted-printable", or "url".

Returns a null on failure

# bytes is a string (input)
# numBytes is an integer (input)
# encoding is a string (input)
# Returns a string
encodeBytes( bytes, numBytes, encoding )

To be documented soon...

# strToEncode is a string (input)
# charsetName is a string (input)
# toEncodingName is a string (input)
# Returns a string
encodeString( strToEncode, charsetName, toEncodingName )

Encode a string to base64, hex, quoted-printable, or URL-encoding. charsetName may be set to any of the following strings: "base64", "hex", "quoted-printable", or "url". The toEncodingName is important, and usually you'll want to specify "ansi". For example, if the string "ABC" is to be encoded to "hex" using ANSI, the result will be "414243". However, if "unicode" is used, the result is "410042004300".

Returns a null on failure

# Returns a string
encodingMode( )

Controls the encoding of binary data to a printable string for many methods. The valid modes are "Base64", "Base32", "UU", "QP" (for quoted-printable), "URL" (for url-encoding), and "Hex".

Returns a null on failure

# bData is a CkByteData object (input)
# Returns a string
encryptBytesENC( bData )

Encrypts a byte array and returns the encrypted data as an encoded (printable) string. The minimal set of properties that should be set before encrypting are: CryptAlgorithm, SecretKey, EncodingMode. Other properties that control encryption are: CipherMode, PaddingScheme, KeyLength, IV. When decrypting, all property settings must match otherwise garbled data is returned. The encoding of the string that is returned is controlled by the EncodingMode property, which can be set to "Base64", "QP", or "Hex".

Returns a null on failure

# str is a string (input)
# Returns a string
encryptEncoded( str )

The input string is first decoded according to the encoding algorithm specified by the EncodingMode property (such as base64, hex, etc.) It is then encrypted according to the encryption algorithm specified by CryptAlgorithm. The resulting encrypted data is encoded (using EncodingMode) and returned.

Returns a null on failure

# str is a string (input)
# Returns a string
encryptStringENC( str )

Encrypts a string and returns the encrypted data as an encoded (printable) string. The minimal set of properties that should be set before encrypting are: CryptAlgorithm, SecretKey, Charset, and EncodingMode. Other properties that control encryption are: CipherMode, PaddingScheme, KeyLength, IV. When decrypting (with DecryptStringENC), all property settings must match otherwise garbled data is returned. The Charset property controls the exact bytes that get encrypted. Languages such as VB.NET, C#, and Visual Basic work with Unicode strings, thus the input string is Unicode. If Unicode is to be encrypted (i.e. 2 bytes per character) then set the Charset property to "Unicode". To implicitly convert the string to another charset before the encryption is applied, set the Charset property to something else, such as "iso-8859-1", "Shift_JIS", "big5", "windows-1252", etc. (Refer to EncryptString for the complete list of charsets.)

The EncodingMode property controls the encoding of the string that is returned. It can be set to "Base64", "QP", or "Hex".

Returns a null on failure

# password is a string (input)
# encoding is a string (input)
# Returns a string
genEncodedSecretKey( password, encoding )

Identical to the GenerateSecretKey method, except it returns the binary secret key as a string encoded according to encoding, which may be "base64", "hex", "url", etc. Please see the documentation for GenerateSecretKey for more information.

Returns a null on failure

# numBytes is an integer (input)
# Returns a string
genRandomBytesENC( numBytes )

Generates numBytes random bytes and returns them as an encoded string. The encoding, such as base64, hex, etc. is controlled by the EncodingMode property.

Returns a null on failure

# encoding is a string (input)
# Returns a string
getEncodedIV( encoding )

Returns the initialization vector as an encoded string. The encoding argument can be set to any of the following strings: "base64", "hex", "quoted-printable", or "url".

Returns a null on failure

# encoding is a string (input)
# Returns a string
getEncodedKey( encoding )

Returns the secret key as an encoded string. The encoding argument can be set to any of the following strings: "base64", "hex", "quoted-printable", or "url".

Returns a null on failure

# encoding is a string (input)
# Returns a string
getEncodedSalt( encoding )

Returns the password-based encryption (PBE) salt bytes as an encoded string. The encoding argument can be set to any of the following strings: "base64", "hex", "quoted-printable", or "url".

Returns a null on failure

# Returns a string
hashAlgorithm( )

Selects the hash algorithm used by methods that create hashes. The valid choices are "sha1", "sha256", "sha384", "sha512", "md2", "md5", "haval", "ripemd128", "ripemd160","ripemd256", or "ripemd320".

Returns a null on failure

# bData is a CkByteData object (input)
# Returns a string
hashBytesENC( bData )

Hashes a byte array and returns an encoded (printable) string of the binary hash. The hash algorithm to be used is controlled by the HashAlgorithm property, which can be set to "sha1", "sha384", "sha512", "md2", "md5", or "haval". The encoding is controlled by the EncodingMode property, which can be set to "Base64", "QP", or "Hex".

Returns a null on failure

# filename is a string (input)
# Returns a string
hashFileENC( filename )

Hashes a file. The hash algorithm to be used is controlled by the HashAlgorithm property, which can be set to "sha1", "sha384", "sha512", "md2", "md5", or "haval". The function returns the hash as a string encoded according to the EncodingMode property. Any size file is supported because the file is hashed internally in streaming mode.

Returns a null on failure

# Returns a string
hashFinalENC( )

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

Returns a null on failure

# str is a string (input)
# Returns a string
hashStringENC( str )

Hashes a string and returns an encoded (printable) string of the binary hash. The hash algorithm to be used is controlled by the HashAlgorithm property, which can be set to "sha1", "sha384", "sha512", "md2", "md5", "haval", "ripemd128", "ripemd160","ripemd256", or "ripemd320".

The Charset property controls the character encoding of the string that is hashed. Languages such as VB.NET, C#, and Visual Basic work with Unicode strings. If it is desired to hash Unicode directly (2 bytes/char) then set the Charset property to "Unicode". To implicitly convert to another charset before hashing, set the Charset property to the desired charset. For example, if Charset is set to "iso-8859-1", the input string is first implicitly converted to iso-8859-1 (1 byte per character) before hashing. The full list of supported charsets is listed in the EncryptString method description.
The encoding of the output string is controlled by the EncodingMode property, which can be set to "Base64", "QP", or "Hex".

The HAVAL hash algorithm is affected by two other properties: HavalRounds and KeyLength. The HavalRounds may have values of 3, 4, or 5. The KeyLength may have values of 128, 160, 192, 224, or 256.

Returns a null on failure

# inBytes is a CkByteData object (input)
# Returns a string
hmacBytesENC( inBytes )

Computes an HMAC using a secret key and hash algorithm. The result is encoded to a string using the encoding (base64, hex, etc.) specified by the EncodingMode property.

The secret key is set by calling one of these methods prior to calling this method: SetHmacKeyBytes, SetHmacKeyEncoded, or SetHmacKeyString.

The hash algorithm is specified by the HashAlgorithm property.

Returns a null on failure

# inText is a string (input)
# Returns a string
hmacStringENC( inText )

Computes an HMAC using a secret key and hash algorithm. The result is encoded to a string using the encoding (base64, hex, etc.) specified by the EncodingMode property.

The secret key is set by calling one of these methods prior to calling this method: SetHmacKeyBytes, SetHmacKeyEncoded, or SetHmacKeyString.

The hash algorithm is specified by the HashAlgorithm property.

Returns a null on failure

# bData is a CkByteData object (input)
# Returns a string
inflateString( bData )

The opposite of CompressString. The Charset and CompressionAlgorithm properties should match what was used when compressing.

Returns a null on failure

# str is a string (input)
# Returns a string
inflateStringENC( str )

The opposite of CompressStringENC. The Charset, EncodingMode, and CompressionAlgorithm properties should match what was used when compressing.

Returns a null on failure

# Returns a string
lastErrorHtml( )

Error information in HTML format for the last method called.

Returns a null on failure

# Returns a string
lastErrorText( )

Error information in plain-text format for the last method called.

Returns a null on failure

# Returns a string
lastErrorXml( )

Error information in XML format for the last method called.

Returns a null on failure

# strEncryptedHex is a string (input)
# strPassword is a string (input)
# Returns a string
mySqlAesDecrypt( strEncryptedHex, strPassword )

Matches MySQL's AES_DECRYPT function. strEncryptedHex is a hex-encoded string of the AES encrypted data. The return value is the original unencrypted string.

Returns a null on failure

# strData is a string (input)
# strPassword is a string (input)
# Returns a string
mySqlAesEncrypt( strData, strPassword )

Matches MySQL's AES_ENCRYPT function. The return value is a hex-encoded string of the encrypted data. The equivalent call in MySQL would look like this: HEX(AES_ENCRYPT('The quick brown fox jumps over the lazy dog','password'))

Returns a null on failure

Match MySQL AES_ENCRYPT Function

# bData is a CkByteData object (input)
# Returns a string
opaqueSignBytesENC( bData )

Digitally signs a byte array and returns the opaque digital signature encoded as a printable string. A certificate must be set by calling SetSigningCert prior to calling this method. The EncodingMode property controls the output encoding, which can be "Base64", "QP", or "Hex".

Returns a null on failure

# str is a string (input)
# Returns a string
opaqueSignStringENC( str )

Digitally signs a string and returns the opaque digital signature as an encoded string. A certificate must be set by calling SetSigningCert prior to calling this method. The Charset property controls the character encoding of the string that is signed. (Languages such as VB.NET, C#, and Visual Basic work with Unicode strings.) To sign Unicode data (2 bytes per char), set the Charset property to "Unicode". To implicitly convert the string to a mutlibyte charset such as "iso-8859-1", "Shift_JIS", "utf-8", or something else, then set the Charset property to the name of the charset before signing. The complete list of charsets is listed in the EncryptString method description.

The encoding of the output string is controlled by the EncodingMode property, which can be set to "Base64", "QP", or "Hex".

Returns a null on failure

# p7s is a CkByteData object (input)
# Returns a string
opaqueVerifyString( p7s )

Verifies an opaque signature and returns the original string. If the signature verification fails, the returned string will be 0 characters in length.

Returns a null on failure

# p7s is a string (input)
# Returns a string
opaqueVerifyStringENC( p7s )

Verifies an opaque signature (encoded in string form) and returns the original data string. If the signature verification fails, the returned string will be 0 characters in length.

Returns a null on failure

# Returns a string
pbesAlgorithm( )

If the CryptAlgorithm property is set to "pbes1" or "pbes2", this property specifies the underlying encryption algorithm to be used with password-based encryption (PBE). Password-based encryption is defined in the PKCS5 Password-Based Cryptography Standard at http://www.rsa.com/rsalabs/node.asp?id=2127

Returns a null on failure

# Returns a string
pbesPassword( )

The password to be used with password-based encryption (PBE). Password-based encryption is defined in the PKCS5 Password-Based Cryptography Standard at http://www.rsa.com/rsalabs/node.asp?id=2127

Returns a null on failure

# password is a string (input)
# charset is a string (input)
# hashAlg is a string (input)
# salt is a string (input)
# iterationCount is an integer (input)
# outputKeyBitLen is an integer (input)
# encoding is a string (input)
# Returns a string
pbkdf1( password, charset, hashAlg, salt, iterationCount, outputKeyBitLen, encoding )

Implements the PBKDF1 algorithm (Password Based Key Derivation Function #1). The password is converted to the character encoding represented by charset before being passed (internally) to the key derivation function. The hashAlg may be "md5", "sha1", "md2", etc. The salt should be random data at least 8 bytes (64 bits) in length. (The GenRandomBytesENC method is good for generating a random salt value.) The iterationCount should be no less than 1000. The length (in bits) of the derived key output by this method is controlled by outputKeyBitLen. The encoding argument may be "base64", "hex", etc. It controls the encoding of the output, and the expected encoding of the salt. The derived key is returned.

Returns a null on failure

# password is a string (input)
# charset is a string (input)
# hashAlg is a string (input)
# salt is a string (input)
# iterationCount is an integer (input)
# outputKeyBitLen is an integer (input)
# encoding is a string (input)
# Returns a string
pbkdf2( password, charset, hashAlg, salt, iterationCount, outputKeyBitLen, encoding )

Implements the PBKDF2 algorithm (Password Based Key Derivation Function #2). The password is converted to the character encoding represented by charset before being passed (internally) to the key derivation function. The hashAlg may be "md5", "sha1", "md2", etc. The salt should be random data at least 8 bytes (64 bits) in length. (The GenRandomBytesENC method is good for generating a random salt value.) The iterationCount should be no less than 1000. The length (in bits) of the derived key output by this method is controlled by outputKeyBitLen. The encoding argument may be "base64", "hex", etc. It controls the encoding of the output, and the expected encoding of the salt. The derived key is returned.

Returns a null on failure

# Returns a string
pkcs7CryptAlg( )

When the CryptAlgorithm property is "PKI" to select PKCS7 public-key encryption, this selects the underlying symmetric encryption algorithm. Possible values are: "aes", "des", "3des", and "rc2".

Returns a null on failure

# encodedData is a string (input)
# fromEncoding is a string (input)
# toEncoding is a string (input)
# Returns a string
reEncode( encodedData, fromEncoding, toEncoding )

Provides a means for converting from one encoding to another (such as base64 to hex). This is helpful for programming environments where byte arrays are a real pain-in-the-***. The fromEncoding and toEncoding may be "base64", "hex", "quoted-printable" (or "qp"), or "url".

Returns a null on failure

# bData is a CkByteData object (input)
# Returns a string
signBytesENC( bData )

Digitally signs a byte array and returns the detached digital signature encoded as a printable string. A certificate must be set by calling SetSigningCert prior to calling this method. The EncodingMode property controls the output encoding, which can be "Base64", "QP", or "Hex".

Returns a null on failure

# str is a string (input)
# Returns a string
signStringENC( str )

Digitally signs a string and returns the PKCS7 detached digital signature as an encoded string. A certificate must be set by calling SetSigningCert prior to calling this method. The Charset property controls the character encoding of the string that is signed. (Languages such as VB.NET, C#, and Visual Basic work with Unicode strings.) To sign Unicode data (2 bytes per char), set the Charset property to "Unicode". To implicitly convert the string to a mutlibyte charset such as "iso-8859-1", "Shift_JIS", "utf-8", or something else, then set the Charset property to the name of the charset before signing. The complete list of charsets is listed in the EncryptString method description.

The encoding of the output string is controlled by the EncodingMode property, which can be set to "Base64", "QP", or "Hex".

Returns a null on failure

# inStr is a string (input)
# ending is a string (input)
# Returns a string
trimEndingWith( inStr, ending )

Trim a string ending with a specific substring until the string no longer ends with that substring.

Returns a null on failure

# Returns a string
uuFilename( )

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.

Returns a null on failure

UU Encoding and Decoding

# Returns a string
uuMode( )

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.

Returns a null on failure

# Returns a string
version( )

The version of the component, such as "4.0.0".

Returns a null on failure