KeyMgr Module

Properties   Methods   Events   Config Settings   Errors  

The KeyMgr module is used to create and manage OpenPGP keys.

Syntax

IPWorksOpenPGP.Keymgr

Remarks

The KeyMgr class can be used to perform a variety of key-related actions. You can create, delete, import, export, and manage keys. Both individual keys and keyrings can be created and used.

Property List


The following is the full list of the properties of the module with short descriptions. Click on the links for further details.

KeyThe currently selected key.
KeyringThe location on disk of the keyring.

Method List


The following is the full list of the methods of the module with short descriptions. Click on the links for further details.

AddRevokerAdds a designated revoker to the key.
AddUserIdAdds the specified user Id to the current key.
ChangeExpirationDateChanges the expiration date of the key.
ChangePassphraseChanges the passphrase of the current key.
ConfigSets or retrieves a configuration setting.
CreateKeyCreates an OpenPGP key pair.
CreateSubKeyCreates a new subkey.
DeleteKeyDeletes the specified key.
ExportPublicKeyExports the public key of the current key.
ExportSecretKeyExports the private key of the current key.
ImportKeyImports the key specified by UserId to the current keyring.
ImportKeyBImports the key specified by UserId to the current keyring.
ListKeysLists keys in the specified Keyring .
ListSignaturesLists all signatures of the current key.
ListSubkeysLists the subkeys of the currently selected key.
LoadKeyringLoads the keyring from disk.
LoadKeyringBLoads the keyring from SecretKeyringData and PublicKeyringData .
ResetResets the module properties.
RevokeKeyRevokes the specified key.
SaveKeyringSaves the current Keyring to disk.
SignUserIdSigns the specified user Id of the current key.
VerifyPassphraseVerifies the passphrase of specified key.

Event List


The following is the full list of the events fired by the module with short descriptions. Click on the links for further details.

ErrorInformation about errors during data delivery.
KeyListFires for each key in the keyring when ListKeys is called.
KeyPassphraseFired if the passphrase of current key is incorrect or empty.
SignatureListFires for each signature of the current key when ListSignatures is called.
StatusShows the progress of the operation.
SubkeyListFires once for each subkey listed when ListSubkeys is called.

Config Settings


The following is a list of config settings for the module with short descriptions. Click on the links for further details.

AllowEmptyPasswordWhether a key can be created without a password.
ContinueOnInvalidKeyWhether to continue loading the keyring when an invalid key is found.
CreateRSASubkeyforEncryptWhether to create a subkey when creating an RSA key.
CurrentKeyPrimaryKeyUsageFlagsThe usage flags of the currently selected primary key.
CurveThe elliptic curve used when calling CreateKey.
DSAPublicSubKeyLengthSpecifies the public subkey length when creating a DSA key.
EnsureValidDSASignatureHashAlgorithmWhether or not to select a suitable signature hash algorithm automatically.
ImportAllKeysWhether or not to import all keys found in a key file.
KeyEncryptionAlgorithmThe encryption algorithm used when creating a key.
KeyIdLengthSpecifies the length of the key's Id.
KeyringFormatWhich format of keyring to use.
KeyUsageFlags that show intended use for the key being created.
KeyValidityTimeThe validity period for the key being created.
LogLevelSpecifies the level of detail that is logged.
PublicKeyAlgorithmThe public key algorithm for the key being created.
PublicKeyLengthSpecifies the public key length when creating a key.
PublicKeyringFileThe file name of the public keyring file.
PublicKeySignatureHashAlgorithmThe public key signature hash algorithm used when creating a key.
RawKeyDataReturns detailed key and keyring data for debugging purposes.
RevocationCodeThe reason why the key was revoked.
RevocationReasonText describing why the key was revoked.
RevokerThe revoker's key Id.
SecretKeyringFileThe file name of the secret keyring file.
SubKeyAlgorithmThe subkey algorithm for the subkey being created.
SubKeyCurveThe elliptic curve of the sub key.
SubKeyUsageFlags that show intended use for the subkey being created.
UseFipsCompliantAlgorithmsRestricts the usage to FIPS compliant algorithms only.
VersionHeaderThe Version header value in ASCII armored public keys.
BuildInfoInformation about the product's build.
CodePageThe system code page used for Unicode to Multibyte translations.
LicenseInfoInformation about the current license.
MaskSensitiveWhether sensitive data is masked in log messages.
UseInternalSecurityAPITells the module whether or not to use the system security libraries or an internal implementation.

Key Property (KeyMgr Module)

The currently selected key.

Syntax

public var key: Key {
  get {...}
  set {...}
}

@property (nonatomic,readonly,assign,getter=keyCurve) NSString* keyCurve;

- (NSString*)keyCurve;

@property (nonatomic,readonly,assign,getter=keyEffectiveDate) NSString* keyEffectiveDate;

- (NSString*)keyEffectiveDate;

@property (nonatomic,readwrite,assign,getter=keyEncoded,setter=setKeyEncoded:) NSString* keyEncoded;

- (NSString*)keyEncoded;
- (void)setKeyEncoded :(NSString*)newKeyEncoded;

@property (nonatomic,readwrite,assign,getter=keyEncodedB,setter=setKeyEncodedB:) NSData* keyEncodedB;

- (NSData*)keyEncodedB;
- (void)setKeyEncodedB :(NSData*)newKeyEncoded;
@property (nonatomic,readonly,assign,getter=keyExpirationDate) NSString* keyExpirationDate;

- (NSString*)keyExpirationDate;

@property (nonatomic,readonly,assign,getter=keyFingerprint) NSString* keyFingerprint;

- (NSString*)keyFingerprint;

@property (nonatomic,readonly,assign,getter=keyId) NSString* keyId;

- (NSString*)keyId;

@property (nonatomic,readonly,assign,getter=keyOtherUserIds) NSString* keyOtherUserIds;

- (NSString*)keyOtherUserIds;

@property (nonatomic,readwrite,assign,getter=keyPassphrase,setter=setKeyPassphrase:) NSString* keyPassphrase;

- (NSString*)keyPassphrase;
- (void)setKeyPassphrase :(NSString*)newKeyPassphrase;

@property (nonatomic,readonly,assign,getter=keyPublicKey) NSString* keyPublicKey;

- (NSString*)keyPublicKey;

@property (nonatomic,readonly,assign,getter=keyPublicKeyAlgorithm) NSString* keyPublicKeyAlgorithm;

- (NSString*)keyPublicKeyAlgorithm;

@property (nonatomic,readonly,assign,getter=keyPublicKeyLength) int keyPublicKeyLength;

- (int)keyPublicKeyLength;

@property (nonatomic,readonly,assign,getter=keyRevoked) BOOL keyRevoked;

- (BOOL)keyRevoked;

@property (nonatomic,readonly,assign,getter=keySecretKey) NSString* keySecretKey;

- (NSString*)keySecretKey;

@property (nonatomic,readonly,assign,getter=keySecretKeyAvailable) BOOL keySecretKeyAvailable;

- (BOOL)keySecretKeyAvailable;

@property (nonatomic,readonly,assign,getter=keyUsage) NSString* keyUsage;

- (NSString*)keyUsage;

@property (nonatomic,readonly,assign,getter=keyUsageFlags) int keyUsageFlags;

- (int)keyUsageFlags;

@property (nonatomic,readwrite,assign,getter=keyUserId,setter=setKeyUserId:) NSString* keyUserId;

- (NSString*)keyUserId;
- (void)setKeyUserId :(NSString*)newKeyUserId;

 

Default Value

""

Remarks

This property holds the currently selected key. It is populated after calling ImportKey or after setting Keyring. This may also be set to directly load an existing key. Both public keys and secret keys are supported.

This property is read-only.

Keyring Property (KeyMgr Module)

The location on disk of the keyring.

Syntax

public var keyring: String {
  get {...}
}

@property (nonatomic,readonly,assign,getter=keyring) NSString* keyring;

- (NSString*)keyring;

Default Value

""

Remarks

To load a keyring use the LoadKeyring method.

This property is read-only.

AddRevoker Method (KeyMgr Module)

Adds a designated revoker to the key.

Syntax

public func addRevoker(userId: String) throws -> Void
- (void)addRevoker:(NSString*)userId;

Remarks

This method adds a designated revoker to the selected Key. The UserId parameter specifies the revoker to add. The revoker's key must be present in the current keyring. Use this with caution: once added, a revoker cannot be removed. The key's passphrase is required for this operation and may be specified via KeyPassphrase or through the KeyPassphrase event.

The UserId format is:

FirstName LastName (Comment) <Email>
Not all values are required when selecting or generating a key, but at least FirstName or Email are required.

AddUserId Method (KeyMgr Module)

Adds the specified user Id to the current key.

Syntax

public func addUserId(userId: String) throws -> Void
- (void)addUserId:(NSString*)userId;

Remarks

The key's passphrase is required for this operation and may be specified via KeyPassphrase or through the KeyPassphrase event.

The UserId format is:

FirstName LastName (Comment) <Email>
Not all values are required when selecting or generating a key, but at least FirstName or Email are required.

ChangeExpirationDate Method (KeyMgr Module)

Changes the expiration date of the key.

Syntax

public func changeExpirationDate(expirationDate: Int32) throws -> Void
- (void)changeExpirationDate:(int)expirationDate;

Remarks

This method changes the expiration date of the current Key. The ExpirationDate parameter specifies the number of days for which the key is valid starting today. For instance a value of "31" means the key is valid for the next 31 days.

The special value "0" means the key will never expire.

The key's passphrase is required for this operation and may be specified via KeyPassphrase or through the KeyPassphrase event.

Note: See KeyValidityTime for information on specifying the expiration date when creating the key with CreateKey.

ChangePassphrase Method (KeyMgr Module)

Changes the passphrase of the current key.

Syntax

public func changePassphrase(passphrase: String) throws -> Void
- (void)changePassphrase:(NSString*)passphrase;

Remarks

The Passphrase parameter specifies the new passphrase.

The key's passphrase is required for this operation and may be specified via KeyPassphrase or through the KeyPassphrase event.

Config Method (KeyMgr Module)

Sets or retrieves a configuration setting.

Syntax

public func config(configurationString: String) throws -> String
- (NSString*)config:(NSString*)configurationString;

Remarks

Config is a generic method available in every class. It is used to set and retrieve configuration settings for the class.

These settings are similar in functionality to properties, but they are rarely used. In order to avoid "polluting" the property namespace of the class, access to these internal properties is provided through the Config method.

To set a configuration setting named PROPERTY, you must call Config("PROPERTY=VALUE"), where VALUE is the value of the setting expressed as a string. For boolean values, use the strings "True", "False", "0", "1", "Yes", or "No" (case does not matter).

To read (query) the value of a configuration setting, you must call Config("PROPERTY"). The value will be returned as a string.

CreateKey Method (KeyMgr Module)

Creates an OpenPGP key pair.

Syntax

public func createKey(userId: String, passphrase: String) throws -> Void
- (void)createKey:(NSString*)userId :(NSString*)passphrase;

Remarks

This method creates a new OpenPGP key pair. The UserId parameter specifies the user Id of the key.

The UserId format is:

FirstName LastName (Comment) <Email>
Not all values are required when selecting or generating a key, but at least FirstName or Email are required.

Additional configuration settings may be set to further configure the details of the key being created. Please see the following settings for details:

CreateSubKey Method (KeyMgr Module)

Creates a new subkey.

Syntax

public func createSubKey() throws -> Void
- (void)createSubKey;

Remarks

This method creates a new subkey. Before calling this method the KeyId property must be set to a valid private key.

The following settings may optionally be set to define specific values for the created subkey:

DeleteKey Method (KeyMgr Module)

Deletes the specified key.

Syntax

public func deleteKey(userId: String) throws -> Void
- (void)deleteKey:(NSString*)userId;

Remarks

This method deletes the key specified by UserId from the current keyring. Below is a table of the type of Ids that may be specified to identify the key:

Id Type Example
UserId FirstName LastName <user@mail.com>
UserId (name only) FirstName LastName
UserId (first name only) FirstName
UserId (email only) user@mail.com
Short KeyId 89C9D7B1
Long KeyId F7B7D49C89C9D7B1

ExportPublicKey Method (KeyMgr Module)

Exports the public key of the current key.

Syntax

public func exportPublicKey(fileName: String, useAsciiArmor: Bool) throws -> Void
- (void)exportPublicKey:(NSString*)fileName :(BOOL)useAsciiArmor;

Remarks

This method exports the public key of the currently selected Key. The FileName parameter specifies the file on disk to which the public key will be written. The UseAsciiArmor parameter determines whether or not ASCII armoring is used when writing the key to disk.

Note: When UseAsciiArmor is set to True the VersionHeader setting may also be set to specify your own header value.

ExportSecretKey Method (KeyMgr Module)

Exports the private key of the current key.

Syntax

public func exportSecretKey(fileName: String, useAsciiArmor: Bool) throws -> Void
- (void)exportSecretKey:(NSString*)fileName :(BOOL)useAsciiArmor;

Remarks

This method exports the private key of the currently selected Key. The FileName parameter specifies the file on disk that the private key will be written to. The UseAsciiArmor parameter determines whether or not ASCII armoring is used when writing the key to disk.

ImportKey Method (KeyMgr Module)

Imports the key specified by UserId to the current keyring.

Syntax

public func importKey(fileName: String, userId: String) throws -> Void
- (void)importKey:(NSString*)fileName :(NSString*)userId;

Remarks

This method imports the key specified by UserId from the key file specified by FileName into the current Keyring. The imported key will be automatically selected and available in the Key property.

If the FileName specifies a key file which contains multiple keys only the key belonging to UserId will be imported.

If UserId is set to "*" or "" (empty string) all keys in the key file will be imported. The ImportAllKeys setting controls the behavior of the class in this case.

Note: If you simply wish to select a key in the current ring set KeyUserId instead.

ImportKeyB Method (KeyMgr Module)

Imports the key specified by UserId to the current keyring.

Syntax

public func importKeyB(data: Data, userId: String) throws -> Void
- (void)importKeyB:(NSData*)data :(NSString*)userId;

Remarks

This method imports the key specified by UserId from the key data specified by Data into the current Keyring. The imported key will be automatically selected and available in the Key property.

If the Data specifies key data that contains multiple keys only the key belonging to UserId will be imported.

If UserId is set to "*" or "" (empty string) all keys in the key data will be imported. The ImportAllKeys setting controls the behavior of the class in this case.

Note: If you simply wish to select a key in the current ring set KeyUserId instead.

ListKeys Method (KeyMgr Module)

Lists keys in the specified Keyring .

Syntax

public func listKeys() throws -> String
- (NSString*)listKeys;

Remarks

This method lists the keys (public/private key pairs) in the specified keyring. The results are provided through the KeyList event.

KeyList data will also be returned from this method, however it is recommended to use the KeyList event if possible.

ListSignatures Method (KeyMgr Module)

Lists all signatures of the current key.

Syntax

public func listSignatures() throws -> String
- (NSString*)listSignatures;

Remarks

This method lists all the signatures of the currently selected key. The SignatureList event will fire for each signature.

SignatureList data will also be returned from this method. However, it is recommended to use the SignatureList event if possible.

ListSubkeys Method (KeyMgr Module)

Lists the subkeys of the currently selected key.

Syntax

public func listSubkeys() throws -> String
- (NSString*)listSubkeys;

Remarks

This method lists all subkeys of current key. The SubkeyList event will be fired for each subkey.

SubkeyList data will also be returned from this method, however it is recommended to use the SubkeyList event if possible.

LoadKeyring Method (KeyMgr Module)

Loads the keyring from disk.

Syntax

public func loadKeyring(keyringPath: String) throws -> Void
- (void)loadKeyring:(NSString*)keyringPath;

Remarks

This method loads the keyring from disk. If the keyring is stored in a directory, set KeyringPath to the directory. The directory must contain the files "secring.gpg" and "pubring.gpg". A keyring may also be stored in a single file. If the keyring is a file KeyringPath should be set to the path of the file.

When this method is called the class will read the keyring and populate the Key property with the first key found in the keyring. Set KeyUserId to select a different key in the current keyring.

LoadKeyringB Method (KeyMgr Module)

Loads the keyring from SecretKeyringData and PublicKeyringData .

Syntax

public func loadKeyringB(secretKeyringData: Data, publicKeyringData: Data) throws -> Void
- (void)loadKeyringB:(NSData*)secretKeyringData :(NSData*)publicKeyringData;

Remarks

This method loads the keyring from SecretKeyringData and PublicKeyringData.

When this method is called the class will read the keyring and populate the Key property with the first key found in the keyring. Set KeyUserId to select a different key in the current keyring.

Reset Method (KeyMgr Module)

Resets the component properties.

Syntax

public func reset() throws -> Void
- (void)reset;

Remarks

This method resets all message and key properties to their default values.

RevokeKey Method (KeyMgr Module)

Revokes the specified key.

Syntax

public func revokeKey(keyId: String) throws -> String
- (NSString*)revokeKey:(NSString*)keyId;

Remarks

This method revokes the key specified by KeyId and returns the revocation certificate.

When creating a revocation certificate there are two supported formats. The first format includes only the revocation signature. This format is returned by this method. The second format includes both the public key and the revocation signature. This format can be obtained by calling ExportPublicKey after calling this method. Both formats are common, and both formats are acceptable when calling ImportKey.

Before calling this method a key must be selected and available in the Key* properties.

The KeyId may be the Id of the main key or a subkey.

SaveKeyring Method (KeyMgr Module)

Saves the current Keyring to disk.

Syntax

public func saveKeyring(keyringPath: String) throws -> Void
- (void)saveKeyring:(NSString*)keyringPath;

Remarks

This method saves the current keyring to disk. There are two output options. The keyring may either be saved to a single key file or may be saved to a directory.

To save the keyring to a directory set KeyringPath to the path. The directory must already exist. The class will create a "pubring.gpg" and "secring.gpg" file in the specified directory. If the files already exist they will be overwritten.

To save the keyring to a key file set KeyringPath to a path and file name. If the file already exists it will be overwritten.

SignUserId Method (KeyMgr Module)

Signs the specified user Id of the current key.

Syntax

public func signUserId(userId: String, issuerUserId: String) throws -> Void
- (void)signUserId:(NSString*)userId :(NSString*)issuerUserId;

Remarks

This method signs the UserId with the IssuerUserId.

To sign all user Ids in the current key set the UserId parameter to "*".

The key's passphrase is required for this operation and may be specified via KeyPassphrase or through the KeyPassphrase event.

VerifyPassphrase Method (KeyMgr Module)

Verifies the passphrase of specified key.

Syntax

public func verifyPassphrase(passphrase: String) throws -> Bool
- (BOOL)verifyPassphrase:(NSString*)passphrase;

Remarks

This method verifies the passphrase of the key specified by UserId.

If the password is correct, this method returns True; otherwise, this method returns False.

Error Event (KeyMgr Module)

Information about errors during data delivery.

Syntax

func onError(errorCode: Int32, description: String)
- (void)onError:(int)errorCode :(NSString*)description;

Remarks

The Error event is fired in case of exceptional conditions during message processing. Normally the class .

ErrorCode contains an error code and Description contains a textual description of the error. For a list of valid error codes and their descriptions, please refer to the Error Codes section.

KeyList Event (KeyMgr Module)

Fires for each key in the keyring when ListKeys is called.

Syntax

func onKeyList(userId: String, keyId: String, fingerprint: String, hasSecretKey: Bool, publicKeyAlgorithm: String, publicKeyLength: Int32, curve: String)
- (void)onKeyList:(NSString*)userId :(NSString*)keyId :(NSString*)fingerprint :(BOOL)hasSecretKey :(NSString*)publicKeyAlgorithm :(int)publicKeyLength :(NSString*)curve;

Remarks

This event fires once for each key in the Keyring when ListKeys is called.

UserId holds the current user Id of the key.

The UserId format is:

FirstName LastName (Comment) <Email>
Not all values are required when selecting or generating a key, but at least FirstName or Email are required.

KeyId is the hex-encoded, 4-byte or 8-byte Id of the key. It is the same as the last 4 or 8 bytes of the Fingerprint. For instance:

BF52A0AB

Fingerprint holds the hex-encoded, 20-byte fingerprint of the key. This is in the form:

5E70662EA810E768391A2FE8F7B7D49C89C9D7B1

HasSecretKey returns True if the key contains a secret key.

PublicKeyAlgorithm is the public key algorithm. Possible values are:

  • RSA
  • DSA
  • ECDSA
  • EdDSA

PublicKeyLength is the length of the public key. Common values are 512, 1024, and 2048. If the PublicKeyAlgorithm is ECDSA or EdDSA the length of the public key is determined by the Curve. Possible lengths are:

CurvePublic Key Length (bits)
secp256r1256
secp384r1384
secp521r1521
Ed25519 256
secp256k1256

Curve is the curve used by the key when PublicKeyAlgorithm is ECDSA or EdDSA. Possible values are:

ValuePublicKeyAlgorithmDescription
secp256r1 ECDSA NIST curve P-256
secp384r1 ECDSA NIST curve P-384
secp521r1 ECDSA NIST curve P-521
Ed25519 EdDSA Ed25519
secp256k1 EdDSA Secp256k1

KeyPassphrase Event (KeyMgr Module)

Fired if the passphrase of current key is incorrect or empty.

Syntax

func onKeyPassphrase(userId: String, keyId: String, passphrase: inout String)
- (void)onKeyPassphrase:(NSString*)userId :(NSString*)keyId :(NSString**)passphrase;

Remarks

This event fires when the passphrase for the key is required. The passphrase must be specified before operations requiring the secret key are attempted. The passphrase may be supplied by setting the Passphrase parameter in this event, or by specifying the KeyPassphrase property before attempting the operation.

The passphrase is required when using the following methods in KeyMgr:

When using the OpenPGP class, or an email-based class, the following methods require a passphrase for the key:

  • Decrypt
  • Sign
  • SignAndEncrypt

SignatureList Event (KeyMgr Module)

Fires for each signature of the current key when ListSignatures is called.

Syntax

func onSignatureList(userId: String, issuerKeyId: String, issuerUserId: String, publicKeyAlgorithm: String, curve: String, hashAlgorithm: String, effectiveDate: String, signatureClass: Int32, validityStatus: Int32)
- (void)onSignatureList:(NSString*)userId :(NSString*)issuerKeyId :(NSString*)issuerUserId :(NSString*)publicKeyAlgorithm :(NSString*)curve :(NSString*)hashAlgorithm :(NSString*)effectiveDate :(int)signatureClass :(int)validityStatus;

Remarks

This event fires once for each signature of the current key when ListSignatures is called.

UserId holds the current user Id of the key.

The UserId format is:

FirstName LastName (Comment) <Email>
Not all values are required when selecting or generating a key, but at least FirstName or Email are required.

IssuerKeyId is the hex-encoded, 4- or-8-byte Id of the issuer's key. It is the same as the last 4 or 8 bytes of the Fingerprint. For instance: BF52A0AB

IssuerUserId is the user Id of the issuer. If this is empty the issuer's key could not be found in the current keyring.

PublicKeyAlgorithm is the public key algorithm. Possible values are:

  • RSA
  • DSA
  • ECDSA
  • EdDSA

Curve is the curve used by the key when PublicKeyAlgorithm is ECDSA or EdDSA. Possible values are:

ValuePublicKeyAlgorithmDescription
secp256r1 ECDSA NIST curve P-256
secp384r1 ECDSA NIST curve P-384
secp521r1 ECDSA NIST curve P-521
Ed25519 EdDSA Ed25519
secp256k1 EdDSA Secp256k1

HashAlgorithm is the hash algorithm used by the signature. Possible values are:

  • SHA1
  • SHA256
  • SHA384
  • SHA512
  • SHA224
  • MD5

EffectiveDate is the date when this signature became valid. The following example illustrates the format of an encoded date: 23-Jan-2000 15:00:00 .

SignatureClass is the type of signature. Possible values are:

16Generic Signature
17Personal Signature
18Casual Signature
19Positive Signature (self-signed)

ValidityStatus specifies the current validity status of the signature. Possible values are:

1Invalid
2Valid
3Unknown (the issuer's public key could not be found)

Status Event (KeyMgr Module)

Shows the progress of the operation.

Syntax

func onStatus(message: String)
- (void)onStatus:(NSString*)message;

Remarks

The event is fired for informational and logging purposes only. It may be used to track the progress of an operation.

The level of detail is controlled by the LogLevel setting.

SubkeyList Event (KeyMgr Module)

Fires once for each subkey listed when ListSubkeys is called.

Syntax

func onSubkeyList(keyId: String, fingerprint: String, publicKeyAlgorithm: String, publicKeyLength: Int32, curve: String, usageFlags: Int32, usage: String, effectiveDate: String, expirationDate: String, revoked: Bool)
- (void)onSubkeyList:(NSString*)keyId :(NSString*)fingerprint :(NSString*)publicKeyAlgorithm :(int)publicKeyLength :(NSString*)curve :(int)usageFlags :(NSString*)usage :(NSString*)effectiveDate :(NSString*)expirationDate :(BOOL)revoked;

Remarks

This event fires once for each subkey when ListSubkeys is called.

KeyId is the hex-encoded, 4- or 8-byte Id of the key. It is the same as the last 4 or 8 bytes of the Fingerprint. For instance:

BF52A0AB

Fingerprint holds the hex-encoded, 20-byte fingerprint of the key. This is in the form:

5E70662EA810E768391A2FE8F7B7D49C89C9D7B1

PublicKeyAlgorithm is the public key algorithm. Possible values are:

  • RSA
  • Elgamal
  • ECDH (Only used with ECDSA and EdDSA keys)

PublicKeyLength is the length of the public key. Common values are 512, 1024, and 2048.

Curve is the curve used by the key when PublicKeyAlgorithm is ECDH. Possible values are:

ValueDescription
secp256r1 NIST curve P-256
secp384r1 NIST curve P-384
secp521r1 NIST curve P-521
Curve25519 Curve25519
Ed25519 Ed25519

Usage is the textual description of UsageFlags.

The value will be of one or more of the following strings, separated by commas:

  • Certifying Other Certificates
  • Signing Emails and Files
  • Encrypting Emails and Files
  • Split Key
  • Authenticate Against Servers
  • Group Key

UsageFlags is an integer flag that shows the intended use for the key. The value is a combination of the following flags:

0x01This key may be used to certify other keys.
0x02This key may be used to sign data.
0x0CThis key may be used to encrypt communications and encrypt storage.
0x10The private component of this key may have been split by a secret-sharing mechanism.
0x20This key may be used for authentication.
0x80The private component of this key may be in the possession of more than one person.

EffectiveDate is the date when this key became valid. The following example illustrates the format of an encoded date: 23-Jan-2000 15:00:00.

ExpirationDate is the date the key expires. After this date the key will no longer be valid. The following example illustrates the format of an encoded date: 23-Jan-2000 15:00:00. If the ExpirationDate is not populated this indicates that the key never expires.

Revoked Indicates whether the subkey is revoked or not.

Key Type

The OpenPGP key being used.

Remarks

This type describes the current key. The key may be a public or secret key. The fields are used to identify or select the key.

Fields

curve
String (read-only)

Default Value: ""

This property specifies the elliptic curve used in the ECDSA or EdDSA key. This property is only applicable if is ECDSA or EdDSA. Possible values are:

ValuePublicKeyAlgorithmDescription
secp256r1 ECDSA NIST curve P-256
secp384r1 ECDSA NIST curve P-384
secp521r1 ECDSA NIST curve P-521
Ed25519 EdDSA Ed25519
secp256k1 EdDSA Secp256k1

effectiveDate
String (read-only)

Default Value: ""

The date when this key becomes valid. Prior to this it is not valid. The following is an example of a valid encoded date:

23-Jan-2000 15:00:00.

encodedB
Data

Default Value: ""

The key. This property is used to assign a specific key. The properties may also be used to specify a key.

encoded
String

Default Value: ""

The key. This property is used to assign a specific key. The properties may also be used to specify a key.

expirationDate
String (read-only)

Default Value: ""

The date the key expires. After this date the key will no longer be valid. The following is an example of a valid encoded date:

23-Jan-2001 15:00:00.

fingerprint
String (read-only)

Default Value: ""

The hex-encoded, 20-byte fingerprint of the key.

This is in the form:

5E70662EA810E768391A2FE8F7B7D49C89C9D7B1

id
String (read-only)

Default Value: ""

The hex-encoded, 4-byte key Id. It is same as last 4 bytes of .

This is in the form:

89C9D7B1
The KeyIdLength setting may be set to a value of 8 to return the last 8 bytes instead of the last 4 bytes.

keyring
String

Default Value: ""

The location of the keyring.

If the keyring is stored in a directory, set this property to the directory. The directory must contain the files "secring.gpg" and "pubring.gpg". A keyring may also be stored in a single file. If the keyring is a file this property should be set to the path of the file.

When This property is set the class will read the keyring and populate the Key* properties with the first key found in the keyring. Set KeyUserId to select a different key in the current keyring.

otherUserIds
String (read-only)

Default Value: ""

If the specified key has alternate user Ids associated with it, this property returns a comma-separated list of the other user Ids.

passphrase
String

Default Value: ""

The passphrase for the key's secret key (if any). This must be specified before operations requiring the secret key are attempted. The passphrase may be supplied in this property or through the KeyPassphrase event, which will fire when a passphrase is required.

The passphrase is required when using the following methods in KeyMgr:

  • AddUserId
  • SignUserId
  • ChangeExpirationDate
  • ChangePassphrase

When using the OpenPGP class, or an email-based class, the following methods require a passphrase for the key:

  • Decrypt
  • Sign
  • SignAndEncrypt

publicKey
String (read-only)

Default Value: ""

The public key of the key. The key is provided as ASCII armored data.

publicKeyAlgorithm
String (read-only)

Default Value: ""

A text description of the public key algorithm of the key. Possible values are:

  • RSA
  • DSA
  • ECDSA
  • EdDSA
  • RSA-Legacy

publicKeyLength
Int32 (read-only)

Default Value: 0

The length of the public key in bits. Common values are 512, 1024, and 2048.

If the property is ECDSA or EcDSA the length of the public key is determined by the . Possible lenghts are:

CurvePublic Key Length (bits)
secp256r1256
secp384r1384
secp521r1521
Ed25519 256
secp256k1256

revoked
Bool (read-only)

Default Value: False

Whether or not the key is revoked.

secretKey
String (read-only)

Default Value: ""

The secret key of the key (if available). The key is provided as ASCII armored data.

secretKeyAvailable
Bool (read-only)

Default Value: False

Whether or not a secret key is available for the selected key.

usage
String (read-only)

Default Value: ""

A text description of .

The value will be of one or more of the following strings, separated by commas:

  • Certifying Other Certificates
  • Signing Emails and Files
  • Encrypting Emails and Files
  • Split Key
  • Authenticate Against Servers
  • Group Key

usageFlags
Int32 (read-only)

Default Value: 47

Flags that show the intended use for the key. The default value is 0x0F. The value of is a combination of the following flags:

0x01This key may be used to certify other keys.
0x02This key may be used to sign data.
0x0CThis key may be used to encrypt communications and encrypt storage.
0x10The private component of this key may have been split by a secret-sharing mechanism.
0x20This key may be used for authentication.
0x80The private component of this key may be in the possession of more than one person.

Please refer to the property for a text representation of .

userId
String

Default Value: ""

The user Id of the key. When a key is loaded this property is populated with the user Id associated with the key. This property may be set to load a key from the Keyring. When this property is set the class will search the Keyring for a key associated with the UserId specified.

When loading a key with multiple user Ids, this property will be populated with the UserId that was most recently added to the key. To discover all of the UserIds associated with a key query this property and KeyOtherUserIds after loading the key.

The UserId format is:

FirstName LastName (Comment) <Email>
Not all values are required when selecting or generating a key, but at least FirstName or Email are required.

When using this property to select a key you may also specify the key's Id, or any of its subkeys' Ids, instead of a user Id. The class will then search for a key with a matching Id. This is helpful in situations where you do not have the UserId but still need to load the key, such as within the OpenPGP class's RecipientInfo event.

Constructors

public init(keyPath: )

Reads the OpenPGP public key from the specified KeyPath . If multiple keys are present only the first one is used.

public init(keyData: )

Reads the OpenPGP key from the specified KeyData . Both binary-formatted and ASCII-armored data are accepted.

public init(keyPath: , userId: )

Searches the KeyPath for an OpenPGP key with a matching UserId . If UserId is set to "*" the first key will be used.

public init(keyData: , userId: )

Searches the KeyData for an OpenPGP key with a matching UserId . If UserId is set to "*" the first key will be used.

Config Settings (KeyMgr Module)

The class accepts one or more of the following configuration settings. Configuration settings are similar in functionality to properties, but they are rarely used. In order to avoid "polluting" the property namespace of the class, access to these internal properties is provided through the Config method.

KeyMgr Config Settings

AllowEmptyPassword:   Whether a key can be created without a password.

This controls whether a password will be used to encrypt a key. When true, CreateKey will accept an empty string as the password, leaving the key unencrypted. The default is false.

ContinueOnInvalidKey:   Whether to continue loading the keyring when an invalid key is found.

This setting determines whether the class will continue loading keys when an invalid key is found. This is applicable when calling LoadKeyring. If set to False (default) the class . If set to True the class will fire the Error event with information about the key which failed to load, and then continue loading additional keys.

CreateRSASubkeyforEncrypt:   Whether to create a subkey when creating an RSA key.

This setting determines whether the class will additionally create a subkey marked for encryption when calling CreateKey when PublicKeyAlgorithm is set to "RSA". The default is true.

CurrentKeyPrimaryKeyUsageFlags:   The usage flags of the currently selected primary key.

When queried, this will return the usage flags of the currently selected primary key, returned in decimal representation. Individual flags may be checked against the list at KeyUsageFlags.

Curve:   The elliptic curve used when calling CreateKey.

This setting specifies the curve to use when creating ECDSA or EdDSA keys. This setting is only applicable when PublicKeyAlgorithm is set to ECDSA or EdDSA. Possible values are:

ValuePublicKeyAlgorithmDescription
secp256r1 ECDSA NIST curve P-256
secp384r1 ECDSA NIST curve P-384
secp521r1 ECDSA NIST curve P-521
Ed25519 EdDSA Ed25519
secp256k1 EdDSA Secp256k1
The default value is secp256r1 for ECDSA keys and Ed25519 for EdDSA keys.
DSAPublicSubKeyLength:   Specifies the public subkey length when creating a DSA key.

This setting is only applicable when creating DSA keys with CreateKey. This specifies the length of the public ElGamal subkey. The value is 0 means this setting is not used and the subkey will have the length defined in PublicKeyLength. The default value is 0.

EnsureValidDSASignatureHashAlgorithm:   Whether or not to select a suitable signature hash algorithm automatically.

This setting specifies whether the class ensures a valid hash algorithm is selected for use with the loaded DSA or ECDSA key. The default value is True.

DSA Notes

DSA requires that the hash be 160 bits or larger, which means MD5 is not a suitable algorithm. When DSA Signature Hash Algorithm selection is enabled (default) the class will use the preferred algorithm from the key if it meets the requirements for DSA. If the preferred algorithm is MD5 and does not meed the requirements for DSA the class will automatically use a suitable algorithm based on the Q element of the DSA key (may be SHA1, SHA224, or SHA256).

ECDSA Notes

The ECDSA Signature Hash Algorithm requirements are directly related to the KeyCurve used by the key. When this setting is enabled (default) the class will use the preferred algorithm from the key if it meets the requirements for ECDSA. If the preferred algorithm does not meet the requirements the class will automatically select a valid hash algorithm based on the curve as follows:

CurveHash Algorithm
secp256r1 SHA256
secp384r1 SHA384
secp521r1 SHA512
secp256k1 SHA256

ImportAllKeys:   Whether or not to import all keys found in a key file.

When calling ImportKey with a UserId parameter of "*" or "", the class will import all keys found in the file if this property is set to True (default). If this is set to False when the UserId parameter of ImportKey is set to "*" or "", only the first key found in the file will be imported. The default value is True.

KeyEncryptionAlgorithm:   The encryption algorithm used when creating a key.

Specifies the encryption algorithm to use when calling CreateKey. The default value is "CAST5". Possible values are "CAST5", "3DES", "AES256", "AES192", "AES128", "IDEA", and "BLOWFISH".

KeyIdLength:   Specifies the length of the key's Id.

When querying the KeyId property the value will be returned with the length (in octets) specified. The default value is 4. The only other acceptable value is 8.

KeyringFormat:   Which format of keyring to use.

GPG has two formats to store multiple keys. Set this to the correct format. keymgr1.Config("KeyringFormat=2");

Config ValueKeyring Format
1GPG 2.0 and older (Default)
2GPG 2.1 and newer

Versions 2.0 and older use keyrings. Public keys are stored in pubring.gpg. Secret keys are stored in secring.gpg.

Versions 2.1 and newer use a keybox. Public keys are stored in a .kbx file. Private keys are stored in private-keys-v1.d.

KeyUsage:   Flags that show intended use for the key being created.

When calling CreateKey this setting defines the flags that show the intended use for the key. The default value is (0x0F). The value of KeyUsage is a combination of the following flags:

0x01This key may be used to certify other keys.
0x02This key may be used to sign data.
0x0CThis key may be used to encrypt communications and encrypt storage.
0x10The private component of this key may have been split by a secret-sharing mechanism.
0x20This key may be used for authentication.
0x80The private component of this key may be in the possession of more than one person.

KeyValidityTime:   The validity period for the key being created.

When CreateKey creates a new key, the key is valid the moment it is created. KeyValidityTime determines the number of days until expiration. The default value is 365 days. The special value 0 means the key will never expire.

LogLevel:   Specifies the level of detail that is logged.

This setting controls the level of detail that is logged through the Status event. Possible values are:

0 (None)No events are logged.
1 (Info - default)Informational events are logged.
2 (Verbose)Detailed data is logged.
3 (Debug)Debug data is logged.
PublicKeyAlgorithm:   The public key algorithm for the key being created.

Specifies the public key algorithm to use when creating the key via CreateKey. The default value is "RSA". Possible values are:

  • RSA
  • DSA
  • ECDSA
  • EdDSA
  • RSA-Legacy

The "RSA-Legacy" algorithm should not be used under normal circumstances. It should only be used to create PGP 2.6.2 compatible keys, when required. This type of key will not have subkeys.

Note: When creating a DSA key only PublicKeyLength values of 512 and 1024 are supported. Additionally the PublicKeySignatureHashAlgorithm value "MD5" is not supported with DSA keys.

ECDSA and EdDSA Notes

When creating an ECDSA or EdDSA key the PublicKeyLength value is automatically determined based on the Curve. The Curve and SubKeyCurve settings is also applicable.

If Curve and SubKeyCurve are not specified the following defaults will be used:

PublicKeyAlgorithmDefault Curve
ECDSAsecp256r1
EdDSAEd2519

PublicKeyLength:   Specifies the public key length when creating a key.

Specifies the length of the public key when calling CreateKey. The default value is 1024. Common values are 512, 1024, and 2048.

When PublicKeyAlgorithm is set to ECDSA or EdDSA this setting is not applicable and the public key length is automatically determined based on the Curve selected. The public key length values are as follows:

CurvePublic Key Length (bits)
secp256r1256
secp384r1384
secp521r1521
Ed25519 256
secp256k1256

PublicKeyringFile:   The file name of the public keyring file.

This specifies the name of the public keyring file. The default value is "pubring.gpg". This may be set to a file name only, or a full path including the file name.

PublicKeySignatureHashAlgorithm:   The public key signature hash algorithm used when creating a key.

This setting specifies the public key signature algorithm to be used when calling CreateKey. The default value is "SHA256". Possible values are:

  • SHA1
  • MD5
  • SHA256 (default)
  • SHA384
  • SHA512
  • SHA224
RawKeyData:   Returns detailed key and keyring data for debugging purposes.

This setting will return detailed debugging information about the current key and keyring.

RevocationCode:   The reason why the key was revoked.

This setting specifies why the key was revoked. It is only applicable if KeyRevoked is True. This may be set before calling RevokeKey and may be inspected after importing and selecting a revoked key. Possible values are:

0No reason specified
1Key is superseded
2Key material has been compromised
3Key is retired and no longer used
4User Id information is no longer valid
100-110Private Use
The default value is 0.
RevocationReason:   Text describing why the key was revoked.

This setting specifies text description of why the key was revoked. It is only applicable if KeyRevoked is True. This may be set before calling RevokeKey and may be queried after importing and selecting a revoked key. The default value is an empty string.

Revoker:   The revoker's key Id.

This setting returns the key Id of the designated revoker associated with this key. This will only be present if a separate revoker was added to the key (for instance by calling AddRevoker). If more than one revoker was added this setting will return a comma-separated list of key Ids.

SecretKeyringFile:   The file name of the secret keyring file.

This specifies the name of the secret keyring file. The default value is "secring.gpg". This may be set to a file name only, or a full path including the file name.

SubKeyAlgorithm:   The subkey algorithm for the subkey being created.

Specifies the public key algorithm to use when creating the key via CreateSubKey. The default value is empty string and the class will automatically select an appropriate algorithm based on PublicKeyAlgorithm and SubKeyUsage. In most cases "RSA" is used by default. If this setting is empty string and PublicKeyAlgorithm is set to "DSA" and SubKeyUsage is set to "0x0C" (Encryption) then "ElGamal" will be used. This setting may be set to any of the following values which will override the default automatic behavior:

Key AlgorithmSupported Operations
RSA Sign and Encrypt
DSA Sign
ElGamal Encrypt
ECDSA Sign
EdDSA Sign
ECDH Encrypt
SubKeyCurve:   The elliptic curve of the sub key.

When calling CreateKey and PublicKeyAlgorithm is set to ECDSA or EdDSA this setting may optionally be specified to set a curve for the subkey which differs from the key curve specified by Curve. Possible values are:

ValueDescription
secp256r1 NIST curve P-256
secp384r1 NIST curve P-384
secp521r1 NIST curve P-521
Curve25519 Curve25519
Ed25519 Ed25519
The default value for ECDSA keys is the same value as specified in Curve. The default value for EdDSA keys is Curve25519.

Note: It is valid to specify the subkey curve of Curve25519 when Curve is set to secp256r1, secp384r1, or secp521r1. It is also valid to set a subkey curve of secp256r1, secp384r1, or secp521r1 when Curve is set to Ed25519.

SubKeyUsage:   Flags that show intended use for the subkey being created.

When calling CreateSubKey this setting defines the flags that show the intended use for the key. The default value is (0x0C). The value of SubKeyUsage is a combination of the following flags:

0x01This key may be used to certify other keys.
0x02This key may be used to sign data.
0x0CThis key may be used to encrypt communications and encrypt storage.
0x10The private component of this key may have been split by a secret-sharing mechanism.
0x20This key may be used for authentication.
0x80The private component of this key may be in the possession of more than one person.

UseFipsCompliantAlgorithms:   Restricts the usage to FIPS compliant algorithms only.

When enabled the class will only support FIPS compliant algorithms. If a non-FIPS compliant algorithm is used an exception is thrown. The following algorithms are supported when this setting is True:

  • 3DES
  • AES128
  • AES192
  • AES256
  • RSA
  • DSA
  • SHA1
  • SHA256
  • SHA384
  • SHA512
  • SHA224
The default value is False.
VersionHeader:   The Version header value in ASCII armored public keys.

This setting specifies the Version header value included in newly created public keys. This includes keys that are exported via ExportPublicKey where the UseAsciiArmor parameter is true. The default value is "IPWorks! OpenPGP v9.0".

Base Config Settings

BuildInfo:   Information about the product's build.

When queried, this setting will return a string containing information about the product's build.

CodePage:   The system code page used for Unicode to Multibyte translations.

The default code page is Unicode UTF-8 (65001).

The following is a list of valid code page identifiers:

IdentifierName
037IBM EBCDIC - U.S./Canada
437OEM - United States
500IBM EBCDIC - International
708Arabic - ASMO 708
709Arabic - ASMO 449+, BCON V4
710Arabic - Transparent Arabic
720Arabic - Transparent ASMO
737OEM - Greek (formerly 437G)
775OEM - Baltic
850OEM - Multilingual Latin I
852OEM - Latin II
855OEM - Cyrillic (primarily Russian)
857OEM - Turkish
858OEM - Multilingual Latin I + Euro symbol
860OEM - Portuguese
861OEM - Icelandic
862OEM - Hebrew
863OEM - Canadian-French
864OEM - Arabic
865OEM - Nordic
866OEM - Russian
869OEM - Modern Greek
870IBM EBCDIC - Multilingual/ROECE (Latin-2)
874ANSI/OEM - Thai (same as 28605, ISO 8859-15)
875IBM EBCDIC - Modern Greek
932ANSI/OEM - Japanese, Shift-JIS
936ANSI/OEM - Simplified Chinese (PRC, Singapore)
949ANSI/OEM - Korean (Unified Hangul Code)
950ANSI/OEM - Traditional Chinese (Taiwan; Hong Kong SAR, PRC)
1026IBM EBCDIC - Turkish (Latin-5)
1047IBM EBCDIC - Latin 1/Open System
1140IBM EBCDIC - U.S./Canada (037 + Euro symbol)
1141IBM EBCDIC - Germany (20273 + Euro symbol)
1142IBM EBCDIC - Denmark/Norway (20277 + Euro symbol)
1143IBM EBCDIC - Finland/Sweden (20278 + Euro symbol)
1144IBM EBCDIC - Italy (20280 + Euro symbol)
1145IBM EBCDIC - Latin America/Spain (20284 + Euro symbol)
1146IBM EBCDIC - United Kingdom (20285 + Euro symbol)
1147IBM EBCDIC - France (20297 + Euro symbol)
1148IBM EBCDIC - International (500 + Euro symbol)
1149IBM EBCDIC - Icelandic (20871 + Euro symbol)
1200Unicode UCS-2 Little-Endian (BMP of ISO 10646)
1201Unicode UCS-2 Big-Endian
1250ANSI - Central European
1251ANSI - Cyrillic
1252ANSI - Latin I
1253ANSI - Greek
1254ANSI - Turkish
1255ANSI - Hebrew
1256ANSI - Arabic
1257ANSI - Baltic
1258ANSI/OEM - Vietnamese
1361Korean (Johab)
10000MAC - Roman
10001MAC - Japanese
10002MAC - Traditional Chinese (Big5)
10003MAC - Korean
10004MAC - Arabic
10005MAC - Hebrew
10006MAC - Greek I
10007MAC - Cyrillic
10008MAC - Simplified Chinese (GB 2312)
10010MAC - Romania
10017MAC - Ukraine
10021MAC - Thai
10029MAC - Latin II
10079MAC - Icelandic
10081MAC - Turkish
10082MAC - Croatia
12000Unicode UCS-4 Little-Endian
12001Unicode UCS-4 Big-Endian
20000CNS - Taiwan
20001TCA - Taiwan
20002Eten - Taiwan
20003IBM5550 - Taiwan
20004TeleText - Taiwan
20005Wang - Taiwan
20105IA5 IRV International Alphabet No. 5 (7-bit)
20106IA5 German (7-bit)
20107IA5 Swedish (7-bit)
20108IA5 Norwegian (7-bit)
20127US-ASCII (7-bit)
20261T.61
20269ISO 6937 Non-Spacing Accent
20273IBM EBCDIC - Germany
20277IBM EBCDIC - Denmark/Norway
20278IBM EBCDIC - Finland/Sweden
20280IBM EBCDIC - Italy
20284IBM EBCDIC - Latin America/Spain
20285IBM EBCDIC - United Kingdom
20290IBM EBCDIC - Japanese Katakana Extended
20297IBM EBCDIC - France
20420IBM EBCDIC - Arabic
20423IBM EBCDIC - Greek
20424IBM EBCDIC - Hebrew
20833IBM EBCDIC - Korean Extended
20838IBM EBCDIC - Thai
20866Russian - KOI8-R
20871IBM EBCDIC - Icelandic
20880IBM EBCDIC - Cyrillic (Russian)
20905IBM EBCDIC - Turkish
20924IBM EBCDIC - Latin-1/Open System (1047 + Euro symbol)
20932JIS X 0208-1990 & 0121-1990
20936Simplified Chinese (GB2312)
21025IBM EBCDIC - Cyrillic (Serbian, Bulgarian)
21027Extended Alpha Lowercase
21866Ukrainian (KOI8-U)
28591ISO 8859-1 Latin I
28592ISO 8859-2 Central Europe
28593ISO 8859-3 Latin 3
28594ISO 8859-4 Baltic
28595ISO 8859-5 Cyrillic
28596ISO 8859-6 Arabic
28597ISO 8859-7 Greek
28598ISO 8859-8 Hebrew
28599ISO 8859-9 Latin 5
28605ISO 8859-15 Latin 9
29001Europa 3
38598ISO 8859-8 Hebrew
50220ISO 2022 Japanese with no halfwidth Katakana
50221ISO 2022 Japanese with halfwidth Katakana
50222ISO 2022 Japanese JIS X 0201-1989
50225ISO 2022 Korean
50227ISO 2022 Simplified Chinese
50229ISO 2022 Traditional Chinese
50930Japanese (Katakana) Extended
50931US/Canada and Japanese
50933Korean Extended and Korean
50935Simplified Chinese Extended and Simplified Chinese
50936Simplified Chinese
50937US/Canada and Traditional Chinese
50939Japanese (Latin) Extended and Japanese
51932EUC - Japanese
51936EUC - Simplified Chinese
51949EUC - Korean
51950EUC - Traditional Chinese
52936HZ-GB2312 Simplified Chinese
54936Windows XP: GB18030 Simplified Chinese (4 Byte)
57002ISCII Devanagari
57003ISCII Bengali
57004ISCII Tamil
57005ISCII Telugu
57006ISCII Assamese
57007ISCII Oriya
57008ISCII Kannada
57009ISCII Malayalam
57010ISCII Gujarati
57011ISCII Punjabi
65000Unicode UTF-7
65001Unicode UTF-8
The following is a list of valid code page identifiers for Mac OS only:
IdentifierName
1ASCII
2NEXTSTEP
3JapaneseEUC
4UTF8
5ISOLatin1
6Symbol
7NonLossyASCII
8ShiftJIS
9ISOLatin2
10Unicode
11WindowsCP1251
12WindowsCP1252
13WindowsCP1253
14WindowsCP1254
15WindowsCP1250
21ISO2022JP
30MacOSRoman
10UTF16String
0x90000100UTF16BigEndian
0x94000100UTF16LittleEndian
0x8c000100UTF32String
0x98000100UTF32BigEndian
0x9c000100UTF32LittleEndian
65536Proprietary

LicenseInfo:   Information about the current license.

When queried, this setting will return a string containing information about the license this instance of a class is using. It will return the following information:

  • Product: The product the license is for.
  • Product Key: The key the license was generated from.
  • License Source: Where the license was found (e.g., RuntimeLicense, License File).
  • License Type: The type of license installed (e.g., Royalty Free, Single Server).
  • Last Valid Build: The last valid build number for which the license will work.
MaskSensitive:   Whether sensitive data is masked in log messages.

In certain circumstances it may be beneficial to mask sensitive data, like passwords, in log messages. Set this to to mask sensitive data. The default is .

This setting only works on these classes: AS3Receiver, AS3Sender, Atom, Client(3DS), FTP, FTPServer, IMAP, OFTPClient, SSHClient, SCP, Server(3DS), Sexec, SFTP, SFTPServer, SSHServer, TCPClient, TCPServer.

UseInternalSecurityAPI:   Tells the class whether or not to use the system security libraries or an internal implementation.

When set to , the class will use the system security libraries by default to perform cryptographic functions where applicable.

Setting this setting to tells the class to use the internal implementation instead of using the system security libraries.

This setting is set to by default on all platforms.

Trappable Errors (KeyMgr Module)

OpenPGP Errors

101   Cannot decode ASCII Armor data.
102   Unknown ASCII Armor data type.
103   Checksum failed.
104   Unknown ASCII Armor header.
105   Cannot decode PGP packet.
106   Cannot encode PGP packet.
107   Unknown PGP packet tag.
108   Unsupported version.
109   Unsupported algorithm.
110   Unknown subpacket.
111   Internal error.
112   Feature not supported.
113   Secret data was not encrypted.
114   Cannot find the key.
115   Error reading file.
116   Error writing file.
117   Error reading key.
118   Error writing key.
119   Cannot verify signature.
120   Cannot create signature.
121   Invalid UserId.
122   Invalid passphrase.
123   Data encryption failed.
124   Error creating key.
125   Unsupported symmetric algorithm.
126   Unsupported hash.
127   Unsupported compression algorithm.
128   Invalid key usage.
129   Component is busy.
130   Error decrypting data.
131   Data is not compressed.
132   Error decompressing data.
133   Error compressing data.
134   Unsupported signature.
135   Failed to overwrite file.
141   No input.
142   Signing was required, but the message was not signed.
143   Encryption was required, but the message was not encrypted.
146   No data integrity packet was found (MDC), but one was required.
200   Out of memory.