com.amazonaws.services.kms.AWSKMSClient Maven / Gradle / Ivy
Show all versions of aws-java-sdk-kms Show documentation
/*
* Copyright 2019-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.kms;
import org.w3c.dom.*;
import java.net.*;
import java.util.*;
import javax.annotation.Generated;
import org.apache.commons.logging.*;
import com.amazonaws.*;
import com.amazonaws.annotation.SdkInternalApi;
import com.amazonaws.auth.*;
import com.amazonaws.handlers.*;
import com.amazonaws.http.*;
import com.amazonaws.internal.*;
import com.amazonaws.internal.auth.*;
import com.amazonaws.metrics.*;
import com.amazonaws.regions.*;
import com.amazonaws.transform.*;
import com.amazonaws.util.*;
import com.amazonaws.protocol.json.*;
import com.amazonaws.util.AWSRequestMetrics.Field;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.client.AwsSyncClientParams;
import com.amazonaws.client.builder.AdvancedConfig;
import com.amazonaws.services.kms.AWSKMSClientBuilder;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.kms.model.*;
import com.amazonaws.services.kms.model.transform.*;
/**
* Client for accessing KMS. All service calls made using this client are blocking, and will not return until the
* service call completes.
*
* Key Management Service
*
* Key Management Service (KMS) is an encryption and key management web service. This guide describes the KMS operations
* that you can call programmatically. For general information about KMS, see the Key Management Service Developer Guide .
*
*
*
* KMS has replaced the term customer master key (CMK) with KMS key and KMS key. The concept has
* not changed. To prevent breaking changes, KMS is keeping some variations of this term.
*
*
* Amazon Web Services provides SDKs that consist of libraries and sample code for various programming languages and
* platforms (Java, Ruby, .Net, macOS, Android, etc.). The SDKs provide a convenient way to create programmatic access
* to KMS and other Amazon Web Services services. For example, the SDKs take care of tasks such as signing requests (see
* below), managing errors, and retrying requests automatically. For more information about the Amazon Web Services
* SDKs, including how to download and install them, see Tools for Amazon Web
* Services.
*
*
*
* We recommend that you use the Amazon Web Services SDKs to make programmatic API calls to KMS.
*
*
* If you need to use FIPS 140-2 validated cryptographic modules when communicating with Amazon Web Services, use the
* FIPS endpoint in your preferred Amazon Web Services Region. For more information about the available FIPS endpoints,
* see Service endpoints in the Key
* Management Service topic of the Amazon Web Services General Reference.
*
*
* All KMS API calls must be signed and be transmitted using Transport Layer Security (TLS). KMS recommends you always
* use the latest supported TLS version. Clients must also support cipher suites with Perfect Forward Secrecy (PFS) such
* as Ephemeral Diffie-Hellman (DHE) or Elliptic Curve Ephemeral Diffie-Hellman (ECDHE). Most modern systems such as
* Java 7 and later support these modes.
*
*
* Signing Requests
*
*
* Requests must be signed using an access key ID and a secret access key. We strongly recommend that you do not use
* your Amazon Web Services account root access key ID and secret access key for everyday work. You can use the access
* key ID and secret access key for an IAM user or you can use the Security Token Service (STS) to generate temporary
* security credentials and use those to sign requests.
*
*
* All KMS requests must be signed with Signature Version 4.
*
*
* Logging API Requests
*
*
* KMS supports CloudTrail, a service that logs Amazon Web Services API calls and related events for your Amazon Web
* Services account and delivers them to an Amazon S3 bucket that you specify. By using the information collected by
* CloudTrail, you can determine what requests were made to KMS, who made the request, when it was made, and so on. To
* learn more about CloudTrail, including how to turn it on and find your log files, see the CloudTrail User Guide.
*
*
* Additional Resources
*
*
* For more information about credentials and request signing, see the following:
*
*
* -
*
* Amazon Web Services Security
* Credentials - This topic provides general information about the types of credentials used to access Amazon Web
* Services.
*
*
* -
*
* Temporary Security
* Credentials - This section of the IAM User Guide describes how to create and use temporary security
* credentials.
*
*
* -
*
* Signature Version 4 Signing
* Process - This set of topics walks you through the process of signing a request using an access key ID and a
* secret access key.
*
*
*
*
* Commonly Used API Operations
*
*
* Of the API operations discussed in this guide, the following will prove the most useful for most applications. You
* will likely perform operations other than these, such as creating keys and assigning policies, by using the console.
*
*
* -
*
* Encrypt
*
*
* -
*
* Decrypt
*
*
* -
*
* GenerateDataKey
*
*
* -
*
*
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSKMSClient extends AmazonWebServiceClient implements AWSKMS {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AWSKMS.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "kms";
/** Client configuration factory providing ClientConfigurations tailored to this client */
protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
private final AdvancedConfig advancedConfig;
private static final com.amazonaws.protocol.json.SdkJsonProtocolFactory protocolFactory = new com.amazonaws.protocol.json.SdkJsonProtocolFactory(
new JsonClientMetadata()
.withProtocolVersion("1.1")
.withSupportsCbor(false)
.withSupportsIon(false)
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("CloudHsmClusterNotFoundException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.CloudHsmClusterNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("XksProxyInvalidConfigurationException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.XksProxyInvalidConfigurationExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ExpiredImportTokenException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.ExpiredImportTokenExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("CustomKeyStoreNotFoundException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.CustomKeyStoreNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("XksProxyVpcEndpointServiceInvalidConfigurationException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.XksProxyVpcEndpointServiceInvalidConfigurationExceptionUnmarshaller
.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("KMSInvalidMacException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.KMSInvalidMacExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("XksProxyIncorrectAuthenticationCredentialException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.XksProxyIncorrectAuthenticationCredentialExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("MalformedPolicyDocumentException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.MalformedPolicyDocumentExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("XksProxyUriUnreachableException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.XksProxyUriUnreachableExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("IncorrectKeyMaterialException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.IncorrectKeyMaterialExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidImportTokenException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.InvalidImportTokenExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("XksProxyUriInUseException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.XksProxyUriInUseExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidArnException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.InvalidArnExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("KMSInvalidSignatureException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.KMSInvalidSignatureExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("KMSInvalidStateException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.KMSInvalidStateExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("CloudHsmClusterNotRelatedException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.CloudHsmClusterNotRelatedExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("CustomKeyStoreInvalidStateException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.CustomKeyStoreInvalidStateExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("IncorrectTrustAnchorException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.IncorrectTrustAnchorExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("DisabledException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.DisabledExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("NotFoundException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.NotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("CustomKeyStoreHasCMKsException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.CustomKeyStoreHasCMKsExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("KeyUnavailableException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.KeyUnavailableExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("LimitExceededException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.LimitExceededExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("CloudHsmClusterInUseException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.CloudHsmClusterInUseExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidCiphertextException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.InvalidCiphertextExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ConflictException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.ConflictExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("XksProxyInvalidResponseException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.XksProxyInvalidResponseExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidGrantIdException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.InvalidGrantIdExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("XksProxyUriEndpointInUseException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.XksProxyUriEndpointInUseExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("IncorrectKeyException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.IncorrectKeyExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidGrantTokenException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.InvalidGrantTokenExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("XksKeyInvalidConfigurationException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.XksKeyInvalidConfigurationExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("UnsupportedOperationException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.UnsupportedOperationExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("CustomKeyStoreNameInUseException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.CustomKeyStoreNameInUseExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("AlreadyExistsException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.AlreadyExistsExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("TagException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.TagExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("XksKeyAlreadyInUseException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.XksKeyAlreadyInUseExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidKeyUsageException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.InvalidKeyUsageExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("XksProxyVpcEndpointServiceInUseException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.XksProxyVpcEndpointServiceInUseExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("CloudHsmClusterInvalidConfigurationException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.CloudHsmClusterInvalidConfigurationExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidMarkerException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.InvalidMarkerExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidAliasNameException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.InvalidAliasNameExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("XksKeyNotFoundException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.XksKeyNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("XksProxyVpcEndpointServiceNotFoundException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.XksProxyVpcEndpointServiceNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("DependencyTimeoutException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.DependencyTimeoutExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("KMSInternalException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.KMSInternalExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("CloudHsmClusterNotActiveException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.CloudHsmClusterNotActiveExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("DryRunOperationException").withExceptionUnmarshaller(
com.amazonaws.services.kms.model.transform.DryRunOperationExceptionUnmarshaller.getInstance()))
.withBaseServiceExceptionClass(com.amazonaws.services.kms.model.AWSKMSException.class));
/**
* Constructs a new client to invoke service methods on KMS. A credentials provider chain will be used that searches
* for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @see DefaultAWSCredentialsProviderChain
* @deprecated use {@link AWSKMSClientBuilder#defaultClient()}
*/
@Deprecated
public AWSKMSClient() {
this(DefaultAWSCredentialsProviderChain.getInstance(), configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on KMS. A credentials provider chain will be used that searches
* for credentials in this order:
*
* - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
* - Java System Properties - aws.accessKeyId and aws.secretKey
* - Instance profile credentials delivered through the Amazon EC2 metadata service
*
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientConfiguration
* The client configuration options controlling how this client connects to KMS (ex: proxy settings, retry
* counts, etc.).
*
* @see DefaultAWSCredentialsProviderChain
* @deprecated use {@link AWSKMSClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AWSKMSClient(ClientConfiguration clientConfiguration) {
this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration);
}
/**
* Constructs a new client to invoke service methods on KMS using the specified AWS account credentials.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @deprecated use {@link AWSKMSClientBuilder#withCredentials(AWSCredentialsProvider)} for example:
* {@code AWSKMSClientBuilder.standard().withCredentials(new AWSStaticCredentialsProvider(awsCredentials)).build();}
*/
@Deprecated
public AWSKMSClient(AWSCredentials awsCredentials) {
this(awsCredentials, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on KMS using the specified AWS account credentials and client
* configuration options.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentials
* The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to KMS (ex: proxy settings, retry
* counts, etc.).
* @deprecated use {@link AWSKMSClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSKMSClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AWSKMSClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration) {
super(clientConfiguration);
this.awsCredentialsProvider = new StaticCredentialsProvider(awsCredentials);
this.advancedConfig = AdvancedConfig.EMPTY;
init();
}
/**
* Constructs a new client to invoke service methods on KMS using the specified AWS account credentials provider.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @deprecated use {@link AWSKMSClientBuilder#withCredentials(AWSCredentialsProvider)}
*/
@Deprecated
public AWSKMSClient(AWSCredentialsProvider awsCredentialsProvider) {
this(awsCredentialsProvider, configFactory.getConfig());
}
/**
* Constructs a new client to invoke service methods on KMS using the specified AWS account credentials provider and
* client configuration options.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to KMS (ex: proxy settings, retry
* counts, etc.).
* @deprecated use {@link AWSKMSClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSKMSClientBuilder#withClientConfiguration(ClientConfiguration)}
*/
@Deprecated
public AWSKMSClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
this(awsCredentialsProvider, clientConfiguration, null);
}
/**
* Constructs a new client to invoke service methods on KMS using the specified AWS account credentials provider,
* client configuration options, and request metric collector.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param awsCredentialsProvider
* The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
* @param clientConfiguration
* The client configuration options controlling how this client connects to KMS (ex: proxy settings, retry
* counts, etc.).
* @param requestMetricCollector
* optional request metric collector
* @deprecated use {@link AWSKMSClientBuilder#withCredentials(AWSCredentialsProvider)} and
* {@link AWSKMSClientBuilder#withClientConfiguration(ClientConfiguration)} and
* {@link AWSKMSClientBuilder#withMetricsCollector(RequestMetricCollector)}
*/
@Deprecated
public AWSKMSClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration, RequestMetricCollector requestMetricCollector) {
super(clientConfiguration, requestMetricCollector);
this.awsCredentialsProvider = awsCredentialsProvider;
this.advancedConfig = AdvancedConfig.EMPTY;
init();
}
public static AWSKMSClientBuilder builder() {
return AWSKMSClientBuilder.standard();
}
/**
* Constructs a new client to invoke service methods on KMS using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AWSKMSClient(AwsSyncClientParams clientParams) {
this(clientParams, false);
}
/**
* Constructs a new client to invoke service methods on KMS using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AWSKMSClient(AwsSyncClientParams clientParams, boolean endpointDiscoveryEnabled) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
this.advancedConfig = clientParams.getAdvancedConfig();
init();
}
private void init() {
setServiceNameIntern(DEFAULT_SIGNING_NAME);
setEndpointPrefix(ENDPOINT_PREFIX);
// calling this.setEndPoint(...) will also modify the signer accordingly
setEndpoint("https://kms.us-east-1.amazonaws.com/");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain("/com/amazonaws/services/kms/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain("/com/amazonaws/services/kms/request.handler2s"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
*
* Cancels the deletion of a KMS key. When this operation succeeds, the key state of the KMS key is
* Disabled. To enable the KMS key, use EnableKey.
*
*
* For more information about scheduling and canceling deletion of a KMS key, see Deleting KMS keys in the
* Key Management Service Developer Guide.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:CancelKeyDeletion (key policy)
*
*
* Related operations: ScheduleKeyDeletion
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param cancelKeyDeletionRequest
* @return Result of the CancelKeyDeletion operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @sample AWSKMS.CancelKeyDeletion
* @see AWS API
* Documentation
*/
@Override
public CancelKeyDeletionResult cancelKeyDeletion(CancelKeyDeletionRequest request) {
request = beforeClientExecution(request);
return executeCancelKeyDeletion(request);
}
@SdkInternalApi
final CancelKeyDeletionResult executeCancelKeyDeletion(CancelKeyDeletionRequest cancelKeyDeletionRequest) {
ExecutionContext executionContext = createExecutionContext(cancelKeyDeletionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CancelKeyDeletionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(cancelKeyDeletionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CancelKeyDeletion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CancelKeyDeletionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Connects or reconnects a custom key store
* to its backing key store. For an CloudHSM key store, ConnectCustomKeyStore connects the key store to
* its associated CloudHSM cluster. For an external key store, ConnectCustomKeyStore connects the key
* store to the external key store proxy that communicates with your external key manager.
*
*
* The custom key store must be connected before you can create KMS keys in the key store or use the KMS keys it
* contains. You can disconnect and reconnect a custom key store at any time.
*
*
* The connection process for a custom key store can take an extended amount of time to complete. This operation
* starts the connection process, but it does not wait for it to complete. When it succeeds, this operation quickly
* returns an HTTP 200 response and a JSON object with no properties. However, this response does not indicate that
* the custom key store is connected. To get the connection state of the custom key store, use the
* DescribeCustomKeyStores operation.
*
*
* This operation is part of the custom key stores
* feature in KMS, which combines the convenience and extensive integration of KMS with the isolation and control of
* a key store that you own and manage.
*
*
* The ConnectCustomKeyStore operation might fail for various reasons. To find the reason, use the
* DescribeCustomKeyStores operation and see the ConnectionErrorCode in the response. For help
* interpreting the ConnectionErrorCode, see CustomKeyStoresListEntry.
*
*
* To fix the failure, use the DisconnectCustomKeyStore operation to disconnect the custom key store, correct
* the error, use the UpdateCustomKeyStore operation if necessary, and then use
* ConnectCustomKeyStore again.
*
*
* CloudHSM key store
*
*
* During the connection process for an CloudHSM key store, KMS finds the CloudHSM cluster that is associated with
* the custom key store, creates the connection infrastructure, connects to the cluster, logs into the CloudHSM
* client as the kmsuser CU, and rotates its password.
*
*
* To connect an CloudHSM key store, its associated CloudHSM cluster must have at least one active HSM. To get the
* number of active HSMs in a cluster, use the DescribeClusters
* operation. To add HSMs to the cluster, use the CreateHsm operation. Also,
* the
* kmsuser crypto user (CU) must not be logged into the cluster. This prevents KMS from using this
* account to log in.
*
*
* If you are having trouble connecting or disconnecting a CloudHSM key store, see Troubleshooting an CloudHSM key
* store in the Key Management Service Developer Guide.
*
*
* External key store
*
*
* When you connect an external key store that uses public endpoint connectivity, KMS tests its ability to
* communicate with your external key manager by sending a request via the external key store proxy.
*
*
* When you connect to an external key store that uses VPC endpoint service connectivity, KMS establishes the
* networking elements that it needs to communicate with your external key manager via the external key store proxy.
* This includes creating an interface endpoint to the VPC endpoint service and a private hosted zone for traffic
* between KMS and the VPC endpoint service.
*
*
* To connect an external key store, KMS must be able to connect to the external key store proxy, the external key
* store proxy must be able to communicate with your external key manager, and the external key manager must be
* available for cryptographic operations.
*
*
* If you are having trouble connecting or disconnecting an external key store, see Troubleshooting an external
* key store in the Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a custom key store in a different Amazon Web
* Services account.
*
*
* Required permissions: kms:ConnectCustomKeyStore (IAM policy)
*
*
* Related operations
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param connectCustomKeyStoreRequest
* @return Result of the ConnectCustomKeyStore operation returned by the service.
* @throws CloudHsmClusterNotActiveException
* The request was rejected because the CloudHSM cluster associated with the CloudHSM key store is not
* active. Initialize and activate the cluster and try the command again. For detailed instructions, see Getting Started in
* the CloudHSM User Guide.
* @throws CustomKeyStoreInvalidStateException
* The request was rejected because of the ConnectionState of the custom key store. To get the
* ConnectionState of a custom key store, use the DescribeCustomKeyStores operation.
*
* This exception is thrown under the following conditions:
*
*
* -
*
* You requested the ConnectCustomKeyStore operation on a custom key store with a
* ConnectionState of DISCONNECTING or FAILED. This operation is
* valid for all other ConnectionState values. To reconnect a custom key store in a
* FAILED state, disconnect it (DisconnectCustomKeyStore), then connect it (
* ConnectCustomKeyStore).
*
*
* -
*
* You requested the CreateKey operation in a custom key store that is not connected. This operations
* is valid only when the custom key store ConnectionState is CONNECTED.
*
*
* -
*
* You requested the DisconnectCustomKeyStore operation on a custom key store with a
* ConnectionState of DISCONNECTING or DISCONNECTED. This operation
* is valid for all other ConnectionState values.
*
*
* -
*
* You requested the UpdateCustomKeyStore or DeleteCustomKeyStore operation on a custom key
* store that is not disconnected. This operation is valid only when the custom key store
* ConnectionState is DISCONNECTED.
*
*
* -
*
* You requested the GenerateRandom operation in an CloudHSM key store that is not connected. This
* operation is valid only when the CloudHSM key store ConnectionState is
* CONNECTED.
*
*
* @throws CustomKeyStoreNotFoundException
* The request was rejected because KMS cannot find a custom key store with the specified key store name or
* ID.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws CloudHsmClusterInvalidConfigurationException
* The request was rejected because the associated CloudHSM cluster did not meet the configuration
* requirements for an CloudHSM key store.
*
* -
*
* The CloudHSM cluster must be configured with private subnets in at least two different Availability Zones
* in the Region.
*
*
* -
*
* The security group for
* the cluster (cloudhsm-cluster-<cluster-id>-sg) must include inbound rules and outbound
* rules that allow TCP traffic on ports 2223-2225. The Source in the inbound rules and the
* Destination in the outbound rules must match the security group ID. These rules are set by default
* when you create the CloudHSM cluster. Do not delete or change them. To get information about a particular
* security group, use the DescribeSecurityGroups operation.
*
*
* -
*
* The CloudHSM cluster must contain at least as many HSMs as the operation requires. To add HSMs, use the
* CloudHSM CreateHsm
* operation.
*
*
* For the CreateCustomKeyStore, UpdateCustomKeyStore, and CreateKey operations, the
* CloudHSM cluster must have at least two active HSMs, each in a different Availability Zone. For the
* ConnectCustomKeyStore operation, the CloudHSM must contain at least one active HSM.
*
*
*
*
* For information about the requirements for an CloudHSM cluster that is associated with an CloudHSM key
* store, see Assemble the Prerequisites in the Key Management Service Developer Guide. For information
* about creating a private subnet for an CloudHSM cluster, see Create a Private
* Subnet in the CloudHSM User Guide. For information about cluster security groups, see Configure a Default
* Security Group in the CloudHSM User Guide .
* @sample AWSKMS.ConnectCustomKeyStore
* @see AWS API
* Documentation
*/
@Override
public ConnectCustomKeyStoreResult connectCustomKeyStore(ConnectCustomKeyStoreRequest request) {
request = beforeClientExecution(request);
return executeConnectCustomKeyStore(request);
}
@SdkInternalApi
final ConnectCustomKeyStoreResult executeConnectCustomKeyStore(ConnectCustomKeyStoreRequest connectCustomKeyStoreRequest) {
ExecutionContext executionContext = createExecutionContext(connectCustomKeyStoreRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ConnectCustomKeyStoreRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(connectCustomKeyStoreRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ConnectCustomKeyStore");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ConnectCustomKeyStoreResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a friendly name for a KMS key.
*
*
*
* Adding, deleting, or updating an alias can allow or deny permission to the KMS key. For details, see ABAC for KMS in the Key Management
* Service Developer Guide.
*
*
*
* You can use an alias to identify a KMS key in the KMS console, in the DescribeKey operation and in cryptographic
* operations, such as Encrypt and GenerateDataKey. You can also change the KMS key that's
* associated with the alias (UpdateAlias) or delete the alias (DeleteAlias) at any time. These
* operations don't affect the underlying KMS key.
*
*
* You can associate the alias with any customer managed key in the same Amazon Web Services Region. Each alias is
* associated with only one KMS key at a time, but a KMS key can have multiple aliases. A valid KMS key is required.
* You can't create an alias without a KMS key.
*
*
* The alias must be unique in the account and Region, but you can have aliases with the same name in different
* Regions. For detailed information about aliases, see Using aliases in the Key
* Management Service Developer Guide.
*
*
* This operation does not return a response. To get the alias that you created, use the ListAliases
* operation.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on an alias in a different Amazon Web Services
* account.
*
*
* Required permissions
*
*
* -
*
* kms:CreateAlias
* on the alias (IAM policy).
*
*
* -
*
* kms:CreateAlias
* on the KMS key (key policy).
*
*
*
*
* For details, see Controlling access to
* aliases in the Key Management Service Developer Guide.
*
*
* Related operations:
*
*
* -
*
* DeleteAlias
*
*
* -
*
* ListAliases
*
*
* -
*
* UpdateAlias
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param createAliasRequest
* @return Result of the CreateAlias operation returned by the service.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws AlreadyExistsException
* The request was rejected because it attempted to create a resource that already exists.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws InvalidAliasNameException
* The request was rejected because the specified alias name is not valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws LimitExceededException
* The request was rejected because a quota was exceeded. For more information, see Quotas in the Key
* Management Service Developer Guide.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @sample AWSKMS.CreateAlias
* @see AWS API
* Documentation
*/
@Override
public CreateAliasResult createAlias(CreateAliasRequest request) {
request = beforeClientExecution(request);
return executeCreateAlias(request);
}
@SdkInternalApi
final CreateAliasResult executeCreateAlias(CreateAliasRequest createAliasRequest) {
ExecutionContext executionContext = createExecutionContext(createAliasRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateAliasRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createAliasRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateAlias");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateAliasResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a custom
* key store backed by a key store that you own and manage. When you use a KMS key in a custom key store for a
* cryptographic operation, the cryptographic operation is actually performed in your key store using your keys. KMS
* supports CloudHSM key
* stores backed by an CloudHSM
* cluster and external
* key stores backed by an external key store proxy and external key manager outside of Amazon Web Services.
*
*
* This operation is part of the custom key stores
* feature in KMS, which combines the convenience and extensive integration of KMS with the isolation and control of
* a key store that you own and manage.
*
*
* Before you create the custom key store, the required elements must be in place and operational. We recommend that
* you use the test tools that KMS provides to verify the configuration your external key store proxy. For details
* about the required elements and verification tests, see Assemble the
* prerequisites (for CloudHSM key stores) or Assemble
* the prerequisites (for external key stores) in the Key Management Service Developer Guide.
*
*
* To create a custom key store, use the following parameters.
*
*
* -
*
* To create an CloudHSM key store, specify the CustomKeyStoreName, CloudHsmClusterId,
* KeyStorePassword, and TrustAnchorCertificate. The CustomKeyStoreType
* parameter is optional for CloudHSM key stores. If you include it, set it to the default value,
* AWS_CLOUDHSM. For help with failures, see Troubleshooting an CloudHSM key
* store in the Key Management Service Developer Guide.
*
*
* -
*
* To create an external key store, specify the CustomKeyStoreName and a
* CustomKeyStoreType of EXTERNAL_KEY_STORE. Also, specify values for
* XksProxyConnectivity, XksProxyAuthenticationCredential,
* XksProxyUriEndpoint, and XksProxyUriPath. If your XksProxyConnectivity
* value is VPC_ENDPOINT_SERVICE, specify the XksProxyVpcEndpointServiceName parameter.
* For help with failures, see Troubleshooting an external
* key store in the Key Management Service Developer Guide.
*
*
*
*
*
* For external key stores:
*
*
* Some external key managers provide a simpler method for creating an external key store. For details, see your
* external key manager documentation.
*
*
* When creating an external key store in the KMS console, you can upload a JSON-based proxy configuration file with
* the desired values. You cannot use a proxy configuration with the CreateCustomKeyStore operation.
* However, you can use the values in the file to help you determine the correct values for the
* CreateCustomKeyStore parameters.
*
*
*
* When the operation completes successfully, it returns the ID of the new custom key store. Before you can use your
* new custom key store, you need to use the ConnectCustomKeyStore operation to connect a new CloudHSM key
* store to its CloudHSM cluster, or to connect a new external key store to the external key store proxy for your
* external key manager. Even if you are not going to use your custom key store immediately, you might want to
* connect it to verify that all settings are correct and then disconnect it until you are ready to use it.
*
*
* For help with failures, see Troubleshooting a custom key
* store in the Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a custom key store in a different Amazon Web
* Services account.
*
*
* Required permissions: kms:CreateCustomKeyStore (IAM policy).
*
*
* Related operations:
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param createCustomKeyStoreRequest
* @return Result of the CreateCustomKeyStore operation returned by the service.
* @throws CloudHsmClusterInUseException
* The request was rejected because the specified CloudHSM cluster is already associated with an CloudHSM
* key store in the account, or it shares a backup history with an CloudHSM key store in the account. Each
* CloudHSM key store in the account must be associated with a different CloudHSM cluster.
*
* CloudHSM clusters that share a backup history have the same cluster certificate. To view the cluster
* certificate of an CloudHSM cluster, use the DescribeClusters operation.
* @throws CustomKeyStoreNameInUseException
* The request was rejected because the specified custom key store name is already assigned to another
* custom key store in the account. Try again with a custom key store name that is unique in the account.
* @throws CloudHsmClusterNotFoundException
* The request was rejected because KMS cannot find the CloudHSM cluster with the specified cluster ID.
* Retry the request with a different cluster ID.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws CloudHsmClusterNotActiveException
* The request was rejected because the CloudHSM cluster associated with the CloudHSM key store is not
* active. Initialize and activate the cluster and try the command again. For detailed instructions, see Getting Started in
* the CloudHSM User Guide.
* @throws IncorrectTrustAnchorException
* The request was rejected because the trust anchor certificate in the request to create an CloudHSM key
* store is not the trust anchor certificate for the specified CloudHSM cluster.
*
*
* When you initialize
* the CloudHSM cluster, you create the trust anchor certificate and save it in the
* customerCA.crt file.
* @throws CloudHsmClusterInvalidConfigurationException
* The request was rejected because the associated CloudHSM cluster did not meet the configuration
* requirements for an CloudHSM key store.
*
*
* -
*
* The CloudHSM cluster must be configured with private subnets in at least two different Availability Zones
* in the Region.
*
*
* -
*
* The security group for
* the cluster (cloudhsm-cluster-<cluster-id>-sg) must include inbound rules and outbound
* rules that allow TCP traffic on ports 2223-2225. The Source in the inbound rules and the
* Destination in the outbound rules must match the security group ID. These rules are set by default
* when you create the CloudHSM cluster. Do not delete or change them. To get information about a particular
* security group, use the DescribeSecurityGroups operation.
*
*
* -
*
* The CloudHSM cluster must contain at least as many HSMs as the operation requires. To add HSMs, use the
* CloudHSM CreateHsm
* operation.
*
*
* For the CreateCustomKeyStore, UpdateCustomKeyStore, and CreateKey operations, the
* CloudHSM cluster must have at least two active HSMs, each in a different Availability Zone. For the
* ConnectCustomKeyStore operation, the CloudHSM must contain at least one active HSM.
*
*
*
*
* For information about the requirements for an CloudHSM cluster that is associated with an CloudHSM key
* store, see Assemble the Prerequisites in the Key Management Service Developer Guide. For information
* about creating a private subnet for an CloudHSM cluster, see Create a Private
* Subnet in the CloudHSM User Guide. For information about cluster security groups, see Configure a Default
* Security Group in the CloudHSM User Guide .
* @throws LimitExceededException
* The request was rejected because a quota was exceeded. For more information, see Quotas in the Key
* Management Service Developer Guide.
* @throws XksProxyUriInUseException
* The request was rejected because the concatenation of the XksProxyUriEndpoint and
* XksProxyUriPath is already associated with another external key store in this Amazon Web
* Services Region. Each external key store in a Region must use a unique external key store proxy API
* address.
* @throws XksProxyUriEndpointInUseException
* The request was rejected because the XksProxyUriEndpoint is already associated with another
* external key store in this Amazon Web Services Region. To identify the cause, see the error message that
* accompanies the exception.
* @throws XksProxyUriUnreachableException
* KMS was unable to reach the specified XksProxyUriPath. The path must be reachable before you
* create the external key store or update its settings.
*
*
* This exception is also thrown when the external key store proxy response to a
* GetHealthStatus request indicates that all external key manager instances are unavailable.
* @throws XksProxyIncorrectAuthenticationCredentialException
* The request was rejected because the proxy credentials failed to authenticate to the specified external
* key store proxy. The specified external key store proxy rejected a status request from KMS due to invalid
* credentials. This can indicate an error in the credentials or in the identification of the external key
* store proxy.
* @throws XksProxyVpcEndpointServiceInUseException
* The request was rejected because the specified Amazon VPC endpoint service is already associated with
* another external key store in this Amazon Web Services Region. Each external key store in a Region must
* use a different Amazon VPC endpoint service.
* @throws XksProxyVpcEndpointServiceNotFoundException
* The request was rejected because KMS could not find the specified VPC endpoint service. Use
* DescribeCustomKeyStores to verify the VPC endpoint service name for the external key store. Also,
* confirm that the Allow principals list for the VPC endpoint service includes the KMS service
* principal for the Region, such as cks.kms.us-east-1.amazonaws.com.
* @throws XksProxyVpcEndpointServiceInvalidConfigurationException
* The request was rejected because the Amazon VPC endpoint service configuration does not fulfill the
* requirements for an external key store. To identify the cause, see the error message that accompanies the
* exception and review the requirements for Amazon VPC endpoint service connectivity for an external key store.
* @throws XksProxyInvalidResponseException
*
* KMS cannot interpret the response it received from the external key store proxy. The problem might be a
* poorly constructed response, but it could also be a transient network issue. If you see this error
* repeatedly, report it to the proxy vendor.
* @throws XksProxyInvalidConfigurationException
* The request was rejected because the external key store proxy is not configured correctly. To identify
* the cause, see the error message that accompanies the exception.
* @sample AWSKMS.CreateCustomKeyStore
* @see AWS API
* Documentation
*/
@Override
public CreateCustomKeyStoreResult createCustomKeyStore(CreateCustomKeyStoreRequest request) {
request = beforeClientExecution(request);
return executeCreateCustomKeyStore(request);
}
@SdkInternalApi
final CreateCustomKeyStoreResult executeCreateCustomKeyStore(CreateCustomKeyStoreRequest createCustomKeyStoreRequest) {
ExecutionContext executionContext = createExecutionContext(createCustomKeyStoreRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateCustomKeyStoreRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createCustomKeyStoreRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateCustomKeyStore");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateCustomKeyStoreResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Adds a grant to a KMS key.
*
*
* A grant is a policy instrument that allows Amazon Web Services principals to use KMS keys in cryptographic
* operations. It also can allow them to view a KMS key (DescribeKey) and create and manage grants. When
* authorizing access to a KMS key, grants are considered along with key policies and IAM policies. Grants are often
* used for temporary permissions because you can create one, use its permissions, and delete it without changing
* your key policies or IAM policies.
*
*
* For detailed information about grants, including grant terminology, see Grants in KMS in the Key
* Management Service Developer Guide . For examples of working with grants in several programming
* languages, see Programming grants.
*
*
* The CreateGrant operation returns a GrantToken and a GrantId.
*
*
* -
*
* When you create, retire, or revoke a grant, there might be a brief delay, usually less than five minutes, until
* the grant is available throughout KMS. This state is known as eventual consistency. Once the grant has
* achieved eventual consistency, the grantee principal can use the permissions in the grant without identifying the
* grant.
*
*
* However, to use the permissions in the grant immediately, use the GrantToken that
* CreateGrant returns. For details, see Using a grant
* token in the Key Management Service Developer Guide .
*
*
* -
*
* The CreateGrant operation also returns a GrantId. You can use the GrantId
* and a key identifier to identify the grant in the RetireGrant and RevokeGrant operations. To find
* the grant ID, use the ListGrants or ListRetirableGrants operations.
*
*
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: Yes. To perform this operation on a KMS key in a different Amazon Web Services account,
* specify the key ARN in the value of the KeyId parameter.
*
*
* Required permissions: kms:CreateGrant (key policy)
*
*
* Related operations:
*
*
* -
*
* ListGrants
*
*
* -
*
*
* -
*
* RetireGrant
*
*
* -
*
* RevokeGrant
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param createGrantRequest
* @return Result of the CreateGrant operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws InvalidGrantTokenException
* The request was rejected because the specified grant token is not valid.
* @throws LimitExceededException
* The request was rejected because a quota was exceeded. For more information, see Quotas in the Key
* Management Service Developer Guide.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws DryRunOperationException
* The request was rejected because the DryRun parameter was specified.
* @sample AWSKMS.CreateGrant
* @see AWS API
* Documentation
*/
@Override
public CreateGrantResult createGrant(CreateGrantRequest request) {
request = beforeClientExecution(request);
return executeCreateGrant(request);
}
@SdkInternalApi
final CreateGrantResult executeCreateGrant(CreateGrantRequest createGrantRequest) {
ExecutionContext executionContext = createExecutionContext(createGrantRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateGrantRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createGrantRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateGrant");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateGrantResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a unique customer managed KMS key in your Amazon
* Web Services account and Region. You can use a KMS key in cryptographic operations, such as encryption and
* signing. Some Amazon Web Services services let you use KMS keys that you create and manage to protect your
* service resources.
*
*
* A KMS key is a logical representation of a cryptographic key. In addition to the key material used in
* cryptographic operations, a KMS key includes metadata, such as the key ID, key policy, creation date,
* description, and key state. For details, see Managing keys in the Key
* Management Service Developer Guide
*
*
* Use the parameters of CreateKey to specify the type of KMS key, the source of its key material, its
* key policy, description, tags, and other properties.
*
*
*
* KMS has replaced the term customer master key (CMK) with KMS key and KMS key. The concept
* has not changed. To prevent breaking changes, KMS is keeping some variations of this term.
*
*
*
* To create different types of KMS keys, use the following guidance:
*
*
* - Symmetric encryption KMS key
* -
*
* By default, CreateKey creates a symmetric encryption KMS key with key material that KMS generates.
* This is the basic and most widely used type of KMS key, and provides the best performance.
*
*
* To create a symmetric encryption KMS key, you don't need to specify any parameters. The default value for
* KeySpec, SYMMETRIC_DEFAULT, the default value for KeyUsage,
* ENCRYPT_DECRYPT, and the default value for Origin, AWS_KMS, create a
* symmetric encryption KMS key with KMS key material.
*
*
* If you need a key for basic encryption and decryption or you are creating a KMS key to protect your resources in
* an Amazon Web Services service, create a symmetric encryption KMS key. The key material in a symmetric encryption
* key never leaves KMS unencrypted. You can use a symmetric encryption KMS key to encrypt and decrypt data up to
* 4,096 bytes, but they are typically used to generate data keys and data keys pairs. For details, see
* GenerateDataKey and GenerateDataKeyPair.
*
*
*
* - Asymmetric KMS keys
* -
*
* To create an asymmetric KMS key, use the KeySpec parameter to specify the type of key material in
* the KMS key. Then, use the KeyUsage parameter to determine whether the KMS key will be used to
* encrypt and decrypt or sign and verify. You can't change these properties after the KMS key is created.
*
*
* Asymmetric KMS keys contain an RSA key pair, Elliptic Curve (ECC) key pair, or an SM2 key pair (China Regions
* only). The private key in an asymmetric KMS key never leaves KMS unencrypted. However, you can use the
* GetPublicKey operation to download the public key so it can be used outside of KMS. Each KMS key can have
* only one key usage. KMS keys with RSA key pairs can be used to encrypt and decrypt data or sign and verify
* messages (but not both). KMS keys with NIST-recommended ECC key pairs can be used to sign and verify messages or
* derive shared secrets (but not both). KMS keys with ECC_SECG_P256K1 can be used only to sign and
* verify messages. KMS keys with SM2 key pairs (China Regions only) can be used to either encrypt and decrypt data,
* sign and verify messages, or derive shared secrets (you must choose one key usage type). For information about
* asymmetric KMS keys, see Asymmetric KMS keys in
* the Key Management Service Developer Guide.
*
*
*
* - HMAC KMS key
* -
*
* To create an HMAC KMS key, set the KeySpec parameter to a key spec value for HMAC KMS keys. Then set
* the KeyUsage parameter to GENERATE_VERIFY_MAC. You must set the key usage even though
* GENERATE_VERIFY_MAC is the only valid key usage value for HMAC KMS keys. You can't change these
* properties after the KMS key is created.
*
*
* HMAC KMS keys are symmetric keys that never leave KMS unencrypted. You can use HMAC keys to generate
* (GenerateMac) and verify (VerifyMac) HMAC codes for messages up to 4096 bytes.
*
*
*
* - Multi-Region primary keys
* - Imported key material
* -
*
* To create a multi-Region primary key in the local Amazon Web Services Region, use the
* MultiRegion parameter with a value of True. To create a multi-Region replica
* key, that is, a KMS key with the same key ID and key material as a primary key, but in a different Amazon Web
* Services Region, use the ReplicateKey operation. To change a replica key to a primary key, and its primary
* key to a replica key, use the UpdatePrimaryRegion operation.
*
*
* You can create multi-Region KMS keys for all supported KMS key types: symmetric encryption KMS keys, HMAC KMS
* keys, asymmetric encryption KMS keys, and asymmetric signing KMS keys. You can also create multi-Region keys with
* imported key material. However, you can't create multi-Region keys in a custom key store.
*
*
* This operation supports multi-Region keys, an KMS feature that lets you create multiple interoperable KMS
* keys in different Amazon Web Services Regions. Because these KMS keys have the same key ID, key material, and
* other metadata, you can use them interchangeably to encrypt data in one Amazon Web Services Region and decrypt it
* in a different Amazon Web Services Region without re-encrypting the data or making a cross-Region call. For more
* information about multi-Region keys, see Multi-Region keys in
* KMS in the Key Management Service Developer Guide.
*
*
*
* -
*
* To import your own key material into a KMS key, begin by creating a KMS key with no key material. To do this, use
* the Origin parameter of CreateKey with a value of EXTERNAL. Next, use
* GetParametersForImport operation to get a public key and import token. Use the wrapping public key to
* encrypt your key material. Then, use ImportKeyMaterial with your import token to import the key material.
* For step-by-step instructions, see Importing Key Material in
* the Key Management Service Developer Guide .
*
*
* You can import key material into KMS keys of all supported KMS key types: symmetric encryption KMS keys, HMAC KMS
* keys, asymmetric encryption KMS keys, and asymmetric signing KMS keys. You can also create multi-Region keys with
* imported key material. However, you can't import key material into a KMS key in a custom key store.
*
*
* To create a multi-Region primary key with imported key material, use the Origin parameter of
* CreateKey with a value of EXTERNAL and the MultiRegion parameter with a
* value of True. To create replicas of the multi-Region primary key, use the ReplicateKey
* operation. For instructions, see Importing key
* material into multi-Region keys. For more information about multi-Region keys, see Multi-Region keys in
* KMS in the Key Management Service Developer Guide.
*
*
*
* - Custom key store
* -
*
* A custom key
* store lets you protect your Amazon Web Services resources using keys in a backing key store that you own and
* manage. When you request a cryptographic operation with a KMS key in a custom key store, the operation is
* performed in the backing key store using its cryptographic keys.
*
*
* KMS supports CloudHSM key
* stores backed by an CloudHSM cluster and external key stores
* backed by an external key manager outside of Amazon Web Services. When you create a KMS key in an CloudHSM key
* store, KMS generates an encryption key in the CloudHSM cluster and associates it with the KMS key. When you
* create a KMS key in an external key store, you specify an existing encryption key in the external key manager.
*
*
*
* Some external key managers provide a simpler method for creating a KMS key in an external key store. For details,
* see your external key manager documentation.
*
*
*
* Before you create a KMS key in a custom key store, the ConnectionState of the key store must be
* CONNECTED. To connect the custom key store, use the ConnectCustomKeyStore operation. To find
* the ConnectionState, use the DescribeCustomKeyStores operation.
*
*
* To create a KMS key in a custom key store, use the CustomKeyStoreId. Use the default
* KeySpec value, SYMMETRIC_DEFAULT, and the default KeyUsage value,
* ENCRYPT_DECRYPT to create a symmetric encryption key. No other key type is supported in a custom key
* store.
*
*
* To create a KMS key in an CloudHSM key store, use
* the Origin parameter with a value of AWS_CLOUDHSM. The CloudHSM cluster that is
* associated with the custom key store must have at least two active HSMs in different Availability Zones in the
* Amazon Web Services Region.
*
*
* To create a KMS key in an external key store, use
* the Origin parameter with a value of EXTERNAL_KEY_STORE and an XksKeyId
* parameter that identifies an existing external key.
*
*
*
* Some external key managers provide a simpler method for creating a KMS key in an external key store. For details,
* see your external key manager documentation.
*
*
*
*
* Cross-account use: No. You cannot use this operation to create a KMS key in a different Amazon Web
* Services account.
*
*
* Required permissions: kms:CreateKey
* (IAM policy). To use the Tags parameter, kms:TagResource (IAM policy). For examples and information about related permissions, see Allow a user to create KMS keys in the Key Management Service Developer Guide.
*
*
* Related operations:
*
*
* -
*
* DescribeKey
*
*
* -
*
* ListKeys
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param createKeyRequest
* @return Result of the CreateKey operation returned by the service.
* @throws MalformedPolicyDocumentException
* The request was rejected because the specified policy is not syntactically or semantically correct.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws UnsupportedOperationException
* The request was rejected because a specified parameter is not supported or a specified resource is not
* valid for this operation.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws LimitExceededException
* The request was rejected because a quota was exceeded. For more information, see Quotas in the Key
* Management Service Developer Guide.
* @throws TagException
* The request was rejected because one or more tags are not valid.
* @throws CustomKeyStoreNotFoundException
* The request was rejected because KMS cannot find a custom key store with the specified key store name or
* ID.
* @throws CustomKeyStoreInvalidStateException
* The request was rejected because of the ConnectionState of the custom key store. To get the
* ConnectionState of a custom key store, use the DescribeCustomKeyStores operation.
*
* This exception is thrown under the following conditions:
*
*
* -
*
* You requested the ConnectCustomKeyStore operation on a custom key store with a
* ConnectionState of DISCONNECTING or FAILED. This operation is
* valid for all other ConnectionState values. To reconnect a custom key store in a
* FAILED state, disconnect it (DisconnectCustomKeyStore), then connect it (
* ConnectCustomKeyStore).
*
*
* -
*
* You requested the CreateKey operation in a custom key store that is not connected. This operations
* is valid only when the custom key store ConnectionState is CONNECTED.
*
*
* -
*
* You requested the DisconnectCustomKeyStore operation on a custom key store with a
* ConnectionState of DISCONNECTING or DISCONNECTED. This operation
* is valid for all other ConnectionState values.
*
*
* -
*
* You requested the UpdateCustomKeyStore or DeleteCustomKeyStore operation on a custom key
* store that is not disconnected. This operation is valid only when the custom key store
* ConnectionState is DISCONNECTED.
*
*
* -
*
* You requested the GenerateRandom operation in an CloudHSM key store that is not connected. This
* operation is valid only when the CloudHSM key store ConnectionState is
* CONNECTED.
*
*
* @throws CloudHsmClusterInvalidConfigurationException
* The request was rejected because the associated CloudHSM cluster did not meet the configuration
* requirements for an CloudHSM key store.
*
* -
*
* The CloudHSM cluster must be configured with private subnets in at least two different Availability Zones
* in the Region.
*
*
* -
*
* The security group for
* the cluster (cloudhsm-cluster-<cluster-id>-sg) must include inbound rules and outbound
* rules that allow TCP traffic on ports 2223-2225. The Source in the inbound rules and the
* Destination in the outbound rules must match the security group ID. These rules are set by default
* when you create the CloudHSM cluster. Do not delete or change them. To get information about a particular
* security group, use the DescribeSecurityGroups operation.
*
*
* -
*
* The CloudHSM cluster must contain at least as many HSMs as the operation requires. To add HSMs, use the
* CloudHSM CreateHsm
* operation.
*
*
* For the CreateCustomKeyStore, UpdateCustomKeyStore, and CreateKey operations, the
* CloudHSM cluster must have at least two active HSMs, each in a different Availability Zone. For the
* ConnectCustomKeyStore operation, the CloudHSM must contain at least one active HSM.
*
*
*
*
* For information about the requirements for an CloudHSM cluster that is associated with an CloudHSM key
* store, see Assemble the Prerequisites in the Key Management Service Developer Guide. For information
* about creating a private subnet for an CloudHSM cluster, see Create a Private
* Subnet in the CloudHSM User Guide. For information about cluster security groups, see Configure a Default
* Security Group in the CloudHSM User Guide .
* @throws XksKeyInvalidConfigurationException
* The request was rejected because the external key specified by the XksKeyId parameter did
* not meet the configuration requirements for an external key store.
*
*
* The external key must be an AES-256 symmetric key that is enabled and performs encryption and decryption.
* @throws XksKeyAlreadyInUseException
* The request was rejected because the (XksKeyId) is already associated with another KMS key
* in this external key store. Each KMS key in an external key store must be associated with a different
* external key.
* @throws XksKeyNotFoundException
* The request was rejected because the external key store proxy could not find the external key. This
* exception is thrown when the value of the XksKeyId parameter doesn't identify a key in the
* external key manager associated with the external key proxy.
*
*
* Verify that the XksKeyId represents an existing key in the external key manager. Use the key
* identifier that the external key store proxy uses to identify the key. For details, see the documentation
* provided with your external key store proxy or key manager.
* @sample AWSKMS.CreateKey
* @see AWS API
* Documentation
*/
@Override
public CreateKeyResult createKey(CreateKeyRequest request) {
request = beforeClientExecution(request);
return executeCreateKey(request);
}
@SdkInternalApi
final CreateKeyResult executeCreateKey(CreateKeyRequest createKeyRequest) {
ExecutionContext executionContext = createExecutionContext(createKeyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateKeyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createKeyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateKey");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateKeyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public CreateKeyResult createKey() {
return createKey(new CreateKeyRequest());
}
/**
*
* Decrypts ciphertext that was encrypted by a KMS key using any of the following operations:
*
*
* -
*
* Encrypt
*
*
* -
*
* GenerateDataKey
*
*
* -
*
*
* -
*
*
* -
*
*
*
*
* You can use this operation to decrypt ciphertext that was encrypted under a symmetric encryption KMS key or an
* asymmetric encryption KMS key. When the KMS key is asymmetric, you must specify the KMS key and the encryption
* algorithm that was used to encrypt the ciphertext. For information about asymmetric KMS keys, see Asymmetric KMS keys in
* the Key Management Service Developer Guide.
*
*
* The Decrypt operation also decrypts ciphertext that was encrypted outside of KMS by the public key
* in an KMS asymmetric KMS key. However, it cannot decrypt symmetric ciphertext produced by other libraries, such
* as the Amazon Web Services
* Encryption SDK or Amazon S3 client-side
* encryption. These libraries return a ciphertext format that is incompatible with KMS.
*
*
* If the ciphertext was encrypted under a symmetric encryption KMS key, the KeyId parameter is
* optional. KMS can get this information from metadata that it adds to the symmetric ciphertext blob. This feature
* adds durability to your implementation by ensuring that authorized users can decrypt ciphertext decades after it
* was encrypted, even if they've lost track of the key ID. However, specifying the KMS key is always recommended as
* a best practice. When you use the KeyId parameter to specify a KMS key, KMS only uses the KMS key
* you specify. If the ciphertext was encrypted under a different KMS key, the Decrypt operation fails.
* This practice ensures that you use the KMS key that you intend.
*
*
* Whenever possible, use key policies to give users permission to call the Decrypt operation on a
* particular KMS key, instead of using &IAM; policies. Otherwise, you might create an &IAM; policy that
* gives the user Decrypt permission on all KMS keys. This user could decrypt ciphertext that was
* encrypted by KMS keys in other accounts if the key policy for the cross-account KMS key permits it. If you must
* use an IAM policy for Decrypt permissions, limit the user to particular KMS keys or particular
* trusted accounts. For details, see Best
* practices for IAM policies in the Key Management Service Developer Guide.
*
*
* Decrypt also supports Amazon Web Services Nitro
* Enclaves, which provide an isolated compute environment in Amazon EC2. To call Decrypt for a
* Nitro enclave, use the Amazon Web Services
* Nitro Enclaves SDK or any Amazon Web Services SDK. Use the Recipient parameter to provide the
* attestation document for the enclave. Instead of the plaintext data, the response includes the plaintext data
* encrypted with the public key from the attestation document (CiphertextForRecipient). For
* information about the interaction between KMS and Amazon Web Services Nitro Enclaves, see How Amazon Web Services
* Nitro Enclaves uses KMS in the Key Management Service Developer Guide.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: Yes. If you use the KeyId parameter to identify a KMS key in a different
* Amazon Web Services account, specify the key ARN or the alias ARN of the KMS key.
*
*
* Required permissions: kms:Decrypt
* (key policy)
*
*
* Related operations:
*
*
* -
*
* Encrypt
*
*
* -
*
* GenerateDataKey
*
*
* -
*
*
* -
*
* ReEncrypt
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param decryptRequest
* @return Result of the Decrypt operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws InvalidCiphertextException
* From the Decrypt or ReEncrypt operation, the request was rejected because the specified
* ciphertext, or additional authenticated data incorporated into the ciphertext, such as the encryption
* context, is corrupted, missing, or otherwise invalid.
*
* From the ImportKeyMaterial operation, the request was rejected because KMS could not decrypt the
* encrypted (wrapped) key material.
* @throws KeyUnavailableException
* The request was rejected because the specified KMS key was not available. You can retry the request.
* @throws IncorrectKeyException
* The request was rejected because the specified KMS key cannot decrypt the data. The KeyId in
* a Decrypt request and the SourceKeyId in a ReEncrypt request must identify the
* same KMS key that was used to encrypt the ciphertext.
* @throws InvalidKeyUsageException
* The request was rejected for one of the following reasons:
*
*
* -
*
* The KeyUsage value of the KMS key is incompatible with the API operation.
*
*
* -
*
* The encryption algorithm or signing algorithm specified for the operation is incompatible with the type
* of key material in the KMS key (KeySpec).
*
*
*
*
* For encrypting, decrypting, re-encrypting, and generating data keys, the KeyUsage must be
* ENCRYPT_DECRYPT. For signing and verifying messages, the KeyUsage must be
* SIGN_VERIFY. For generating and verifying message authentication codes (MACs), the
* KeyUsage must be GENERATE_VERIFY_MAC. For deriving key agreement secrets, the
* KeyUsage must be KEY_AGREEMENT. To find the KeyUsage of a KMS key,
* use the DescribeKey operation.
*
*
* To find the encryption or signing algorithms supported for a particular KMS key, use the
* DescribeKey operation.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws InvalidGrantTokenException
* The request was rejected because the specified grant token is not valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws DryRunOperationException
* The request was rejected because the DryRun parameter was specified.
* @sample AWSKMS.Decrypt
* @see AWS API
* Documentation
*/
@Override
public DecryptResult decrypt(DecryptRequest request) {
request = beforeClientExecution(request);
return executeDecrypt(request);
}
@SdkInternalApi
final DecryptResult executeDecrypt(DecryptRequest decryptRequest) {
ExecutionContext executionContext = createExecutionContext(decryptRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DecryptRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(decryptRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "Decrypt");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new DecryptResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified alias.
*
*
*
* Adding, deleting, or updating an alias can allow or deny permission to the KMS key. For details, see ABAC for KMS in the Key Management
* Service Developer Guide.
*
*
*
* Because an alias is not a property of a KMS key, you can delete and change the aliases of a KMS key without
* affecting the KMS key. Also, aliases do not appear in the response from the DescribeKey operation. To get
* the aliases of all KMS keys, use the ListAliases operation.
*
*
* Each KMS key can have multiple aliases. To change the alias of a KMS key, use DeleteAlias to delete the
* current alias and CreateAlias to create a new alias. To associate an existing alias with a different KMS
* key, call UpdateAlias.
*
*
* Cross-account use: No. You cannot perform this operation on an alias in a different Amazon Web Services
* account.
*
*
* Required permissions
*
*
* -
*
* kms:DeleteAlias
* on the alias (IAM policy).
*
*
* -
*
* kms:DeleteAlias
* on the KMS key (key policy).
*
*
*
*
* For details, see Controlling access to
* aliases in the Key Management Service Developer Guide.
*
*
* Related operations:
*
*
* -
*
* CreateAlias
*
*
* -
*
* ListAliases
*
*
* -
*
* UpdateAlias
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param deleteAliasRequest
* @return Result of the DeleteAlias operation returned by the service.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @sample AWSKMS.DeleteAlias
* @see AWS API
* Documentation
*/
@Override
public DeleteAliasResult deleteAlias(DeleteAliasRequest request) {
request = beforeClientExecution(request);
return executeDeleteAlias(request);
}
@SdkInternalApi
final DeleteAliasResult executeDeleteAlias(DeleteAliasRequest deleteAliasRequest) {
ExecutionContext executionContext = createExecutionContext(deleteAliasRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteAliasRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteAliasRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteAlias");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteAliasResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a custom
* key store. This operation does not affect any backing elements of the custom key store. It does not delete
* the CloudHSM cluster that is associated with an CloudHSM key store, or affect any users or keys in the cluster.
* For an external key store, it does not affect the external key store proxy, external key manager, or any external
* keys.
*
*
* This operation is part of the custom key stores
* feature in KMS, which combines the convenience and extensive integration of KMS with the isolation and control of
* a key store that you own and manage.
*
*
* The custom key store that you delete cannot contain any KMS keys. Before deleting
* the key store, verify that you will never need to use any of the KMS keys in the key store for any cryptographic
* operations. Then, use ScheduleKeyDeletion to delete the KMS keys from the key store. After the
* required waiting period expires and all KMS keys are deleted from the custom key store, use
* DisconnectCustomKeyStore to disconnect the key store from KMS. Then, you can delete the custom key store.
*
*
* For keys in an CloudHSM key store, the ScheduleKeyDeletion operation makes a best effort to delete
* the key material from the associated cluster. However, you might need to manually delete
* the orphaned key material from the cluster and its backups. KMS never creates, manages, or deletes
* cryptographic keys in the external key manager associated with an external key store. You must manage them using
* your external key manager tools.
*
*
* Instead of deleting the custom key store, consider using the DisconnectCustomKeyStore operation to
* disconnect the custom key store from its backing key store. While the key store is disconnected, you cannot
* create or use the KMS keys in the key store. But, you do not need to delete KMS keys and you can reconnect a
* disconnected custom key store at any time.
*
*
* If the operation succeeds, it returns a JSON object with no properties.
*
*
* Cross-account use: No. You cannot perform this operation on a custom key store in a different Amazon Web
* Services account.
*
*
* Required permissions: kms:DeleteCustomKeyStore (IAM policy)
*
*
* Related operations:
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param deleteCustomKeyStoreRequest
* @return Result of the DeleteCustomKeyStore operation returned by the service.
* @throws CustomKeyStoreHasCMKsException
* The request was rejected because the custom key store contains KMS keys. After verifying that you do not
* need to use the KMS keys, use the ScheduleKeyDeletion operation to delete the KMS keys. After they
* are deleted, you can delete the custom key store.
* @throws CustomKeyStoreInvalidStateException
* The request was rejected because of the ConnectionState of the custom key store. To get the
* ConnectionState of a custom key store, use the DescribeCustomKeyStores operation.
*
* This exception is thrown under the following conditions:
*
*
* -
*
* You requested the ConnectCustomKeyStore operation on a custom key store with a
* ConnectionState of DISCONNECTING or FAILED. This operation is
* valid for all other ConnectionState values. To reconnect a custom key store in a
* FAILED state, disconnect it (DisconnectCustomKeyStore), then connect it (
* ConnectCustomKeyStore).
*
*
* -
*
* You requested the CreateKey operation in a custom key store that is not connected. This operations
* is valid only when the custom key store ConnectionState is CONNECTED.
*
*
* -
*
* You requested the DisconnectCustomKeyStore operation on a custom key store with a
* ConnectionState of DISCONNECTING or DISCONNECTED. This operation
* is valid for all other ConnectionState values.
*
*
* -
*
* You requested the UpdateCustomKeyStore or DeleteCustomKeyStore operation on a custom key
* store that is not disconnected. This operation is valid only when the custom key store
* ConnectionState is DISCONNECTED.
*
*
* -
*
* You requested the GenerateRandom operation in an CloudHSM key store that is not connected. This
* operation is valid only when the CloudHSM key store ConnectionState is
* CONNECTED.
*
*
* @throws CustomKeyStoreNotFoundException
* The request was rejected because KMS cannot find a custom key store with the specified key store name or
* ID.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @sample AWSKMS.DeleteCustomKeyStore
* @see AWS API
* Documentation
*/
@Override
public DeleteCustomKeyStoreResult deleteCustomKeyStore(DeleteCustomKeyStoreRequest request) {
request = beforeClientExecution(request);
return executeDeleteCustomKeyStore(request);
}
@SdkInternalApi
final DeleteCustomKeyStoreResult executeDeleteCustomKeyStore(DeleteCustomKeyStoreRequest deleteCustomKeyStoreRequest) {
ExecutionContext executionContext = createExecutionContext(deleteCustomKeyStoreRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteCustomKeyStoreRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteCustomKeyStoreRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteCustomKeyStore");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteCustomKeyStoreResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes key material that was previously imported. This operation makes the specified KMS key temporarily
* unusable. To restore the usability of the KMS key, reimport the same key material. For more information about
* importing key material into KMS, see Importing Key Material in
* the Key Management Service Developer Guide.
*
*
* When the specified KMS key is in the PendingDeletion state, this operation does not change the KMS
* key's state. Otherwise, it changes the KMS key's state to PendingImport.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:DeleteImportedKeyMaterial (key policy)
*
*
* Related operations:
*
*
* -
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param deleteImportedKeyMaterialRequest
* @return Result of the DeleteImportedKeyMaterial operation returned by the service.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws UnsupportedOperationException
* The request was rejected because a specified parameter is not supported or a specified resource is not
* valid for this operation.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @sample AWSKMS.DeleteImportedKeyMaterial
* @see AWS
* API Documentation
*/
@Override
public DeleteImportedKeyMaterialResult deleteImportedKeyMaterial(DeleteImportedKeyMaterialRequest request) {
request = beforeClientExecution(request);
return executeDeleteImportedKeyMaterial(request);
}
@SdkInternalApi
final DeleteImportedKeyMaterialResult executeDeleteImportedKeyMaterial(DeleteImportedKeyMaterialRequest deleteImportedKeyMaterialRequest) {
ExecutionContext executionContext = createExecutionContext(deleteImportedKeyMaterialRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteImportedKeyMaterialRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteImportedKeyMaterialRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteImportedKeyMaterial");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteImportedKeyMaterialResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Derives a shared secret using a key agreement algorithm.
*
*
*
* You must use an asymmetric NIST-recommended elliptic curve (ECC) or SM2 (China Regions only) KMS key pair with a
* KeyUsage value of KEY_AGREEMENT to call DeriveSharedSecret.
*
*
*
* DeriveSharedSecret uses the Elliptic Curve
* Cryptography Cofactor Diffie-Hellman Primitive (ECDH) to establish a key agreement between two peers by
* deriving a shared secret from their elliptic curve public-private key pairs. You can use the raw shared secret
* that DeriveSharedSecret returns to derive a symmetric key that can encrypt and decrypt data that is sent between
* the two peers, or that can generate and verify HMACs. KMS recommends that you follow NIST recommendations for key
* derivation when using the raw shared secret to derive a symmetric key.
*
*
* The following workflow demonstrates how to establish key agreement over an insecure communication channel using
* DeriveSharedSecret.
*
*
* -
*
* Alice calls CreateKey to create an asymmetric KMS key pair with a KeyUsage value of
* KEY_AGREEMENT.
*
*
* The asymmetric KMS key must use a NIST-recommended elliptic curve (ECC) or SM2 (China Regions only) key spec.
*
*
* -
*
* Bob creates an elliptic curve key pair.
*
*
* Bob can call CreateKey to create an asymmetric KMS key pair or generate a key pair outside of KMS. Bob's
* key pair must use the same NIST-recommended elliptic curve (ECC) or SM2 (China Regions ony) curve as Alice.
*
*
* -
*
* Alice and Bob exchange their public keys through an insecure communication channel (like the internet).
*
*
* Use GetPublicKey to download the public key of your asymmetric KMS key pair.
*
*
*
* KMS strongly recommends verifying that the public key you receive came from the expected party before using it to
* derive a shared secret.
*
*
* -
*
* Alice calls DeriveSharedSecret.
*
*
* KMS uses the private key from the KMS key pair generated in Step 1, Bob's public key, and the Elliptic
* Curve Cryptography Cofactor Diffie-Hellman Primitive to derive the shared secret. The private key in your KMS key
* pair never leaves KMS unencrypted. DeriveSharedSecret returns the raw shared secret.
*
*
* -
*
* Bob uses the Elliptic Curve Cryptography Cofactor Diffie-Hellman Primitive to calculate the same raw
* secret using his private key and Alice's public key.
*
*
*
*
* To derive a shared secret you must provide a key agreement algorithm, the private key of the caller's asymmetric
* NIST-recommended elliptic curve or SM2 (China Regions only) KMS key pair, and the public key from your peer's
* NIST-recommended elliptic curve or SM2 (China Regions only) key pair. The public key can be from another
* asymmetric KMS key pair or from a key pair generated outside of KMS, but both key pairs must be on the same
* elliptic curve.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: Yes. To perform this operation with a KMS key in a different Amazon Web Services
* account, specify the key ARN or alias ARN in the value of the KeyId parameter.
*
*
* Required permissions: kms:DeriveSharedSecret (key policy)
*
*
* Related operations:
*
*
* -
*
* CreateKey
*
*
* -
*
* GetPublicKey
*
*
* -
*
* DescribeKey
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param deriveSharedSecretRequest
* @return Result of the DeriveSharedSecret operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws KeyUnavailableException
* The request was rejected because the specified KMS key was not available. You can retry the request.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws InvalidGrantTokenException
* The request was rejected because the specified grant token is not valid.
* @throws InvalidKeyUsageException
* The request was rejected for one of the following reasons:
*
* -
*
* The KeyUsage value of the KMS key is incompatible with the API operation.
*
*
* -
*
* The encryption algorithm or signing algorithm specified for the operation is incompatible with the type
* of key material in the KMS key (KeySpec).
*
*
*
*
* For encrypting, decrypting, re-encrypting, and generating data keys, the KeyUsage must be
* ENCRYPT_DECRYPT. For signing and verifying messages, the KeyUsage must be
* SIGN_VERIFY. For generating and verifying message authentication codes (MACs), the
* KeyUsage must be GENERATE_VERIFY_MAC. For deriving key agreement secrets, the
* KeyUsage must be KEY_AGREEMENT. To find the KeyUsage of a KMS key,
* use the DescribeKey operation.
*
*
* To find the encryption or signing algorithms supported for a particular KMS key, use the
* DescribeKey operation.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws DryRunOperationException
* The request was rejected because the DryRun parameter was specified.
* @sample AWSKMS.DeriveSharedSecret
* @see AWS API
* Documentation
*/
@Override
public DeriveSharedSecretResult deriveSharedSecret(DeriveSharedSecretRequest request) {
request = beforeClientExecution(request);
return executeDeriveSharedSecret(request);
}
@SdkInternalApi
final DeriveSharedSecretResult executeDeriveSharedSecret(DeriveSharedSecretRequest deriveSharedSecretRequest) {
ExecutionContext executionContext = createExecutionContext(deriveSharedSecretRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeriveSharedSecretRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deriveSharedSecretRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeriveSharedSecret");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeriveSharedSecretResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Gets information about custom key stores
* in the account and Region.
*
*
* This operation is part of the custom key stores
* feature in KMS, which combines the convenience and extensive integration of KMS with the isolation and control of
* a key store that you own and manage.
*
*
* By default, this operation returns information about all custom key stores in the account and Region. To get only
* information about a particular custom key store, use either the CustomKeyStoreName or
* CustomKeyStoreId parameter (but not both).
*
*
* To determine whether the custom key store is connected to its CloudHSM cluster or external key store proxy, use
* the ConnectionState element in the response. If an attempt to connect the custom key store failed,
* the ConnectionState value is FAILED and the ConnectionErrorCode element in
* the response indicates the cause of the failure. For help interpreting the ConnectionErrorCode, see
* CustomKeyStoresListEntry.
*
*
* Custom key stores have a DISCONNECTED connection state if the key store has never been connected or
* you used the DisconnectCustomKeyStore operation to disconnect it. Otherwise, the connection state is
* CONNECTED. If your custom key store connection state is CONNECTED but you are having trouble using
* it, verify that the backing store is active and available. For an CloudHSM key store, verify that the associated
* CloudHSM cluster is active and contains the minimum number of HSMs required for the operation, if any. For an
* external key store, verify that the external key store proxy and its associated external key manager are
* reachable and enabled.
*
*
* For help repairing your CloudHSM key store, see the Troubleshooting CloudHSM key
* stores. For help repairing your external key store, see the Troubleshooting external
* key stores. Both topics are in the Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a custom key store in a different Amazon Web
* Services account.
*
*
* Required permissions: kms:DescribeCustomKeyStores (IAM policy)
*
*
* Related operations:
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param describeCustomKeyStoresRequest
* @return Result of the DescribeCustomKeyStores operation returned by the service.
* @throws CustomKeyStoreNotFoundException
* The request was rejected because KMS cannot find a custom key store with the specified key store name or
* ID.
* @throws InvalidMarkerException
* The request was rejected because the marker that specifies where pagination should next begin is not
* valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @sample AWSKMS.DescribeCustomKeyStores
* @see AWS
* API Documentation
*/
@Override
public DescribeCustomKeyStoresResult describeCustomKeyStores(DescribeCustomKeyStoresRequest request) {
request = beforeClientExecution(request);
return executeDescribeCustomKeyStores(request);
}
@SdkInternalApi
final DescribeCustomKeyStoresResult executeDescribeCustomKeyStores(DescribeCustomKeyStoresRequest describeCustomKeyStoresRequest) {
ExecutionContext executionContext = createExecutionContext(describeCustomKeyStoresRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeCustomKeyStoresRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeCustomKeyStoresRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeCustomKeyStores");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeCustomKeyStoresResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Provides detailed information about a KMS key. You can run DescribeKey on a customer managed key
* or an Amazon Web
* Services managed key.
*
*
* This detailed information includes the key ARN, creation date (and deletion date, if applicable), the key state,
* and the origin and expiration date (if any) of the key material. It includes fields, like KeySpec,
* that help you distinguish different types of KMS keys. It also displays the key usage (encryption, signing, or
* generating and verifying MACs) and the algorithms that the KMS key supports.
*
*
* For multi-Region
* keys, DescribeKey displays the primary key and all related replica keys. For KMS keys in CloudHSM key stores, it
* includes information about the key store, such as the key store ID and the CloudHSM cluster ID. For KMS keys in
* external key stores,
* it includes the custom key store ID and the ID of the external key.
*
*
* DescribeKey does not return the following information:
*
*
* -
*
* Aliases associated with the KMS key. To get this information, use ListAliases.
*
*
* -
*
* Whether automatic key rotation is enabled on the KMS key. To get this information, use
* GetKeyRotationStatus. Also, some key states prevent a KMS key from being automatically rotated. For
* details, see How
* Automatic Key Rotation Works in the Key Management Service Developer Guide.
*
*
* -
*
* Tags on the KMS key. To get this information, use ListResourceTags.
*
*
* -
*
* Key policies and grants on the KMS key. To get this information, use GetKeyPolicy and ListGrants.
*
*
*
*
* In general, DescribeKey is a non-mutating operation. It returns data about KMS keys, but doesn't
* change them. However, Amazon Web Services services use DescribeKey to create Amazon Web Services
* managed keys from a predefined Amazon Web Services alias with no key ID.
*
*
* Cross-account use: Yes. To perform this operation with a KMS key in a different Amazon Web Services
* account, specify the key ARN or alias ARN in the value of the KeyId parameter.
*
*
* Required permissions: kms:DescribeKey (key policy)
*
*
* Related operations:
*
*
* -
*
* GetKeyPolicy
*
*
* -
*
*
* -
*
* ListAliases
*
*
* -
*
* ListGrants
*
*
* -
*
* ListKeys
*
*
* -
*
* ListResourceTags
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param describeKeyRequest
* @return Result of the DescribeKey operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @sample AWSKMS.DescribeKey
* @see AWS API
* Documentation
*/
@Override
public DescribeKeyResult describeKey(DescribeKeyRequest request) {
request = beforeClientExecution(request);
return executeDescribeKey(request);
}
@SdkInternalApi
final DescribeKeyResult executeDescribeKey(DescribeKeyRequest describeKeyRequest) {
ExecutionContext executionContext = createExecutionContext(describeKeyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeKeyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeKeyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeKey");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeKeyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Sets the state of a KMS key to disabled. This change temporarily prevents use of the KMS key for cryptographic
* operations.
*
*
* For more information about how key state affects the use of a KMS key, see Key states of KMS keys in the
* Key Management Service Developer Guide .
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:DisableKey (key policy)
*
*
* Related operations: EnableKey
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param disableKeyRequest
* @return Result of the DisableKey operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @sample AWSKMS.DisableKey
* @see AWS API
* Documentation
*/
@Override
public DisableKeyResult disableKey(DisableKeyRequest request) {
request = beforeClientExecution(request);
return executeDisableKey(request);
}
@SdkInternalApi
final DisableKeyResult executeDisableKey(DisableKeyRequest disableKeyRequest) {
ExecutionContext executionContext = createExecutionContext(disableKeyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DisableKeyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(disableKeyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DisableKey");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new DisableKeyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Disables automatic rotation of
* the key material of the specified symmetric encryption KMS key.
*
*
* Automatic key rotation is supported only on symmetric encryption KMS keys. You cannot enable automatic rotation
* of asymmetric KMS
* keys, HMAC KMS keys, KMS keys
* with imported key
* material, or KMS keys in a custom key store.
* To enable or disable automatic rotation of a set of related multi-Region keys, set the property on the primary key.
*
*
* You can enable (EnableKeyRotation) and disable automatic rotation of the key material in customer managed KMS
* keys. Key material rotation of Amazon Web Services
* managed KMS keys is not configurable. KMS always rotates the key material for every year. Rotation of Amazon Web Services
* owned KMS keys varies.
*
*
*
* In May 2022, KMS changed the rotation schedule for Amazon Web Services managed keys from every three years to
* every year. For details, see EnableKeyRotation.
*
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:DisableKeyRotation (key policy)
*
*
* Related operations:
*
*
* -
*
*
* -
*
*
* -
*
* ListKeyRotations
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param disableKeyRotationRequest
* @return Result of the DisableKeyRotation operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws UnsupportedOperationException
* The request was rejected because a specified parameter is not supported or a specified resource is not
* valid for this operation.
* @sample AWSKMS.DisableKeyRotation
* @see AWS API
* Documentation
*/
@Override
public DisableKeyRotationResult disableKeyRotation(DisableKeyRotationRequest request) {
request = beforeClientExecution(request);
return executeDisableKeyRotation(request);
}
@SdkInternalApi
final DisableKeyRotationResult executeDisableKeyRotation(DisableKeyRotationRequest disableKeyRotationRequest) {
ExecutionContext executionContext = createExecutionContext(disableKeyRotationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DisableKeyRotationRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(disableKeyRotationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DisableKeyRotation");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DisableKeyRotationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Disconnects the custom key store
* from its backing key store. This operation disconnects an CloudHSM key store from its associated CloudHSM cluster
* or disconnects an external key store from the external key store proxy that communicates with your external key
* manager.
*
*
* This operation is part of the custom key stores
* feature in KMS, which combines the convenience and extensive integration of KMS with the isolation and control of
* a key store that you own and manage.
*
*
* While a custom key store is disconnected, you can manage the custom key store and its KMS keys, but you cannot
* create or use its KMS keys. You can reconnect the custom key store at any time.
*
*
*
* While a custom key store is disconnected, all attempts to create KMS keys in the custom key store or to use
* existing KMS keys in cryptographic
* operations will fail. This action can prevent users from storing and accessing sensitive data.
*
*
*
* When you disconnect a custom key store, its ConnectionState changes to Disconnected. To
* find the connection state of a custom key store, use the DescribeCustomKeyStores operation. To reconnect a
* custom key store, use the ConnectCustomKeyStore operation.
*
*
* If the operation succeeds, it returns a JSON object with no properties.
*
*
* Cross-account use: No. You cannot perform this operation on a custom key store in a different Amazon Web
* Services account.
*
*
* Required permissions: kms:DisconnectCustomKeyStore (IAM policy)
*
*
* Related operations:
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param disconnectCustomKeyStoreRequest
* @return Result of the DisconnectCustomKeyStore operation returned by the service.
* @throws CustomKeyStoreInvalidStateException
* The request was rejected because of the ConnectionState of the custom key store. To get the
* ConnectionState of a custom key store, use the DescribeCustomKeyStores operation.
*
* This exception is thrown under the following conditions:
*
*
* -
*
* You requested the ConnectCustomKeyStore operation on a custom key store with a
* ConnectionState of DISCONNECTING or FAILED. This operation is
* valid for all other ConnectionState values. To reconnect a custom key store in a
* FAILED state, disconnect it (DisconnectCustomKeyStore), then connect it (
* ConnectCustomKeyStore).
*
*
* -
*
* You requested the CreateKey operation in a custom key store that is not connected. This operations
* is valid only when the custom key store ConnectionState is CONNECTED.
*
*
* -
*
* You requested the DisconnectCustomKeyStore operation on a custom key store with a
* ConnectionState of DISCONNECTING or DISCONNECTED. This operation
* is valid for all other ConnectionState values.
*
*
* -
*
* You requested the UpdateCustomKeyStore or DeleteCustomKeyStore operation on a custom key
* store that is not disconnected. This operation is valid only when the custom key store
* ConnectionState is DISCONNECTED.
*
*
* -
*
* You requested the GenerateRandom operation in an CloudHSM key store that is not connected. This
* operation is valid only when the CloudHSM key store ConnectionState is
* CONNECTED.
*
*
* @throws CustomKeyStoreNotFoundException
* The request was rejected because KMS cannot find a custom key store with the specified key store name or
* ID.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @sample AWSKMS.DisconnectCustomKeyStore
* @see AWS
* API Documentation
*/
@Override
public DisconnectCustomKeyStoreResult disconnectCustomKeyStore(DisconnectCustomKeyStoreRequest request) {
request = beforeClientExecution(request);
return executeDisconnectCustomKeyStore(request);
}
@SdkInternalApi
final DisconnectCustomKeyStoreResult executeDisconnectCustomKeyStore(DisconnectCustomKeyStoreRequest disconnectCustomKeyStoreRequest) {
ExecutionContext executionContext = createExecutionContext(disconnectCustomKeyStoreRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DisconnectCustomKeyStoreRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(disconnectCustomKeyStoreRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DisconnectCustomKeyStore");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DisconnectCustomKeyStoreResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Sets the key state of a KMS key to enabled. This allows you to use the KMS key for cryptographic
* operations.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:EnableKey
* (key policy)
*
*
* Related operations: DisableKey
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param enableKeyRequest
* @return Result of the EnableKey operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws LimitExceededException
* The request was rejected because a quota was exceeded. For more information, see Quotas in the Key
* Management Service Developer Guide.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @sample AWSKMS.EnableKey
* @see AWS API
* Documentation
*/
@Override
public EnableKeyResult enableKey(EnableKeyRequest request) {
request = beforeClientExecution(request);
return executeEnableKey(request);
}
@SdkInternalApi
final EnableKeyResult executeEnableKey(EnableKeyRequest enableKeyRequest) {
ExecutionContext executionContext = createExecutionContext(enableKeyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new EnableKeyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(enableKeyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "EnableKey");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new EnableKeyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Enables automatic rotation of the key material of the specified symmetric encryption KMS key.
*
*
* By default, when you enable automatic rotation of a customer managed KMS
* key, KMS rotates the key material of the KMS key one year (approximately 365 days) from the enable date and
* every year thereafter. You can use the optional RotationPeriodInDays parameter to specify a custom
* rotation period when you enable key rotation, or you can use RotationPeriodInDays to modify the
* rotation period of a key that you previously enabled automatic key rotation on.
*
*
* You can monitor rotation of the key material for your KMS keys in CloudTrail and Amazon CloudWatch. To disable
* rotation of the key material in a customer managed KMS key, use the DisableKeyRotation operation. You can
* use the GetKeyRotationStatus operation to identify any in progress rotations. You can use the
* ListKeyRotations operation to view the details of completed rotations.
*
*
* Automatic key rotation is supported only on symmetric encryption
* KMS keys. You cannot enable automatic rotation of asymmetric KMS keys,
* HMAC KMS keys, KMS keys with imported key material, or
* KMS keys in a custom key store.
* To enable or disable automatic rotation of a set of related multi-Region keys, set the property on the primary key.
*
*
* You cannot enable or disable automatic rotation of Amazon Web Services
* managed KMS keys. KMS always rotates the key material of Amazon Web Services managed keys every year.
* Rotation of Amazon
* Web Services owned KMS keys is managed by the Amazon Web Services service that owns the key.
*
*
*
* In May 2022, KMS changed the rotation schedule for Amazon Web Services managed keys from every three years
* (approximately 1,095 days) to every year (approximately 365 days).
*
*
* New Amazon Web Services managed keys are automatically rotated one year after they are created, and approximately
* every year thereafter.
*
*
* Existing Amazon Web Services managed keys are automatically rotated one year after their most recent rotation,
* and every year thereafter.
*
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:EnableKeyRotation (key policy)
*
*
* Related operations:
*
*
* -
*
*
* -
*
*
* -
*
* ListKeyRotations
*
*
* -
*
*
*
* You can perform on-demand (RotateKeyOnDemand) rotation of the key material in customer managed KMS keys,
* regardless of whether or not automatic key rotation is enabled.
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param enableKeyRotationRequest
* @return Result of the EnableKeyRotation operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws UnsupportedOperationException
* The request was rejected because a specified parameter is not supported or a specified resource is not
* valid for this operation.
* @sample AWSKMS.EnableKeyRotation
* @see AWS API
* Documentation
*/
@Override
public EnableKeyRotationResult enableKeyRotation(EnableKeyRotationRequest request) {
request = beforeClientExecution(request);
return executeEnableKeyRotation(request);
}
@SdkInternalApi
final EnableKeyRotationResult executeEnableKeyRotation(EnableKeyRotationRequest enableKeyRotationRequest) {
ExecutionContext executionContext = createExecutionContext(enableKeyRotationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new EnableKeyRotationRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(enableKeyRotationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "EnableKeyRotation");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new EnableKeyRotationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Encrypts plaintext of up to 4,096 bytes using a KMS key. You can use a symmetric or asymmetric KMS key with a
* KeyUsage of ENCRYPT_DECRYPT.
*
*
* You can use this operation to encrypt small amounts of arbitrary data, such as a personal identifier or database
* password, or other sensitive information. You don't need to use the Encrypt operation to encrypt a
* data key. The GenerateDataKey and GenerateDataKeyPair operations return a plaintext data key and an
* encrypted copy of that data key.
*
*
* If you use a symmetric encryption KMS key, you can use an encryption context to add additional security to your
* encryption operation. If you specify an EncryptionContext when encrypting data, you must specify the
* same encryption context (a case-sensitive exact match) when decrypting the data. Otherwise, the request to
* decrypt fails with an InvalidCiphertextException. For more information, see Encryption Context
* in the Key Management Service Developer Guide.
*
*
* If you specify an asymmetric KMS key, you must also specify the encryption algorithm. The algorithm must be
* compatible with the KMS key spec.
*
*
*
* When you use an asymmetric KMS key to encrypt or reencrypt data, be sure to record the KMS key and encryption
* algorithm that you choose. You will be required to provide the same KMS key and encryption algorithm when you
* decrypt the data. If the KMS key and algorithm do not match the values used to encrypt the data, the decrypt
* operation fails.
*
*
* You are not required to supply the key ID and encryption algorithm when you decrypt with symmetric encryption KMS
* keys because KMS stores this information in the ciphertext blob. KMS cannot store metadata in ciphertext
* generated with asymmetric keys. The standard format for asymmetric key ciphertext does not include configurable
* fields.
*
*
*
* The maximum size of the data that you can encrypt varies with the type of KMS key and the encryption algorithm
* that you choose.
*
*
* -
*
* Symmetric encryption KMS keys
*
*
* -
*
* SYMMETRIC_DEFAULT: 4096 bytes
*
*
*
*
* -
*
* RSA_2048
*
*
* -
*
* RSAES_OAEP_SHA_1: 214 bytes
*
*
* -
*
* RSAES_OAEP_SHA_256: 190 bytes
*
*
*
*
* -
*
* RSA_3072
*
*
* -
*
* RSAES_OAEP_SHA_1: 342 bytes
*
*
* -
*
* RSAES_OAEP_SHA_256: 318 bytes
*
*
*
*
* -
*
* RSA_4096
*
*
* -
*
* RSAES_OAEP_SHA_1: 470 bytes
*
*
* -
*
* RSAES_OAEP_SHA_256: 446 bytes
*
*
*
*
* -
*
* SM2PKE: 1024 bytes (China Regions only)
*
*
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: Yes. To perform this operation with a KMS key in a different Amazon Web Services
* account, specify the key ARN or alias ARN in the value of the KeyId parameter.
*
*
* Required permissions: kms:Encrypt
* (key policy)
*
*
* Related operations:
*
*
* -
*
* Decrypt
*
*
* -
*
* GenerateDataKey
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param encryptRequest
* @return Result of the Encrypt operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws KeyUnavailableException
* The request was rejected because the specified KMS key was not available. You can retry the request.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws InvalidKeyUsageException
* The request was rejected for one of the following reasons:
*
* -
*
* The KeyUsage value of the KMS key is incompatible with the API operation.
*
*
* -
*
* The encryption algorithm or signing algorithm specified for the operation is incompatible with the type
* of key material in the KMS key (KeySpec).
*
*
*
*
* For encrypting, decrypting, re-encrypting, and generating data keys, the KeyUsage must be
* ENCRYPT_DECRYPT. For signing and verifying messages, the KeyUsage must be
* SIGN_VERIFY. For generating and verifying message authentication codes (MACs), the
* KeyUsage must be GENERATE_VERIFY_MAC. For deriving key agreement secrets, the
* KeyUsage must be KEY_AGREEMENT. To find the KeyUsage of a KMS key,
* use the DescribeKey operation.
*
*
* To find the encryption or signing algorithms supported for a particular KMS key, use the
* DescribeKey operation.
* @throws InvalidGrantTokenException
* The request was rejected because the specified grant token is not valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws DryRunOperationException
* The request was rejected because the DryRun parameter was specified.
* @sample AWSKMS.Encrypt
* @see AWS API
* Documentation
*/
@Override
public EncryptResult encrypt(EncryptRequest request) {
request = beforeClientExecution(request);
return executeEncrypt(request);
}
@SdkInternalApi
final EncryptResult executeEncrypt(EncryptRequest encryptRequest) {
ExecutionContext executionContext = createExecutionContext(encryptRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new EncryptRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(encryptRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "Encrypt");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new EncryptResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a unique symmetric data key for use outside of KMS. This operation returns a plaintext copy of the data
* key and a copy that is encrypted under a symmetric encryption KMS key that you specify. The bytes in the
* plaintext key are random; they are not related to the caller or the KMS key. You can use the plaintext key to
* encrypt your data outside of KMS and store the encrypted data key with the encrypted data.
*
*
* To generate a data key, specify the symmetric encryption KMS key that will be used to encrypt the data key. You
* cannot use an asymmetric KMS key to encrypt data keys. To get the type of your KMS key, use the
* DescribeKey operation.
*
*
* You must also specify the length of the data key. Use either the KeySpec or
* NumberOfBytes parameters (but not both). For 128-bit and 256-bit data keys, use the
* KeySpec parameter.
*
*
* To generate a 128-bit SM4 data key (China Regions only), specify a KeySpec value of
* AES_128 or a NumberOfBytes value of 16. The symmetric encryption key used
* in China Regions to encrypt your data key is an SM4 encryption key.
*
*
* To get only an encrypted copy of the data key, use GenerateDataKeyWithoutPlaintext. To generate an
* asymmetric data key pair, use the GenerateDataKeyPair or GenerateDataKeyPairWithoutPlaintext
* operation. To get a cryptographically secure random byte string, use GenerateRandom.
*
*
* You can use an optional encryption context to add additional security to the encryption operation. If you specify
* an EncryptionContext, you must specify the same encryption context (a case-sensitive exact match)
* when decrypting the encrypted data key. Otherwise, the request to decrypt fails with an
* InvalidCiphertextException. For more information, see Encryption Context
* in the Key Management Service Developer Guide.
*
*
* GenerateDataKey also supports Amazon Web Services Nitro
* Enclaves, which provide an isolated compute environment in Amazon EC2. To call GenerateDataKey
* for an Amazon Web Services Nitro enclave, use the Amazon Web Services
* Nitro Enclaves SDK or any Amazon Web Services SDK. Use the Recipient parameter to provide the
* attestation document for the enclave. GenerateDataKey returns a copy of the data key encrypted under
* the specified KMS key, as usual. But instead of a plaintext copy of the data key, the response includes a copy of
* the data key encrypted under the public key from the attestation document (CiphertextForRecipient).
* For information about the interaction between KMS and Amazon Web Services Nitro Enclaves, see How Amazon Web Services
* Nitro Enclaves uses KMS in the Key Management Service Developer Guide..
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* How to use your data key
*
*
* We recommend that you use the following pattern to encrypt data locally in your application. You can write your
* own code or use a client-side encryption library, such as the Amazon Web Services Encryption SDK,
* the Amazon DynamoDB Encryption
* Client, or Amazon S3
* client-side encryption to do these tasks for you.
*
*
* To encrypt data outside of KMS:
*
*
* -
*
* Use the GenerateDataKey operation to get a data key.
*
*
* -
*
* Use the plaintext data key (in the Plaintext field of the response) to encrypt your data outside of
* KMS. Then erase the plaintext data key from memory.
*
*
* -
*
* Store the encrypted data key (in the CiphertextBlob field of the response) with the encrypted data.
*
*
*
*
* To decrypt data outside of KMS:
*
*
* -
*
* Use the Decrypt operation to decrypt the encrypted data key. The operation returns a plaintext copy of the
* data key.
*
*
* -
*
* Use the plaintext data key to decrypt data outside of KMS, then erase the plaintext data key from memory.
*
*
*
*
* Cross-account use: Yes. To perform this operation with a KMS key in a different Amazon Web Services
* account, specify the key ARN or alias ARN in the value of the KeyId parameter.
*
*
* Required permissions: kms:GenerateDataKey (key policy)
*
*
* Related operations:
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param generateDataKeyRequest
* @return Result of the GenerateDataKey operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws KeyUnavailableException
* The request was rejected because the specified KMS key was not available. You can retry the request.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws InvalidKeyUsageException
* The request was rejected for one of the following reasons:
*
* -
*
* The KeyUsage value of the KMS key is incompatible with the API operation.
*
*
* -
*
* The encryption algorithm or signing algorithm specified for the operation is incompatible with the type
* of key material in the KMS key (KeySpec).
*
*
*
*
* For encrypting, decrypting, re-encrypting, and generating data keys, the KeyUsage must be
* ENCRYPT_DECRYPT. For signing and verifying messages, the KeyUsage must be
* SIGN_VERIFY. For generating and verifying message authentication codes (MACs), the
* KeyUsage must be GENERATE_VERIFY_MAC. For deriving key agreement secrets, the
* KeyUsage must be KEY_AGREEMENT. To find the KeyUsage of a KMS key,
* use the DescribeKey operation.
*
*
* To find the encryption or signing algorithms supported for a particular KMS key, use the
* DescribeKey operation.
* @throws InvalidGrantTokenException
* The request was rejected because the specified grant token is not valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws DryRunOperationException
* The request was rejected because the DryRun parameter was specified.
* @sample AWSKMS.GenerateDataKey
* @see AWS API
* Documentation
*/
@Override
public GenerateDataKeyResult generateDataKey(GenerateDataKeyRequest request) {
request = beforeClientExecution(request);
return executeGenerateDataKey(request);
}
@SdkInternalApi
final GenerateDataKeyResult executeGenerateDataKey(GenerateDataKeyRequest generateDataKeyRequest) {
ExecutionContext executionContext = createExecutionContext(generateDataKeyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GenerateDataKeyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(generateDataKeyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GenerateDataKey");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GenerateDataKeyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a unique asymmetric data key pair for use outside of KMS. This operation returns a plaintext public key,
* a plaintext private key, and a copy of the private key that is encrypted under the symmetric encryption KMS key
* you specify. You can use the data key pair to perform asymmetric cryptography and implement digital signatures
* outside of KMS. The bytes in the keys are random; they are not related to the caller or to the KMS key that is
* used to encrypt the private key.
*
*
* You can use the public key that GenerateDataKeyPair returns to encrypt data or verify a signature
* outside of KMS. Then, store the encrypted private key with the data. When you are ready to decrypt data or sign a
* message, you can use the Decrypt operation to decrypt the encrypted private key.
*
*
* To generate a data key pair, you must specify a symmetric encryption KMS key to encrypt the private key in a data
* key pair. You cannot use an asymmetric KMS key or a KMS key in a custom key store. To get the type and origin of
* your KMS key, use the DescribeKey operation.
*
*
* Use the KeyPairSpec parameter to choose an RSA or Elliptic Curve (ECC) data key pair. In China
* Regions, you can also choose an SM2 data key pair. KMS recommends that you use ECC key pairs for signing, and use
* RSA and SM2 key pairs for either encryption or signing, but not both. However, KMS cannot enforce any
* restrictions on the use of data key pairs outside of KMS.
*
*
* If you are using the data key pair to encrypt data, or for any operation where you don't immediately need a
* private key, consider using the GenerateDataKeyPairWithoutPlaintext operation.
* GenerateDataKeyPairWithoutPlaintext returns a plaintext public key and an encrypted private key, but
* omits the plaintext private key that you need only to decrypt ciphertext or sign a message. Later, when you need
* to decrypt the data or sign a message, use the Decrypt operation to decrypt the encrypted private key in
* the data key pair.
*
*
* GenerateDataKeyPair returns a unique data key pair for each request. The bytes in the keys are
* random; they are not related to the caller or the KMS key that is used to encrypt the private key. The public key
* is a DER-encoded X.509 SubjectPublicKeyInfo, as specified in RFC
* 5280. The private key is a DER-encoded PKCS8 PrivateKeyInfo, as specified in RFC 5958.
*
*
* GenerateDataKeyPair also supports Amazon Web Services Nitro
* Enclaves, which provide an isolated compute environment in Amazon EC2. To call
* GenerateDataKeyPair for an Amazon Web Services Nitro enclave, use the Amazon Web Services
* Nitro Enclaves SDK or any Amazon Web Services SDK. Use the Recipient parameter to provide the
* attestation document for the enclave. GenerateDataKeyPair returns the public data key and a copy of
* the private data key encrypted under the specified KMS key, as usual. But instead of a plaintext copy of the
* private data key (PrivateKeyPlaintext), the response includes a copy of the private data key
* encrypted under the public key from the attestation document (CiphertextForRecipient). For
* information about the interaction between KMS and Amazon Web Services Nitro Enclaves, see How Amazon Web Services
* Nitro Enclaves uses KMS in the Key Management Service Developer Guide..
*
*
* You can use an optional encryption context to add additional security to the encryption operation. If you specify
* an EncryptionContext, you must specify the same encryption context (a case-sensitive exact match)
* when decrypting the encrypted data key. Otherwise, the request to decrypt fails with an
* InvalidCiphertextException. For more information, see Encryption Context
* in the Key Management Service Developer Guide.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: Yes. To perform this operation with a KMS key in a different Amazon Web Services
* account, specify the key ARN or alias ARN in the value of the KeyId parameter.
*
*
* Required permissions: kms:GenerateDataKeyPair (key policy)
*
*
* Related operations:
*
*
* -
*
* Decrypt
*
*
* -
*
* Encrypt
*
*
* -
*
* GenerateDataKey
*
*
* -
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param generateDataKeyPairRequest
* @return Result of the GenerateDataKeyPair operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws KeyUnavailableException
* The request was rejected because the specified KMS key was not available. You can retry the request.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws InvalidKeyUsageException
* The request was rejected for one of the following reasons:
*
* -
*
* The KeyUsage value of the KMS key is incompatible with the API operation.
*
*
* -
*
* The encryption algorithm or signing algorithm specified for the operation is incompatible with the type
* of key material in the KMS key (KeySpec).
*
*
*
*
* For encrypting, decrypting, re-encrypting, and generating data keys, the KeyUsage must be
* ENCRYPT_DECRYPT. For signing and verifying messages, the KeyUsage must be
* SIGN_VERIFY. For generating and verifying message authentication codes (MACs), the
* KeyUsage must be GENERATE_VERIFY_MAC. For deriving key agreement secrets, the
* KeyUsage must be KEY_AGREEMENT. To find the KeyUsage of a KMS key,
* use the DescribeKey operation.
*
*
* To find the encryption or signing algorithms supported for a particular KMS key, use the
* DescribeKey operation.
* @throws InvalidGrantTokenException
* The request was rejected because the specified grant token is not valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws UnsupportedOperationException
* The request was rejected because a specified parameter is not supported or a specified resource is not
* valid for this operation.
* @throws DryRunOperationException
* The request was rejected because the DryRun parameter was specified.
* @sample AWSKMS.GenerateDataKeyPair
* @see AWS API
* Documentation
*/
@Override
public GenerateDataKeyPairResult generateDataKeyPair(GenerateDataKeyPairRequest request) {
request = beforeClientExecution(request);
return executeGenerateDataKeyPair(request);
}
@SdkInternalApi
final GenerateDataKeyPairResult executeGenerateDataKeyPair(GenerateDataKeyPairRequest generateDataKeyPairRequest) {
ExecutionContext executionContext = createExecutionContext(generateDataKeyPairRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GenerateDataKeyPairRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(generateDataKeyPairRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GenerateDataKeyPair");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GenerateDataKeyPairResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a unique asymmetric data key pair for use outside of KMS. This operation returns a plaintext public key
* and a copy of the private key that is encrypted under the symmetric encryption KMS key you specify. Unlike
* GenerateDataKeyPair, this operation does not return a plaintext private key. The bytes in the keys are
* random; they are not related to the caller or to the KMS key that is used to encrypt the private key.
*
*
* You can use the public key that GenerateDataKeyPairWithoutPlaintext returns to encrypt data or
* verify a signature outside of KMS. Then, store the encrypted private key with the data. When you are ready to
* decrypt data or sign a message, you can use the Decrypt operation to decrypt the encrypted private key.
*
*
* To generate a data key pair, you must specify a symmetric encryption KMS key to encrypt the private key in a data
* key pair. You cannot use an asymmetric KMS key or a KMS key in a custom key store. To get the type and origin of
* your KMS key, use the DescribeKey operation.
*
*
* Use the KeyPairSpec parameter to choose an RSA or Elliptic Curve (ECC) data key pair. In China
* Regions, you can also choose an SM2 data key pair. KMS recommends that you use ECC key pairs for signing, and use
* RSA and SM2 key pairs for either encryption or signing, but not both. However, KMS cannot enforce any
* restrictions on the use of data key pairs outside of KMS.
*
*
* GenerateDataKeyPairWithoutPlaintext returns a unique data key pair for each request. The bytes in
* the key are not related to the caller or KMS key that is used to encrypt the private key. The public key is a
* DER-encoded X.509 SubjectPublicKeyInfo, as specified in RFC
* 5280.
*
*
* You can use an optional encryption context to add additional security to the encryption operation. If you specify
* an EncryptionContext, you must specify the same encryption context (a case-sensitive exact match)
* when decrypting the encrypted data key. Otherwise, the request to decrypt fails with an
* InvalidCiphertextException. For more information, see Encryption Context
* in the Key Management Service Developer Guide.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: Yes. To perform this operation with a KMS key in a different Amazon Web Services
* account, specify the key ARN or alias ARN in the value of the KeyId parameter.
*
*
* Required permissions: kms:GenerateDataKeyPairWithoutPlaintext (key policy)
*
*
* Related operations:
*
*
* -
*
* Decrypt
*
*
* -
*
* Encrypt
*
*
* -
*
* GenerateDataKey
*
*
* -
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param generateDataKeyPairWithoutPlaintextRequest
* @return Result of the GenerateDataKeyPairWithoutPlaintext operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws KeyUnavailableException
* The request was rejected because the specified KMS key was not available. You can retry the request.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws InvalidKeyUsageException
* The request was rejected for one of the following reasons:
*
* -
*
* The KeyUsage value of the KMS key is incompatible with the API operation.
*
*
* -
*
* The encryption algorithm or signing algorithm specified for the operation is incompatible with the type
* of key material in the KMS key (KeySpec).
*
*
*
*
* For encrypting, decrypting, re-encrypting, and generating data keys, the KeyUsage must be
* ENCRYPT_DECRYPT. For signing and verifying messages, the KeyUsage must be
* SIGN_VERIFY. For generating and verifying message authentication codes (MACs), the
* KeyUsage must be GENERATE_VERIFY_MAC. For deriving key agreement secrets, the
* KeyUsage must be KEY_AGREEMENT. To find the KeyUsage of a KMS key,
* use the DescribeKey operation.
*
*
* To find the encryption or signing algorithms supported for a particular KMS key, use the
* DescribeKey operation.
* @throws InvalidGrantTokenException
* The request was rejected because the specified grant token is not valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws UnsupportedOperationException
* The request was rejected because a specified parameter is not supported or a specified resource is not
* valid for this operation.
* @throws DryRunOperationException
* The request was rejected because the DryRun parameter was specified.
* @sample AWSKMS.GenerateDataKeyPairWithoutPlaintext
* @see AWS API Documentation
*/
@Override
public GenerateDataKeyPairWithoutPlaintextResult generateDataKeyPairWithoutPlaintext(GenerateDataKeyPairWithoutPlaintextRequest request) {
request = beforeClientExecution(request);
return executeGenerateDataKeyPairWithoutPlaintext(request);
}
@SdkInternalApi
final GenerateDataKeyPairWithoutPlaintextResult executeGenerateDataKeyPairWithoutPlaintext(
GenerateDataKeyPairWithoutPlaintextRequest generateDataKeyPairWithoutPlaintextRequest) {
ExecutionContext executionContext = createExecutionContext(generateDataKeyPairWithoutPlaintextRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GenerateDataKeyPairWithoutPlaintextRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(generateDataKeyPairWithoutPlaintextRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GenerateDataKeyPairWithoutPlaintext");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GenerateDataKeyPairWithoutPlaintextResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a unique symmetric data key for use outside of KMS. This operation returns a data key that is encrypted
* under a symmetric encryption KMS key that you specify. The bytes in the key are random; they are not related to
* the caller or to the KMS key.
*
*
* GenerateDataKeyWithoutPlaintext is identical to the GenerateDataKey operation except that it
* does not return a plaintext copy of the data key.
*
*
* This operation is useful for systems that need to encrypt data at some point, but not immediately. When you need
* to encrypt the data, you call the Decrypt operation on the encrypted copy of the key.
*
*
* It's also useful in distributed systems with different levels of trust. For example, you might store encrypted
* data in containers. One component of your system creates new containers and stores an encrypted data key with
* each container. Then, a different component puts the data into the containers. That component first decrypts the
* data key, uses the plaintext data key to encrypt data, puts the encrypted data into the container, and then
* destroys the plaintext data key. In this system, the component that creates the containers never sees the
* plaintext data key.
*
*
* To request an asymmetric data key pair, use the GenerateDataKeyPair or
* GenerateDataKeyPairWithoutPlaintext operations.
*
*
* To generate a data key, you must specify the symmetric encryption KMS key that is used to encrypt the data key.
* You cannot use an asymmetric KMS key or a key in a custom key store to generate a data key. To get the type of
* your KMS key, use the DescribeKey operation.
*
*
* You must also specify the length of the data key. Use either the KeySpec or
* NumberOfBytes parameters (but not both). For 128-bit and 256-bit data keys, use the
* KeySpec parameter.
*
*
* To generate an SM4 data key (China Regions only), specify a KeySpec value of AES_128 or
* NumberOfBytes value of 16. The symmetric encryption key used in China Regions to
* encrypt your data key is an SM4 encryption key.
*
*
* If the operation succeeds, you will find the encrypted copy of the data key in the CiphertextBlob
* field.
*
*
* You can use an optional encryption context to add additional security to the encryption operation. If you specify
* an EncryptionContext, you must specify the same encryption context (a case-sensitive exact match)
* when decrypting the encrypted data key. Otherwise, the request to decrypt fails with an
* InvalidCiphertextException. For more information, see Encryption Context
* in the Key Management Service Developer Guide.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: Yes. To perform this operation with a KMS key in a different Amazon Web Services
* account, specify the key ARN or alias ARN in the value of the KeyId parameter.
*
*
* Required permissions: kms:GenerateDataKeyWithoutPlaintext (key policy)
*
*
* Related operations:
*
*
* -
*
* Decrypt
*
*
* -
*
* Encrypt
*
*
* -
*
* GenerateDataKey
*
*
* -
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param generateDataKeyWithoutPlaintextRequest
* @return Result of the GenerateDataKeyWithoutPlaintext operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws KeyUnavailableException
* The request was rejected because the specified KMS key was not available. You can retry the request.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws InvalidKeyUsageException
* The request was rejected for one of the following reasons:
*
* -
*
* The KeyUsage value of the KMS key is incompatible with the API operation.
*
*
* -
*
* The encryption algorithm or signing algorithm specified for the operation is incompatible with the type
* of key material in the KMS key (KeySpec).
*
*
*
*
* For encrypting, decrypting, re-encrypting, and generating data keys, the KeyUsage must be
* ENCRYPT_DECRYPT. For signing and verifying messages, the KeyUsage must be
* SIGN_VERIFY. For generating and verifying message authentication codes (MACs), the
* KeyUsage must be GENERATE_VERIFY_MAC. For deriving key agreement secrets, the
* KeyUsage must be KEY_AGREEMENT. To find the KeyUsage of a KMS key,
* use the DescribeKey operation.
*
*
* To find the encryption or signing algorithms supported for a particular KMS key, use the
* DescribeKey operation.
* @throws InvalidGrantTokenException
* The request was rejected because the specified grant token is not valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws DryRunOperationException
* The request was rejected because the DryRun parameter was specified.
* @sample AWSKMS.GenerateDataKeyWithoutPlaintext
* @see AWS API Documentation
*/
@Override
public GenerateDataKeyWithoutPlaintextResult generateDataKeyWithoutPlaintext(GenerateDataKeyWithoutPlaintextRequest request) {
request = beforeClientExecution(request);
return executeGenerateDataKeyWithoutPlaintext(request);
}
@SdkInternalApi
final GenerateDataKeyWithoutPlaintextResult executeGenerateDataKeyWithoutPlaintext(
GenerateDataKeyWithoutPlaintextRequest generateDataKeyWithoutPlaintextRequest) {
ExecutionContext executionContext = createExecutionContext(generateDataKeyWithoutPlaintextRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GenerateDataKeyWithoutPlaintextRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(generateDataKeyWithoutPlaintextRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GenerateDataKeyWithoutPlaintext");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GenerateDataKeyWithoutPlaintextResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Generates a hash-based message authentication code (HMAC) for a message using an HMAC KMS key and a MAC algorithm
* that the key supports. HMAC KMS keys and the HMAC algorithms that KMS uses conform to industry standards defined
* in RFC 2104.
*
*
* You can use value that GenerateMac returns in the VerifyMac operation to demonstrate that the original
* message has not changed. Also, because a secret key is used to create the hash, you can verify that the party
* that generated the hash has the required secret key. You can also use the raw result to implement HMAC-based
* algorithms such as key derivation functions. This operation is part of KMS support for HMAC KMS keys. For
* details, see HMAC keys in KMS in
* the Key Management Service Developer Guide .
*
*
*
* Best practices recommend that you limit the time during which any signing mechanism, including an HMAC, is
* effective. This deters an attack where the actor uses a signed message to establish validity repeatedly or long
* after the message is superseded. HMAC tags do not include a timestamp, but you can include a timestamp in the
* token or message to help you detect when its time to refresh the HMAC.
*
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: Yes. To perform this operation with a KMS key in a different Amazon Web Services
* account, specify the key ARN or alias ARN in the value of the KeyId parameter.
*
*
* Required permissions: kms:GenerateMac (key policy)
*
*
* Related operations: VerifyMac
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param generateMacRequest
* @return Result of the GenerateMac operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws KeyUnavailableException
* The request was rejected because the specified KMS key was not available. You can retry the request.
* @throws InvalidKeyUsageException
* The request was rejected for one of the following reasons:
*
* -
*
* The KeyUsage value of the KMS key is incompatible with the API operation.
*
*
* -
*
* The encryption algorithm or signing algorithm specified for the operation is incompatible with the type
* of key material in the KMS key (KeySpec).
*
*
*
*
* For encrypting, decrypting, re-encrypting, and generating data keys, the KeyUsage must be
* ENCRYPT_DECRYPT. For signing and verifying messages, the KeyUsage must be
* SIGN_VERIFY. For generating and verifying message authentication codes (MACs), the
* KeyUsage must be GENERATE_VERIFY_MAC. For deriving key agreement secrets, the
* KeyUsage must be KEY_AGREEMENT. To find the KeyUsage of a KMS key,
* use the DescribeKey operation.
*
*
* To find the encryption or signing algorithms supported for a particular KMS key, use the
* DescribeKey operation.
* @throws InvalidGrantTokenException
* The request was rejected because the specified grant token is not valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws DryRunOperationException
* The request was rejected because the DryRun parameter was specified.
* @sample AWSKMS.GenerateMac
* @see AWS API
* Documentation
*/
@Override
public GenerateMacResult generateMac(GenerateMacRequest request) {
request = beforeClientExecution(request);
return executeGenerateMac(request);
}
@SdkInternalApi
final GenerateMacResult executeGenerateMac(GenerateMacRequest generateMacRequest) {
ExecutionContext executionContext = createExecutionContext(generateMacRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GenerateMacRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(generateMacRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GenerateMac");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GenerateMacResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a random byte string that is cryptographically secure.
*
*
* You must use the NumberOfBytes parameter to specify the length of the random byte string. There is
* no default value for string length.
*
*
* By default, the random byte string is generated in KMS. To generate the byte string in the CloudHSM cluster
* associated with an CloudHSM key store, use the CustomKeyStoreId parameter.
*
*
* GenerateRandom also supports Amazon Web Services Nitro
* Enclaves, which provide an isolated compute environment in Amazon EC2. To call GenerateRandom
* for a Nitro enclave, use the Amazon Web Services
* Nitro Enclaves SDK or any Amazon Web Services SDK. Use the Recipient parameter to provide the
* attestation document for the enclave. Instead of plaintext bytes, the response includes the plaintext bytes
* encrypted under the public key from the attestation document (CiphertextForRecipient).For
* information about the interaction between KMS and Amazon Web Services Nitro Enclaves, see How Amazon Web Services
* Nitro Enclaves uses KMS in the Key Management Service Developer Guide.
*
*
* For more information about entropy and random number generation, see Key Management Service Cryptographic
* Details.
*
*
* Cross-account use: Not applicable. GenerateRandom does not use any account-specific
* resources, such as KMS keys.
*
*
* Required permissions: kms:GenerateRandom (IAM policy)
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param generateRandomRequest
* @return Result of the GenerateRandom operation returned by the service.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws UnsupportedOperationException
* The request was rejected because a specified parameter is not supported or a specified resource is not
* valid for this operation.
* @throws CustomKeyStoreNotFoundException
* The request was rejected because KMS cannot find a custom key store with the specified key store name or
* ID.
* @throws CustomKeyStoreInvalidStateException
* The request was rejected because of the ConnectionState of the custom key store. To get the
* ConnectionState of a custom key store, use the DescribeCustomKeyStores operation.
*
* This exception is thrown under the following conditions:
*
*
* -
*
* You requested the ConnectCustomKeyStore operation on a custom key store with a
* ConnectionState of DISCONNECTING or FAILED. This operation is
* valid for all other ConnectionState values. To reconnect a custom key store in a
* FAILED state, disconnect it (DisconnectCustomKeyStore), then connect it (
* ConnectCustomKeyStore).
*
*
* -
*
* You requested the CreateKey operation in a custom key store that is not connected. This operations
* is valid only when the custom key store ConnectionState is CONNECTED.
*
*
* -
*
* You requested the DisconnectCustomKeyStore operation on a custom key store with a
* ConnectionState of DISCONNECTING or DISCONNECTED. This operation
* is valid for all other ConnectionState values.
*
*
* -
*
* You requested the UpdateCustomKeyStore or DeleteCustomKeyStore operation on a custom key
* store that is not disconnected. This operation is valid only when the custom key store
* ConnectionState is DISCONNECTED.
*
*
* -
*
* You requested the GenerateRandom operation in an CloudHSM key store that is not connected. This
* operation is valid only when the CloudHSM key store ConnectionState is
* CONNECTED.
*
*
* @sample AWSKMS.GenerateRandom
* @see AWS API
* Documentation
*/
@Override
public GenerateRandomResult generateRandom(GenerateRandomRequest request) {
request = beforeClientExecution(request);
return executeGenerateRandom(request);
}
@SdkInternalApi
final GenerateRandomResult executeGenerateRandom(GenerateRandomRequest generateRandomRequest) {
ExecutionContext executionContext = createExecutionContext(generateRandomRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GenerateRandomRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(generateRandomRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GenerateRandom");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GenerateRandomResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public GenerateRandomResult generateRandom() {
return generateRandom(new GenerateRandomRequest());
}
/**
*
* Gets a key policy attached to the specified KMS key.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:GetKeyPolicy (key policy)
*
*
* Related operations: PutKeyPolicy
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param getKeyPolicyRequest
* @return Result of the GetKeyPolicy operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @sample AWSKMS.GetKeyPolicy
* @see AWS API
* Documentation
*/
@Override
public GetKeyPolicyResult getKeyPolicy(GetKeyPolicyRequest request) {
request = beforeClientExecution(request);
return executeGetKeyPolicy(request);
}
@SdkInternalApi
final GetKeyPolicyResult executeGetKeyPolicy(GetKeyPolicyRequest getKeyPolicyRequest) {
ExecutionContext executionContext = createExecutionContext(getKeyPolicyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetKeyPolicyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getKeyPolicyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetKeyPolicy");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetKeyPolicyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Provides detailed information about the rotation status for a KMS key, including whether automatic rotation of the key
* material is enabled for the specified KMS key, the rotation
* period, and the next scheduled rotation date.
*
*
* Automatic key rotation is supported only on symmetric encryption
* KMS keys. You cannot enable automatic rotation of asymmetric KMS keys,
* HMAC KMS keys, KMS keys with imported key material, or
* KMS keys in a custom key store.
* To enable or disable automatic rotation of a set of related multi-Region keys, set the property on the primary key..
*
*
* You can enable (EnableKeyRotation) and disable automatic rotation (DisableKeyRotation) of the key
* material in customer managed KMS keys. Key material rotation of Amazon Web Services
* managed KMS keys is not configurable. KMS always rotates the key material in Amazon Web Services managed KMS
* keys every year. The key rotation status for Amazon Web Services managed KMS keys is always true.
*
*
* You can perform on-demand (RotateKeyOnDemand) rotation of the key material in customer managed KMS keys,
* regardless of whether or not automatic key rotation is enabled. You can use GetKeyRotationStatus to identify the
* date and time that an in progress on-demand rotation was initiated. You can use ListKeyRotations to view
* the details of completed rotations.
*
*
*
* In May 2022, KMS changed the rotation schedule for Amazon Web Services managed keys from every three years to
* every year. For details, see EnableKeyRotation.
*
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* -
*
* Disabled: The key rotation status does not change when you disable a KMS key. However, while the KMS key is
* disabled, KMS does not rotate the key material. When you re-enable the KMS key, rotation resumes. If the key
* material in the re-enabled KMS key hasn't been rotated in one year, KMS rotates it immediately, and every year
* thereafter. If it's been less than a year since the key material in the re-enabled KMS key was rotated, the KMS
* key resumes its prior rotation schedule.
*
*
* -
*
* Pending deletion: While a KMS key is pending deletion, its key rotation status is false and KMS does
* not rotate the key material. If you cancel the deletion, the original key rotation status returns to
* true.
*
*
*
*
* Cross-account use: Yes. To perform this operation on a KMS key in a different Amazon Web Services account,
* specify the key ARN in the value of the KeyId parameter.
*
*
* Required permissions: kms:GetKeyRotationStatus (key policy)
*
*
* Related operations:
*
*
* -
*
*
* -
*
*
* -
*
* ListKeyRotations
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param getKeyRotationStatusRequest
* @return Result of the GetKeyRotationStatus operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws UnsupportedOperationException
* The request was rejected because a specified parameter is not supported or a specified resource is not
* valid for this operation.
* @sample AWSKMS.GetKeyRotationStatus
* @see AWS API
* Documentation
*/
@Override
public GetKeyRotationStatusResult getKeyRotationStatus(GetKeyRotationStatusRequest request) {
request = beforeClientExecution(request);
return executeGetKeyRotationStatus(request);
}
@SdkInternalApi
final GetKeyRotationStatusResult executeGetKeyRotationStatus(GetKeyRotationStatusRequest getKeyRotationStatusRequest) {
ExecutionContext executionContext = createExecutionContext(getKeyRotationStatusRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetKeyRotationStatusRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getKeyRotationStatusRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetKeyRotationStatus");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetKeyRotationStatusResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the public key and an import token you need to import or reimport key material for a KMS key.
*
*
* By default, KMS keys are created with key material that KMS generates. This operation supports Importing key material, an
* advanced feature that lets you generate and import the cryptographic key material for a KMS key. For more
* information about importing key material into KMS, see Importing key material in
* the Key Management Service Developer Guide.
*
*
* Before calling GetParametersForImport, use the CreateKey operation with an
* Origin value of EXTERNAL to create a KMS key with no key material. You can import key
* material for a symmetric encryption KMS key, HMAC KMS key, asymmetric encryption KMS key, or asymmetric signing
* KMS key. You can also import key material into a multi-Region key
* of any supported type. However, you can't import key material into a KMS key in a custom key store.
* You can also use GetParametersForImport to get a public key and import token to reimport
* the original key material into a KMS key whose key material expired or was deleted.
*
*
* GetParametersForImport returns the items that you need to import your key material.
*
*
* -
*
* The public key (or "wrapping key") of an RSA key pair that KMS generates.
*
*
* You will use this public key to encrypt ("wrap") your key material while it's in transit to KMS.
*
*
* -
*
* A import token that ensures that KMS can decrypt your key material and associate it with the correct KMS key.
*
*
*
*
* The public key and its import token are permanently linked and must be used together. Each public key and import
* token set is valid for 24 hours. The expiration date and time appear in the ParametersValidTo field
* in the GetParametersForImport response. You cannot use an expired public key or import token in an
* ImportKeyMaterial request. If your key and token expire, send another GetParametersForImport
* request.
*
*
* GetParametersForImport requires the following information:
*
*
* -
*
* The key ID of the KMS key for which you are importing the key material.
*
*
* -
*
* The key spec of the public key ("wrapping key") that you will use to encrypt your key material during import.
*
*
* -
*
* The wrapping algorithm that you will use with the public key to encrypt your key material.
*
*
*
*
* You can use the same or a different public key spec and wrapping algorithm each time you import or reimport the
* same key material.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:GetParametersForImport (key policy)
*
*
* Related operations:
*
*
* -
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param getParametersForImportRequest
* @return Result of the GetParametersForImport operation returned by the service.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws UnsupportedOperationException
* The request was rejected because a specified parameter is not supported or a specified resource is not
* valid for this operation.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @sample AWSKMS.GetParametersForImport
* @see AWS API
* Documentation
*/
@Override
public GetParametersForImportResult getParametersForImport(GetParametersForImportRequest request) {
request = beforeClientExecution(request);
return executeGetParametersForImport(request);
}
@SdkInternalApi
final GetParametersForImportResult executeGetParametersForImport(GetParametersForImportRequest getParametersForImportRequest) {
ExecutionContext executionContext = createExecutionContext(getParametersForImportRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetParametersForImportRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getParametersForImportRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetParametersForImport");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GetParametersForImportResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the public key of an asymmetric KMS key. Unlike the private key of a asymmetric KMS key, which never
* leaves KMS unencrypted, callers with kms:GetPublicKey permission can download the public key of an
* asymmetric KMS key. You can share the public key to allow others to encrypt messages and verify signatures
* outside of KMS. For information about asymmetric KMS keys, see Asymmetric KMS keys in
* the Key Management Service Developer Guide.
*
*
* You do not need to download the public key. Instead, you can use the public key within KMS by calling the
* Encrypt, ReEncrypt, or Verify operations with the identifier of an asymmetric KMS key. When
* you use the public key within KMS, you benefit from the authentication, authorization, and logging that are part
* of every KMS operation. You also reduce of risk of encrypting data that cannot be decrypted. These features are
* not effective outside of KMS.
*
*
* To help you use the public key safely outside of KMS, GetPublicKey returns important information
* about the public key in the response, including:
*
*
* -
*
* KeySpec: The type of key material in the public key, such as RSA_4096 or
* ECC_NIST_P521.
*
*
* -
*
* KeyUsage: Whether the key is used for encryption, signing, or deriving a shared secret.
*
*
* -
*
* EncryptionAlgorithms or SigningAlgorithms: A list of the encryption algorithms or the signing algorithms for the key.
*
*
*
*
* Although KMS cannot enforce these restrictions on external operations, it is crucial that you use this
* information to prevent the public key from being used improperly. For example, you can prevent a public signing
* key from being used encrypt data, or prevent a public key from being used with an encryption algorithm that is
* not supported by KMS. You can also avoid errors, such as using the wrong signing algorithm in a verification
* operation.
*
*
* To verify a signature outside of KMS with an SM2 public key (China Regions only), you must specify the
* distinguishing ID. By default, KMS uses 1234567812345678 as the distinguishing ID. For more
* information, see Offline verification with SM2 key pairs.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: Yes. To perform this operation with a KMS key in a different Amazon Web Services
* account, specify the key ARN or alias ARN in the value of the KeyId parameter.
*
*
* Required permissions: kms:GetPublicKey (key policy)
*
*
* Related operations: CreateKey
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param getPublicKeyRequest
* @return Result of the GetPublicKey operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws KeyUnavailableException
* The request was rejected because the specified KMS key was not available. You can retry the request.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws UnsupportedOperationException
* The request was rejected because a specified parameter is not supported or a specified resource is not
* valid for this operation.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws InvalidGrantTokenException
* The request was rejected because the specified grant token is not valid.
* @throws InvalidKeyUsageException
* The request was rejected for one of the following reasons:
*
* -
*
* The KeyUsage value of the KMS key is incompatible with the API operation.
*
*
* -
*
* The encryption algorithm or signing algorithm specified for the operation is incompatible with the type
* of key material in the KMS key (KeySpec).
*
*
*
*
* For encrypting, decrypting, re-encrypting, and generating data keys, the KeyUsage must be
* ENCRYPT_DECRYPT. For signing and verifying messages, the KeyUsage must be
* SIGN_VERIFY. For generating and verifying message authentication codes (MACs), the
* KeyUsage must be GENERATE_VERIFY_MAC. For deriving key agreement secrets, the
* KeyUsage must be KEY_AGREEMENT. To find the KeyUsage of a KMS key,
* use the DescribeKey operation.
*
*
* To find the encryption or signing algorithms supported for a particular KMS key, use the
* DescribeKey operation.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @sample AWSKMS.GetPublicKey
* @see AWS API
* Documentation
*/
@Override
public GetPublicKeyResult getPublicKey(GetPublicKeyRequest request) {
request = beforeClientExecution(request);
return executeGetPublicKey(request);
}
@SdkInternalApi
final GetPublicKeyResult executeGetPublicKey(GetPublicKeyRequest getPublicKeyRequest) {
ExecutionContext executionContext = createExecutionContext(getPublicKeyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetPublicKeyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getPublicKeyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetPublicKey");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetPublicKeyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Imports or reimports key material into an existing KMS key that was created without key material.
* ImportKeyMaterial also sets the expiration model and expiration date of the imported key material.
*
*
* By default, KMS keys are created with key material that KMS generates. This operation supports Importing key material, an
* advanced feature that lets you generate and import the cryptographic key material for a KMS key. For more
* information about importing key material into KMS, see Importing key material in
* the Key Management Service Developer Guide.
*
*
* After you successfully import key material into a KMS key, you can reimport
* the same key material into that KMS key, but you cannot import different key material. You might reimport key
* material to replace key material that expired or key material that you deleted. You might also reimport key
* material to change the expiration model or expiration date of the key material.
*
*
* Each time you import key material into KMS, you can determine whether (ExpirationModel) and when (
* ValidTo) the key material expires. To change the expiration of your key material, you must import it
* again, either by calling ImportKeyMaterial or using the import features of the KMS console.
*
*
* Before calling ImportKeyMaterial:
*
*
* -
*
* Create or identify a KMS key with no key material. The KMS key must have an Origin value of
* EXTERNAL, which indicates that the KMS key is designed for imported key material.
*
*
* To create an new KMS key for imported key material, call the CreateKey operation with an
* Origin value of EXTERNAL. You can create a symmetric encryption KMS key, HMAC KMS key,
* asymmetric encryption KMS key, or asymmetric signing KMS key. You can also import key material into a multi-Region key of any supported type.
* However, you can't import key material into a KMS key in a custom key store.
*
*
* -
*
* Use the DescribeKey operation to verify that the KeyState of the KMS key is
* PendingImport, which indicates that the KMS key has no key material.
*
*
* If you are reimporting the same key material into an existing KMS key, you might need to call the
* DeleteImportedKeyMaterial to delete its existing key material.
*
*
* -
*
* Call the GetParametersForImport operation to get a public key and import token set for importing key
* material.
*
*
* -
*
* Use the public key in the GetParametersForImport response to encrypt your key material.
*
*
*
*
* Then, in an ImportKeyMaterial request, you submit your encrypted key material and import token. When
* calling this operation, you must specify the following values:
*
*
* -
*
* The key ID or key ARN of the KMS key to associate with the imported key material. Its Origin must be
* EXTERNAL and its KeyState must be PendingImport. You cannot perform this
* operation on a KMS key in a custom key
* store, or on a KMS key in a different Amazon Web Services account. To get the Origin and
* KeyState of a KMS key, call DescribeKey.
*
*
* -
*
* The encrypted key material.
*
*
* -
*
* The import token that GetParametersForImport returned. You must use a public key and token from the same
* GetParametersForImport response.
*
*
* -
*
* Whether the key material expires (ExpirationModel) and, if so, when (ValidTo). For help
* with this choice, see Setting an expiration time in the Key Management Service Developer Guide.
*
*
* If you set an expiration date, KMS deletes the key material from the KMS key on the specified date, making the
* KMS key unusable. To use the KMS key in cryptographic operations again, you must reimport the same key material.
* However, you can delete and reimport the key material at any time, including before the key material expires.
* Each time you reimport, you can eliminate or reset the expiration time.
*
*
*
*
* When this operation is successful, the key state of the KMS key changes from PendingImport to
* Enabled, and you can use the KMS key in cryptographic operations.
*
*
* If this operation fails, use the exception to help determine the problem. If the error is related to the key
* material, the import token, or wrapping key, use GetParametersForImport to get a new public key and import
* token for the KMS key and repeat the import procedure. For help, see How To
* Import Key Material in the Key Management Service Developer Guide.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:ImportKeyMaterial (key policy)
*
*
* Related operations:
*
*
* -
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param importKeyMaterialRequest
* @return Result of the ImportKeyMaterial operation returned by the service.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws UnsupportedOperationException
* The request was rejected because a specified parameter is not supported or a specified resource is not
* valid for this operation.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws InvalidCiphertextException
* From the Decrypt or ReEncrypt operation, the request was rejected because the specified
* ciphertext, or additional authenticated data incorporated into the ciphertext, such as the encryption
* context, is corrupted, missing, or otherwise invalid.
*
* From the ImportKeyMaterial operation, the request was rejected because KMS could not decrypt the
* encrypted (wrapped) key material.
* @throws IncorrectKeyMaterialException
* The request was rejected because the key material in the request is, expired, invalid, or is not the same
* key material that was previously imported into this KMS key.
* @throws ExpiredImportTokenException
* The request was rejected because the specified import token is expired. Use GetParametersForImport
* to get a new import token and public key, use the new public key to encrypt the key material, and then
* try the request again.
* @throws InvalidImportTokenException
* The request was rejected because the provided import token is invalid or is associated with a different
* KMS key.
* @sample AWSKMS.ImportKeyMaterial
* @see AWS API
* Documentation
*/
@Override
public ImportKeyMaterialResult importKeyMaterial(ImportKeyMaterialRequest request) {
request = beforeClientExecution(request);
return executeImportKeyMaterial(request);
}
@SdkInternalApi
final ImportKeyMaterialResult executeImportKeyMaterial(ImportKeyMaterialRequest importKeyMaterialRequest) {
ExecutionContext executionContext = createExecutionContext(importKeyMaterialRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ImportKeyMaterialRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(importKeyMaterialRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ImportKeyMaterial");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ImportKeyMaterialResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Gets a list of aliases in the caller's Amazon Web Services account and region. For more information about
* aliases, see CreateAlias.
*
*
* By default, the ListAliases operation returns all aliases in the account and region. To get only the
* aliases associated with a particular KMS key, use the KeyId parameter.
*
*
* The ListAliases response can include aliases that you created and associated with your customer
* managed keys, and aliases that Amazon Web Services created and associated with Amazon Web Services managed keys
* in your account. You can recognize Amazon Web Services aliases because their names have the format
* aws/<service-name>, such as aws/dynamodb.
*
*
* The response might also include aliases that have no TargetKeyId field. These are predefined aliases
* that Amazon Web Services has created but has not yet associated with a KMS key. Aliases that Amazon Web Services
* creates in your account, including predefined aliases, do not count against your KMS aliases quota.
*
*
* Cross-account use: No. ListAliases does not return aliases in other Amazon Web Services
* accounts.
*
*
* Required permissions: kms:ListAliases (IAM policy)
*
*
* For details, see Controlling access to
* aliases in the Key Management Service Developer Guide.
*
*
* Related operations:
*
*
* -
*
* CreateAlias
*
*
* -
*
* DeleteAlias
*
*
* -
*
* UpdateAlias
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param listAliasesRequest
* @return Result of the ListAliases operation returned by the service.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws InvalidMarkerException
* The request was rejected because the marker that specifies where pagination should next begin is not
* valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @sample AWSKMS.ListAliases
* @see AWS API
* Documentation
*/
@Override
public ListAliasesResult listAliases(ListAliasesRequest request) {
request = beforeClientExecution(request);
return executeListAliases(request);
}
@SdkInternalApi
final ListAliasesResult executeListAliases(ListAliasesRequest listAliasesRequest) {
ExecutionContext executionContext = createExecutionContext(listAliasesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListAliasesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listAliasesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListAliases");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListAliasesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ListAliasesResult listAliases() {
return listAliases(new ListAliasesRequest());
}
/**
*
* Gets a list of all grants for the specified KMS key.
*
*
* You must specify the KMS key in all requests. You can filter the grant list by grant ID or grantee principal.
*
*
* For detailed information about grants, including grant terminology, see Grants in KMS in the Key
* Management Service Developer Guide . For examples of working with grants in several programming
* languages, see Programming grants.
*
*
*
* The GranteePrincipal field in the ListGrants response usually contains the user or role
* designated as the grantee principal in the grant. However, when the grantee principal in the grant is an Amazon
* Web Services service, the GranteePrincipal field contains the service principal, which might represent several different grantee principals.
*
*
*
* Cross-account use: Yes. To perform this operation on a KMS key in a different Amazon Web Services account,
* specify the key ARN in the value of the KeyId parameter.
*
*
* Required permissions: kms:ListGrants (key policy)
*
*
* Related operations:
*
*
* -
*
* CreateGrant
*
*
* -
*
*
* -
*
* RetireGrant
*
*
* -
*
* RevokeGrant
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param listGrantsRequest
* @return Result of the ListGrants operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws InvalidMarkerException
* The request was rejected because the marker that specifies where pagination should next begin is not
* valid.
* @throws InvalidGrantIdException
* The request was rejected because the specified GrantId is not valid.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @sample AWSKMS.ListGrants
* @see AWS API
* Documentation
*/
@Override
public ListGrantsResult listGrants(ListGrantsRequest request) {
request = beforeClientExecution(request);
return executeListGrants(request);
}
@SdkInternalApi
final ListGrantsResult executeListGrants(ListGrantsRequest listGrantsRequest) {
ExecutionContext executionContext = createExecutionContext(listGrantsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListGrantsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listGrantsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListGrants");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListGrantsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Gets the names of the key policies that are attached to a KMS key. This operation is designed to get policy names
* that you can use in a GetKeyPolicy operation. However, the only valid policy name is default.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:ListKeyPolicies (key policy)
*
*
* Related operations:
*
*
* -
*
* GetKeyPolicy
*
*
* -
*
* PutKeyPolicy
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param listKeyPoliciesRequest
* @return Result of the ListKeyPolicies operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @sample AWSKMS.ListKeyPolicies
* @see AWS API
* Documentation
*/
@Override
public ListKeyPoliciesResult listKeyPolicies(ListKeyPoliciesRequest request) {
request = beforeClientExecution(request);
return executeListKeyPolicies(request);
}
@SdkInternalApi
final ListKeyPoliciesResult executeListKeyPolicies(ListKeyPoliciesRequest listKeyPoliciesRequest) {
ExecutionContext executionContext = createExecutionContext(listKeyPoliciesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListKeyPoliciesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listKeyPoliciesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListKeyPolicies");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListKeyPoliciesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about all completed key material rotations for the specified KMS key.
*
*
* You must specify the KMS key in all requests. You can refine the key rotations list by limiting the number of
* rotations returned.
*
*
* For detailed information about automatic and on-demand key rotations, see Rotating KMS keys in the Key
* Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:ListKeyRotations (key policy)
*
*
* Related operations:
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param listKeyRotationsRequest
* @return Result of the ListKeyRotations operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws InvalidMarkerException
* The request was rejected because the marker that specifies where pagination should next begin is not
* valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws UnsupportedOperationException
* The request was rejected because a specified parameter is not supported or a specified resource is not
* valid for this operation.
* @sample AWSKMS.ListKeyRotations
* @see AWS API
* Documentation
*/
@Override
public ListKeyRotationsResult listKeyRotations(ListKeyRotationsRequest request) {
request = beforeClientExecution(request);
return executeListKeyRotations(request);
}
@SdkInternalApi
final ListKeyRotationsResult executeListKeyRotations(ListKeyRotationsRequest listKeyRotationsRequest) {
ExecutionContext executionContext = createExecutionContext(listKeyRotationsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListKeyRotationsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listKeyRotationsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListKeyRotations");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListKeyRotationsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Gets a list of all KMS keys in the caller's Amazon Web Services account and Region.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:ListKeys
* (IAM policy)
*
*
* Related operations:
*
*
* -
*
* CreateKey
*
*
* -
*
* DescribeKey
*
*
* -
*
* ListAliases
*
*
* -
*
* ListResourceTags
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param listKeysRequest
* @return Result of the ListKeys operation returned by the service.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws InvalidMarkerException
* The request was rejected because the marker that specifies where pagination should next begin is not
* valid.
* @sample AWSKMS.ListKeys
* @see AWS API
* Documentation
*/
@Override
public ListKeysResult listKeys(ListKeysRequest request) {
request = beforeClientExecution(request);
return executeListKeys(request);
}
@SdkInternalApi
final ListKeysResult executeListKeys(ListKeysRequest listKeysRequest) {
ExecutionContext executionContext = createExecutionContext(listKeysRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListKeysRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listKeysRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListKeys");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListKeysResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public ListKeysResult listKeys() {
return listKeys(new ListKeysRequest());
}
/**
*
* Returns all tags on the specified KMS key.
*
*
* For general information about tags, including the format and syntax, see Tagging Amazon Web Services resources
* in the Amazon Web Services General Reference. For information about using tags in KMS, see Tagging keys.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:ListResourceTags (key policy)
*
*
* Related operations:
*
*
* -
*
* CreateKey
*
*
* -
*
* ReplicateKey
*
*
* -
*
* TagResource
*
*
* -
*
* UntagResource
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param listResourceTagsRequest
* @return Result of the ListResourceTags operation returned by the service.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws InvalidMarkerException
* The request was rejected because the marker that specifies where pagination should next begin is not
* valid.
* @sample AWSKMS.ListResourceTags
* @see AWS API
* Documentation
*/
@Override
public ListResourceTagsResult listResourceTags(ListResourceTagsRequest request) {
request = beforeClientExecution(request);
return executeListResourceTags(request);
}
@SdkInternalApi
final ListResourceTagsResult executeListResourceTags(ListResourceTagsRequest listResourceTagsRequest) {
ExecutionContext executionContext = createExecutionContext(listResourceTagsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListResourceTagsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listResourceTagsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListResourceTags");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListResourceTagsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about all grants in the Amazon Web Services account and Region that have the specified
* retiring principal.
*
*
* You can specify any principal in your Amazon Web Services account. The grants that are returned include grants
* for KMS keys in your Amazon Web Services account and other Amazon Web Services accounts. You might use this
* operation to determine which grants you may retire. To retire a grant, use the RetireGrant operation.
*
*
* For detailed information about grants, including grant terminology, see Grants in KMS in the Key
* Management Service Developer Guide . For examples of working with grants in several programming
* languages, see Programming grants.
*
*
* Cross-account use: You must specify a principal in your Amazon Web Services account. This operation
* returns a list of grants where the retiring principal specified in the ListRetirableGrants request
* is the same retiring principal on the grant. This can include grants on KMS keys owned by other Amazon Web
* Services accounts, but you do not need kms:ListRetirableGrants permission (or any other additional
* permission) in any Amazon Web Services account other than your own.
*
*
* Required permissions: kms:ListRetirableGrants (IAM policy) in your Amazon Web Services account.
*
*
*
* KMS authorizes ListRetirableGrants requests by evaluating the caller account's
* kms:ListRetirableGrants permissions. The authorized resource in ListRetirableGrants calls is the
* retiring principal specified in the request. KMS does not evaluate the caller's permissions to verify their
* access to any KMS keys or grants that might be returned by the ListRetirableGrants call.
*
*
*
* Related operations:
*
*
* -
*
* CreateGrant
*
*
* -
*
* ListGrants
*
*
* -
*
* RetireGrant
*
*
* -
*
* RevokeGrant
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param listRetirableGrantsRequest
* @return Result of the ListRetirableGrants operation returned by the service.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws InvalidMarkerException
* The request was rejected because the marker that specifies where pagination should next begin is not
* valid.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @sample AWSKMS.ListRetirableGrants
* @see AWS API
* Documentation
*/
@Override
public ListRetirableGrantsResult listRetirableGrants(ListRetirableGrantsRequest request) {
request = beforeClientExecution(request);
return executeListRetirableGrants(request);
}
@SdkInternalApi
final ListRetirableGrantsResult executeListRetirableGrants(ListRetirableGrantsRequest listRetirableGrantsRequest) {
ExecutionContext executionContext = createExecutionContext(listRetirableGrantsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListRetirableGrantsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listRetirableGrantsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListRetirableGrants");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListRetirableGrantsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Attaches a key policy to the specified KMS key.
*
*
* For more information about key policies, see Key Policies in the Key
* Management Service Developer Guide. For help writing and formatting a JSON policy document, see the IAM JSON Policy Reference in
* the Identity and Access Management User Guide . For examples of adding a key policy in multiple
* programming languages, see Setting a
* key policy in the Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:PutKeyPolicy (key policy)
*
*
* Related operations: GetKeyPolicy
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param putKeyPolicyRequest
* @return Result of the PutKeyPolicy operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws MalformedPolicyDocumentException
* The request was rejected because the specified policy is not syntactically or semantically correct.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws UnsupportedOperationException
* The request was rejected because a specified parameter is not supported or a specified resource is not
* valid for this operation.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws LimitExceededException
* The request was rejected because a quota was exceeded. For more information, see Quotas in the Key
* Management Service Developer Guide.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @sample AWSKMS.PutKeyPolicy
* @see AWS API
* Documentation
*/
@Override
public PutKeyPolicyResult putKeyPolicy(PutKeyPolicyRequest request) {
request = beforeClientExecution(request);
return executePutKeyPolicy(request);
}
@SdkInternalApi
final PutKeyPolicyResult executePutKeyPolicy(PutKeyPolicyRequest putKeyPolicyRequest) {
ExecutionContext executionContext = createExecutionContext(putKeyPolicyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new PutKeyPolicyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(putKeyPolicyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "PutKeyPolicy");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new PutKeyPolicyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Decrypts ciphertext and then reencrypts it entirely within KMS. You can use this operation to change the KMS key
* under which data is encrypted, such as when you manually
* rotate a KMS key or change the KMS key that protects a ciphertext. You can also use it to reencrypt
* ciphertext under the same KMS key, such as to change the encryption context
* of a ciphertext.
*
*
* The ReEncrypt operation can decrypt ciphertext that was encrypted by using a KMS key in an KMS
* operation, such as Encrypt or GenerateDataKey. It can also decrypt ciphertext that was encrypted by
* using the public key of an asymmetric
* KMS key outside of KMS. However, it cannot decrypt ciphertext produced by other libraries, such as the Amazon Web Services Encryption SDK
* or Amazon S3 client-side
* encryption. These libraries return a ciphertext format that is incompatible with KMS.
*
*
* When you use the ReEncrypt operation, you need to provide information for the decrypt operation and
* the subsequent encrypt operation.
*
*
* -
*
* If your ciphertext was encrypted under an asymmetric KMS key, you must use the SourceKeyId parameter
* to identify the KMS key that encrypted the ciphertext. You must also supply the encryption algorithm that was
* used. This information is required to decrypt the data.
*
*
* -
*
* If your ciphertext was encrypted under a symmetric encryption KMS key, the SourceKeyId parameter is
* optional. KMS can get this information from metadata that it adds to the symmetric ciphertext blob. This feature
* adds durability to your implementation by ensuring that authorized users can decrypt ciphertext decades after it
* was encrypted, even if they've lost track of the key ID. However, specifying the source KMS key is always
* recommended as a best practice. When you use the SourceKeyId parameter to specify a KMS key, KMS
* uses only the KMS key you specify. If the ciphertext was encrypted under a different KMS key, the
* ReEncrypt operation fails. This practice ensures that you use the KMS key that you intend.
*
*
* -
*
* To reencrypt the data, you must use the DestinationKeyId parameter to specify the KMS key that
* re-encrypts the data after it is decrypted. If the destination KMS key is an asymmetric KMS key, you must also
* provide the encryption algorithm. The algorithm that you choose must be compatible with the KMS key.
*
*
*
* When you use an asymmetric KMS key to encrypt or reencrypt data, be sure to record the KMS key and encryption
* algorithm that you choose. You will be required to provide the same KMS key and encryption algorithm when you
* decrypt the data. If the KMS key and algorithm do not match the values used to encrypt the data, the decrypt
* operation fails.
*
*
* You are not required to supply the key ID and encryption algorithm when you decrypt with symmetric encryption KMS
* keys because KMS stores this information in the ciphertext blob. KMS cannot store metadata in ciphertext
* generated with asymmetric keys. The standard format for asymmetric key ciphertext does not include configurable
* fields.
*
*
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: Yes. The source KMS key and destination KMS key can be in different Amazon Web Services
* accounts. Either or both KMS keys can be in a different account than the caller. To specify a KMS key in a
* different account, you must use its key ARN or alias ARN.
*
*
* Required permissions:
*
*
* -
*
* kms:
* ReEncryptFrom permission on the source KMS key (key policy)
*
*
* -
*
* kms:ReEncryptTo
* permission on the destination KMS key (key policy)
*
*
*
*
* To permit reencryption from or to a KMS key, include the "kms:ReEncrypt*" permission in your key policy. This permission is
* automatically included in the key policy when you use the console to create a KMS key. But you must include it
* manually when you create a KMS key programmatically or when you use the PutKeyPolicy operation to set a
* key policy.
*
*
* Related operations:
*
*
* -
*
* Decrypt
*
*
* -
*
* Encrypt
*
*
* -
*
* GenerateDataKey
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param reEncryptRequest
* @return Result of the ReEncrypt operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws InvalidCiphertextException
* From the Decrypt or ReEncrypt operation, the request was rejected because the specified
* ciphertext, or additional authenticated data incorporated into the ciphertext, such as the encryption
* context, is corrupted, missing, or otherwise invalid.
*
* From the ImportKeyMaterial operation, the request was rejected because KMS could not decrypt the
* encrypted (wrapped) key material.
* @throws KeyUnavailableException
* The request was rejected because the specified KMS key was not available. You can retry the request.
* @throws IncorrectKeyException
* The request was rejected because the specified KMS key cannot decrypt the data. The KeyId in
* a Decrypt request and the SourceKeyId in a ReEncrypt request must identify the
* same KMS key that was used to encrypt the ciphertext.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws InvalidKeyUsageException
* The request was rejected for one of the following reasons:
*
*
* -
*
* The KeyUsage value of the KMS key is incompatible with the API operation.
*
*
* -
*
* The encryption algorithm or signing algorithm specified for the operation is incompatible with the type
* of key material in the KMS key (KeySpec).
*
*
*
*
* For encrypting, decrypting, re-encrypting, and generating data keys, the KeyUsage must be
* ENCRYPT_DECRYPT. For signing and verifying messages, the KeyUsage must be
* SIGN_VERIFY. For generating and verifying message authentication codes (MACs), the
* KeyUsage must be GENERATE_VERIFY_MAC. For deriving key agreement secrets, the
* KeyUsage must be KEY_AGREEMENT. To find the KeyUsage of a KMS key,
* use the DescribeKey operation.
*
*
* To find the encryption or signing algorithms supported for a particular KMS key, use the
* DescribeKey operation.
* @throws InvalidGrantTokenException
* The request was rejected because the specified grant token is not valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws DryRunOperationException
* The request was rejected because the DryRun parameter was specified.
* @sample AWSKMS.ReEncrypt
* @see AWS API
* Documentation
*/
@Override
public ReEncryptResult reEncrypt(ReEncryptRequest request) {
request = beforeClientExecution(request);
return executeReEncrypt(request);
}
@SdkInternalApi
final ReEncryptResult executeReEncrypt(ReEncryptRequest reEncryptRequest) {
ExecutionContext executionContext = createExecutionContext(reEncryptRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ReEncryptRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(reEncryptRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ReEncrypt");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new ReEncryptResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Replicates a multi-Region key into the specified Region. This operation creates a multi-Region replica key based
* on a multi-Region primary key in a different Region of the same Amazon Web Services partition. You can create
* multiple replicas of a primary key, but each must be in a different Region. To create a multi-Region primary key,
* use the CreateKey operation.
*
*
* This operation supports multi-Region keys, an KMS feature that lets you create multiple interoperable KMS
* keys in different Amazon Web Services Regions. Because these KMS keys have the same key ID, key material, and
* other metadata, you can use them interchangeably to encrypt data in one Amazon Web Services Region and decrypt it
* in a different Amazon Web Services Region without re-encrypting the data or making a cross-Region call. For more
* information about multi-Region keys, see Multi-Region keys in
* KMS in the Key Management Service Developer Guide.
*
*
* A replica key is a fully-functional KMS key that can be used independently of its primary and peer replica
* keys. A primary key and its replica keys share properties that make them interoperable. They have the same key ID and key
* material. They also have the same key spec, key usage, key material origin,
* and automatic key rotation
* status. KMS automatically synchronizes these shared properties among related multi-Region keys. All other
* properties of a replica key can differ, including its key policy, tags, aliases, and Key states of KMS keys. KMS
* pricing and quotas for KMS keys apply to each primary key and replica key.
*
*
* When this operation completes, the new replica key has a transient key state of Creating. This key
* state changes to Enabled (or PendingImport) after a few seconds when the process of
* creating the new replica key is complete. While the key state is Creating, you can manage key, but
* you cannot yet use it in cryptographic operations. If you are creating and using the replica key
* programmatically, retry on KMSInvalidStateException or call DescribeKey to check its
* KeyState value before using it. For details about the Creating key state, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* You cannot create more than one replica of a primary key in any Region. If the Region already includes a replica
* of the key you're trying to replicate, ReplicateKey returns an AlreadyExistsException
* error. If the key state of the existing replica is PendingDeletion, you can cancel the scheduled key
* deletion (CancelKeyDeletion) or wait for the key to be deleted. The new replica key you create will have
* the same shared properties as the original replica key.
*
*
* The CloudTrail log of a ReplicateKey operation records a ReplicateKey operation in the
* primary key's Region and a CreateKey operation in the replica key's Region.
*
*
* If you replicate a multi-Region primary key with imported key material, the replica key is created with no key
* material. You must import the same key material that you imported into the primary key. For details, see Importing key material
* into multi-Region keys in the Key Management Service Developer Guide.
*
*
* To convert a replica key to a primary key, use the UpdatePrimaryRegion operation.
*
*
*
* ReplicateKey uses different default values for the KeyPolicy and Tags
* parameters than those used in the KMS console. For details, see the parameter descriptions.
*
*
*
* Cross-account use: No. You cannot use this operation to create a replica key in a different Amazon Web
* Services account.
*
*
* Required permissions:
*
*
* -
*
* kms:ReplicateKey on the primary key (in the primary key's Region). Include this permission in the
* primary key's key policy.
*
*
* -
*
* kms:CreateKey in an IAM policy in the replica Region.
*
*
* -
*
* To use the Tags parameter, kms:TagResource in an IAM policy in the replica Region.
*
*
*
*
* Related operations
*
*
* -
*
* CreateKey
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param replicateKeyRequest
* @return Result of the ReplicateKey operation returned by the service.
* @throws AlreadyExistsException
* The request was rejected because it attempted to create a resource that already exists.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws LimitExceededException
* The request was rejected because a quota was exceeded. For more information, see Quotas in the Key
* Management Service Developer Guide.
* @throws MalformedPolicyDocumentException
* The request was rejected because the specified policy is not syntactically or semantically correct.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws TagException
* The request was rejected because one or more tags are not valid.
* @throws UnsupportedOperationException
* The request was rejected because a specified parameter is not supported or a specified resource is not
* valid for this operation.
* @sample AWSKMS.ReplicateKey
* @see AWS API
* Documentation
*/
@Override
public ReplicateKeyResult replicateKey(ReplicateKeyRequest request) {
request = beforeClientExecution(request);
return executeReplicateKey(request);
}
@SdkInternalApi
final ReplicateKeyResult executeReplicateKey(ReplicateKeyRequest replicateKeyRequest) {
ExecutionContext executionContext = createExecutionContext(replicateKeyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ReplicateKeyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(replicateKeyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ReplicateKey");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ReplicateKeyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a grant. Typically, you retire a grant when you no longer need its permissions. To identify the grant to
* retire, use a grant
* token, or both the grant ID and a key identifier (key ID or key ARN) of the KMS key. The CreateGrant
* operation returns both values.
*
*
* This operation can be called by the retiring principal for a grant, by the grantee principal if the
* grant allows the RetireGrant operation, and by the Amazon Web Services account in which the grant is
* created. It can also be called by principals to whom permission for retiring a grant is delegated. For details,
* see Retiring and
* revoking grants in the Key Management Service Developer Guide.
*
*
* For detailed information about grants, including grant terminology, see Grants in KMS in the Key
* Management Service Developer Guide . For examples of working with grants in several programming
* languages, see Programming grants.
*
*
* Cross-account use: Yes. You can retire a grant on a KMS key in a different Amazon Web Services account.
*
*
* Required permissions: Permission to retire a grant is determined primarily by the grant. For details, see
* Retiring and
* revoking grants in the Key Management Service Developer Guide.
*
*
* Related operations:
*
*
* -
*
* CreateGrant
*
*
* -
*
* ListGrants
*
*
* -
*
*
* -
*
* RevokeGrant
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param retireGrantRequest
* @return Result of the RetireGrant operation returned by the service.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws InvalidGrantTokenException
* The request was rejected because the specified grant token is not valid.
* @throws InvalidGrantIdException
* The request was rejected because the specified GrantId is not valid.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws DryRunOperationException
* The request was rejected because the DryRun parameter was specified.
* @sample AWSKMS.RetireGrant
* @see AWS API
* Documentation
*/
@Override
public RetireGrantResult retireGrant(RetireGrantRequest request) {
request = beforeClientExecution(request);
return executeRetireGrant(request);
}
@SdkInternalApi
final RetireGrantResult executeRetireGrant(RetireGrantRequest retireGrantRequest) {
ExecutionContext executionContext = createExecutionContext(retireGrantRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RetireGrantRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(retireGrantRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RetireGrant");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new RetireGrantResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
@Override
public RetireGrantResult retireGrant() {
return retireGrant(new RetireGrantRequest());
}
/**
*
* Deletes the specified grant. You revoke a grant to terminate the permissions that the grant allows. For more
* information, see Retiring and revoking
* grants in the Key Management Service Developer Guide .
*
*
* When you create, retire, or revoke a grant, there might be a brief delay, usually less than five minutes, until
* the grant is available throughout KMS. This state is known as eventual consistency. For details, see Eventual
* consistency in the Key Management Service Developer Guide .
*
*
* For detailed information about grants, including grant terminology, see Grants in KMS in the Key
* Management Service Developer Guide . For examples of working with grants in several programming
* languages, see Programming grants.
*
*
* Cross-account use: Yes. To perform this operation on a KMS key in a different Amazon Web Services account,
* specify the key ARN in the value of the KeyId parameter.
*
*
* Required permissions: kms:RevokeGrant (key policy).
*
*
* Related operations:
*
*
* -
*
* CreateGrant
*
*
* -
*
* ListGrants
*
*
* -
*
*
* -
*
* RetireGrant
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param revokeGrantRequest
* @return Result of the RevokeGrant operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws InvalidGrantIdException
* The request was rejected because the specified GrantId is not valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws DryRunOperationException
* The request was rejected because the DryRun parameter was specified.
* @sample AWSKMS.RevokeGrant
* @see AWS API
* Documentation
*/
@Override
public RevokeGrantResult revokeGrant(RevokeGrantRequest request) {
request = beforeClientExecution(request);
return executeRevokeGrant(request);
}
@SdkInternalApi
final RevokeGrantResult executeRevokeGrant(RevokeGrantRequest revokeGrantRequest) {
ExecutionContext executionContext = createExecutionContext(revokeGrantRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RevokeGrantRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(revokeGrantRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RevokeGrant");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new RevokeGrantResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Immediately initiates rotation of the key material of the specified symmetric encryption KMS key.
*
*
* You can perform on-demand
* rotation of the key material in customer managed KMS keys, regardless of whether or not automatic key rotation is enabled. On-demand rotations do not change existing automatic rotation schedules.
* For example, consider a KMS key that has automatic key rotation enabled with a rotation period of 730 days. If
* the key is scheduled to automatically rotate on April 14, 2024, and you perform an on-demand rotation on April
* 10, 2024, the key will automatically rotate, as scheduled, on April 14, 2024 and every 730 days thereafter.
*
*
*
* You can perform on-demand key rotation a maximum of 10 times per KMS key. You can use the KMS console to
* view the number of remaining on-demand rotations available for a KMS key.
*
*
*
* You can use GetKeyRotationStatus to identify any in progress on-demand rotations. You can use
* ListKeyRotations to identify the date that completed on-demand rotations were performed. You can monitor
* rotation of the key material for your KMS keys in CloudTrail and Amazon CloudWatch.
*
*
* On-demand key rotation is supported only on symmetric encryption
* KMS keys. You cannot perform on-demand rotation of asymmetric KMS keys,
* HMAC KMS keys, KMS keys with imported key material, or
* KMS keys in a custom key store.
* To perform on-demand rotation of a set of related multi-Region keys, invoke the on-demand rotation on the primary key.
*
*
* You cannot initiate on-demand rotation of Amazon Web Services
* managed KMS keys. KMS always rotates the key material of Amazon Web Services managed keys every year.
* Rotation of Amazon
* Web Services owned KMS keys is managed by the Amazon Web Services service that owns the key.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:RotateKeyOnDemand (key policy)
*
*
* Related operations:
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
* ListKeyRotations
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param rotateKeyOnDemandRequest
* @return Result of the RotateKeyOnDemand operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws UnsupportedOperationException
* The request was rejected because a specified parameter is not supported or a specified resource is not
* valid for this operation.
* @throws LimitExceededException
* The request was rejected because a quota was exceeded. For more information, see Quotas in the Key
* Management Service Developer Guide.
* @throws ConflictException
* The request was rejected because an automatic rotation of this key is currently in progress or scheduled
* to begin within the next 20 minutes.
* @sample AWSKMS.RotateKeyOnDemand
* @see AWS API
* Documentation
*/
@Override
public RotateKeyOnDemandResult rotateKeyOnDemand(RotateKeyOnDemandRequest request) {
request = beforeClientExecution(request);
return executeRotateKeyOnDemand(request);
}
@SdkInternalApi
final RotateKeyOnDemandResult executeRotateKeyOnDemand(RotateKeyOnDemandRequest rotateKeyOnDemandRequest) {
ExecutionContext executionContext = createExecutionContext(rotateKeyOnDemandRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RotateKeyOnDemandRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(rotateKeyOnDemandRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RotateKeyOnDemand");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new RotateKeyOnDemandResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Schedules the deletion of a KMS key. By default, KMS applies a waiting period of 30 days, but you can specify a
* waiting period of 7-30 days. When this operation is successful, the key state of the KMS key changes to
* PendingDeletion and the key can't be used in any cryptographic operations. It remains in this state
* for the duration of the waiting period. Before the waiting period ends, you can use CancelKeyDeletion to
* cancel the deletion of the KMS key. After the waiting period ends, KMS deletes the KMS key, its key material, and
* all KMS data associated with it, including all aliases that refer to it.
*
*
*
* Deleting a KMS key is a destructive and potentially dangerous operation. When a KMS key is deleted, all data that
* was encrypted under the KMS key is unrecoverable. (The only exception is a multi-Region replica
* key, or an asymmetric or
* HMAC KMS key with imported key material.) To prevent the use of a KMS key without deleting it, use
* DisableKey.
*
*
*
* You can schedule the deletion of a multi-Region primary key and its replica keys at any time. However, KMS will
* not delete a multi-Region primary key with existing replica keys. If you schedule the deletion of a primary key
* with replicas, its key state changes to PendingReplicaDeletion and it cannot be replicated or used
* in cryptographic operations. This status can continue indefinitely. When the last of its replicas keys is deleted
* (not just scheduled), the key state of the primary key changes to PendingDeletion and its waiting
* period (PendingWindowInDays) begins. For details, see Deleting multi-Region
* keys in the Key Management Service Developer Guide.
*
*
* When KMS deletes a KMS
* key from an CloudHSM key store, it makes a best effort to delete the associated key material from the
* associated CloudHSM cluster. However, you might need to manually delete
* the orphaned key material from the cluster and its backups. Deleting a KMS key from an
* external key store has no effect on the associated external key. However, for both types of custom key
* stores, deleting a KMS key is destructive and irreversible. You cannot decrypt ciphertext encrypted under the KMS
* key by using only its associated external key or CloudHSM key. Also, you cannot recreate a KMS key in an external
* key store by creating a new KMS key with the same key material.
*
*
* For more information about scheduling a KMS key for deletion, see Deleting KMS keys in the
* Key Management Service Developer Guide.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:ScheduleKeyDeletion (key policy)
*
*
* Related operations
*
*
* -
*
*
* -
*
* DisableKey
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param scheduleKeyDeletionRequest
* @return Result of the ScheduleKeyDeletion operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @sample AWSKMS.ScheduleKeyDeletion
* @see AWS API
* Documentation
*/
@Override
public ScheduleKeyDeletionResult scheduleKeyDeletion(ScheduleKeyDeletionRequest request) {
request = beforeClientExecution(request);
return executeScheduleKeyDeletion(request);
}
@SdkInternalApi
final ScheduleKeyDeletionResult executeScheduleKeyDeletion(ScheduleKeyDeletionRequest scheduleKeyDeletionRequest) {
ExecutionContext executionContext = createExecutionContext(scheduleKeyDeletionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ScheduleKeyDeletionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(scheduleKeyDeletionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ScheduleKeyDeletion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ScheduleKeyDeletionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a digital signature for a message or
* message digest by using the private key in an asymmetric signing KMS key. To verify the signature, use the
* Verify operation, or use the public key in the same asymmetric KMS key outside of KMS. For information
* about asymmetric KMS keys, see Asymmetric KMS keys in
* the Key Management Service Developer Guide.
*
*
* Digital signatures are generated and verified by using asymmetric key pair, such as an RSA or ECC pair that is
* represented by an asymmetric KMS key. The key owner (or an authorized user) uses their private key to sign a
* message. Anyone with the public key can verify that the message was signed with that particular private key and
* that the message hasn't changed since it was signed.
*
*
* To use the Sign operation, provide the following information:
*
*
* -
*
* Use the KeyId parameter to identify an asymmetric KMS key with a KeyUsage value of
* SIGN_VERIFY. To get the KeyUsage value of a KMS key, use the DescribeKey
* operation. The caller must have kms:Sign permission on the KMS key.
*
*
* -
*
* Use the Message parameter to specify the message or message digest to sign. You can submit messages
* of up to 4096 bytes. To sign a larger message, generate a hash digest of the message, and then provide the hash
* digest in the Message parameter. To indicate whether the message is a full message or a digest, use
* the MessageType parameter.
*
*
* -
*
* Choose a signing algorithm that is compatible with the KMS key.
*
*
*
*
*
* When signing a message, be sure to record the KMS key and the signing algorithm. This information is required to
* verify the signature.
*
*
*
* Best practices recommend that you limit the time during which any signature is effective. This deters an attack
* where the actor uses a signed message to establish validity repeatedly or long after the message is superseded.
* Signatures do not include a timestamp, but you can include a timestamp in the signed message to help you detect
* when its time to refresh the signature.
*
*
*
* To verify the signature that this operation generates, use the Verify operation. Or use the
* GetPublicKey operation to download the public key and then use the public key to verify the signature
* outside of KMS.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: Yes. To perform this operation with a KMS key in a different Amazon Web Services
* account, specify the key ARN or alias ARN in the value of the KeyId parameter.
*
*
* Required permissions: kms:Sign (key
* policy)
*
*
* Related operations: Verify
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param signRequest
* @return Result of the Sign operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws KeyUnavailableException
* The request was rejected because the specified KMS key was not available. You can retry the request.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws InvalidKeyUsageException
* The request was rejected for one of the following reasons:
*
* -
*
* The KeyUsage value of the KMS key is incompatible with the API operation.
*
*
* -
*
* The encryption algorithm or signing algorithm specified for the operation is incompatible with the type
* of key material in the KMS key (KeySpec).
*
*
*
*
* For encrypting, decrypting, re-encrypting, and generating data keys, the KeyUsage must be
* ENCRYPT_DECRYPT. For signing and verifying messages, the KeyUsage must be
* SIGN_VERIFY. For generating and verifying message authentication codes (MACs), the
* KeyUsage must be GENERATE_VERIFY_MAC. For deriving key agreement secrets, the
* KeyUsage must be KEY_AGREEMENT. To find the KeyUsage of a KMS key,
* use the DescribeKey operation.
*
*
* To find the encryption or signing algorithms supported for a particular KMS key, use the
* DescribeKey operation.
* @throws InvalidGrantTokenException
* The request was rejected because the specified grant token is not valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws DryRunOperationException
* The request was rejected because the DryRun parameter was specified.
* @sample AWSKMS.Sign
* @see AWS API Documentation
*/
@Override
public SignResult sign(SignRequest request) {
request = beforeClientExecution(request);
return executeSign(request);
}
@SdkInternalApi
final SignResult executeSign(SignRequest signRequest) {
ExecutionContext executionContext = createExecutionContext(signRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SignRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(signRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "Sign");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new SignResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Adds or edits tags on a customer managed key.
*
*
*
* Tagging or untagging a KMS key can allow or deny permission to the KMS key. For details, see ABAC for KMS in the Key Management
* Service Developer Guide.
*
*
*
* Each tag consists of a tag key and a tag value, both of which are case-sensitive strings. The tag value can be an
* empty (null) string. To add a tag, specify a new tag key and a tag value. To edit a tag, specify an existing tag
* key and a new tag value.
*
*
* You can use this operation to tag a customer managed key,
* but you cannot tag an Amazon Web Services
* managed key, an Amazon Web Services
* owned key, a custom key store,
* or an alias.
*
*
* You can also add tags to a KMS key while creating it (CreateKey) or replicating it (ReplicateKey).
*
*
* For information about using tags in KMS, see Tagging keys. For general
* information about tags, including the format and syntax, see Tagging Amazon Web Services resources
* in the Amazon Web Services General Reference.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:TagResource (key policy)
*
*
* Related operations
*
*
* -
*
* CreateKey
*
*
* -
*
* ListResourceTags
*
*
* -
*
* ReplicateKey
*
*
* -
*
* UntagResource
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param tagResourceRequest
* @return Result of the TagResource operation returned by the service.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws LimitExceededException
* The request was rejected because a quota was exceeded. For more information, see Quotas in the Key
* Management Service Developer Guide.
* @throws TagException
* The request was rejected because one or more tags are not valid.
* @sample AWSKMS.TagResource
* @see AWS API
* Documentation
*/
@Override
public TagResourceResult tagResource(TagResourceRequest request) {
request = beforeClientExecution(request);
return executeTagResource(request);
}
@SdkInternalApi
final TagResourceResult executeTagResource(TagResourceRequest tagResourceRequest) {
ExecutionContext executionContext = createExecutionContext(tagResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new TagResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(tagResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "TagResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new TagResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes tags from a customer managed key.
* To delete a tag, specify the tag key and the KMS key.
*
*
*
* Tagging or untagging a KMS key can allow or deny permission to the KMS key. For details, see ABAC for KMS in the Key Management
* Service Developer Guide.
*
*
*
* When it succeeds, the UntagResource operation doesn't return any output. Also, if the specified tag
* key isn't found on the KMS key, it doesn't throw an exception or return a response. To confirm that the operation
* worked, use the ListResourceTags operation.
*
*
* For information about using tags in KMS, see Tagging keys. For general
* information about tags, including the format and syntax, see Tagging Amazon Web Services resources
* in the Amazon Web Services General Reference.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:UntagResource (key policy)
*
*
* Related operations
*
*
* -
*
* CreateKey
*
*
* -
*
* ListResourceTags
*
*
* -
*
* ReplicateKey
*
*
* -
*
* TagResource
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param untagResourceRequest
* @return Result of the UntagResource operation returned by the service.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws TagException
* The request was rejected because one or more tags are not valid.
* @sample AWSKMS.UntagResource
* @see AWS API
* Documentation
*/
@Override
public UntagResourceResult untagResource(UntagResourceRequest request) {
request = beforeClientExecution(request);
return executeUntagResource(request);
}
@SdkInternalApi
final UntagResourceResult executeUntagResource(UntagResourceRequest untagResourceRequest) {
ExecutionContext executionContext = createExecutionContext(untagResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UntagResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(untagResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UntagResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UntagResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Associates an existing KMS alias with a different KMS key. Each alias is associated with only one KMS key at a
* time, although a KMS key can have multiple aliases. The alias and the KMS key must be in the same Amazon Web
* Services account and Region.
*
*
*
* Adding, deleting, or updating an alias can allow or deny permission to the KMS key. For details, see ABAC for KMS in the Key Management
* Service Developer Guide.
*
*
*
* The current and new KMS key must be the same type (both symmetric or both asymmetric or both HMAC), and they must
* have the same key usage. This restriction prevents errors in code that uses aliases. If you must assign an alias
* to a different type of KMS key, use DeleteAlias to delete the old alias and CreateAlias to create a
* new alias.
*
*
* You cannot use UpdateAlias to change an alias name. To change an alias name, use DeleteAlias
* to delete the old alias and CreateAlias to create a new alias.
*
*
* Because an alias is not a property of a KMS key, you can create, update, and delete the aliases of a KMS key
* without affecting the KMS key. Also, aliases do not appear in the response from the DescribeKey operation.
* To get the aliases of all KMS keys in the account, use the ListAliases operation.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions
*
*
* -
*
* kms:UpdateAlias
* on the alias (IAM policy).
*
*
* -
*
* kms:UpdateAlias
* on the current KMS key (key policy).
*
*
* -
*
* kms:UpdateAlias
* on the new KMS key (key policy).
*
*
*
*
* For details, see Controlling access to
* aliases in the Key Management Service Developer Guide.
*
*
* Related operations:
*
*
* -
*
* CreateAlias
*
*
* -
*
* DeleteAlias
*
*
* -
*
* ListAliases
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param updateAliasRequest
* @return Result of the UpdateAlias operation returned by the service.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws LimitExceededException
* The request was rejected because a quota was exceeded. For more information, see Quotas in the Key
* Management Service Developer Guide.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @sample AWSKMS.UpdateAlias
* @see AWS API
* Documentation
*/
@Override
public UpdateAliasResult updateAlias(UpdateAliasRequest request) {
request = beforeClientExecution(request);
return executeUpdateAlias(request);
}
@SdkInternalApi
final UpdateAliasResult executeUpdateAlias(UpdateAliasRequest updateAliasRequest) {
ExecutionContext executionContext = createExecutionContext(updateAliasRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateAliasRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateAliasRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateAlias");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateAliasResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Changes the properties of a custom key store. You can use this operation to change the properties of an CloudHSM
* key store or an external key store.
*
*
* Use the required CustomKeyStoreId parameter to identify the custom key store. Use the remaining
* optional parameters to change its properties. This operation does not return any property values. To verify the
* updated property values, use the DescribeCustomKeyStores operation.
*
*
* This operation is part of the custom key stores
* feature in KMS, which combines the convenience and extensive integration of KMS with the isolation and control of
* a key store that you own and manage.
*
*
*
* When updating the properties of an external key store, verify that the updated settings connect your key store,
* via the external key store proxy, to the same external key manager as the previous settings, or to a backup or
* snapshot of the external key manager with the same cryptographic keys. If the updated connection settings fail,
* you can fix them and retry, although an extended delay might disrupt Amazon Web Services services. However, if
* KMS permanently loses its access to cryptographic keys, ciphertext encrypted under those keys is unrecoverable.
*
*
*
* For external key stores:
*
*
* Some external key managers provide a simpler method for updating an external key store. For details, see your
* external key manager documentation.
*
*
* When updating an external key store in the KMS console, you can upload a JSON-based proxy configuration file with
* the desired values. You cannot upload the proxy configuration file to the UpdateCustomKeyStore
* operation. However, you can use the file to help you determine the correct values for the
* UpdateCustomKeyStore parameters.
*
*
*
* For an CloudHSM key store, you can use this operation to change the custom key store friendly name (
* NewCustomKeyStoreName), to tell KMS about a change to the kmsuser crypto user password
* (KeyStorePassword), or to associate the custom key store with a different, but related, CloudHSM
* cluster (CloudHsmClusterId). To update any property of an CloudHSM key store, the
* ConnectionState of the CloudHSM key store must be DISCONNECTED.
*
*
* For an external key store, you can use this operation to change the custom key store friendly name (
* NewCustomKeyStoreName), or to tell KMS about a change to the external key store proxy authentication
* credentials (XksProxyAuthenticationCredential), connection method (XksProxyConnectivity
* ), external proxy endpoint (XksProxyUriEndpoint) and path (XksProxyUriPath). For
* external key stores with an XksProxyConnectivity of VPC_ENDPOINT_SERVICE, you can also
* update the Amazon VPC endpoint service name (XksProxyVpcEndpointServiceName). To update most
* properties of an external key store, the ConnectionState of the external key store must be
* DISCONNECTED. However, you can update the CustomKeyStoreName,
* XksProxyAuthenticationCredential, and XksProxyUriPath of an external key store when it
* is in the CONNECTED or DISCONNECTED state.
*
*
* If your update requires a DISCONNECTED state, before using UpdateCustomKeyStore, use
* the DisconnectCustomKeyStore operation to disconnect the custom key store. After the
* UpdateCustomKeyStore operation completes, use the ConnectCustomKeyStore to reconnect the
* custom key store. To find the ConnectionState of the custom key store, use the
* DescribeCustomKeyStores operation.
*
*
*
*
* Before updating the custom key store, verify that the new values allow KMS to connect the custom key store to its
* backing key store. For example, before you change the XksProxyUriPath value, verify that the
* external key store proxy is reachable at the new path.
*
*
* If the operation succeeds, it returns a JSON object with no properties.
*
*
* Cross-account use: No. You cannot perform this operation on a custom key store in a different Amazon Web
* Services account.
*
*
* Required permissions: kms:UpdateCustomKeyStore (IAM policy)
*
*
* Related operations:
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
* -
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param updateCustomKeyStoreRequest
* @return Result of the UpdateCustomKeyStore operation returned by the service.
* @throws CustomKeyStoreNotFoundException
* The request was rejected because KMS cannot find a custom key store with the specified key store name or
* ID.
* @throws CustomKeyStoreNameInUseException
* The request was rejected because the specified custom key store name is already assigned to another
* custom key store in the account. Try again with a custom key store name that is unique in the account.
* @throws CloudHsmClusterNotFoundException
* The request was rejected because KMS cannot find the CloudHSM cluster with the specified cluster ID.
* Retry the request with a different cluster ID.
* @throws CloudHsmClusterNotRelatedException
* The request was rejected because the specified CloudHSM cluster has a different cluster certificate than
* the original cluster. You cannot use the operation to specify an unrelated cluster for an CloudHSM key
* store.
*
* Specify an CloudHSM cluster that shares a backup history with the original cluster. This includes
* clusters that were created from a backup of the current cluster, and clusters that were created from the
* same backup that produced the current cluster.
*
*
* CloudHSM clusters that share a backup history have the same cluster certificate. To view the cluster
* certificate of an CloudHSM cluster, use the DescribeClusters operation.
* @throws CustomKeyStoreInvalidStateException
* The request was rejected because of the ConnectionState of the custom key store. To get the
* ConnectionState of a custom key store, use the DescribeCustomKeyStores operation.
*
*
* This exception is thrown under the following conditions:
*
*
* -
*
* You requested the ConnectCustomKeyStore operation on a custom key store with a
* ConnectionState of DISCONNECTING or FAILED. This operation is
* valid for all other ConnectionState values. To reconnect a custom key store in a
* FAILED state, disconnect it (DisconnectCustomKeyStore), then connect it (
* ConnectCustomKeyStore).
*
*
* -
*
* You requested the CreateKey operation in a custom key store that is not connected. This operations
* is valid only when the custom key store ConnectionState is CONNECTED.
*
*
* -
*
* You requested the DisconnectCustomKeyStore operation on a custom key store with a
* ConnectionState of DISCONNECTING or DISCONNECTED. This operation
* is valid for all other ConnectionState values.
*
*
* -
*
* You requested the UpdateCustomKeyStore or DeleteCustomKeyStore operation on a custom key
* store that is not disconnected. This operation is valid only when the custom key store
* ConnectionState is DISCONNECTED.
*
*
* -
*
* You requested the GenerateRandom operation in an CloudHSM key store that is not connected. This
* operation is valid only when the CloudHSM key store ConnectionState is
* CONNECTED.
*
*
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws CloudHsmClusterNotActiveException
* The request was rejected because the CloudHSM cluster associated with the CloudHSM key store is not
* active. Initialize and activate the cluster and try the command again. For detailed instructions, see Getting Started in
* the CloudHSM User Guide.
* @throws CloudHsmClusterInvalidConfigurationException
* The request was rejected because the associated CloudHSM cluster did not meet the configuration
* requirements for an CloudHSM key store.
*
* -
*
* The CloudHSM cluster must be configured with private subnets in at least two different Availability Zones
* in the Region.
*
*
* -
*
* The security group for
* the cluster (cloudhsm-cluster-<cluster-id>-sg) must include inbound rules and outbound
* rules that allow TCP traffic on ports 2223-2225. The Source in the inbound rules and the
* Destination in the outbound rules must match the security group ID. These rules are set by default
* when you create the CloudHSM cluster. Do not delete or change them. To get information about a particular
* security group, use the DescribeSecurityGroups operation.
*
*
* -
*
* The CloudHSM cluster must contain at least as many HSMs as the operation requires. To add HSMs, use the
* CloudHSM CreateHsm
* operation.
*
*
* For the CreateCustomKeyStore, UpdateCustomKeyStore, and CreateKey operations, the
* CloudHSM cluster must have at least two active HSMs, each in a different Availability Zone. For the
* ConnectCustomKeyStore operation, the CloudHSM must contain at least one active HSM.
*
*
*
*
* For information about the requirements for an CloudHSM cluster that is associated with an CloudHSM key
* store, see Assemble the Prerequisites in the Key Management Service Developer Guide. For information
* about creating a private subnet for an CloudHSM cluster, see Create a Private
* Subnet in the CloudHSM User Guide. For information about cluster security groups, see Configure a Default
* Security Group in the CloudHSM User Guide .
* @throws XksProxyUriInUseException
* The request was rejected because the concatenation of the XksProxyUriEndpoint and
* XksProxyUriPath is already associated with another external key store in this Amazon Web
* Services Region. Each external key store in a Region must use a unique external key store proxy API
* address.
* @throws XksProxyUriEndpointInUseException
* The request was rejected because the XksProxyUriEndpoint is already associated with another
* external key store in this Amazon Web Services Region. To identify the cause, see the error message that
* accompanies the exception.
* @throws XksProxyUriUnreachableException
* KMS was unable to reach the specified XksProxyUriPath. The path must be reachable before you
* create the external key store or update its settings.
*
*
* This exception is also thrown when the external key store proxy response to a
* GetHealthStatus request indicates that all external key manager instances are unavailable.
* @throws XksProxyIncorrectAuthenticationCredentialException
* The request was rejected because the proxy credentials failed to authenticate to the specified external
* key store proxy. The specified external key store proxy rejected a status request from KMS due to invalid
* credentials. This can indicate an error in the credentials or in the identification of the external key
* store proxy.
* @throws XksProxyVpcEndpointServiceInUseException
* The request was rejected because the specified Amazon VPC endpoint service is already associated with
* another external key store in this Amazon Web Services Region. Each external key store in a Region must
* use a different Amazon VPC endpoint service.
* @throws XksProxyVpcEndpointServiceNotFoundException
* The request was rejected because KMS could not find the specified VPC endpoint service. Use
* DescribeCustomKeyStores to verify the VPC endpoint service name for the external key store. Also,
* confirm that the Allow principals list for the VPC endpoint service includes the KMS service
* principal for the Region, such as cks.kms.us-east-1.amazonaws.com.
* @throws XksProxyVpcEndpointServiceInvalidConfigurationException
* The request was rejected because the Amazon VPC endpoint service configuration does not fulfill the
* requirements for an external key store. To identify the cause, see the error message that accompanies the
* exception and review the requirements for Amazon VPC endpoint service connectivity for an external key store.
* @throws XksProxyInvalidResponseException
*
* KMS cannot interpret the response it received from the external key store proxy. The problem might be a
* poorly constructed response, but it could also be a transient network issue. If you see this error
* repeatedly, report it to the proxy vendor.
* @throws XksProxyInvalidConfigurationException
* The request was rejected because the external key store proxy is not configured correctly. To identify
* the cause, see the error message that accompanies the exception.
* @sample AWSKMS.UpdateCustomKeyStore
* @see AWS API
* Documentation
*/
@Override
public UpdateCustomKeyStoreResult updateCustomKeyStore(UpdateCustomKeyStoreRequest request) {
request = beforeClientExecution(request);
return executeUpdateCustomKeyStore(request);
}
@SdkInternalApi
final UpdateCustomKeyStoreResult executeUpdateCustomKeyStore(UpdateCustomKeyStoreRequest updateCustomKeyStoreRequest) {
ExecutionContext executionContext = createExecutionContext(updateCustomKeyStoreRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateCustomKeyStoreRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateCustomKeyStoreRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateCustomKeyStore");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateCustomKeyStoreResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the description of a KMS key. To see the description of a KMS key, use DescribeKey.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: No. You cannot perform this operation on a KMS key in a different Amazon Web Services
* account.
*
*
* Required permissions: kms:UpdateKeyDescription (key policy)
*
*
* Related operations
*
*
* -
*
* CreateKey
*
*
* -
*
* DescribeKey
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param updateKeyDescriptionRequest
* @return Result of the UpdateKeyDescription operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @sample AWSKMS.UpdateKeyDescription
* @see AWS API
* Documentation
*/
@Override
public UpdateKeyDescriptionResult updateKeyDescription(UpdateKeyDescriptionRequest request) {
request = beforeClientExecution(request);
return executeUpdateKeyDescription(request);
}
@SdkInternalApi
final UpdateKeyDescriptionResult executeUpdateKeyDescription(UpdateKeyDescriptionRequest updateKeyDescriptionRequest) {
ExecutionContext executionContext = createExecutionContext(updateKeyDescriptionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateKeyDescriptionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateKeyDescriptionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateKeyDescription");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateKeyDescriptionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Changes the primary key of a multi-Region key.
*
*
* This operation changes the replica key in the specified Region to a primary key and changes the former primary
* key to a replica key. For example, suppose you have a primary key in us-east-1 and a replica key in
* eu-west-2. If you run UpdatePrimaryRegion with a PrimaryRegion value of
* eu-west-2, the primary key is now the key in eu-west-2, and the key in
* us-east-1 becomes a replica key. For details, see Updating the primary Region in the Key Management Service Developer Guide.
*
*
* This operation supports multi-Region keys, an KMS feature that lets you create multiple interoperable KMS
* keys in different Amazon Web Services Regions. Because these KMS keys have the same key ID, key material, and
* other metadata, you can use them interchangeably to encrypt data in one Amazon Web Services Region and decrypt it
* in a different Amazon Web Services Region without re-encrypting the data or making a cross-Region call. For more
* information about multi-Region keys, see Multi-Region keys in
* KMS in the Key Management Service Developer Guide.
*
*
* The primary key of a multi-Region key is the source for properties that are always shared by primary and
* replica keys, including the key material, key ID, key spec, key usage, key material origin,
* and automatic key rotation.
* It's the only key that can be replicated. You cannot delete the primary
* key until all replica keys are deleted.
*
*
* The key ID and primary Region that you specify uniquely identify the replica key that will become the primary
* key. The primary Region must already have a replica key. This operation does not create a KMS key in the
* specified Region. To find the replica keys, use the DescribeKey operation on the primary key or any
* replica key. To create a replica key, use the ReplicateKey operation.
*
*
* You can run this operation while using the affected multi-Region keys in cryptographic operations. This operation
* should not delay, interrupt, or cause failures in cryptographic operations.
*
*
* Even after this operation completes, the process of updating the primary Region might still be in progress for a
* few more seconds. Operations such as DescribeKey might display both the old and new primary keys as
* replicas. The old and new primary keys have a transient key state of Updating. The original key
* state is restored when the update is complete. While the key state is Updating, you can use the keys
* in cryptographic operations, but you cannot replicate the new primary key or perform certain management
* operations, such as enabling or disabling these keys. For details about the Updating key state, see
* Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* This operation does not return any output. To verify that primary key is changed, use the DescribeKey
* operation.
*
*
* Cross-account use: No. You cannot use this operation in a different Amazon Web Services account.
*
*
* Required permissions:
*
*
* -
*
* kms:UpdatePrimaryRegion on the current primary key (in the primary key's Region). Include this
* permission primary key's key policy.
*
*
* -
*
* kms:UpdatePrimaryRegion on the current replica key (in the replica key's Region). Include this
* permission in the replica key's key policy.
*
*
*
*
* Related operations
*
*
* -
*
* CreateKey
*
*
* -
*
* ReplicateKey
*
*
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param updatePrimaryRegionRequest
* @return Result of the UpdatePrimaryRegion operation returned by the service.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws InvalidArnException
* The request was rejected because a specified ARN, or an ARN in a key policy, is not valid.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws UnsupportedOperationException
* The request was rejected because a specified parameter is not supported or a specified resource is not
* valid for this operation.
* @sample AWSKMS.UpdatePrimaryRegion
* @see AWS API
* Documentation
*/
@Override
public UpdatePrimaryRegionResult updatePrimaryRegion(UpdatePrimaryRegionRequest request) {
request = beforeClientExecution(request);
return executeUpdatePrimaryRegion(request);
}
@SdkInternalApi
final UpdatePrimaryRegionResult executeUpdatePrimaryRegion(UpdatePrimaryRegionRequest updatePrimaryRegionRequest) {
ExecutionContext executionContext = createExecutionContext(updatePrimaryRegionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdatePrimaryRegionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updatePrimaryRegionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdatePrimaryRegion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdatePrimaryRegionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Verifies a digital signature that was generated by the Sign operation.
*
*
*
* Verification confirms that an authorized user signed the message with the specified KMS key and signing
* algorithm, and the message hasn't changed since it was signed. If the signature is verified, the value of the
* SignatureValid field in the response is True. If the signature verification fails, the
* Verify operation fails with an KMSInvalidSignatureException exception.
*
*
* A digital signature is generated by using the private key in an asymmetric KMS key. The signature is verified by
* using the public key in the same asymmetric KMS key. For information about asymmetric KMS keys, see Asymmetric KMS keys in
* the Key Management Service Developer Guide.
*
*
* To use the Verify operation, specify the same asymmetric KMS key, message, and signing algorithm
* that were used to produce the signature. The message type does not need to be the same as the one used for
* signing, but it must indicate whether the value of the Message parameter should be hashed as part of
* the verification process.
*
*
* You can also verify the digital signature by using the public key of the KMS key outside of KMS. Use the
* GetPublicKey operation to download the public key in the asymmetric KMS key and then use the public key to
* verify the signature outside of KMS. The advantage of using the Verify operation is that it is
* performed within KMS. As a result, it's easy to call, the operation is performed within the FIPS boundary, it is
* logged in CloudTrail, and you can use key policy and IAM policy to determine who is authorized to use the KMS key
* to verify signatures.
*
*
* To verify a signature outside of KMS with an SM2 public key (China Regions only), you must specify the
* distinguishing ID. By default, KMS uses 1234567812345678 as the distinguishing ID. For more
* information, see Offline verification with SM2 key pairs.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: Yes. To perform this operation with a KMS key in a different Amazon Web Services
* account, specify the key ARN or alias ARN in the value of the KeyId parameter.
*
*
* Required permissions: kms:Verify
* (key policy)
*
*
* Related operations: Sign
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param verifyRequest
* @return Result of the Verify operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws KeyUnavailableException
* The request was rejected because the specified KMS key was not available. You can retry the request.
* @throws DependencyTimeoutException
* The system timed out while trying to fulfill the request. You can retry the request.
* @throws InvalidKeyUsageException
* The request was rejected for one of the following reasons:
*
* -
*
* The KeyUsage value of the KMS key is incompatible with the API operation.
*
*
* -
*
* The encryption algorithm or signing algorithm specified for the operation is incompatible with the type
* of key material in the KMS key (KeySpec).
*
*
*
*
* For encrypting, decrypting, re-encrypting, and generating data keys, the KeyUsage must be
* ENCRYPT_DECRYPT. For signing and verifying messages, the KeyUsage must be
* SIGN_VERIFY. For generating and verifying message authentication codes (MACs), the
* KeyUsage must be GENERATE_VERIFY_MAC. For deriving key agreement secrets, the
* KeyUsage must be KEY_AGREEMENT. To find the KeyUsage of a KMS key,
* use the DescribeKey operation.
*
*
* To find the encryption or signing algorithms supported for a particular KMS key, use the
* DescribeKey operation.
* @throws InvalidGrantTokenException
* The request was rejected because the specified grant token is not valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws KMSInvalidSignatureException
* The request was rejected because the signature verification failed. Signature verification fails when it
* cannot confirm that signature was produced by signing the specified message with the specified KMS key
* and signing algorithm.
* @throws DryRunOperationException
* The request was rejected because the DryRun parameter was specified.
* @sample AWSKMS.Verify
* @see AWS API
* Documentation
*/
@Override
public VerifyResult verify(VerifyRequest request) {
request = beforeClientExecution(request);
return executeVerify(request);
}
@SdkInternalApi
final VerifyResult executeVerify(VerifyRequest verifyRequest) {
ExecutionContext executionContext = createExecutionContext(verifyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new VerifyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(verifyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "Verify");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new VerifyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Verifies the hash-based message authentication code (HMAC) for a specified message, HMAC KMS key, and MAC
* algorithm. To verify the HMAC, VerifyMac computes an HMAC using the message, HMAC KMS key, and MAC
* algorithm that you specify, and compares the computed HMAC to the HMAC that you specify. If the HMACs are
* identical, the verification succeeds; otherwise, it fails. Verification indicates that the message hasn't changed
* since the HMAC was calculated, and the specified key was used to generate and verify the HMAC.
*
*
* HMAC KMS keys and the HMAC algorithms that KMS uses conform to industry standards defined in RFC 2104.
*
*
* This operation is part of KMS support for HMAC KMS keys. For details, see HMAC keys in KMS in the Key
* Management Service Developer Guide.
*
*
* The KMS key that you use for this operation must be in a compatible key state. For details, see Key states of KMS keys in the
* Key Management Service Developer Guide.
*
*
* Cross-account use: Yes. To perform this operation with a KMS key in a different Amazon Web Services
* account, specify the key ARN or alias ARN in the value of the KeyId parameter.
*
*
* Required permissions: kms:VerifyMac
* (key policy)
*
*
* Related operations: GenerateMac
*
*
* Eventual consistency: The KMS API follows an eventual consistency model. For more information, see KMS eventual
* consistency.
*
*
* @param verifyMacRequest
* @return Result of the VerifyMac operation returned by the service.
* @throws NotFoundException
* The request was rejected because the specified entity or resource could not be found.
* @throws DisabledException
* The request was rejected because the specified KMS key is not enabled.
* @throws KeyUnavailableException
* The request was rejected because the specified KMS key was not available. You can retry the request.
* @throws InvalidKeyUsageException
* The request was rejected for one of the following reasons:
*
* -
*
* The KeyUsage value of the KMS key is incompatible with the API operation.
*
*
* -
*
* The encryption algorithm or signing algorithm specified for the operation is incompatible with the type
* of key material in the KMS key (KeySpec).
*
*
*
*
* For encrypting, decrypting, re-encrypting, and generating data keys, the KeyUsage must be
* ENCRYPT_DECRYPT. For signing and verifying messages, the KeyUsage must be
* SIGN_VERIFY. For generating and verifying message authentication codes (MACs), the
* KeyUsage must be GENERATE_VERIFY_MAC. For deriving key agreement secrets, the
* KeyUsage must be KEY_AGREEMENT. To find the KeyUsage of a KMS key,
* use the DescribeKey operation.
*
*
* To find the encryption or signing algorithms supported for a particular KMS key, use the
* DescribeKey operation.
* @throws InvalidGrantTokenException
* The request was rejected because the specified grant token is not valid.
* @throws KMSInternalException
* The request was rejected because an internal exception occurred. The request can be retried.
* @throws KMSInvalidMacException
* The request was rejected because the HMAC verification failed. HMAC verification fails when the HMAC
* computed by using the specified message, HMAC KMS key, and MAC algorithm does not match the HMAC
* specified in the request.
* @throws KMSInvalidStateException
* The request was rejected because the state of the specified resource is not valid for this request.
*
*
* This exceptions means one of the following:
*
*
* -
*
* The key state of the KMS key is not compatible with the operation.
*
*
* To find the key state, use the DescribeKey operation. For more information about which key states
* are compatible with each KMS operation, see Key states of KMS keys in
* the Key Management Service Developer Guide .
*
*
* -
*
* For cryptographic operations on KMS keys in custom key stores, this exception represents a general
* failure with many possible causes. To identify the cause, see the error message that accompanies the
* exception.
*
*
* @throws DryRunOperationException
* The request was rejected because the DryRun parameter was specified.
* @sample AWSKMS.VerifyMac
* @see AWS API
* Documentation
*/
@Override
public VerifyMacResult verifyMac(VerifyMacRequest request) {
request = beforeClientExecution(request);
return executeVerifyMac(request);
}
@SdkInternalApi
final VerifyMacResult executeVerifyMac(VerifyMacRequest verifyMacRequest) {
ExecutionContext executionContext = createExecutionContext(verifyMacRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new VerifyMacRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(verifyMacRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "KMS");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "VerifyMac");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new VerifyMacResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* Returns additional metadata for a previously executed successful, request, typically used for debugging issues
* where a service isn't acting as expected. This data isn't considered part of the result data returned by an
* operation, so it's available through this separate, diagnostic interface.
*
* Response metadata is only cached for a limited period of time, so if you need to access this extra diagnostic
* information for an executed request, you should use this method to retrieve it as soon as possible after
* executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none is available.
*/
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
return invoke(request, responseHandler, executionContext, null, null);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI cachedEndpoint, URI uriFromEndpointTrait) {
executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(request.getOriginalRequest(), awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext, cachedEndpoint, uriFromEndpointTrait);
}
/**
* Invoke with no authentication. Credentials are not required and any credentials set on the client or request will
* be ignored for this operation.
**/
private Response anonymousInvoke(Request request,
HttpResponseHandler> responseHandler, ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext, null, null);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack thereof) have been configured in the
* ExecutionContext beforehand.
**/
private Response doInvoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI discoveredEndpoint, URI uriFromEndpointTrait) {
if (discoveredEndpoint != null) {
request.setEndpoint(discoveredEndpoint);
request.getOriginalRequest().getRequestClientOptions().appendUserAgent("endpoint-discovery");
} else if (uriFromEndpointTrait != null) {
request.setEndpoint(uriFromEndpointTrait);
} else {
request.setEndpoint(endpoint);
}
request.setTimeOffset(timeOffset);
HttpResponseHandler errorResponseHandler = protocolFactory.createErrorResponseHandler(new JsonErrorResponseMetadata());
return client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
@com.amazonaws.annotation.SdkInternalApi
static com.amazonaws.protocol.json.SdkJsonProtocolFactory getProtocolFactory() {
return protocolFactory;
}
@Override
public void shutdown() {
super.shutdown();
}
}