Add support for certificates to be signed by 3rd party certificate authorities. New API GetCertificateSigningRequest API and support for providing certificates at run-time for tr-34 import/export

Author: aws-sdk-cpp-automation

VERSION

@@ -1 +1 @@
-1.11.646
+1.11.647

generated/src/aws-cpp-sdk-payment-cryptography/include/aws/payment-cryptography/PaymentCryptographyClient.h

@@ -641,6 +641,31 @@ namespace PaymentCryptography
             return SubmitAsync(&PaymentCryptographyClient::GetAlias, request, handler, context);
         }
 
+        /**
+         * <p>Used to retrieve the public key for a keypair.</p><p><h3>See Also:</h3>   <a
+         * href="http://docs.aws.amazon.com/goto/WebAPI/payment-cryptography-2021-09-14/GetCertificateSigningRequest">AWS
+         * API Reference</a></p>
+         */
+        virtual Model::GetCertificateSigningRequestOutcome GetCertificateSigningRequest(const Model::GetCertificateSigningRequestRequest& request) const;
+
+        /**
+         * A Callable wrapper for GetCertificateSigningRequest that returns a future to the operation so that it can be executed in parallel to other requests.
+         */
+        template<typename GetCertificateSigningRequestRequestT = Model::GetCertificateSigningRequestRequest>
+        Model::GetCertificateSigningRequestOutcomeCallable GetCertificateSigningRequestCallable(const GetCertificateSigningRequestRequestT& request) const
+        {
+            return SubmitCallable(&PaymentCryptographyClient::GetCertificateSigningRequest, request);
+        }
+
+        /**
+         * An Async wrapper for GetCertificateSigningRequest that queues the request into a thread executor and triggers associated callback when operation has finished.
+         */
+        template<typename GetCertificateSigningRequestRequestT = Model::GetCertificateSigningRequestRequest>
+        void GetCertificateSigningRequestAsync(const GetCertificateSigningRequestRequestT& request, const GetCertificateSigningRequestResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
+        {
+            return SubmitAsync(&PaymentCryptographyClient::GetCertificateSigningRequest, request, handler, context);
+        }
+
         /**
          * <p>Retrieves the list of regions where default key replication is currently
          * enabled for your account.</p> <p>This operation returns the current

generated/src/aws-cpp-sdk-payment-cryptography/include/aws/payment-cryptography/PaymentCryptographyServiceClientModel.h

@@ -27,6 +27,7 @@
 #include <aws/payment-cryptography/model/EnableDefaultKeyReplicationRegionsResult.h>
 #include <aws/payment-cryptography/model/ExportKeyResult.h>
 #include <aws/payment-cryptography/model/GetAliasResult.h>
+#include <aws/payment-cryptography/model/GetCertificateSigningRequestResult.h>
 #include <aws/payment-cryptography/model/GetDefaultKeyReplicationRegionsResult.h>
 #include <aws/payment-cryptography/model/GetKeyResult.h>
 #include <aws/payment-cryptography/model/GetParametersForExportResult.h>
@@ -95,6 +96,7 @@ namespace Aws
       class EnableDefaultKeyReplicationRegionsRequest;
       class ExportKeyRequest;
       class GetAliasRequest;
+      class GetCertificateSigningRequestRequest;
       class GetDefaultKeyReplicationRegionsRequest;
       class GetKeyRequest;
       class GetParametersForExportRequest;
@@ -123,6 +125,7 @@ namespace Aws
       typedef Aws::Utils::Outcome<EnableDefaultKeyReplicationRegionsResult, PaymentCryptographyError> EnableDefaultKeyReplicationRegionsOutcome;
       typedef Aws::Utils::Outcome<ExportKeyResult, PaymentCryptographyError> ExportKeyOutcome;
       typedef Aws::Utils::Outcome<GetAliasResult, PaymentCryptographyError> GetAliasOutcome;
+      typedef Aws::Utils::Outcome<GetCertificateSigningRequestResult, PaymentCryptographyError> GetCertificateSigningRequestOutcome;
       typedef Aws::Utils::Outcome<GetDefaultKeyReplicationRegionsResult, PaymentCryptographyError> GetDefaultKeyReplicationRegionsOutcome;
       typedef Aws::Utils::Outcome<GetKeyResult, PaymentCryptographyError> GetKeyOutcome;
       typedef Aws::Utils::Outcome<GetParametersForExportResult, PaymentCryptographyError> GetParametersForExportOutcome;
@@ -151,6 +154,7 @@ namespace Aws
       typedef std::future<EnableDefaultKeyReplicationRegionsOutcome> EnableDefaultKeyReplicationRegionsOutcomeCallable;
       typedef std::future<ExportKeyOutcome> ExportKeyOutcomeCallable;
       typedef std::future<GetAliasOutcome> GetAliasOutcomeCallable;
+      typedef std::future<GetCertificateSigningRequestOutcome> GetCertificateSigningRequestOutcomeCallable;
       typedef std::future<GetDefaultKeyReplicationRegionsOutcome> GetDefaultKeyReplicationRegionsOutcomeCallable;
       typedef std::future<GetKeyOutcome> GetKeyOutcomeCallable;
       typedef std::future<GetParametersForExportOutcome> GetParametersForExportOutcomeCallable;
@@ -182,6 +186,7 @@ namespace Aws
     typedef std::function<void(const PaymentCryptographyClient*, const Model::EnableDefaultKeyReplicationRegionsRequest&, const Model::EnableDefaultKeyReplicationRegionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > EnableDefaultKeyReplicationRegionsResponseReceivedHandler;
     typedef std::function<void(const PaymentCryptographyClient*, const Model::ExportKeyRequest&, const Model::ExportKeyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > ExportKeyResponseReceivedHandler;
     typedef std::function<void(const PaymentCryptographyClient*, const Model::GetAliasRequest&, const Model::GetAliasOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetAliasResponseReceivedHandler;
+    typedef std::function<void(const PaymentCryptographyClient*, const Model::GetCertificateSigningRequestRequest&, const Model::GetCertificateSigningRequestOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetCertificateSigningRequestResponseReceivedHandler;
     typedef std::function<void(const PaymentCryptographyClient*, const Model::GetDefaultKeyReplicationRegionsRequest&, const Model::GetDefaultKeyReplicationRegionsOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetDefaultKeyReplicationRegionsResponseReceivedHandler;
     typedef std::function<void(const PaymentCryptographyClient*, const Model::GetKeyRequest&, const Model::GetKeyOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetKeyResponseReceivedHandler;
     typedef std::function<void(const PaymentCryptographyClient*, const Model::GetParametersForExportRequest&, const Model::GetParametersForExportOutcome&, const std::shared_ptr<const Aws::Client::AsyncCallerContext>&) > GetParametersForExportResponseReceivedHandler;

generated/src/aws-cpp-sdk-payment-cryptography/include/aws/payment-cryptography/model/CertificateSubjectType.h

@@ -0,0 +1,149 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/payment-cryptography/PaymentCryptography_EXPORTS.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <utility>
+
+namespace Aws
+{
+namespace Utils
+{
+namespace Json
+{
+  class JsonValue;
+  class JsonView;
+} // namespace Json
+} // namespace Utils
+namespace PaymentCryptography
+{
+namespace Model
+{
+
+  /**
+   * <p>Metadata used in generating the CSR</p><p><h3>See Also:</h3>   <a
+   * href="http://docs.aws.amazon.com/goto/WebAPI/payment-cryptography-2021-09-14/CertificateSubjectType">AWS
+   * API Reference</a></p>
+   */
+  class CertificateSubjectType
+  {
+  public:
+    AWS_PAYMENTCRYPTOGRAPHY_API CertificateSubjectType() = default;
+    AWS_PAYMENTCRYPTOGRAPHY_API CertificateSubjectType(Aws::Utils::Json::JsonView jsonValue);
+    AWS_PAYMENTCRYPTOGRAPHY_API CertificateSubjectType& operator=(Aws::Utils::Json::JsonView jsonValue);
+    AWS_PAYMENTCRYPTOGRAPHY_API Aws::Utils::Json::JsonValue Jsonize() const;
+
+
+    ///@{
+    /**
+     * <p>Common Name to be used in the certificate signing request</p>
+     */
+    inline const Aws::String& GetCommonName() const { return m_commonName; }
+    inline bool CommonNameHasBeenSet() const { return m_commonNameHasBeenSet; }
+    template<typename CommonNameT = Aws::String>
+    void SetCommonName(CommonNameT&& value) { m_commonNameHasBeenSet = true; m_commonName = std::forward<CommonNameT>(value); }
+    template<typename CommonNameT = Aws::String>
+    CertificateSubjectType& WithCommonName(CommonNameT&& value) { SetCommonName(std::forward<CommonNameT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Organization Unit to be used in the certificate signing request</p>
+     */
+    inline const Aws::String& GetOrganizationUnit() const { return m_organizationUnit; }
+    inline bool OrganizationUnitHasBeenSet() const { return m_organizationUnitHasBeenSet; }
+    template<typename OrganizationUnitT = Aws::String>
+    void SetOrganizationUnit(OrganizationUnitT&& value) { m_organizationUnitHasBeenSet = true; m_organizationUnit = std::forward<OrganizationUnitT>(value); }
+    template<typename OrganizationUnitT = Aws::String>
+    CertificateSubjectType& WithOrganizationUnit(OrganizationUnitT&& value) { SetOrganizationUnit(std::forward<OrganizationUnitT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Organization to be used in the certificate signing request</p>
+     */
+    inline const Aws::String& GetOrganization() const { return m_organization; }
+    inline bool OrganizationHasBeenSet() const { return m_organizationHasBeenSet; }
+    template<typename OrganizationT = Aws::String>
+    void SetOrganization(OrganizationT&& value) { m_organizationHasBeenSet = true; m_organization = std::forward<OrganizationT>(value); }
+    template<typename OrganizationT = Aws::String>
+    CertificateSubjectType& WithOrganization(OrganizationT&& value) { SetOrganization(std::forward<OrganizationT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>City to be used in the certificate signing request</p>
+     */
+    inline const Aws::String& GetCity() const { return m_city; }
+    inline bool CityHasBeenSet() const { return m_cityHasBeenSet; }
+    template<typename CityT = Aws::String>
+    void SetCity(CityT&& value) { m_cityHasBeenSet = true; m_city = std::forward<CityT>(value); }
+    template<typename CityT = Aws::String>
+    CertificateSubjectType& WithCity(CityT&& value) { SetCity(std::forward<CityT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Country to be used in the certificate signing request</p>
+     */
+    inline const Aws::String& GetCountry() const { return m_country; }
+    inline bool CountryHasBeenSet() const { return m_countryHasBeenSet; }
+    template<typename CountryT = Aws::String>
+    void SetCountry(CountryT&& value) { m_countryHasBeenSet = true; m_country = std::forward<CountryT>(value); }
+    template<typename CountryT = Aws::String>
+    CertificateSubjectType& WithCountry(CountryT&& value) { SetCountry(std::forward<CountryT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>State Or Province to be used in the certificate signing request</p>
+     */
+    inline const Aws::String& GetStateOrProvince() const { return m_stateOrProvince; }
+    inline bool StateOrProvinceHasBeenSet() const { return m_stateOrProvinceHasBeenSet; }
+    template<typename StateOrProvinceT = Aws::String>
+    void SetStateOrProvince(StateOrProvinceT&& value) { m_stateOrProvinceHasBeenSet = true; m_stateOrProvince = std::forward<StateOrProvinceT>(value); }
+    template<typename StateOrProvinceT = Aws::String>
+    CertificateSubjectType& WithStateOrProvince(StateOrProvinceT&& value) { SetStateOrProvince(std::forward<StateOrProvinceT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Email to be used in the certificate signing request</p>
+     */
+    inline const Aws::String& GetEmailAddress() const { return m_emailAddress; }
+    inline bool EmailAddressHasBeenSet() const { return m_emailAddressHasBeenSet; }
+    template<typename EmailAddressT = Aws::String>
+    void SetEmailAddress(EmailAddressT&& value) { m_emailAddressHasBeenSet = true; m_emailAddress = std::forward<EmailAddressT>(value); }
+    template<typename EmailAddressT = Aws::String>
+    CertificateSubjectType& WithEmailAddress(EmailAddressT&& value) { SetEmailAddress(std::forward<EmailAddressT>(value)); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_commonName;
+    bool m_commonNameHasBeenSet = false;
+
+    Aws::String m_organizationUnit;
+    bool m_organizationUnitHasBeenSet = false;
+
+    Aws::String m_organization;
+    bool m_organizationHasBeenSet = false;
+
+    Aws::String m_city;
+    bool m_cityHasBeenSet = false;
+
+    Aws::String m_country;
+    bool m_countryHasBeenSet = false;
+
+    Aws::String m_stateOrProvince;
+    bool m_stateOrProvinceHasBeenSet = false;
+
+    Aws::String m_emailAddress;
+    bool m_emailAddressHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace PaymentCryptography
+} // namespace Aws

generated/src/aws-cpp-sdk-payment-cryptography/include/aws/payment-cryptography/model/ExportTr34KeyBlock.h

@@ -83,6 +83,30 @@ namespace Model
     ExportTr34KeyBlock& WithExportToken(ExportTokenT&& value) { SetExportToken(std::forward<ExportTokenT>(value)); return *this;}
     ///@}
 
+    ///@{
+    /**
+     * <p>Key Identifier used for signing the export key</p>
+     */
+    inline const Aws::String& GetSigningKeyIdentifier() const { return m_signingKeyIdentifier; }
+    inline bool SigningKeyIdentifierHasBeenSet() const { return m_signingKeyIdentifierHasBeenSet; }
+    template<typename SigningKeyIdentifierT = Aws::String>
+    void SetSigningKeyIdentifier(SigningKeyIdentifierT&& value) { m_signingKeyIdentifierHasBeenSet = true; m_signingKeyIdentifier = std::forward<SigningKeyIdentifierT>(value); }
+    template<typename SigningKeyIdentifierT = Aws::String>
+    ExportTr34KeyBlock& WithSigningKeyIdentifier(SigningKeyIdentifierT&& value) { SetSigningKeyIdentifier(std::forward<SigningKeyIdentifierT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Certificate used for signing the export key</p>
+     */
+    inline const Aws::String& GetSigningKeyCertificate() const { return m_signingKeyCertificate; }
+    inline bool SigningKeyCertificateHasBeenSet() const { return m_signingKeyCertificateHasBeenSet; }
+    template<typename SigningKeyCertificateT = Aws::String>
+    void SetSigningKeyCertificate(SigningKeyCertificateT&& value) { m_signingKeyCertificateHasBeenSet = true; m_signingKeyCertificate = std::forward<SigningKeyCertificateT>(value); }
+    template<typename SigningKeyCertificateT = Aws::String>
+    ExportTr34KeyBlock& WithSigningKeyCertificate(SigningKeyCertificateT&& value) { SetSigningKeyCertificate(std::forward<SigningKeyCertificateT>(value)); return *this;}
+    ///@}
+
     ///@{
     /**
      * <p>The format of key block that Amazon Web Services Payment Cryptography will
@@ -131,6 +155,12 @@ namespace Model
     Aws::String m_exportToken;
     bool m_exportTokenHasBeenSet = false;
 
+    Aws::String m_signingKeyIdentifier;
+    bool m_signingKeyIdentifierHasBeenSet = false;
+
+    Aws::String m_signingKeyCertificate;
+    bool m_signingKeyCertificateHasBeenSet = false;
+
     Tr34KeyBlockFormat m_keyBlockFormat{Tr34KeyBlockFormat::NOT_SET};
     bool m_keyBlockFormatHasBeenSet = false;
 

generated/src/aws-cpp-sdk-payment-cryptography/include/aws/payment-cryptography/model/GetCertificateSigningRequestRequest.h

@@ -0,0 +1,86 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#pragma once
+#include <aws/payment-cryptography/PaymentCryptography_EXPORTS.h>
+#include <aws/payment-cryptography/PaymentCryptographyRequest.h>
+#include <aws/core/utils/memory/stl/AWSString.h>
+#include <aws/payment-cryptography/model/SigningAlgorithmType.h>
+#include <aws/payment-cryptography/model/CertificateSubjectType.h>
+#include <utility>
+
+namespace Aws
+{
+namespace PaymentCryptography
+{
+namespace Model
+{
+
+  /**
+   */
+  class GetCertificateSigningRequestRequest : public PaymentCryptographyRequest
+  {
+  public:
+    AWS_PAYMENTCRYPTOGRAPHY_API GetCertificateSigningRequestRequest() = default;
+
+    // Service request name is the Operation name which will send this request out,
+    // each operation should has unique request name, so that we can get operation's name from this request.
+    // Note: this is not true for response, multiple operations may have the same response name,
+    // so we can not get operation's name from response.
+    inline virtual const char* GetServiceRequestName() const override { return "GetCertificateSigningRequest"; }
+
+    AWS_PAYMENTCRYPTOGRAPHY_API Aws::String SerializePayload() const override;
+
+    AWS_PAYMENTCRYPTOGRAPHY_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
+
+
+    ///@{
+    /**
+     * <p>Asymmetric key used for generating the certificate signing request</p>
+     */
+    inline const Aws::String& GetKeyIdentifier() const { return m_keyIdentifier; }
+    inline bool KeyIdentifierHasBeenSet() const { return m_keyIdentifierHasBeenSet; }
+    template<typename KeyIdentifierT = Aws::String>
+    void SetKeyIdentifier(KeyIdentifierT&& value) { m_keyIdentifierHasBeenSet = true; m_keyIdentifier = std::forward<KeyIdentifierT>(value); }
+    template<typename KeyIdentifierT = Aws::String>
+    GetCertificateSigningRequestRequest& WithKeyIdentifier(KeyIdentifierT&& value) { SetKeyIdentifier(std::forward<KeyIdentifierT>(value)); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Algorithm used to generate the certificate signing request</p>
+     */
+    inline SigningAlgorithmType GetSigningAlgorithm() const { return m_signingAlgorithm; }
+    inline bool SigningAlgorithmHasBeenSet() const { return m_signingAlgorithmHasBeenSet; }
+    inline void SetSigningAlgorithm(SigningAlgorithmType value) { m_signingAlgorithmHasBeenSet = true; m_signingAlgorithm = value; }
+    inline GetCertificateSigningRequestRequest& WithSigningAlgorithm(SigningAlgorithmType value) { SetSigningAlgorithm(value); return *this;}
+    ///@}
+
+    ///@{
+    /**
+     * <p>Certificate subject data</p>
+     */
+    inline const CertificateSubjectType& GetCertificateSubject() const { return m_certificateSubject; }
+    inline bool CertificateSubjectHasBeenSet() const { return m_certificateSubjectHasBeenSet; }
+    template<typename CertificateSubjectT = CertificateSubjectType>
+    void SetCertificateSubject(CertificateSubjectT&& value) { m_certificateSubjectHasBeenSet = true; m_certificateSubject = std::forward<CertificateSubjectT>(value); }
+    template<typename CertificateSubjectT = CertificateSubjectType>
+    GetCertificateSigningRequestRequest& WithCertificateSubject(CertificateSubjectT&& value) { SetCertificateSubject(std::forward<CertificateSubjectT>(value)); return *this;}
+    ///@}
+  private:
+
+    Aws::String m_keyIdentifier;
+    bool m_keyIdentifierHasBeenSet = false;
+
+    SigningAlgorithmType m_signingAlgorithm{SigningAlgorithmType::NOT_SET};
+    bool m_signingAlgorithmHasBeenSet = false;
+
+    CertificateSubjectType m_certificateSubject;
+    bool m_certificateSubjectHasBeenSet = false;
+  };
+
+} // namespace Model
+} // namespace PaymentCryptography
+} // namespace Aws