GoogleKMS Class

Properties   Methods   Events   Config Settings   Errors  

The GoogleKMS class provides an easy-to-use interface for the Google Cloud Key Management Service.

Syntax

GoogleKMS

Remarks

The GoogleKMS class makes it easy to work with the Google Cloud Key Management Service (KMS) in a secure manner using TLS. Google KMS allows you to create and manage key rings that contain symmetric and asymmetric keys. Each key has one or more versions which can be used for cryptographic operations.

To begin, register for a Google Cloud account. Set the GoogleProjectId property to your full Google Cloud project Id, and set the Location property to the Google Cloud location you'd like to make requests against (by default, the us multi-regional location is used). Note that each location's resources are completely separate from the others'.

This class requires authentication via OAuth 2.0. First, perform OAuth authentication using the OAuth property to set the appropriate fields for the chosen ClientProfile and GrantType.

The class has the following defaults:

Application Profile

This profile encompasses the most basic grant types that OAuth supports. When this profile is set, all the requests and response handling is done by the class. Depending on the grant type, this may involve launching a browser so a user can login to authenticate with a authorization server. It may also involve starting an embedded web server to receive a response from a redirect.

To start the authentication and authorization process, the Authorize method should be called. If the authorization and authentication was successful, then the AccessToken field will be populated. Additionally, if a refresh token was provided the RefreshToken field will be populated as well. These values of the fields are for informational purposes. The class will also cache these tokens along with when the AccessToken will be expired. When a method that makes requests to the service provider is called or the Authorize method is called the class will automatically check to see if the access token is expired. If it is, it will then automatically try to get a new AccessToken. If the Authorize method was not used and user interaction would be required, the class will throw an error which can be caught. When user interaction is needed depends on what grant type is set in the GrantType field. To force the component to only check the access token when the Authorize method is called, the OAuthAutomaticRefresh configuration setting can be set to false.

A brief description of the supported values for the GrantType field are below. For more information, see the service documentation.

Authorization Code

When using the Authorization Code grant type, the class will use an authorization code to get an access token. For this GrantType the class expects a ClientId, ClientSecret, ServerAuthURL, and ServerTokenURL to be set. When the Authorize method is called, the component will start the embedded web server and launch the browser so the user can authorize the application. Once the user authorizes, the service provider will redirect them to the embedded web server and the class will parse the authorization code, setting the AuthorizationCode field, from the redirect. Immediately, the class will make a request to the token server to exchange the authorization code for an access token. The token server will return an access token and possibly a refresh token. If the RefreshToken field is set, or a refresh token is cached, then the class will not launch the browser and use the refresh token in its request to the token server instead of an authorization code.

Example: GoogleKMS googlekms = new GoogleKMS(); googlekms.OAuth.ClientProfile = CloudOAuthClientProfiles.cocpApplication; googlekms.OAuth.GrantType = OAuthSettingsGrantTypes.cogtAuthorizationCode; googlekms.OAuth.ClientId = CLIENT_ID; googlekms.OAuth.ClientSecret = CLIENT_SECRET; googlekms.Authorize();

Implicit

Note: This grant type is considered insecure and should only be used when necessary.

When using the Implicit grant type, the class will request the authorization server to get an access token. For this GrantType the class expects a ClientId, ClientSecret, and ServerAuthURL to be set. When the Authorize method is called, the component will start the embedded web server and launch the browser so the user can authorize the application. Once the user authorizes, the service provider will redirect them to the embedded web server and the class will parse the access token from the redirect.

A disadvantage of the grant type is that can not use a refresh token to silently get a new access token. Most service providers offer a way to silently get a new access token. See the service documentation for specifics. This means the class will not be able to automatically get a fresh token once it expires.

Web Profile

External OAuth Support

Bearer ACCESS_TOKEN_VALUE

Assign this value to the Authorization property before attempting any operations. Setting the Authorization property will cause the class to ignore the values set in the OAuth property.

For Example: Oauth oauth = new Oauth(); oauth.ClientId = "CLIENT_ID"; oauth.ClientSecret = "CLIENT_SECRET"; oauth.AuthorizationScope = "https://www.googleapis.com/auth/cloud-platform"; oauth.ServerAuthURL = "https://accounts.google.com/o/oauth2/auth"; oauth.ServerTokenURL = "https://accounts.google.com/o/oauth2/token"; oauth.GrantType = OauthGrantTypes.ogtAuthorizationCode; googlekms.Authorization = oauth.GetAuthorization(); Consult the documentation for the service for more information about supported scope values and more details on OAuth authentication.

Using the Class

First, select which key ring the class should interact with using the KeyRing property. If the selected key ring does not yet exist, use the CreateKeyRing method to create it. Note that key rings cannot be deleted later, and therefore key ring names can never be reused within a given Location (unless you create a new Google Cloud project).

Once a key ring has been selected (and created, if necessary), keys can be created in it using the CreateKey method. A key consists of one or more key versions (which themselves can be thought of as distinct resources), each of which has its own cryptographic material. Symmetric keys have a primary version which is used when encrypting data. Asymmetric keys do not have a primary version; a specific version must always be targeted.

When a key is created, a single key version is automatically created for it as well (and for symmetric keys, this becomes the primary version). Additional key versions can be created using the CreateVersion method. Each key version receives a sequentially-assigned version Id, and the first version's Id is always 1. As will become apparent, most operations are performed with key versions, not keys. googlekms.KeyRing = "MyKeyRing"; googlekms.CreateKeyRing(); // When a key is created, you specify its name, purpose, algorithm, and protection level. // Refer to the CreateKey method's documentation for more information. googlekms.CreateKey("MyKey", 1, "GOOGLE_SYMMETRIC_ENCRYPTION", false); // When a new version is created, the algorithm and protection level are reused. googlekms.CreateVersion("MyKey");

Like key rings, keys and key versions cannot be deleted. However, a key version can be disabled, or its cryptographic material can be destroyed, making it permanently unusable. To enable or disable a key version, use the SetVersionEnabled method; to destroy a key version's cryptographic material, use the DestroyVersion method. Note that the latter doesn't destroy the cryptographic material immediately; instead, it schedules it for destruction 24 hours from the time of the call. The CancelDestruction method can be called within this waiting period to cancel the destruction. // Disable a key version to make it unusable until it is re-enabled. googlekms.SetVersionEnabled("MyKey", "7", false); // Destroy a key version's cryptographic material to make it permanently unusable. googlekms.DestroyVersion("MyKey", "7"); // The destruction takes place after a 24 hour waiting period; it can be canceled during that period. // If destruction is canceled, the key version is always placed into a disabled state. googlekms.CancelDestruction("MyKey", "7");

To list key rings, keys, or key versions, use the ListKeyRings, ListKeys, or ListVersions method. If there are multiple pages of results when listing a resource, the appropriate marker property will be populated, and all pages of results can be accumulated by continuing to call the relevant listing method until the marker property is empty. do { googlekms.ListKeyRings(); } while (!string.IsNullOrEmpty(googlekms.KeyRingMarker)); foreach (GoogleKeyRing keyring in googlekms.KeyRings) { Console.WriteLine(keyring.Name); } googlekms.KeyRing = "MyKeyRing"; do { googlekms.ListKeys(); } while (!string.IsNullOrEmpty(googlekms.KeyMarker)); foreach (GoogleKey key in googlekms.Keys) { Console.WriteLine(key.Name); } do { googlekms.ListKeyVersions("MyKey"); } while (!string.IsNullOrEmpty(googlekms.VersionMarker)); foreach (GoogleKeyVersion version in googlekms.Versions) { Console.WriteLine(version.Name + " " + version.VersionId); }

Depending on a key's purpose, it can be used to perform different cryptographic operations. Keys whose purpose is encryption/decryption can be used in Encrypt and Decrypt operations. Keys whose purpose is sign/verify can be used in Sign and Verify operations. To perform a cryptographic operation, use InputData, InputFile, or SetInputStream to supply the input data that should be processed. All operations will output the result data to OutputData, OutputFile, or SetOutputStream (except Verify; refer to its documentation for more information).

Note that Google does not support server-side asymmetric encryption or asymmetric verification. The class performs these operations locally as a convenience to account for this. // Create an asymmetric key whose purpose is encryption/decryption. googlekms.CreateKey("MyAsymmEncKey", 3, "RSA_DECRYPT_OAEP_3072_SHA256", false); // Encrypt the string "Test123" and write the encrypted data to an output file. googlekms.InputData = "Test123"; googlekms.OutputFile = "C:/temp/enc.dat"; googlekms.Encrypt("MyAsymmEncKey", "1"); // ...Later, decrypt the data again. googlekms.InputFile = "C:/temp/enc.dat"; googlekms.OutputFile = ""; // So that the data will be output to the OutputData property. googlekms.Decrypt("MyAsymmEncKey", "1");

The class also supports a variety of other functionality, including:

• Retrieval of a single resource's information with GetKeyRingInfo, GetKeyInfo, or GetVersionInfo.
• Getting an asymmetric key's public key using GetPublicKey.
• Label support using AddLabel and the Labels properties.
• Updating key information with UpdateKey and SetPrimaryVersion.
• And more!

Property List

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

Method List

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

Event List

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

Config Settings

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

AdditionalData Property (GoogleKMS Class)

Additional data to send when performing symmetric encryption or decryption.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetAdditionalData(char* &lpAdditionalData, int &lenAdditionalData);
int SetAdditionalData(const char* lpAdditionalData, int lenAdditionalData);

Unicode (Windows)
INT GetAdditionalData(LPSTR &lpAdditionalData, INT &lenAdditionalData);
INT SetAdditionalData(LPCSTR lpAdditionalData, INT lenAdditionalData);

int cloudkeys_googlekms_getadditionaldata(void* lpObj, char** lpAdditionalData, int* lenAdditionalData);
int cloudkeys_googlekms_setadditionaldata(void* lpObj, const char* lpAdditionalData, int lenAdditionalData);

QByteArray GetAdditionalData();
int SetAdditionalData(QByteArray qbaAdditionalData);

Default Value

""

Remarks

This property can be set before calling Encrypt or Decrypt with a symmetric key to have the server include the specified data, known as additional authenticated data, when performing the cryptographic operation. If such data is provided during encryption, it must also be provided in order to successfully decrypt the data. Refer to the Google Cloud KMS documentation for more information.

Up to 65536 bytes of data may be provided. Note that this property is ignored when asymmetric encryption or decryption is performed.

This property is not available at design time.

Data Type

Binary String

Authorization Property (GoogleKMS Class)

OAuth 2.0 Authorization Token.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetAuthorization();
int SetAuthorization(const char* lpszAuthorization);

Unicode (Windows)
LPWSTR GetAuthorization();
INT SetAuthorization(LPCWSTR lpszAuthorization);

char* cloudkeys_googlekms_getauthorization(void* lpObj);
int cloudkeys_googlekms_setauthorization(void* lpObj, const char* lpszAuthorization);

QString GetAuthorization();
int SetAuthorization(QString qsAuthorization);

Default Value

""

Remarks

This class supports authentication via OAuth 2.0. First, perform OAuth authentication using the OAuth class or a separate process. Once complete you should have an authorization string which looks like:

Bearer ACCESS_TOKEN

Data Type

String

Firewall Property (GoogleKMS Class)

A set of properties related to firewall access.

Syntax

• C++
• C
• Qt

CloudKeysFirewall* GetFirewall();
int SetFirewall(CloudKeysFirewall* val);

int cloudkeys_googlekms_getfirewallautodetect(void* lpObj);
int cloudkeys_googlekms_setfirewallautodetect(void* lpObj, int bFirewallAutoDetect);

int cloudkeys_googlekms_getfirewalltype(void* lpObj);
int cloudkeys_googlekms_setfirewalltype(void* lpObj, int iFirewallType);

char* cloudkeys_googlekms_getfirewallhost(void* lpObj);
int cloudkeys_googlekms_setfirewallhost(void* lpObj, const char* lpszFirewallHost);

char* cloudkeys_googlekms_getfirewallpassword(void* lpObj);
int cloudkeys_googlekms_setfirewallpassword(void* lpObj, const char* lpszFirewallPassword);

int cloudkeys_googlekms_getfirewallport(void* lpObj);
int cloudkeys_googlekms_setfirewallport(void* lpObj, int iFirewallPort);

char* cloudkeys_googlekms_getfirewalluser(void* lpObj);
int cloudkeys_googlekms_setfirewalluser(void* lpObj, const char* lpszFirewallUser);

bool GetFirewallAutoDetect();
int SetFirewallAutoDetect(bool bFirewallAutoDetect);

int GetFirewallType();
int SetFirewallType(int iFirewallType);

QString GetFirewallHost();
int SetFirewallHost(QString qsFirewallHost);

QString GetFirewallPassword();
int SetFirewallPassword(QString qsFirewallPassword);

int GetFirewallPort();
int SetFirewallPort(int iFirewallPort);

QString GetFirewallUser();
int SetFirewallUser(QString qsFirewallUser);

Remarks

This is a Firewall-type property, which contains fields describing the firewall through which the class will attempt to connect.

Data Type

CloudKeysFirewall

GoogleProjectId Property (GoogleKMS Class)

The Id of the Google Cloud project to make requests against.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetGoogleProjectId();
int SetGoogleProjectId(const char* lpszGoogleProjectId);

Unicode (Windows)
LPWSTR GetGoogleProjectId();
INT SetGoogleProjectId(LPCWSTR lpszGoogleProjectId);

char* cloudkeys_googlekms_getgoogleprojectid(void* lpObj);
int cloudkeys_googlekms_setgoogleprojectid(void* lpObj, const char* lpszGoogleProjectId);

QString GetGoogleProjectId();
int SetGoogleProjectId(QString qsGoogleProjectId);

Default Value

""

Remarks

This property specifies the Id of the Google Cloud project that the class should make requests against; it must be set before attempting any operations.

Note that the full Google Cloud project Id must be specified, not just the project number.

This property is not available at design time.

Data Type

String

Idle Property (GoogleKMS Class)

The current status of the class.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetIdle();

Unicode (Windows)
BOOL GetIdle();

int cloudkeys_googlekms_getidle(void* lpObj);

bool GetIdle();

Default Value

TRUE

Remarks

This property will be False if the component is currently busy (communicating or waiting for an answer), and True at all other times.

This property is read-only.

Data Type

Boolean

InputData Property (GoogleKMS Class)

The data to process.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetInputData(char* &lpInputData, int &lenInputData);
int SetInputData(const char* lpInputData, int lenInputData);

Unicode (Windows)
INT GetInputData(LPSTR &lpInputData, INT &lenInputData);
INT SetInputData(LPCSTR lpInputData, INT lenInputData);

int cloudkeys_googlekms_getinputdata(void* lpObj, char** lpInputData, int* lenInputData);
int cloudkeys_googlekms_setinputdata(void* lpObj, const char* lpInputData, int lenInputData);

QByteArray GetInputData();
int SetInputData(QByteArray qbaInputData);

Default Value

""

Remarks

This property specifies the data that should be processed in a cryptographic operation.

Input Sources & Output Destinations

The class automatically determines the source and destination of the input and output based on which properties are set.

The order in which the input properties are checked is as follows:

1. An input stream supplied via the SetInputStream method
2. The InputFile property
3. The InputData property

The first valid input source found is used. The order in which the output properties are considered is as follows:

1. An output stream supplied via the SetOutputStream method
2. The OutputFile property
3. The OutputData property

This property is not available at design time.

Data Type

Binary String

InputFile Property (GoogleKMS Class)

The file whose data should be processed.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetInputFile();
wchar_t* GetInputFile_W(); // Windows only
int SetInputFile(const char* lpszInputFile);
int SetInputFile(const wchar_t* lpszInputFile); // Windows only

Unicode (Windows)
LPWSTR GetInputFile();
INT SetInputFile(LPCWSTR lpszInputFile);

char* cloudkeys_googlekms_getinputfile(void* lpObj);
wchar_t* cloudkeys_googlekms_getinputfile_W(void* lpObj); // Windows only
int cloudkeys_googlekms_setinputfile(void* lpObj, const char* lpszInputFile);
int cloudkeys_googlekms_setinputfile(void* lpObj, const wchar_t* lpszInputFile); // Windows only

QString GetInputFile();
int SetInputFile(QString qsInputFile);

Default Value

""

Remarks

This property specifies the file whose data should be processed in a cryptographic operation. It accepts both absolute and relative file paths.

Setting this property to a non-empty value will discard any stream set using the SetInputStream method. Similarly, passing a non-null value to the aforementioned method will clear this property.

Input Sources & Output Destinations

The class automatically determines the source and destination of the input and output based on which properties are set.

The order in which the input properties are checked is as follows:

1. An input stream supplied via the SetInputStream method
2. The InputFile property
3. The InputData property

The first valid input source found is used. The order in which the output properties are considered is as follows:

1. An output stream supplied via the SetOutputStream method
2. The OutputFile property
3. The OutputData property

Data Type

String

KeyMarker Property (GoogleKMS Class)

A marker indicating what page of keys to return next.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetKeyMarker();
int SetKeyMarker(const char* lpszKeyMarker);

Unicode (Windows)
LPWSTR GetKeyMarker();
INT SetKeyMarker(LPCWSTR lpszKeyMarker);

char* cloudkeys_googlekms_getkeymarker(void* lpObj);
int cloudkeys_googlekms_setkeymarker(void* lpObj, const char* lpszKeyMarker);

QString GetKeyMarker();
int SetKeyMarker(QString qsKeyMarker);

Default Value

""

Remarks

This property will be populated when ListKeys is called if the results are paged and there are more pages. To list all keys, continue to call ListKeys until this property returns empty string.

Refer to ListKeys for more information.

This property is not available at design time.

Data Type

String

KeyRing Property (GoogleKMS Class)

Selects a key ring for the class to interact with.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetKeyRing();
int SetKeyRing(const char* lpszKeyRing);

Unicode (Windows)
LPWSTR GetKeyRing();
INT SetKeyRing(LPCWSTR lpszKeyRing);

char* cloudkeys_googlekms_getkeyring(void* lpObj);
int cloudkeys_googlekms_setkeyring(void* lpObj, const char* lpszKeyRing);

QString GetKeyRing();
int SetKeyRing(QString qsKeyRing);

Default Value

""

Remarks

This property specifies the key ring, by name, that the class should interact with.

This property is not available at design time.

Data Type

String

KeyRingMarker Property (GoogleKMS Class)

A marker indicating what page of key rings to return next.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetKeyRingMarker();
int SetKeyRingMarker(const char* lpszKeyRingMarker);

Unicode (Windows)
LPWSTR GetKeyRingMarker();
INT SetKeyRingMarker(LPCWSTR lpszKeyRingMarker);

char* cloudkeys_googlekms_getkeyringmarker(void* lpObj);
int cloudkeys_googlekms_setkeyringmarker(void* lpObj, const char* lpszKeyRingMarker);

QString GetKeyRingMarker();
int SetKeyRingMarker(QString qsKeyRingMarker);

Default Value

""

Remarks

This property will be populated when ListKeyRings is called if the results are paged and there are more pages. To list all key rings, continue to call ListKeyRings until this property returns empty string.

Refer to ListKeyRings for more information.

This property is not available at design time.

Data Type

String

KeyRings Property (GoogleKMS Class)

A collection of key rings.

Syntax

• C++
• C
• Qt

CloudKeysList<CloudKeysGoogleKeyRing>* GetKeyRings();

int cloudkeys_googlekms_getkeyringcount(void* lpObj);

char* cloudkeys_googlekms_getkeyringcreationdate(void* lpObj, int keyringindex);

char* cloudkeys_googlekms_getkeyringname(void* lpObj, int keyringindex);

int GetKeyRingCount();

QString GetKeyRingCreationDate(int iKeyRingIndex);

QString GetKeyRingName(int iKeyRingIndex);

Remarks

This collection holds a list of GoogleKeyRing items.

Calling ListKeyRings or GetKeyRingInfo will populate this collection.

This property is read-only and not available at design time.

Data Type

CloudKeysGoogleKeyRing

Keys Property (GoogleKMS Class)

A collection of keys.

Syntax

• C++
• C
• Qt

CloudKeysList<CloudKeysGoogleKey>* GetKeys();

int cloudkeys_googlekms_getkeycount(void* lpObj);

char* cloudkeys_googlekms_getkeycreationdate(void* lpObj, int keyindex);

char* cloudkeys_googlekms_getkeyname(void* lpObj, int keyindex);

char* cloudkeys_googlekms_getkeynextrotatedate(void* lpObj, int keyindex);

char* cloudkeys_googlekms_getkeyprimaryversion(void* lpObj, int keyindex);

int cloudkeys_googlekms_getkeypurpose(void* lpObj, int keyindex);

char* cloudkeys_googlekms_getkeyrotationperiod(void* lpObj, int keyindex);

char* cloudkeys_googlekms_getkeytemplatealgorithm(void* lpObj, int keyindex);

char* cloudkeys_googlekms_getkeytemplateprotectionlevel(void* lpObj, int keyindex);

int GetKeyCount();

QString GetKeyCreationDate(int iKeyIndex);

QString GetKeyName(int iKeyIndex);

QString GetKeyNextRotateDate(int iKeyIndex);

QString GetKeyPrimaryVersion(int iKeyIndex);

int GetKeyPurpose(int iKeyIndex);

QString GetKeyRotationPeriod(int iKeyIndex);

QString GetKeyTemplateAlgorithm(int iKeyIndex);

QString GetKeyTemplateProtectionLevel(int iKeyIndex);

Remarks

This collection holds a list of GoogleKey items.

Calling ListKeys or GetKeyInfo will populate this collection.

This property is read-only and not available at design time.

Data Type

CloudKeysGoogleKey

Labels Property (GoogleKMS Class)

A collection of labels.

Syntax

• C++
• C
• Qt

CloudKeysList<CloudKeysGoogleLabel>* GetLabels();
int SetLabels(CloudKeysList<CloudKeysGoogleLabel>* val);

int cloudkeys_googlekms_getlabelcount(void* lpObj);
int cloudkeys_googlekms_setlabelcount(void* lpObj, int iLabelCount);

char* cloudkeys_googlekms_getlabelname(void* lpObj, int labelindex);
int cloudkeys_googlekms_setlabelname(void* lpObj, int labelindex, const char* lpszLabelName);

char* cloudkeys_googlekms_getlabelvalue(void* lpObj, int labelindex);
int cloudkeys_googlekms_setlabelvalue(void* lpObj, int labelindex, const char* lpszLabelValue);

int GetLabelCount();
int SetLabelCount(int iLabelCount);

QString GetLabelName(int iLabelIndex);
int SetLabelName(int iLabelIndex, QString qsLabelName);

QString GetLabelValue(int iLabelIndex);
int SetLabelValue(int iLabelIndex, QString qsLabelValue);

Remarks

This collection holds a list of GoogleLabel items.

Calling AddLabel or GetKeyInfo will populate this collection. The items in this collection are used by the CreateKey and UpdateKey methods.

This property is not available at design time.

Data Type

CloudKeysGoogleLabel

LocalHost Property (GoogleKMS Class)

The name of the local host or user-assigned IP interface through which connections are initiated or accepted.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetLocalHost();
int SetLocalHost(const char* lpszLocalHost);

Unicode (Windows)
LPWSTR GetLocalHost();
INT SetLocalHost(LPCWSTR lpszLocalHost);

char* cloudkeys_googlekms_getlocalhost(void* lpObj);
int cloudkeys_googlekms_setlocalhost(void* lpObj, const char* lpszLocalHost);

QString GetLocalHost();
int SetLocalHost(QString qsLocalHost);

Default Value

""

Remarks

This property contains the name of the local host as obtained by the gethostname() system call, or if the user has assigned an IP address, the value of that address.

In multihomed hosts (machines with more than one IP interface) setting LocalHost to the IP address of an interface will make the class initiate connections (or accept in the case of server classs) only through that interface. It is recommended to provide an IP address rather than a hostname when setting this property to ensure the desired interface is used.

If the class is connected, the LocalHost property shows the IP address of the interface through which the connection is made in internet dotted format (aaa.bbb.ccc.ddd). In most cases, this is the address of the local host, except for multihomed hosts (machines with more than one IP interface).

Note: LocalHost is not persistent. You must always set it in code, and never in the property window.

Data Type

String

Location Property (GoogleKMS Class)

The Google Cloud location to make requests against.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetLocation();
int SetLocation(const char* lpszLocation);

Unicode (Windows)
LPWSTR GetLocation();
INT SetLocation(LPCWSTR lpszLocation);

char* cloudkeys_googlekms_getlocation(void* lpObj);
int cloudkeys_googlekms_setlocation(void* lpObj, const char* lpszLocation);

QString GetLocation();
int SetLocation(QString qsLocation);

Default Value

"us"

Remarks

This property specifies the Google Cloud location that the class should make requests against.

Regional Locations:

A regional location's data centers exist in a specific geographical place.

Dual-Regional Locations:

A dual-regional location's data centers exist in two specific geographical places (plus a third region included for data replication and durability).

Multi-Regional Locations:

A multi-regional location's data centers are spread across a geographical area; it is not possible to predict or control exactly which data centers are selected or where they are located.

The class will always convert this property's value to lowercase. If this property is cleared, the class will reset it to the default value.

This property is not available at design time.

Data Type

String

OAuth Property (GoogleKMS Class)

This property holds the OAuth Settings.

Syntax

• C++
• C
• Qt

CloudKeysOAuthSettings* GetOAuth();

char* cloudkeys_googlekms_getoauthaccesstoken(void* lpObj);
int cloudkeys_googlekms_setoauthaccesstoken(void* lpObj, const char* lpszOAuthAccessToken);

char* cloudkeys_googlekms_getoauthauthorizationcode(void* lpObj);
int cloudkeys_googlekms_setoauthauthorizationcode(void* lpObj, const char* lpszOAuthAuthorizationCode);

char* cloudkeys_googlekms_getoauthauthorizationscope(void* lpObj);
int cloudkeys_googlekms_setoauthauthorizationscope(void* lpObj, const char* lpszOAuthAuthorizationScope);

char* cloudkeys_googlekms_getoauthclientid(void* lpObj);
int cloudkeys_googlekms_setoauthclientid(void* lpObj, const char* lpszOAuthClientId);

int cloudkeys_googlekms_getoauthclientprofile(void* lpObj);
int cloudkeys_googlekms_setoauthclientprofile(void* lpObj, int iOAuthClientProfile);

char* cloudkeys_googlekms_getoauthclientsecret(void* lpObj);
int cloudkeys_googlekms_setoauthclientsecret(void* lpObj, const char* lpszOAuthClientSecret);

int cloudkeys_googlekms_getoauthgranttype(void* lpObj);
int cloudkeys_googlekms_setoauthgranttype(void* lpObj, int iOAuthGrantType);

char* cloudkeys_googlekms_getoauthrefreshtoken(void* lpObj);
int cloudkeys_googlekms_setoauthrefreshtoken(void* lpObj, const char* lpszOAuthRefreshToken);

int cloudkeys_googlekms_getoauthrequestrefreshtoken(void* lpObj);
int cloudkeys_googlekms_setoauthrequestrefreshtoken(void* lpObj, int bOAuthRequestRefreshToken);

char* cloudkeys_googlekms_getoauthreturnurl(void* lpObj);
int cloudkeys_googlekms_setoauthreturnurl(void* lpObj, const char* lpszOAuthReturnURL);

char* cloudkeys_googlekms_getoauthserverauthurl(void* lpObj);
int cloudkeys_googlekms_setoauthserverauthurl(void* lpObj, const char* lpszOAuthServerAuthURL);

char* cloudkeys_googlekms_getoauthservertokenurl(void* lpObj);
int cloudkeys_googlekms_setoauthservertokenurl(void* lpObj, const char* lpszOAuthServerTokenURL);

char* cloudkeys_googlekms_getoauthwebauthurl(void* lpObj);

QString GetOAuthAccessToken();
int SetOAuthAccessToken(QString qsOAuthAccessToken);

QString GetOAuthAuthorizationCode();
int SetOAuthAuthorizationCode(QString qsOAuthAuthorizationCode);

QString GetOAuthAuthorizationScope();
int SetOAuthAuthorizationScope(QString qsOAuthAuthorizationScope);

QString GetOAuthClientId();
int SetOAuthClientId(QString qsOAuthClientId);

int GetOAuthClientProfile();
int SetOAuthClientProfile(int iOAuthClientProfile);

QString GetOAuthClientSecret();
int SetOAuthClientSecret(QString qsOAuthClientSecret);

int GetOAuthGrantType();
int SetOAuthGrantType(int iOAuthGrantType);

QString GetOAuthRefreshToken();
int SetOAuthRefreshToken(QString qsOAuthRefreshToken);

bool GetOAuthRequestRefreshToken();
int SetOAuthRequestRefreshToken(bool bOAuthRequestRefreshToken);

QString GetOAuthReturnURL();
int SetOAuthReturnURL(QString qsOAuthReturnURL);

QString GetOAuthServerAuthURL();
int SetOAuthServerAuthURL(QString qsOAuthServerAuthURL);

QString GetOAuthServerTokenURL();
int SetOAuthServerTokenURL(QString qsOAuthServerTokenURL);

QString GetOAuthWebAuthURL();

Remarks

This property is used to define the necessary fields to authenticate with the service provider. See the introduction for more information.

This property is read-only and not available at design time.

Data Type

CloudKeysOAuthSettings

OtherHeaders Property (GoogleKMS Class)

Other headers as determined by the user (optional).

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetOtherHeaders();
int SetOtherHeaders(const char* lpszOtherHeaders);

Unicode (Windows)
LPWSTR GetOtherHeaders();
INT SetOtherHeaders(LPCWSTR lpszOtherHeaders);

char* cloudkeys_googlekms_getotherheaders(void* lpObj);
int cloudkeys_googlekms_setotherheaders(void* lpObj, const char* lpszOtherHeaders);

QString GetOtherHeaders();
int SetOtherHeaders(QString qsOtherHeaders);

Default Value

""

Remarks

This property can be set to a string of headers to be appended to the HTTP request headers created from other properties like ContentType and From.

The headers must follow the format Header: Value as described in the HTTP specifications. Header lines should be separated by CRLF ("\r\n") .

Use this property with caution. If this property contains invalid headers, HTTP requests may fail.

This property is useful for extending the functionality of the class beyond what is provided.

This property is not available at design time.

Data Type

String

OutputData Property (GoogleKMS Class)

The output data.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetOutputData(char* &lpOutputData, int &lenOutputData);
int SetOutputData(const char* lpOutputData, int lenOutputData);

Unicode (Windows)
INT GetOutputData(LPSTR &lpOutputData, INT &lenOutputData);
INT SetOutputData(LPCSTR lpOutputData, INT lenOutputData);

int cloudkeys_googlekms_getoutputdata(void* lpObj, char** lpOutputData, int* lenOutputData);
int cloudkeys_googlekms_setoutputdata(void* lpObj, const char* lpOutputData, int lenOutputData);

QByteArray GetOutputData();
int SetOutputData(QByteArray qbaOutputData);

Default Value

""

Remarks

This property is populated with the data that was output from a successful cryptographic operation.

Note: For the Verify operation, this property functions as a secondary input property instead (along with InputData); refer to the Verify method for more information.

Input Sources & Output Destinations

The class automatically determines the source and destination of the input and output based on which properties are set.

The order in which the input properties are checked is as follows:

1. An input stream supplied via the SetInputStream method
2. The InputFile property
3. The InputData property

The first valid input source found is used. The order in which the output properties are considered is as follows:

1. An output stream supplied via the SetOutputStream method
2. The OutputFile property
3. The OutputData property

This property is not available at design time.

Data Type

Binary String

OutputFile Property (GoogleKMS Class)

The file to which output data should be written.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetOutputFile();
wchar_t* GetOutputFile_W(); // Windows only
int SetOutputFile(const char* lpszOutputFile);
int SetOutputFile(const wchar_t* lpszOutputFile); // Windows only

Unicode (Windows)
LPWSTR GetOutputFile();
INT SetOutputFile(LPCWSTR lpszOutputFile);

char* cloudkeys_googlekms_getoutputfile(void* lpObj);
wchar_t* cloudkeys_googlekms_getoutputfile_W(void* lpObj); // Windows only
int cloudkeys_googlekms_setoutputfile(void* lpObj, const char* lpszOutputFile);
int cloudkeys_googlekms_setoutputfile(void* lpObj, const wchar_t* lpszOutputFile); // Windows only

QString GetOutputFile();
int SetOutputFile(QString qsOutputFile);

Default Value

""

Remarks

This property specifies the file to which data output from a successful cryptographic operation should be written.

Setting this property to a non-empty value will discard any stream set using the SetOutputStream method. Similarly, passing a non-null value to the aforementioned method will clear this property.

Note: For the Verify operation, the specified file functions as a secondary input file instead (along with InputFile); refer to the Verify method for more information.

Input Sources & Output Destinations

The class automatically determines the source and destination of the input and output based on which properties are set.

The order in which the input properties are checked is as follows:

1. An input stream supplied via the SetInputStream method
2. The InputFile property
3. The InputData property

The first valid input source found is used. The order in which the output properties are considered is as follows:

1. An output stream supplied via the SetOutputStream method
2. The OutputFile property
3. The OutputData property

Data Type

String

Overwrite Property (GoogleKMS Class)

Whether the output file should be overwritten if necessary.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetOverwrite();
int SetOverwrite(int bOverwrite);

Unicode (Windows)
BOOL GetOverwrite();
INT SetOverwrite(BOOL bOverwrite);

int cloudkeys_googlekms_getoverwrite(void* lpObj);
int cloudkeys_googlekms_setoverwrite(void* lpObj, int bOverwrite);

bool GetOverwrite();
int SetOverwrite(bool bOverwrite);

Default Value

FALSE

Remarks

This property controls whether the specified OutputFile should be overwritten if it already exists.

Data Type

Boolean

ParsedHeaders Property (GoogleKMS Class)

This property includes a collection of headers returned from the last request.

Syntax

• C++
• C
• Qt

CloudKeysList<CloudKeysHeader>* GetParsedHeaders();

int cloudkeys_googlekms_getparsedheadercount(void* lpObj);

char* cloudkeys_googlekms_getparsedheaderfield(void* lpObj, int parsedheaderindex);

char* cloudkeys_googlekms_getparsedheadervalue(void* lpObj, int parsedheaderindex);

int GetParsedHeaderCount();

QString GetParsedHeaderField(int iParsedHeaderIndex);

QString GetParsedHeaderValue(int iParsedHeaderIndex);

Remarks

This property contains a collection of headers returned from the last request. Whenever headers are returned from the server, the headers are parsed into a collection of headers. Each Header in this collection contains information describing that header.

MaxHeaders can be used to control the maximum number of headers saved.

This property is read-only and not available at design time.

Data Type

CloudKeysHeader

Proxy Property (GoogleKMS Class)

A set of properties related to proxy access.

Syntax

• C++
• C
• Qt

CloudKeysProxy* GetProxy();
int SetProxy(CloudKeysProxy* val);

int cloudkeys_googlekms_getproxyauthscheme(void* lpObj);
int cloudkeys_googlekms_setproxyauthscheme(void* lpObj, int iProxyAuthScheme);

int cloudkeys_googlekms_getproxyautodetect(void* lpObj);
int cloudkeys_googlekms_setproxyautodetect(void* lpObj, int bProxyAutoDetect);

char* cloudkeys_googlekms_getproxypassword(void* lpObj);
int cloudkeys_googlekms_setproxypassword(void* lpObj, const char* lpszProxyPassword);

int cloudkeys_googlekms_getproxyport(void* lpObj);
int cloudkeys_googlekms_setproxyport(void* lpObj, int iProxyPort);

char* cloudkeys_googlekms_getproxyserver(void* lpObj);
int cloudkeys_googlekms_setproxyserver(void* lpObj, const char* lpszProxyServer);

int cloudkeys_googlekms_getproxyssl(void* lpObj);
int cloudkeys_googlekms_setproxyssl(void* lpObj, int iProxySSL);

char* cloudkeys_googlekms_getproxyuser(void* lpObj);
int cloudkeys_googlekms_setproxyuser(void* lpObj, const char* lpszProxyUser);

int GetProxyAuthScheme();
int SetProxyAuthScheme(int iProxyAuthScheme);

bool GetProxyAutoDetect();
int SetProxyAutoDetect(bool bProxyAutoDetect);

QString GetProxyPassword();
int SetProxyPassword(QString qsProxyPassword);

int GetProxyPort();
int SetProxyPort(int iProxyPort);

QString GetProxyServer();
int SetProxyServer(QString qsProxyServer);

int GetProxySSL();
int SetProxySSL(int iProxySSL);

QString GetProxyUser();
int SetProxyUser(QString qsProxyUser);

Remarks

This property contains fields describing the proxy through which the class will attempt to connect.

Data Type

CloudKeysProxy

PublicKey Property (GoogleKMS Class)

The public key of an asymmetric key pair.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetPublicKey();

Unicode (Windows)
LPWSTR GetPublicKey();

char* cloudkeys_googlekms_getpublickey(void* lpObj);

QString GetPublicKey();

Default Value

""

Remarks

This property reflects the public key of an asymmetric key pair stored on the server, in PEM format; it is populated anytime the GetPublicKey method is called successfully.

This property is read-only and not available at design time.

Data Type

String

PublicKeyAlgorithm Property (GoogleKMS Class)

The algorithm of an asymmetric key pair.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetPublicKeyAlgorithm();

Unicode (Windows)
LPWSTR GetPublicKeyAlgorithm();

char* cloudkeys_googlekms_getpublickeyalgorithm(void* lpObj);

QString GetPublicKeyAlgorithm();

Default Value

""

Remarks

This property reflects the algorithm of an asymmetric key pair stored on the server; it is populated anytime the GetPublicKey method is called successfully. Possible values are:

• RSA_SIGN_PSS_2048_SHA256: RSASSA-PSS 2048 bit key with a SHA256 digest
• RSA_SIGN_PSS_3072_SHA256: RSASSA-PSS 3072 bit key with a SHA256 digest
• RSA_SIGN_PSS_4096_SHA256: RSASSA-PSS 4096 bit key with a SHA256 digest
• RSA_SIGN_PSS_4096_SHA512: RSASSA-PSS 4096 bit key with a SHA512 digest
• RSA_SIGN_PKCS1_2048_SHA256: RSASSA-PKCS1-v1_5 with a 2048 bit key and a SHA256 digest
• RSA_SIGN_PKCS1_3072_SHA256: RSASSA-PKCS1-v1_5 with a 3072 bit key and a SHA256 digest
• RSA_SIGN_PKCS1_4096_SHA256: RSASSA-PKCS1-v1_5 with a 4096 bit key and a SHA256 digest
• RSA_SIGN_PKCS1_4096_SHA512: RSASSA-PKCS1-v1_5 with a 4096 bit key and a SHA512 digest
• RSA_DECRYPT_OAEP_2048_SHA256: RSAES-OAEP 2048 bit key with a SHA256 digest
• RSA_DECRYPT_OAEP_3072_SHA256: RSAES-OAEP 3072 bit key with a SHA256 digest
• RSA_DECRYPT_OAEP_4096_SHA256: RSAES-OAEP 4096 bit key with a SHA256 digest
• RSA_DECRYPT_OAEP_4096_SHA512: RSAES-OAEP 4096 bit key with a SHA512 digest
• EC_SIGN_P256_SHA256: ECDSA on the NIST P-256 curve with a SHA256 digest
• EC_SIGN_P384_SHA384: ECDSA on the NIST P-384 curve with a SHA384 digest

Refer to Google's CryptoKeyVersionAlgorithm documentation page for more information.

This property is read-only and not available at design time.

Data Type

String

QueryParams Property (GoogleKMS Class)

Additional query parameters to be included in the request.

Syntax

• C++
• C
• Qt

CloudKeysList<CloudKeysQueryParam>* GetQueryParams();
int SetQueryParams(CloudKeysList<CloudKeysQueryParam>* val);

int cloudkeys_googlekms_getqueryparamcount(void* lpObj);
int cloudkeys_googlekms_setqueryparamcount(void* lpObj, int iQueryParamCount);

char* cloudkeys_googlekms_getqueryparamname(void* lpObj, int queryparamindex);
int cloudkeys_googlekms_setqueryparamname(void* lpObj, int queryparamindex, const char* lpszQueryParamName);

char* cloudkeys_googlekms_getqueryparamvalue(void* lpObj, int queryparamindex);
int cloudkeys_googlekms_setqueryparamvalue(void* lpObj, int queryparamindex, const char* lpszQueryParamValue);

int GetQueryParamCount();
int SetQueryParamCount(int iQueryParamCount);

QString GetQueryParamName(int iQueryParamIndex);
int SetQueryParamName(int iQueryParamIndex, QString qsQueryParamName);

QString GetQueryParamValue(int iQueryParamIndex);
int SetQueryParamValue(int iQueryParamIndex, QString qsQueryParamValue);

Remarks

This is a collection of query parameters that will be added to the request. Parameters can be added via the AddQueryParam method.

Data Type

CloudKeysQueryParam

SSLAcceptServerCert Property (GoogleKMS Class)

Instructs the class to unconditionally accept the server certificate that matches the supplied certificate.

Syntax

• C++
• C
• Qt

CloudKeysCertificate* GetSSLAcceptServerCert();
int SetSSLAcceptServerCert(CloudKeysCertificate* val);

char* cloudkeys_googlekms_getsslacceptservercerteffectivedate(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertexpirationdate(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertextendedkeyusage(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertfingerprint(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertfingerprintsha1(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertfingerprintsha256(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertissuer(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertprivatekey(void* lpObj);

int cloudkeys_googlekms_getsslacceptservercertprivatekeyavailable(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertprivatekeycontainer(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertpublickey(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertpublickeyalgorithm(void* lpObj);

int cloudkeys_googlekms_getsslacceptservercertpublickeylength(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertserialnumber(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertsignaturealgorithm(void* lpObj);

int cloudkeys_googlekms_getsslacceptservercertstore(void* lpObj, char** lpSSLAcceptServerCertStore, int* lenSSLAcceptServerCertStore);
int cloudkeys_googlekms_setsslacceptservercertstore(void* lpObj, const char* lpSSLAcceptServerCertStore, int lenSSLAcceptServerCertStore);

char* cloudkeys_googlekms_getsslacceptservercertstorepassword(void* lpObj);
int cloudkeys_googlekms_setsslacceptservercertstorepassword(void* lpObj, const char* lpszSSLAcceptServerCertStorePassword);

int cloudkeys_googlekms_getsslacceptservercertstoretype(void* lpObj);
int cloudkeys_googlekms_setsslacceptservercertstoretype(void* lpObj, int iSSLAcceptServerCertStoreType);

char* cloudkeys_googlekms_getsslacceptservercertsubjectaltnames(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertthumbprintmd5(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertthumbprintsha1(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertthumbprintsha256(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertusage(void* lpObj);

int cloudkeys_googlekms_getsslacceptservercertusageflags(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertversion(void* lpObj);

char* cloudkeys_googlekms_getsslacceptservercertsubject(void* lpObj);
int cloudkeys_googlekms_setsslacceptservercertsubject(void* lpObj, const char* lpszSSLAcceptServerCertSubject);

int cloudkeys_googlekms_getsslacceptservercertencoded(void* lpObj, char** lpSSLAcceptServerCertEncoded, int* lenSSLAcceptServerCertEncoded);
int cloudkeys_googlekms_setsslacceptservercertencoded(void* lpObj, const char* lpSSLAcceptServerCertEncoded, int lenSSLAcceptServerCertEncoded);

QString GetSSLAcceptServerCertEffectiveDate();

QString GetSSLAcceptServerCertExpirationDate();

QString GetSSLAcceptServerCertExtendedKeyUsage();

QString GetSSLAcceptServerCertFingerprint();

QString GetSSLAcceptServerCertFingerprintSHA1();

QString GetSSLAcceptServerCertFingerprintSHA256();

QString GetSSLAcceptServerCertIssuer();

QString GetSSLAcceptServerCertPrivateKey();

bool GetSSLAcceptServerCertPrivateKeyAvailable();

QString GetSSLAcceptServerCertPrivateKeyContainer();

QString GetSSLAcceptServerCertPublicKey();

QString GetSSLAcceptServerCertPublicKeyAlgorithm();

int GetSSLAcceptServerCertPublicKeyLength();

QString GetSSLAcceptServerCertSerialNumber();

QString GetSSLAcceptServerCertSignatureAlgorithm();

QByteArray GetSSLAcceptServerCertStore();
int SetSSLAcceptServerCertStore(QByteArray qbaSSLAcceptServerCertStore);

QString GetSSLAcceptServerCertStorePassword();
int SetSSLAcceptServerCertStorePassword(QString qsSSLAcceptServerCertStorePassword);

int GetSSLAcceptServerCertStoreType();
int SetSSLAcceptServerCertStoreType(int iSSLAcceptServerCertStoreType);

QString GetSSLAcceptServerCertSubjectAltNames();

QString GetSSLAcceptServerCertThumbprintMD5();

QString GetSSLAcceptServerCertThumbprintSHA1();

QString GetSSLAcceptServerCertThumbprintSHA256();

QString GetSSLAcceptServerCertUsage();

int GetSSLAcceptServerCertUsageFlags();

QString GetSSLAcceptServerCertVersion();

QString GetSSLAcceptServerCertSubject();
int SetSSLAcceptServerCertSubject(QString qsSSLAcceptServerCertSubject);

QByteArray GetSSLAcceptServerCertEncoded();
int SetSSLAcceptServerCertEncoded(QByteArray qbaSSLAcceptServerCertEncoded);

Remarks

If it finds any issues with the certificate presented by the server, the class will normally terminate the connection with an error.

You may override this behavior by supplying a value for SSLAcceptServerCert. If the certificate supplied in SSLAcceptServerCert is the same as the certificate presented by the server, then the server certificate is accepted unconditionally, and the connection will continue normally.

Note: This functionality is provided only for cases in which you otherwise know that you are communicating with the right server. If used improperly, this property may create a security breach. Use it at your own risk.

Data Type

CloudKeysCertificate

SSLCert Property (GoogleKMS Class)

The certificate to be used during Secure Sockets Layer (SSL) negotiation.

Syntax

• C++
• C
• Qt

CloudKeysCertificate* GetSSLCert();
int SetSSLCert(CloudKeysCertificate* val);

char* cloudkeys_googlekms_getsslcerteffectivedate(void* lpObj);

char* cloudkeys_googlekms_getsslcertexpirationdate(void* lpObj);

char* cloudkeys_googlekms_getsslcertextendedkeyusage(void* lpObj);

char* cloudkeys_googlekms_getsslcertfingerprint(void* lpObj);

char* cloudkeys_googlekms_getsslcertfingerprintsha1(void* lpObj);

char* cloudkeys_googlekms_getsslcertfingerprintsha256(void* lpObj);

char* cloudkeys_googlekms_getsslcertissuer(void* lpObj);

char* cloudkeys_googlekms_getsslcertprivatekey(void* lpObj);

int cloudkeys_googlekms_getsslcertprivatekeyavailable(void* lpObj);

char* cloudkeys_googlekms_getsslcertprivatekeycontainer(void* lpObj);

char* cloudkeys_googlekms_getsslcertpublickey(void* lpObj);

char* cloudkeys_googlekms_getsslcertpublickeyalgorithm(void* lpObj);

int cloudkeys_googlekms_getsslcertpublickeylength(void* lpObj);

char* cloudkeys_googlekms_getsslcertserialnumber(void* lpObj);

char* cloudkeys_googlekms_getsslcertsignaturealgorithm(void* lpObj);

int cloudkeys_googlekms_getsslcertstore(void* lpObj, char** lpSSLCertStore, int* lenSSLCertStore);
int cloudkeys_googlekms_setsslcertstore(void* lpObj, const char* lpSSLCertStore, int lenSSLCertStore);

char* cloudkeys_googlekms_getsslcertstorepassword(void* lpObj);
int cloudkeys_googlekms_setsslcertstorepassword(void* lpObj, const char* lpszSSLCertStorePassword);

int cloudkeys_googlekms_getsslcertstoretype(void* lpObj);
int cloudkeys_googlekms_setsslcertstoretype(void* lpObj, int iSSLCertStoreType);

char* cloudkeys_googlekms_getsslcertsubjectaltnames(void* lpObj);

char* cloudkeys_googlekms_getsslcertthumbprintmd5(void* lpObj);

char* cloudkeys_googlekms_getsslcertthumbprintsha1(void* lpObj);

char* cloudkeys_googlekms_getsslcertthumbprintsha256(void* lpObj);

char* cloudkeys_googlekms_getsslcertusage(void* lpObj);

int cloudkeys_googlekms_getsslcertusageflags(void* lpObj);

char* cloudkeys_googlekms_getsslcertversion(void* lpObj);

char* cloudkeys_googlekms_getsslcertsubject(void* lpObj);
int cloudkeys_googlekms_setsslcertsubject(void* lpObj, const char* lpszSSLCertSubject);

int cloudkeys_googlekms_getsslcertencoded(void* lpObj, char** lpSSLCertEncoded, int* lenSSLCertEncoded);
int cloudkeys_googlekms_setsslcertencoded(void* lpObj, const char* lpSSLCertEncoded, int lenSSLCertEncoded);

QString GetSSLCertEffectiveDate();

QString GetSSLCertExpirationDate();

QString GetSSLCertExtendedKeyUsage();

QString GetSSLCertFingerprint();

QString GetSSLCertFingerprintSHA1();

QString GetSSLCertFingerprintSHA256();

QString GetSSLCertIssuer();

QString GetSSLCertPrivateKey();

bool GetSSLCertPrivateKeyAvailable();

QString GetSSLCertPrivateKeyContainer();

QString GetSSLCertPublicKey();

QString GetSSLCertPublicKeyAlgorithm();

int GetSSLCertPublicKeyLength();

QString GetSSLCertSerialNumber();

QString GetSSLCertSignatureAlgorithm();

QByteArray GetSSLCertStore();
int SetSSLCertStore(QByteArray qbaSSLCertStore);

QString GetSSLCertStorePassword();
int SetSSLCertStorePassword(QString qsSSLCertStorePassword);

int GetSSLCertStoreType();
int SetSSLCertStoreType(int iSSLCertStoreType);

QString GetSSLCertSubjectAltNames();

QString GetSSLCertThumbprintMD5();

QString GetSSLCertThumbprintSHA1();

QString GetSSLCertThumbprintSHA256();

QString GetSSLCertUsage();

int GetSSLCertUsageFlags();

QString GetSSLCertVersion();

QString GetSSLCertSubject();
int SetSSLCertSubject(QString qsSSLCertSubject);

QByteArray GetSSLCertEncoded();
int SetSSLCertEncoded(QByteArray qbaSSLCertEncoded);

Remarks

This property includes the digital certificate that the class will use during SSL negotiation. Set this property to a valid certificate before starting SSL negotiation. To set a certificate, you may set the Encoded field to the encoded certificate. To select a certificate, use the store and subject fields.

Data Type

CloudKeysCertificate

SSLProvider Property (GoogleKMS Class)

The Secure Sockets Layer/Transport Layer Security (SSL/TLS) implementation to use.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetSSLProvider();
int SetSSLProvider(int iSSLProvider);

Unicode (Windows)
INT GetSSLProvider();
INT SetSSLProvider(INT iSSLProvider);

SSLP_AUTOMATIC(0), 
SSLP_PLATFORM(1), 
SSLP_INTERNAL(2)

int cloudkeys_googlekms_getsslprovider(void* lpObj);
int cloudkeys_googlekms_setsslprovider(void* lpObj, int iSSLProvider);

int GetSSLProvider();
int SetSSLProvider(int iSSLProvider);

Default Value

0

Remarks

This property specifies the SSL/TLS implementation to use. In most cases the default value of 0 (Automatic) is recommended and should not be changed. When set to 0 (Automatic), the class will select whether to use the platform implementation or the internal implementation depending on the operating system as well as the TLS version being used.

Possible values are as follows:

In most cases using the default value (Automatic) is recommended. The class will select a provider depending on the current platform.

When Automatic is selected, on Windows, the class will use the platform implementation. On Linux/macOS, the class will use the internal implementation. When TLS 1.3 is enabled via SSLEnabledProtocols, the internal implementation is used on all platforms.

Data Type

Integer

SSLServerCert Property (GoogleKMS Class)

The server certificate for the last established connection.

Syntax

• C++
• C
• Qt

CloudKeysCertificate* GetSSLServerCert();

char* cloudkeys_googlekms_getsslservercerteffectivedate(void* lpObj);

char* cloudkeys_googlekms_getsslservercertexpirationdate(void* lpObj);

char* cloudkeys_googlekms_getsslservercertextendedkeyusage(void* lpObj);

char* cloudkeys_googlekms_getsslservercertfingerprint(void* lpObj);

char* cloudkeys_googlekms_getsslservercertfingerprintsha1(void* lpObj);

char* cloudkeys_googlekms_getsslservercertfingerprintsha256(void* lpObj);

char* cloudkeys_googlekms_getsslservercertissuer(void* lpObj);

char* cloudkeys_googlekms_getsslservercertprivatekey(void* lpObj);

int cloudkeys_googlekms_getsslservercertprivatekeyavailable(void* lpObj);

char* cloudkeys_googlekms_getsslservercertprivatekeycontainer(void* lpObj);

char* cloudkeys_googlekms_getsslservercertpublickey(void* lpObj);

char* cloudkeys_googlekms_getsslservercertpublickeyalgorithm(void* lpObj);

int cloudkeys_googlekms_getsslservercertpublickeylength(void* lpObj);

char* cloudkeys_googlekms_getsslservercertserialnumber(void* lpObj);

char* cloudkeys_googlekms_getsslservercertsignaturealgorithm(void* lpObj);

int cloudkeys_googlekms_getsslservercertstore(void* lpObj, char** lpSSLServerCertStore, int* lenSSLServerCertStore);

char* cloudkeys_googlekms_getsslservercertstorepassword(void* lpObj);

int cloudkeys_googlekms_getsslservercertstoretype(void* lpObj);

char* cloudkeys_googlekms_getsslservercertsubjectaltnames(void* lpObj);

char* cloudkeys_googlekms_getsslservercertthumbprintmd5(void* lpObj);

char* cloudkeys_googlekms_getsslservercertthumbprintsha1(void* lpObj);

char* cloudkeys_googlekms_getsslservercertthumbprintsha256(void* lpObj);

char* cloudkeys_googlekms_getsslservercertusage(void* lpObj);

int cloudkeys_googlekms_getsslservercertusageflags(void* lpObj);

char* cloudkeys_googlekms_getsslservercertversion(void* lpObj);

char* cloudkeys_googlekms_getsslservercertsubject(void* lpObj);

int cloudkeys_googlekms_getsslservercertencoded(void* lpObj, char** lpSSLServerCertEncoded, int* lenSSLServerCertEncoded);

QString GetSSLServerCertEffectiveDate();

QString GetSSLServerCertExpirationDate();

QString GetSSLServerCertExtendedKeyUsage();

QString GetSSLServerCertFingerprint();

QString GetSSLServerCertFingerprintSHA1();

QString GetSSLServerCertFingerprintSHA256();

QString GetSSLServerCertIssuer();

QString GetSSLServerCertPrivateKey();

bool GetSSLServerCertPrivateKeyAvailable();

QString GetSSLServerCertPrivateKeyContainer();

QString GetSSLServerCertPublicKey();

QString GetSSLServerCertPublicKeyAlgorithm();

int GetSSLServerCertPublicKeyLength();

QString GetSSLServerCertSerialNumber();

QString GetSSLServerCertSignatureAlgorithm();

QByteArray GetSSLServerCertStore();

QString GetSSLServerCertStorePassword();

int GetSSLServerCertStoreType();

QString GetSSLServerCertSubjectAltNames();

QString GetSSLServerCertThumbprintMD5();

QString GetSSLServerCertThumbprintSHA1();

QString GetSSLServerCertThumbprintSHA256();

QString GetSSLServerCertUsage();

int GetSSLServerCertUsageFlags();

QString GetSSLServerCertVersion();

QString GetSSLServerCertSubject();

QByteArray GetSSLServerCertEncoded();

Remarks

This property contains the server certificate for the last established connection.

SSLServerCert is reset every time a new connection is attempted.

This property is read-only.

Data Type

CloudKeysCertificate

Timeout Property (GoogleKMS Class)

The timeout for the class.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetTimeout();
int SetTimeout(int iTimeout);

Unicode (Windows)
INT GetTimeout();
INT SetTimeout(INT iTimeout);

int cloudkeys_googlekms_gettimeout(void* lpObj);
int cloudkeys_googlekms_settimeout(void* lpObj, int iTimeout);

int GetTimeout();
int SetTimeout(int iTimeout);

Default Value

60

Remarks

If the Timeout property is set to 0, all operations will run uninterrupted until successful completion or an error condition is encountered.

If Timeout is set to a positive value, the class will wait for the operation to complete before returning control.

The class will use DoEvents to enter an efficient wait loop during any potential waiting period, making sure that all system events are processed immediately as they arrive. This ensures that the host application does not freeze and remains responsive.

If Timeout expires, and the operation is not yet complete, the class fails with an error.

Note: By default, all timeouts are inactivity timeouts, that is, the timeout period is extended by Timeout seconds when any amount of data is successfully sent or received.

The default value for the Timeout property is 60 seconds.

Data Type

Integer

VersionMarker Property (GoogleKMS Class)

A marker indicating what page of key versions to return next.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* GetVersionMarker();
int SetVersionMarker(const char* lpszVersionMarker);

Unicode (Windows)
LPWSTR GetVersionMarker();
INT SetVersionMarker(LPCWSTR lpszVersionMarker);

char* cloudkeys_googlekms_getversionmarker(void* lpObj);
int cloudkeys_googlekms_setversionmarker(void* lpObj, const char* lpszVersionMarker);

QString GetVersionMarker();
int SetVersionMarker(QString qsVersionMarker);

Default Value

""

Remarks

This property will be populated when ListVersions is called if the results are paged and there are more pages. To list all key versions, continue to call ListVersions until this property returns empty string.

Refer to ListVersions for more information.

This property is not available at design time.

Data Type

String

Versions Property (GoogleKMS Class)

A collection of key versions.

Syntax

• C++
• C
• Qt

CloudKeysList<CloudKeysGoogleKeyVersion>* GetVersions();

int cloudkeys_googlekms_getversioncount(void* lpObj);

char* cloudkeys_googlekms_getversionalgorithm(void* lpObj, int versionindex);

char* cloudkeys_googlekms_getversioncreationdate(void* lpObj, int versionindex);

char* cloudkeys_googlekms_getversiondestructiondate(void* lpObj, int versionindex);

char* cloudkeys_googlekms_getversiongenerationdate(void* lpObj, int versionindex);

char* cloudkeys_googlekms_getversionname(void* lpObj, int versionindex);

char* cloudkeys_googlekms_getversionprotectionlevel(void* lpObj, int versionindex);

char* cloudkeys_googlekms_getversionstate(void* lpObj, int versionindex);

char* cloudkeys_googlekms_getversionversionid(void* lpObj, int versionindex);

int GetVersionCount();

QString GetVersionAlgorithm(int iVersionIndex);

QString GetVersionCreationDate(int iVersionIndex);

QString GetVersionDestructionDate(int iVersionIndex);

QString GetVersionGenerationDate(int iVersionIndex);

QString GetVersionName(int iVersionIndex);

QString GetVersionProtectionLevel(int iVersionIndex);

QString GetVersionState(int iVersionIndex);

QString GetVersionVersionId(int iVersionIndex);

Remarks

This collection holds a list of GoogleKeyVersion items.

Calling ListVersions or GetVersionInfo will populate this collection.

This property is read-only and not available at design time.

Data Type

CloudKeysGoogleKeyVersion

AddLabel Method (GoogleKMS Class)

Adds an item to the Labels properties.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int AddLabel(const char* lpszName, const char* lpszValue);

Unicode (Windows)
INT AddLabel(LPCWSTR lpszName, LPCWSTR lpszValue);

int cloudkeys_googlekms_addlabel(void* lpObj, const char* lpszName, const char* lpszValue);

int AddLabel(const QString& qsName, const QString& qsValue);

Remarks

This method adds an item to the Labels properties. Name specifies the name of the item, and Value specifies the value of the item.

A resource may have up to 64 labels. Label names and values must consist solely of lowercase letters, numbers, underscores, and hyphens; and may be up to 63 characters in length. Label names must also be unique and begin with a lowercase letter.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

AddQueryParam Method (GoogleKMS Class)

Adds a query parameter to the QueryParams properties.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int AddQueryParam(const char* lpszName, const char* lpszValue);

Unicode (Windows)
INT AddQueryParam(LPCWSTR lpszName, LPCWSTR lpszValue);

int cloudkeys_googlekms_addqueryparam(void* lpObj, const char* lpszName, const char* lpszValue);

int AddQueryParam(const QString& qsName, const QString& qsValue);

Remarks

This method is used to add a query parameter to the QueryParams properties. Name specifies the name of the parameter, and Value specifies the value of the parameter.

All specified Values will be URL encoded by the class automatically. Consult the service documentation for details on the available parameters.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

Authorize Method (GoogleKMS Class)

Get the authorization string required to access the protected resource.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Authorize();

Unicode (Windows)
INT Authorize();

int cloudkeys_googlekms_authorize(void* lpObj);

int Authorize();

Remarks

This method is used to get an access token that is required to access the protected resource. The method will act differently based on what is set in the ClientProfile field and the GrantType field. This method is not to be used in conjunction with the Authorization property. It should instead be used when setting the OAuth property.

For more information, see the introduction section.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

CancelDestruction Method (GoogleKMS Class)

Cancels the destruction of a key version's cryptographic material.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int CancelDestruction(const char* lpszKeyName, const char* lpszVersionId);

Unicode (Windows)
INT CancelDestruction(LPCWSTR lpszKeyName, LPCWSTR lpszVersionId);

int cloudkeys_googlekms_canceldestruction(void* lpObj, const char* lpszKeyName, const char* lpszVersionId);

int CancelDestruction(const QString& qsKeyName, const QString& qsVersionId);

Remarks

This method cancels the destruction of the cryptographic material for the key version specified by KeyName and VersionId. If successful, the key version's State changes to DISABLED.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

Config Method (GoogleKMS Class)

Sets or retrieves a configuration setting.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* Config(const char* lpszConfigurationString);

Unicode (Windows)
LPWSTR Config(LPCWSTR lpszConfigurationString);

char* cloudkeys_googlekms_config(void* lpObj, const char* lpszConfigurationString);

QString Config(const QString& qsConfigurationString);

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.

Error Handling (C++)

This method returns a String value; after it returns, call the GetLastErrorCode() method to obtain its result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message.

CreateKey Method (GoogleKMS Class)

Creates a new key.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int CreateKey(const char* lpszKeyName, int iPurpose, const char* lpszAlgorithm, int bUseHSM);

Unicode (Windows)
INT CreateKey(LPCWSTR lpszKeyName, INT iPurpose, LPCWSTR lpszAlgorithm, BOOL bUseHSM);

int cloudkeys_googlekms_createkey(void* lpObj, const char* lpszKeyName, int iPurpose, const char* lpszAlgorithm, int bUseHSM);

int CreateKey(const QString& qsKeyName, int iPurpose, const QString& qsAlgorithm, bool bUseHSM);

Remarks

This method creates a new key with the specified KeyName in the currently-selected KeyRing. A key version is automatically created when this occurs (and for symmetric keys, it automatically becomes the primary version).

The value passed for KeyName must consist solely of alphanumeric characters, underscores, and hyphens; and may be up to 63 characters in length.

The Purpose parameter specifies what the key's purpose should be. Possible values are:

• 1: A symmetric key used for encryption and decryption.
• 2: An asymmetric key used for signing and verification.
• 3: An asymmetric key used for encryption and decryption.

For symmetric keys, the only valid value for Algorithm is GOOGLE_SYMMETRIC_ENCRYPTION (which is assumed if empty string is passed). For asymmetric keys, the algorithm specifies the key type, repeats the purpose (either SIGN or DECRYPT), and dictates the algorithm that will be used for the relevant cryptographic operations; and valid values are:

• RSA_SIGN_PSS_2048_SHA256: RSASSA-PSS 2048 bit key with a SHA256 digest
• RSA_SIGN_PSS_3072_SHA256: RSASSA-PSS 3072 bit key with a SHA256 digest
• RSA_SIGN_PSS_4096_SHA256: RSASSA-PSS 4096 bit key with a SHA256 digest
• RSA_SIGN_PSS_4096_SHA512: RSASSA-PSS 4096 bit key with a SHA512 digest
• RSA_SIGN_PKCS1_2048_SHA256: RSASSA-PKCS1-v1_5 with a 2048 bit key and a SHA256 digest
• RSA_SIGN_PKCS1_3072_SHA256: RSASSA-PKCS1-v1_5 with a 3072 bit key and a SHA256 digest
• RSA_SIGN_PKCS1_4096_SHA256: RSASSA-PKCS1-v1_5 with a 4096 bit key and a SHA256 digest
• RSA_SIGN_PKCS1_4096_SHA512: RSASSA-PKCS1-v1_5 with a 4096 bit key and a SHA512 digest
• RSA_DECRYPT_OAEP_2048_SHA256: RSAES-OAEP 2048 bit key with a SHA256 digest
• RSA_DECRYPT_OAEP_3072_SHA256: RSAES-OAEP 3072 bit key with a SHA256 digest
• RSA_DECRYPT_OAEP_4096_SHA256: RSAES-OAEP 4096 bit key with a SHA256 digest
• RSA_DECRYPT_OAEP_4096_SHA512: RSAES-OAEP 4096 bit key with a SHA512 digest
• EC_SIGN_P256_SHA256: ECDSA on the NIST P-256 curve with a SHA256 digest
• EC_SIGN_P384_SHA384: ECDSA on the NIST P-384 curve with a SHA384 digest

Refer to Google's CryptoKeyVersionAlgorithm documentation page for more information.

The UseHSM parameter specifies whether the key's protection level should be SOFTWARE (false) or HSM (true).

Note that the values passed for Algorithm and UseHSM will be stored on the server as template values, and used again anytime a new key version is created with CreateVersion. The template algorithm can be changed at any time using UpdateKey; the template protection level cannot be changed.

If there are any items in the Labels properties, they will be applied to the newly-created key. Keys may have up to 64 labels.

For symmetric keys, the RotationPeriod and NextRotateDate configuration settings can also be used to enable automatic rotation, refer to their documentation for more information.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

CreateKeyRing Method (GoogleKMS Class)

Creates a new key ring.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int CreateKeyRing();

Unicode (Windows)
INT CreateKeyRing();

int cloudkeys_googlekms_createkeyring(void* lpObj);

int CreateKeyRing();

Remarks

This method creates a new key ring using the name specified by the KeyRing property.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

CreateVersion Method (GoogleKMS Class)

Creates a new key version.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
char* CreateVersion(const char* lpszKeyName);

Unicode (Windows)
LPWSTR CreateVersion(LPCWSTR lpszKeyName);

char* cloudkeys_googlekms_createversion(void* lpObj, const char* lpszKeyName);

QString CreateVersion(const QString& qsKeyName);

Remarks

This method creates a new version of the key specified by KeyName and returns the Id of the version. Note that, for symmetric keys, the new version will not become the primary version; SetPrimaryVersion can be used to update the primary version if desired.

The key's current TemplateAlgorithm and TemplateProtectionLevel are used to create the key version. To change the key's template algorithm prior to creating a new version, use the UpdateKey method.

Error Handling (C++)

This method returns a String value; after it returns, call the GetLastErrorCode() method to obtain its result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message.

Decrypt Method (GoogleKMS Class)

Decrypts data using a key.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Decrypt(const char* lpszKeyName, const char* lpszVersionId);

Unicode (Windows)
INT Decrypt(LPCWSTR lpszKeyName, LPCWSTR lpszVersionId);

int cloudkeys_googlekms_decrypt(void* lpObj, const char* lpszKeyName, const char* lpszVersionId);

int Decrypt(const QString& qsKeyName, const QString& qsVersionId);

Remarks

This method decrypts data using the key specified by KeyName and (for asymmetric keys) VersionId.

The data to decrypt is taken from the input stream supplied via the SetInputStream method, the specified InputFile, or the InputData property. The decrypted data is output to the output stream supplied via the SetOutputStream method, the specified OutputFile, or the OutputData property.

For symmetric keys, VersionId must be empty; the server automatically detects which version of the symmetric key to use for decryption.

For asymmetric keys, VersionId must be specified.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

DestroyVersion Method (GoogleKMS Class)

Schedules the specified key version's cryptographic material for destruction.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int DestroyVersion(const char* lpszKeyName, const char* lpszVersionId);

Unicode (Windows)
INT DestroyVersion(LPCWSTR lpszKeyName, LPCWSTR lpszVersionId);

int cloudkeys_googlekms_destroyversion(void* lpObj, const char* lpszKeyName, const char* lpszVersionId);

int DestroyVersion(const QString& qsKeyName, const QString& qsVersionId);

Remarks

This method schedules the destruction of the cryptographic material for the key version specified by KeyName and VersionId. The key version itself is not deleted, just its cryptographic material.

If this method is successful, the key version's State changes to DESTROY_SCHEDULED, and the its cryptographic material will be destroyed after 24 hours. During this waiting period, the destruction can be canceled using the CancelDestruction method.

Important: Destroying a key version's cryptographic material makes the key version permanently unusable. If a key version must not be used by may be needed again in the future, disable using SetVersionEnabled instead.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

DoEvents Method (GoogleKMS Class)

This method processes events from the internal message queue.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int DoEvents();

Unicode (Windows)
INT DoEvents();

int cloudkeys_googlekms_doevents(void* lpObj);

int DoEvents();

Remarks

When DoEvents is called, the class processes any available events. If no events are available, it waits for a preset period of time, and then returns.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

Encrypt Method (GoogleKMS Class)

Encrypts data using a key.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Encrypt(const char* lpszKeyName, const char* lpszVersionId);

Unicode (Windows)
INT Encrypt(LPCWSTR lpszKeyName, LPCWSTR lpszVersionId);

int cloudkeys_googlekms_encrypt(void* lpObj, const char* lpszKeyName, const char* lpszVersionId);

int Encrypt(const QString& qsKeyName, const QString& qsVersionId);

Remarks

This method encrypts data using the key specified by KeyName and (for asymmetric keys) VersionId.

The data to encrypt is taken from the input stream supplied via the SetInputStream method, the specified InputFile, or the InputData property. The encrypted data is output to the output stream supplied via the SetOutputStream method, the specified OutputFile, or the OutputData property.

For symmetric keys, VersionId must be empty; the server always uses the primary version of the symmetric key. (Unless the ForceSymmetricEncryption configuration setting is enabled, in which case VersionId can be used to specify a non-primary version.)

For asymmetric keys, VersionId must be specified. Note, however, that Google does not support server-side asymmetric encryption (only decryption), so this method will instead call GetPublicKey internally and then use the public key to encrypt the input data locally. This functionality is offered as a convenience.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

GetKeyInfo Method (GoogleKMS Class)

Gets information about a key.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetKeyInfo(const char* lpszKeyName);

Unicode (Windows)
INT GetKeyInfo(LPCWSTR lpszKeyName);

int cloudkeys_googlekms_getkeyinfo(void* lpObj, const char* lpszKeyName);

int GetKeyInfo(const QString& qsKeyName);

Remarks

This method gets information about the key specified by KeyName.

When the information is returned, the class clears the Keys properties and repopulates it properties. The KeyList and LabelList events are also fired.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

GetKeyRingInfo Method (GoogleKMS Class)

Gets information about a key ring.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetKeyRingInfo();

Unicode (Windows)
INT GetKeyRingInfo();

int cloudkeys_googlekms_getkeyringinfo(void* lpObj);

int GetKeyRingInfo();

Remarks

This method gets information about the currently-selected KeyRing.

When the information is returned, the class clears the KeyRings properties and repopulates them with a single item that contains the key ring's information. The KeyRingList event is also fired.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

GetPublicKey Method (GoogleKMS Class)

Retrieves the public key of an asymmetric key pair.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetPublicKey(const char* lpszKeyName, const char* lpszVersionId);

Unicode (Windows)
INT GetPublicKey(LPCWSTR lpszKeyName, LPCWSTR lpszVersionId);

int cloudkeys_googlekms_getpublickey(void* lpObj, const char* lpszKeyName, const char* lpszVersionId);

int GetPublicKey(const QString& qsKeyName, const QString& qsVersionId);

Remarks

This method retrieves the public key of the asymmetric key pair version specified by KeyName and VersionId. The algorithm of the key pair version is also retrieved. If successful, this method populates the PublicKey and PublicKeyAlgorithm properties.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

GetVersionInfo Method (GoogleKMS Class)

Gets information about a key version.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int GetVersionInfo(const char* lpszKeyName, const char* lpszVersionId);

Unicode (Windows)
INT GetVersionInfo(LPCWSTR lpszKeyName, LPCWSTR lpszVersionId);

int cloudkeys_googlekms_getversioninfo(void* lpObj, const char* lpszKeyName, const char* lpszVersionId);

int GetVersionInfo(const QString& qsKeyName, const QString& qsVersionId);

Remarks

This method gets information about the key version specified by KeyName and VersionId.

When the information is returned, the class clears the Versions properties and repopulates them with a single item that contains the key version's information. The VersionList event is also fired.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

ListKeyRings Method (GoogleKMS Class)

Lists the key rings in the currently-selected location.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int ListKeyRings();

Unicode (Windows)
INT ListKeyRings();

int cloudkeys_googlekms_listkeyrings(void* lpObj);

int ListKeyRings();

Remarks

This method lists the key rings in the currently-selected Location.

Calling this method will fire the KeyRingList event once for each key ring, and will also populate the KeyRings properties.

If there are still more key rings available to list when this method returns, the KeyRingMarker property will be populated. Continue to call this method until KeyRingMarker is empty to accumulate all pages of results in the KeyRings properties.

The MaxKeyRings configuration setting can be used to control the maximum number of results to return at once.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

ListKeys Method (GoogleKMS Class)

Lists the keys in the currently-selected key ring.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int ListKeys();

Unicode (Windows)
INT ListKeys();

int cloudkeys_googlekms_listkeys(void* lpObj);

int ListKeys();

Remarks

This method lists the keys in the currently-selected KeyRing.

Calling this method will fire the KeyList event once for each key, and will also populate the Keys properties.

If there are still more keys available to list when this method returns, the KeyMarker property will be populated. Continue to call this method until KeyMarker is empty to accumulate all pages of results in the Keys properties.

The MaxKeys configuration setting can be used to control the maximum number of results to return at once.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

ListVersions Method (GoogleKMS Class)

Lists the key versions for the specified key.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int ListVersions(const char* lpszKeyName);

Unicode (Windows)
INT ListVersions(LPCWSTR lpszKeyName);

int cloudkeys_googlekms_listversions(void* lpObj, const char* lpszKeyName);

int ListVersions(const QString& qsKeyName);

Remarks

This method lists the key versions for the key specified by KeyName.

Calling this method will fire the VersionList event once for each key version, and will also populate the Versions properties.

If there are still more key versions available to list when this method returns, the VersionMarker property will be populated. Continue to call this method until VersionMarker is empty to accumulate all pages of results in the Versions properties.

The MaxVersions configuration setting can be used to control the maximum number of results to return at once.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

Reset Method (GoogleKMS Class)

Resets the class to its initial state.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Reset();

Unicode (Windows)
INT Reset();

int cloudkeys_googlekms_reset(void* lpObj);

int Reset();

Remarks

This method resets the class to its initial state.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

SendCustomRequest Method (GoogleKMS Class)

Sends a custom request to the server.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int SendCustomRequest(const char* lpszHttpMethod, const char* lpszKeyName, const char* lpszVersionId, const char* lpszAction);

Unicode (Windows)
INT SendCustomRequest(LPCWSTR lpszHttpMethod, LPCWSTR lpszKeyName, LPCWSTR lpszVersionId, LPCWSTR lpszAction);

int cloudkeys_googlekms_sendcustomrequest(void* lpObj, const char* lpszHttpMethod, const char* lpszKeyName, const char* lpszVersionId, const char* lpszAction);

int SendCustomRequest(const QString& qsHttpMethod, const QString& qsKeyName, const QString& qsVersionId, const QString& qsAction);

Remarks

This method can be used to send arbitrary requests to the server.

Valid values for HttpMethod are:

• GET (default if empty)
• HEAD
• POST
• PUT
• PATCH
• DELETE

KeyName and VersionId are optional. The former must be specified if the latter is specified; both are ignored if KeyRing is empty. Action is also optional.

When this method is called, the class does the following:

1. Builds a request URL, including query parameters, like https://cloudkms.googleapis.com/v1/projects/{GoogleProjectId}/locations/{Location}[/keyRings/{KeyRing}[/cryptoKeys/{KeyName}[/cryptoKeyVersions/{VersionId}]]][{Action}] using:
   • The GoogleProjectId, Location, and (if non-empty) KeyRing properties.
   • The KeyName, VersionId, and Action parameters.
   • All query parameters from QueryParams.
2. Adds an Authorization header with the value specified by Authorization.
3. Adds any request headers from OtherHeaders.
4. Adds any request body supplied via the stream specified using SetInputStream, the specified InputFile, or InputData.
5. Sends the request to the server.
6. Stores the response headers in the ParsedHeaders properties; and the response body in the stream specified using SetOutputStream, the specified OutputFile, or OutputData.

If the response body is JSON data, the XPath, XText, and other X* configuration settings can then be used to navigate and extract information from it.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

SetInputStream Method (GoogleKMS Class)

Sets the stream whose data should be processed.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int SetInputStream(CloudKeysStream* sInputStream);

Unicode (Windows)
INT SetInputStream(CloudKeysStream* sInputStream);

int cloudkeys_googlekms_setinputstream(void* lpObj, CloudKeysStream* sInputStream);

int SetInputStream(CloudKeysStream* sInputStream);

Remarks

This method sets the stream whose data should be processed in a cryptographic operation.

Passing a non-null value for InputStream will cause the InputFile property to be cleared. Similarly, setting InputFile to a non-empty value will discard any stream set using this method.

Input Sources & Output Destinations

The class automatically determines the source and destination of the input and output based on which properties are set.

The order in which the input properties are checked is as follows:

1. An input stream supplied via the SetInputStream method
2. The InputFile property
3. The InputData property

The first valid input source found is used. The order in which the output properties are considered is as follows:

1. An output stream supplied via the SetOutputStream method
2. The OutputFile property
3. The OutputData property

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

SetOutputStream Method (GoogleKMS Class)

Sets the stream to which output data should be written.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int SetOutputStream(CloudKeysStream* sOutputStream);

Unicode (Windows)
INT SetOutputStream(CloudKeysStream* sOutputStream);

int cloudkeys_googlekms_setoutputstream(void* lpObj, CloudKeysStream* sOutputStream);

int SetOutputStream(CloudKeysStream* sOutputStream);

Remarks

This method sets the stream to which data output from a successful cryptographic operation should be written.

Passing a non-null value for OutputStream will cause the OutputFile property to be cleared. Similarly, setting OutputFile to a non-empty value will discard any stream set using this method.

Input Sources & Output Destinations

The class automatically determines the source and destination of the input and output based on which properties are set.

The order in which the input properties are checked is as follows:

1. An input stream supplied via the SetInputStream method
2. The InputFile property
3. The InputData property

The first valid input source found is used. The order in which the output properties are considered is as follows:

1. An output stream supplied via the SetOutputStream method
2. The OutputFile property
3. The OutputData property

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

SetPrimaryVersion Method (GoogleKMS Class)

Sets the primary version of a symmetric key.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int SetPrimaryVersion(const char* lpszKeyName, const char* lpszVersionId);

Unicode (Windows)
INT SetPrimaryVersion(LPCWSTR lpszKeyName, LPCWSTR lpszVersionId);

int cloudkeys_googlekms_setprimaryversion(void* lpObj, const char* lpszKeyName, const char* lpszVersionId);

int SetPrimaryVersion(const QString& qsKeyName, const QString& qsVersionId);

Remarks

This method sets the primary version of the symmetric key specified by KeyName to the version identified by VersionId.

A symmetric key's primary version is the one used by the server when Encrypt is called. It can be changed at any time. Asymmetric keys cannot have primary versions.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

SetVersionEnabled Method (GoogleKMS Class)

Enables or disables a key version.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int SetVersionEnabled(const char* lpszKeyName, const char* lpszVersionId, int bEnabled);

Unicode (Windows)
INT SetVersionEnabled(LPCWSTR lpszKeyName, LPCWSTR lpszVersionId, BOOL bEnabled);

int cloudkeys_googlekms_setversionenabled(void* lpObj, const char* lpszKeyName, const char* lpszVersionId, int bEnabled);

int SetVersionEnabled(const QString& qsKeyName, const QString& qsVersionId, bool bEnabled);

Remarks

This method enables or disables the key version specified by KeyName and VersionId.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

Sign Method (GoogleKMS Class)

Signs a message using a key.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int Sign(const char* lpszKeyName, const char* lpszVersionId, const char* lpszAlgorithm, int bIsDigest);

Unicode (Windows)
INT Sign(LPCWSTR lpszKeyName, LPCWSTR lpszVersionId, LPCWSTR lpszAlgorithm, BOOL bIsDigest);

int cloudkeys_googlekms_sign(void* lpObj, const char* lpszKeyName, const char* lpszVersionId, const char* lpszAlgorithm, int bIsDigest);

int Sign(const QString& qsKeyName, const QString& qsVersionId, const QString& qsAlgorithm, bool bIsDigest);

Remarks

This method signs a message using the asymmetric key version specified by KeyName and VersionId.

The message data to sign is taken from the input stream supplied via the SetInputStream method, the specified InputFile, or the InputData property. The signature data is output to the output stream supplied via the SetOutputStream method, the specified OutputFile, or the OutputData property.

The Algorithm parameter specifies the hash algorithm used to generate a message digest; this must be the same algorithm that appears in the key version's Algorithm string. The value passed must contain one of the following strings (passing the key version's complete algorithm string is acceptable):

• SHA256
• SHA384
• SHA512

The IsDigest parameter specifies whether the message data is the original message (false) or a message digest (true). When supplying a message digest, keep in mind that the same digest will need to be provided in order to Verify the signature later.

If IsDigest is false, the class will automatically compute an appropriate message digest before the request is made. In such cases, the computed digest is made available via the MessageDigest configuration setting.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

UpdateKey Method (GoogleKMS Class)

Updates a key.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
int UpdateKey(const char* lpszKeyName, const char* lpszTemplateAlgorithm, int bUpdateLabels);

Unicode (Windows)
INT UpdateKey(LPCWSTR lpszKeyName, LPCWSTR lpszTemplateAlgorithm, BOOL bUpdateLabels);

int cloudkeys_googlekms_updatekey(void* lpObj, const char* lpszKeyName, const char* lpszTemplateAlgorithm, int bUpdateLabels);

int UpdateKey(const QString& qsKeyName, const QString& qsTemplateAlgorithm, bool bUpdateLabels);

Remarks

This method updates the key specified by KeyName.

The TemplateAlgorithm parameter specifies the algorithm value that the server should use when creating new versions of the key (i.e., when CreateVersion is called). If TemplateAlgorithm is empty, the existing template value remains unchanged; otherwise, TemplateAlgorithm must be one of the following:

• RSA_SIGN_PSS_2048_SHA256: RSASSA-PSS 2048 bit key with a SHA256 digest
• RSA_SIGN_PSS_3072_SHA256: RSASSA-PSS 3072 bit key with a SHA256 digest
• RSA_SIGN_PSS_4096_SHA256: RSASSA-PSS 4096 bit key with a SHA256 digest
• RSA_SIGN_PSS_4096_SHA512: RSASSA-PSS 4096 bit key with a SHA512 digest
• RSA_SIGN_PKCS1_2048_SHA256: RSASSA-PKCS1-v1_5 with a 2048 bit key and a SHA256 digest
• RSA_SIGN_PKCS1_3072_SHA256: RSASSA-PKCS1-v1_5 with a 3072 bit key and a SHA256 digest
• RSA_SIGN_PKCS1_4096_SHA256: RSASSA-PKCS1-v1_5 with a 4096 bit key and a SHA256 digest
• RSA_SIGN_PKCS1_4096_SHA512: RSASSA-PKCS1-v1_5 with a 4096 bit key and a SHA512 digest
• RSA_DECRYPT_OAEP_2048_SHA256: RSAES-OAEP 2048 bit key with a SHA256 digest
• RSA_DECRYPT_OAEP_3072_SHA256: RSAES-OAEP 3072 bit key with a SHA256 digest
• RSA_DECRYPT_OAEP_4096_SHA256: RSAES-OAEP 4096 bit key with a SHA256 digest
• RSA_DECRYPT_OAEP_4096_SHA512: RSAES-OAEP 4096 bit key with a SHA512 digest
• EC_SIGN_P256_SHA256: ECDSA on the NIST P-256 curve with a SHA256 digest
• EC_SIGN_P384_SHA384: ECDSA on the NIST P-384 curve with a SHA384 digest

Refer to Google's CryptoKeyVersionAlgorithm documentation page for more information.

The UpdateLabels parameter determines whether the class replaces the key's current labels with the items in the Labels properties (which may be empty). Keys may have up to 64 labels.

The RotationPeriod and NextRotateDate configuration settings may also be used to send additional values, refer to their documentation for more information.

Error Handling (C++)

This method returns a result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message. (Note: This method's result code can also be obtained by calling the GetLastErrorCode() method after it returns.)

Verify Method (GoogleKMS Class)

Verifies a digital signature using a key.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
bool Verify(const char* lpszKeyName, const char* lpszVersionId, int bIsDigest);

Unicode (Windows)
INT Verify(LPCWSTR lpszKeyName, LPCWSTR lpszVersionId, BOOL bIsDigest);

bool cloudkeys_googlekms_verify(void* lpObj, const char* lpszKeyName, const char* lpszVersionId, int bIsDigest);

bool Verify(const QString& qsKeyName, const QString& qsVersionId, bool bIsDigest);

Remarks

This method verifies a digital signature using the asymmetric key version specified by KeyName and VersionId. If the signature is successfully verified, this method return true, otherwise it returns false.

The message data is taken from the input stream supplied via the SetInputStream method, the specified InputFile, or the InputData property. The digital signature data is taken from the specified OutputFile or the OutputData property.

The IsDigest parameter specifies whether the message data is the original message (false) or a message digest (true). When a message digest is supplied, keep in mind that it must be the exact same digest that was used at signing time, regardless of whether it has been recomputed.

Google does not support server-side signature verification, so this method will call GetPublicKey internally and then use the public key to verify the digital signature locally. This functionality is offered as a convenience.

Error Handling (C++)

This method returns a Boolean value; after it returns, call the GetLastErrorCode() method to obtain its result code; 0 indicates success, while a non-zero error code indicates that this method encountered an error during its execution. If an error occurs, the GetLastError() method can be called to retrieve the associated error message.

EndTransfer Event (GoogleKMS Class)

This event fires when a document finishes transferring.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireEndTransfer(GoogleKMSEndTransferEventParams *e);

typedef struct {
  int Direction;
  int reserved;
} GoogleKMSEndTransferEventParams;


Unicode (Windows)
virtual INT FireEndTransfer(GoogleKMSEndTransferEventParams *e);

typedef struct {
  INT Direction;
  INT reserved;
} GoogleKMSEndTransferEventParams;

#define EID_GOOGLEKMS_ENDTRANSFER 1

virtual INT CLOUDKEYS_CALL FireEndTransfer(INT &iDirection);

class GoogleKMSEndTransferEventParams {
public:
  int Direction();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void EndTransfer(GoogleKMSEndTransferEventParams *e);

// Or, subclass GoogleKMS and override this emitter function.
virtual int FireEndTransfer(GoogleKMSEndTransferEventParams *e) {...}

Remarks

The EndTransfer event is fired when the document text finishes transferring from the server to the local host.

The Direction parameter shows whether the client (0) or the server (1) is sending the data.

Error Event (GoogleKMS Class)

Fired when information is available about errors during data delivery.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireError(GoogleKMSErrorEventParams *e);

typedef struct {
  int ErrorCode;
  const char *Description;
  int reserved;
} GoogleKMSErrorEventParams;


Unicode (Windows)
virtual INT FireError(GoogleKMSErrorEventParams *e);

typedef struct {
  INT ErrorCode;
  LPCWSTR Description;
  INT reserved;
} GoogleKMSErrorEventParams;

#define EID_GOOGLEKMS_ERROR 2

virtual INT CLOUDKEYS_CALL FireError(INT &iErrorCode, LPSTR &lpszDescription);

class GoogleKMSErrorEventParams {
public:
  int ErrorCode();

  const QString &Description();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Error(GoogleKMSErrorEventParams *e);

// Or, subclass GoogleKMS and override this emitter function.
virtual int FireError(GoogleKMSErrorEventParams *e) {...}

Remarks

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

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

Header Event (GoogleKMS Class)

Fired every time a header line comes in.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireHeader(GoogleKMSHeaderEventParams *e);

typedef struct {
  const char *Field;
  const char *Value;
  int reserved;
} GoogleKMSHeaderEventParams;


Unicode (Windows)
virtual INT FireHeader(GoogleKMSHeaderEventParams *e);

typedef struct {
  LPCWSTR Field;
  LPCWSTR Value;
  INT reserved;
} GoogleKMSHeaderEventParams;

#define EID_GOOGLEKMS_HEADER 3

virtual INT CLOUDKEYS_CALL FireHeader(LPSTR &lpszField, LPSTR &lpszValue);

class GoogleKMSHeaderEventParams {
public:
  const QString &Field();

  const QString &Value();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Header(GoogleKMSHeaderEventParams *e);

// Or, subclass GoogleKMS and override this emitter function.
virtual int FireHeader(GoogleKMSHeaderEventParams *e) {...}

Remarks

The Field parameter contains the name of the HTTP header (which is the same as it is delivered). The Value parameter contains the header contents.

If the header line being retrieved is a continuation header line, then the Field parameter contains "" (empty string).

KeyList Event (GoogleKMS Class)

Fires once for each key when listing keys.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireKeyList(GoogleKMSKeyListEventParams *e);

typedef struct {
  const char *Name;
  int Purpose;
  const char *CreationDate;
  const char *PrimaryVersion;
  int reserved;
} GoogleKMSKeyListEventParams;


Unicode (Windows)
virtual INT FireKeyList(GoogleKMSKeyListEventParams *e);

typedef struct {
  LPCWSTR Name;
  INT Purpose;
  LPCWSTR CreationDate;
  LPCWSTR PrimaryVersion;
  INT reserved;
} GoogleKMSKeyListEventParams;

#define EID_GOOGLEKMS_KEYLIST 4

virtual INT CLOUDKEYS_CALL FireKeyList(LPSTR &lpszName, INT &iPurpose, LPSTR &lpszCreationDate, LPSTR &lpszPrimaryVersion);

class GoogleKMSKeyListEventParams {
public:
  const QString &Name();

  int Purpose();

  const QString &CreationDate();

  const QString &PrimaryVersion();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void KeyList(GoogleKMSKeyListEventParams *e);

// Or, subclass GoogleKMS and override this emitter function.
virtual int FireKeyList(GoogleKMSKeyListEventParams *e) {...}

Remarks

This event fires once for each key returned when ListKeys or GetKeyInfo is called.

Name reflects the name of the key.

Purpose reflects the key's purpose. Possible values are:

• 0: Unspecified.
• 1: A symmetric key used for encryption and decryption.
• 2: An asymmetric key used for signing and verification.
• 3: An asymmetric key used for encryption and decryption.

CreationDate reflects the key's creation date, formatted as an RFC 3339 UTC timestamp.

PrimaryVersion reflects the Id of the key's primary version if it is symmetric. For asymmetric keys, it is always empty, since asymmetric keys cannot have a primary version.

KeyRingList Event (GoogleKMS Class)

Fires once for each key ring when listing key rings.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireKeyRingList(GoogleKMSKeyRingListEventParams *e);

typedef struct {
  const char *Name;
  const char *CreationDate;
  int reserved;
} GoogleKMSKeyRingListEventParams;


Unicode (Windows)
virtual INT FireKeyRingList(GoogleKMSKeyRingListEventParams *e);

typedef struct {
  LPCWSTR Name;
  LPCWSTR CreationDate;
  INT reserved;
} GoogleKMSKeyRingListEventParams;

#define EID_GOOGLEKMS_KEYRINGLIST 5

virtual INT CLOUDKEYS_CALL FireKeyRingList(LPSTR &lpszName, LPSTR &lpszCreationDate);

class GoogleKMSKeyRingListEventParams {
public:
  const QString &Name();

  const QString &CreationDate();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void KeyRingList(GoogleKMSKeyRingListEventParams *e);

// Or, subclass GoogleKMS and override this emitter function.
virtual int FireKeyRingList(GoogleKMSKeyRingListEventParams *e) {...}

Remarks

This event fires once for each key ring returned when ListKeyRings or GetKeyRingInfo is called.

Name reflects the name of the key ring.

CreationDate reflects the key ring's creation date, formatted as an RFC 3339 UTC timestamp.

LabelList Event (GoogleKMS Class)

Fires once for each label returned when a key's information is retrieved.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireLabelList(GoogleKMSLabelListEventParams *e);

typedef struct {
  const char *KeyName;
  const char *Name;
  const char *Value;
  int reserved;
} GoogleKMSLabelListEventParams;


Unicode (Windows)
virtual INT FireLabelList(GoogleKMSLabelListEventParams *e);

typedef struct {
  LPCWSTR KeyName;
  LPCWSTR Name;
  LPCWSTR Value;
  INT reserved;
} GoogleKMSLabelListEventParams;

#define EID_GOOGLEKMS_LABELLIST 6

virtual INT CLOUDKEYS_CALL FireLabelList(LPSTR &lpszKeyName, LPSTR &lpszName, LPSTR &lpszValue);

class GoogleKMSLabelListEventParams {
public:
  const QString &KeyName();

  const QString &Name();

  const QString &Value();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void LabelList(GoogleKMSLabelListEventParams *e);

// Or, subclass GoogleKMS and override this emitter function.
virtual int FireLabelList(GoogleKMSLabelListEventParams *e) {...}

Remarks

This event fires once for each label returned when GetKeyInfo is called.

KeyName reflects the name of the key.

Name reflects the name of the label.

Value reflects the value of the label.

Log Event (GoogleKMS Class)

Fired once for each log message.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireLog(GoogleKMSLogEventParams *e);

typedef struct {
  int LogLevel;
  const char *Message;
  const char *LogType;
  int reserved;
} GoogleKMSLogEventParams;


Unicode (Windows)
virtual INT FireLog(GoogleKMSLogEventParams *e);

typedef struct {
  INT LogLevel;
  LPCWSTR Message;
  LPCWSTR LogType;
  INT reserved;
} GoogleKMSLogEventParams;

#define EID_GOOGLEKMS_LOG 7

virtual INT CLOUDKEYS_CALL FireLog(INT &iLogLevel, LPSTR &lpszMessage, LPSTR &lpszLogType);

class GoogleKMSLogEventParams {
public:
  int LogLevel();

  const QString &Message();

  const QString &LogType();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Log(GoogleKMSLogEventParams *e);

// Or, subclass GoogleKMS and override this emitter function.
virtual int FireLog(GoogleKMSLogEventParams *e) {...}

Remarks

This event is fired once for each log message generated by the class. The verbosity is controlled by the LogLevel setting.

LogLevel indicates the level of message. Possible values are as follows:

The value 1 (Info) logs basic information, including the URL, HTTP version, and status details.

The value 2 (Verbose) logs additional information about the request and response.

The value 3 (Debug) logs the headers and body for both the request and response, as well as additional debug information (if any).

Message is the log entry.

LogType identifies the type of log entry. Possible values are as follows:

• "Info"
• "RequestHeaders"
• "ResponseHeaders"
• "RequestBody"
• "ResponseBody"
• "ProxyRequest"
• "ProxyResponse"
• "FirewallRequest"
• "FirewallResponse"

SSLServerAuthentication Event (GoogleKMS Class)

Fired after the server presents its certificate to the client.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireSSLServerAuthentication(GoogleKMSSSLServerAuthenticationEventParams *e);

typedef struct {
  const char *CertEncoded;
  int lenCertEncoded;
  const char *CertSubject;
  const char *CertIssuer;
  const char *Status;
  int Accept;
  int reserved;
} GoogleKMSSSLServerAuthenticationEventParams;


Unicode (Windows)
virtual INT FireSSLServerAuthentication(GoogleKMSSSLServerAuthenticationEventParams *e);

typedef struct {
  LPCSTR CertEncoded;
  INT lenCertEncoded;
  LPCWSTR CertSubject;
  LPCWSTR CertIssuer;
  LPCWSTR Status;
  BOOL Accept;
  INT reserved;
} GoogleKMSSSLServerAuthenticationEventParams;

#define EID_GOOGLEKMS_SSLSERVERAUTHENTICATION 8

virtual INT CLOUDKEYS_CALL FireSSLServerAuthentication(LPSTR &lpCertEncoded, INT &lenCertEncoded, LPSTR &lpszCertSubject, LPSTR &lpszCertIssuer, LPSTR &lpszStatus, BOOL &bAccept);

class GoogleKMSSSLServerAuthenticationEventParams {
public:
  const QByteArray &CertEncoded();

  const QString &CertSubject();

  const QString &CertIssuer();

  const QString &Status();

  bool Accept();
  void SetAccept(bool bAccept);

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void SSLServerAuthentication(GoogleKMSSSLServerAuthenticationEventParams *e);

// Or, subclass GoogleKMS and override this emitter function.
virtual int FireSSLServerAuthentication(GoogleKMSSSLServerAuthenticationEventParams *e) {...}

Remarks

During this event, the client can decide whether or not to continue with the connection process. The Accept parameter is a recommendation on whether to continue or close the connection. This is just a suggestion: application software must use its own logic to determine whether or not to continue.

When Accept is False, Status shows why the verification failed (otherwise, Status contains the string OK). If it is decided to continue, you can override and accept the certificate by setting the Accept parameter to True.

SSLStatus Event (GoogleKMS Class)

Fired when secure connection progress messages are available.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireSSLStatus(GoogleKMSSSLStatusEventParams *e);

typedef struct {
  const char *Message;
  int reserved;
} GoogleKMSSSLStatusEventParams;


Unicode (Windows)
virtual INT FireSSLStatus(GoogleKMSSSLStatusEventParams *e);

typedef struct {
  LPCWSTR Message;
  INT reserved;
} GoogleKMSSSLStatusEventParams;

#define EID_GOOGLEKMS_SSLSTATUS 9

virtual INT CLOUDKEYS_CALL FireSSLStatus(LPSTR &lpszMessage);

class GoogleKMSSSLStatusEventParams {
public:
  const QString &Message();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void SSLStatus(GoogleKMSSSLStatusEventParams *e);

// Or, subclass GoogleKMS and override this emitter function.
virtual int FireSSLStatus(GoogleKMSSSLStatusEventParams *e) {...}

Remarks

The event is fired for informational and logging purposes only. This event tracks the progress of the connection.

StartTransfer Event (GoogleKMS Class)

This event fires when a document starts transferring (after the headers).

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireStartTransfer(GoogleKMSStartTransferEventParams *e);

typedef struct {
  int Direction;
  int reserved;
} GoogleKMSStartTransferEventParams;


Unicode (Windows)
virtual INT FireStartTransfer(GoogleKMSStartTransferEventParams *e);

typedef struct {
  INT Direction;
  INT reserved;
} GoogleKMSStartTransferEventParams;

#define EID_GOOGLEKMS_STARTTRANSFER 10

virtual INT CLOUDKEYS_CALL FireStartTransfer(INT &iDirection);

class GoogleKMSStartTransferEventParams {
public:
  int Direction();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void StartTransfer(GoogleKMSStartTransferEventParams *e);

// Or, subclass GoogleKMS and override this emitter function.
virtual int FireStartTransfer(GoogleKMSStartTransferEventParams *e) {...}

Remarks

The StartTransfer event is fired when the document text starts transferring from the server to the local host.

The Direction parameter shows whether the client (0) or the server (1) is sending the data.

Transfer Event (GoogleKMS Class)

Fired while a document transfers (delivers document).

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireTransfer(GoogleKMSTransferEventParams *e);

typedef struct {
  int Direction;
  int64 BytesTransferred;
  int PercentDone;
  const char *Text;
  int lenText;
  int reserved;
} GoogleKMSTransferEventParams;


Unicode (Windows)
virtual INT FireTransfer(GoogleKMSTransferEventParams *e);

typedef struct {
  INT Direction;
  LONG64 BytesTransferred;
  INT PercentDone;
  LPCSTR Text;
  INT lenText;
  INT reserved;
} GoogleKMSTransferEventParams;

#define EID_GOOGLEKMS_TRANSFER 11

virtual INT CLOUDKEYS_CALL FireTransfer(INT &iDirection, LONG64 &lBytesTransferred, INT &iPercentDone, LPSTR &lpText, INT &lenText);

class GoogleKMSTransferEventParams {
public:
  int Direction();

  qint64 BytesTransferred();

  int PercentDone();

  const QByteArray &Text();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void Transfer(GoogleKMSTransferEventParams *e);

// Or, subclass GoogleKMS and override this emitter function.
virtual int FireTransfer(GoogleKMSTransferEventParams *e) {...}

Remarks

The Text parameter contains the portion of the document text being received. It is empty if data are being posted to the server.

The BytesTransferred parameter contains the number of bytes transferred in this Direction since the beginning of the document text (excluding HTTP response headers).

The Direction parameter shows whether the client (0) or the server (1) is sending the data.

The PercentDone parameter shows the progress of the transfer in the corresponding direction. If PercentDone can not be calculated the value will be -1.

Note: Events are not re-entrant. Performing time-consuming operations within this event will prevent it from firing again in a timely manner and may affect overall performance.

VersionList Event (GoogleKMS Class)

Fires once for each key version when listing key versions.

Syntax

• C++
• C
• Qt

ANSI (Cross Platform)
virtual int FireVersionList(GoogleKMSVersionListEventParams *e);

typedef struct {
  const char *Name;
  const char *VersionId;
  const char *State;
  const char *Algorithm;
  const char *ProtectionLevel;
  const char *CreationDate;
  const char *DestructionDate;
  int reserved;
} GoogleKMSVersionListEventParams;


Unicode (Windows)
virtual INT FireVersionList(GoogleKMSVersionListEventParams *e);

typedef struct {
  LPCWSTR Name;
  LPCWSTR VersionId;
  LPCWSTR State;
  LPCWSTR Algorithm;
  LPCWSTR ProtectionLevel;
  LPCWSTR CreationDate;
  LPCWSTR DestructionDate;
  INT reserved;
} GoogleKMSVersionListEventParams;

#define EID_GOOGLEKMS_VERSIONLIST 12

virtual INT CLOUDKEYS_CALL FireVersionList(LPSTR &lpszName, LPSTR &lpszVersionId, LPSTR &lpszState, LPSTR &lpszAlgorithm, LPSTR &lpszProtectionLevel, LPSTR &lpszCreationDate, LPSTR &lpszDestructionDate);

class GoogleKMSVersionListEventParams {
public:
  const QString &Name();

  const QString &VersionId();

  const QString &State();

  const QString &Algorithm();

  const QString &ProtectionLevel();

  const QString &CreationDate();

  const QString &DestructionDate();

  int EventRetVal();
  void SetEventRetVal(int iRetVal);
};

// To handle, connect one or more slots to this signal.
void VersionList(GoogleKMSVersionListEventParams *e);

// Or, subclass GoogleKMS and override this emitter function.
virtual int FireVersionList(GoogleKMSVersionListEventParams *e) {...}

Remarks

This event fires once for each key version returned when ListVersions or GetVersionInfo is called.

Name reflects the name of the key.

VersionId reflects the Id of the key version.

State reflects the state of the key version. Possible values are:

• PENDING_GENERATION: The version is still being generated, and cannot be used yet. Once generation has finished, it will become ENABLED.
• ENABLED: The version is enabled and available for use.
• DISABLED: The version is disabled; it cannot be used unless it is enabled again. It may be destroyed.
• DESTROY_SCHEDULED: The version's cryptographic material is scheduled for destruction, and will be destroyed at the time reflected by DestructionDate unless CancelDestruction before then.
• DESTROYED: The version's cryptographic material has been destroyed, and the version is no longer usable. This state is permanent once entered.
• PENDING_IMPORT*: Cryptographic material has not finished importing, and the version cannot be used yet. Once the import has finished, it will become ENABLED.
• IMPORT_FAILED*: The version was not imported successfully; it cannot be used, and any imported cryptographic material has been discarded.

Algorithm reflects the key version's algorithm. For symmetric keys, this will always be GOOGLE_SYMMETRIC_ENCRYPTION. For asymmetric keys, this value describes both the key type and the algorithm that must be used during cryptographic operations, and possible values are:

• RSA_SIGN_PSS_2048_SHA256: RSASSA-PSS 2048 bit key with a SHA256 digest
• RSA_SIGN_PSS_3072_SHA256: RSASSA-PSS 3072 bit key with a SHA256 digest
• RSA_SIGN_PSS_4096_SHA256: RSASSA-PSS 4096 bit key with a SHA256 digest
• RSA_SIGN_PSS_4096_SHA512: RSASSA-PSS 4096 bit key with a SHA512 digest
• RSA_SIGN_PKCS1_2048_SHA256: RSASSA-PKCS1-v1_5 with a 2048 bit key and a SHA256 digest
• RSA_SIGN_PKCS1_3072_SHA256: RSASSA-PKCS1-v1_5 with a 3072 bit key and a SHA256 digest
• RSA_SIGN_PKCS1_4096_SHA256: RSASSA-PKCS1-v1_5 with a 4096 bit key and a SHA256 digest
• RSA_SIGN_PKCS1_4096_SHA512: RSASSA-PKCS1-v1_5 with a 4096 bit key and a SHA512 digest
• RSA_DECRYPT_OAEP_2048_SHA256: RSAES-OAEP 2048 bit key with a SHA256 digest
• RSA_DECRYPT_OAEP_3072_SHA256: RSAES-OAEP 3072 bit key with a SHA256 digest
• RSA_DECRYPT_OAEP_4096_SHA256: RSAES-OAEP 4096 bit key with a SHA256 digest
• RSA_DECRYPT_OAEP_4096_SHA512: RSAES-OAEP 4096 bit key with a SHA512 digest
• EC_SIGN_P256_SHA256: ECDSA on the NIST P-256 curve with a SHA256 digest
• EC_SIGN_P384_SHA384: ECDSA on the NIST P-384 curve with a SHA384 digest

Refer to Google's CryptoKeyVersionAlgorithm documentation page for more information.

ProtectionLevel reflects the key version's protection level. Possible values are:

• SOFTWARE
• HSM
• EXTERNAL

CreationDate reflects the key version's creation date, formatted as an RFC 3339 UTC timestamp.

DestructionDate reflects the date at which the key version's cryptographic material was (or will be) destroyed, formatted as an RFC 3339 UTC timestamp; or empty string if the key version's cryptographic material has not been, and is not scheduled to be, destroyed.

Certificate Type

This is the digital certificate being used.

Syntax

CloudKeysCertificate (declared in cloudkeys.h)

Remarks

This type describes the current digital certificate. The certificate may be a public or private key. The fields are used to identify or select certificates.

Fields

Constructors

Certificate()

Certificate(const char* lpEncoded, int lenEncoded)

Certificate(int iStoreType, const char* lpStore, int lenStore, const char* lpszStorePassword, const char* lpszSubject)

Firewall Type

The firewall the component will connect through.

Syntax

CloudKeysFirewall (declared in cloudkeys.h)

Remarks

When connecting through a firewall, this type is used to specify different properties of the firewall, such as the firewall Host and the FirewallType.

Fields

Constructors

Firewall()

GoogleKey Type

A Google KMS key.

Syntax

CloudKeysGoogleKey (declared in cloudkeys.h)

Remarks

This type represents a Google KMS key.

Fields

GoogleKeyRing Type

A Google KMS key ring.

Syntax

CloudKeysGoogleKeyRing (declared in cloudkeys.h)

Remarks

This type represents a Google KMS key ring.

Fields

GoogleKeyVersion Type

A Google KMS key version.

Syntax

CloudKeysGoogleKeyVersion (declared in cloudkeys.h)

Remarks

This type represents a Google KMS key version.

Fields

GoogleLabel Type

A Google resource label.

Syntax

CloudKeysGoogleLabel (declared in cloudkeys.h)

Remarks

This type represents a Google resource label.

Fields

Constructors

GoogleLabel()

GoogleLabel(const char* lpszName, const char* lpszValue)

Header Type

This is an HTTP header as it is received from the server.

Syntax

CloudKeysHeader (declared in cloudkeys.h)

Remarks

When a header is received through a Header event, it is parsed into a Header type. This type contains a Field, and its corresponding Value.

Fields

Constructors

Header()

Header(const char* lpszField, const char* lpszValue)

OAuthSettings Type

The settings to use to authenticate with the service provider.

Syntax

CloudKeysOAuthSettings (declared in cloudkeys.h)

Remarks

Used to set give the class the necessary information needed to complete OAuth authentication.

Fields