types

package
v1.10.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 23, 2024 License: Apache-2.0 Imports: 4 Imported by: 0

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessDeniedException 

type AccessDeniedException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

You do not have sufficient access to perform this action.

func (*AccessDeniedException) Error 

func (e *AccessDeniedException) Error() string

func (*AccessDeniedException) ErrorCode 

func (e *AccessDeniedException) ErrorCode() string

func (*AccessDeniedException) ErrorFault 

func (e *AccessDeniedException) ErrorFault() smithy.ErrorFault

func (*AccessDeniedException) ErrorMessage 

func (e *AccessDeniedException) ErrorMessage() string

type Alias 

type Alias struct {

	// A friendly name that you can use to refer to a key. The value must begin with
	// alias/ .
	//
	// Do not include confidential or sensitive information in this field. This field
	// may be displayed in plaintext in CloudTrail logs and other output.
	//
	// This member is required.
	AliasName *string

	// The KeyARN of the key associated with the alias.
	KeyArn *string
	// contains filtered or unexported fields
}

Contains information about an alias.

type ConflictException 

type ConflictException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

This request can cause an inconsistent state for the resource.

func (*ConflictException) Error 

func (e *ConflictException) Error() string

func (*ConflictException) ErrorCode 

func (e *ConflictException) ErrorCode() string

func (*ConflictException) ErrorFault 

func (e *ConflictException) ErrorFault() smithy.ErrorFault

func (*ConflictException) ErrorMessage 

func (e *ConflictException) ErrorMessage() string

type ExportAttributes added in v1.6.0 

type ExportAttributes struct {

	// Parameter information for IPEK export.
	ExportDukptInitialKey *ExportDukptInitialKey

	// The algorithm that Amazon Web Services Payment Cryptography uses to calculate
	// the key check value (KCV). It is used to validate the key integrity. Specify KCV
	// for IPEK export only.
	//
	// For TDES keys, the KCV is computed by encrypting 8 bytes, each with value of
	// zero, with the key to be checked and retaining the 3 highest order bytes of the
	// encrypted result. For AES keys, the KCV is computed using a CMAC algorithm where
	// the input data is 16 bytes of zero and retaining the 3 highest order bytes of
	// the encrypted result.
	KeyCheckValueAlgorithm KeyCheckValueAlgorithm
	// contains filtered or unexported fields
}

The attributes for IPEK generation during export.

type ExportDukptInitialKey added in v1.6.0 

type ExportDukptInitialKey struct {

	// The KSN for IPEK generation using DUKPT.
	//
	// KSN must be padded before sending to Amazon Web Services Payment Cryptography.
	// KSN hex length should be 20 for a TDES_2KEY key or 24 for an AES key.
	//
	// This member is required.
	KeySerialNumber *string
	// contains filtered or unexported fields
}

Parameter information for IPEK generation during export.

type ExportKeyCryptogram added in v1.7.0 

type ExportKeyCryptogram struct {

	// The KeyARN of the certificate chain that signs the wrapping key certificate
	// during RSA wrap and unwrap key export.
	//
	// This member is required.
	CertificateAuthorityPublicKeyIdentifier *string

	// The wrapping key certificate in PEM format (base64 encoded). Amazon Web
	// Services Payment Cryptography uses this certificate to wrap the key under
	// export.
	//
	// This member is required.
	WrappingKeyCertificate *string

	// The wrapping spec for the key under export.
	WrappingSpec WrappingKeySpec
	// contains filtered or unexported fields
}

Parameter information for key material export using asymmetric RSA wrap and unwrap key exchange method.

type ExportKeyMaterial 

type ExportKeyMaterial interface {
	// contains filtered or unexported methods
}

Parameter information for key material export from Amazon Web Services Payment Cryptography using TR-31 or TR-34 or RSA wrap and unwrap key exchange method.

The following types satisfy this interface: 

ExportKeyMaterialMemberKeyCryptogram
ExportKeyMaterialMemberTr31KeyBlock
ExportKeyMaterialMemberTr34KeyBlock
Example (OutputUsage) 
package main

import (
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/paymentcryptography/types"
)

func main() {
	var union types.ExportKeyMaterial
	// type switches can be used to check the union value
	switch v := union.(type) {
	case *types.ExportKeyMaterialMemberKeyCryptogram:
		_ = v.Value // Value is types.ExportKeyCryptogram

	case *types.ExportKeyMaterialMemberTr31KeyBlock:
		_ = v.Value // Value is types.ExportTr31KeyBlock

	case *types.ExportKeyMaterialMemberTr34KeyBlock:
		_ = v.Value // Value is types.ExportTr34KeyBlock

	case *types.UnknownUnionMember:
		fmt.Println("unknown tag:", v.Tag)

	default:
		fmt.Println("union is nil or unknown type")

	}
}

Output:

type ExportKeyMaterialMemberKeyCryptogram added in v1.7.0 

type ExportKeyMaterialMemberKeyCryptogram struct {
	Value ExportKeyCryptogram
	// contains filtered or unexported fields
}

Parameter information for key material export using asymmetric RSA wrap and unwrap key exchange method

type ExportKeyMaterialMemberTr31KeyBlock 

type ExportKeyMaterialMemberTr31KeyBlock struct {
	Value ExportTr31KeyBlock
	// contains filtered or unexported fields
}

Parameter information for key material export using symmetric TR-31 key exchange method.

type ExportKeyMaterialMemberTr34KeyBlock 

type ExportKeyMaterialMemberTr34KeyBlock struct {
	Value ExportTr34KeyBlock
	// contains filtered or unexported fields
}

Parameter information for key material export using the asymmetric TR-34 key exchange method.

type ExportTr31KeyBlock 

type ExportTr31KeyBlock struct {

	// The KeyARN of the the wrapping key. This key encrypts or wraps the key under
	// export for TR-31 key block generation.
	//
	// This member is required.
	WrappingKeyIdentifier *string

	// Optional metadata for export associated with the key material. This data is
	// signed but transmitted in clear text.
	KeyBlockHeaders *KeyBlockHeaders
	// contains filtered or unexported fields
}

Parameter information for key material export using symmetric TR-31 key exchange method.

type ExportTr34KeyBlock 

type ExportTr34KeyBlock struct {

	// The KeyARN of the certificate chain that signs the wrapping key certificate
	// during TR-34 key export.
	//
	// This member is required.
	CertificateAuthorityPublicKeyIdentifier *string

	// The export token to initiate key export from Amazon Web Services Payment
	// Cryptography. It also contains the signing key certificate that will sign the
	// wrapped key during TR-34 key block generation. Call [GetParametersForExport]to receive an export token.
	// It expires after 7 days. You can use the same export token to export multiple
	// keys from the same service account.
	//
	// [GetParametersForExport]: https://docs.aws.amazon.com/payment-cryptography/latest/APIReference/API_GetParametersForExport.html
	//
	// This member is required.
	ExportToken *string

	// The format of key block that Amazon Web Services Payment Cryptography will use
	// during key export.
	//
	// This member is required.
	KeyBlockFormat Tr34KeyBlockFormat

	// The KeyARN of the wrapping key certificate. Amazon Web Services Payment
	// Cryptography uses this certificate to wrap the key under export.
	//
	// This member is required.
	WrappingKeyCertificate *string

	// Optional metadata for export associated with the key material. This data is
	// signed but transmitted in clear text.
	KeyBlockHeaders *KeyBlockHeaders

	// A random number value that is unique to the TR-34 key block generated using 2
	// pass. The operation will fail, if a random nonce value is not provided for a
	// TR-34 key block generated using 2 pass.
	RandomNonce *string
	// contains filtered or unexported fields
}

Parameter information for key material export using the asymmetric TR-34 key exchange method.

type ImportKeyCryptogram added in v1.7.0 

type ImportKeyCryptogram struct {

	// Specifies whether the key is exportable from the service.
	//
	// This member is required.
	Exportable *bool

	// The import token that initiates key import using the asymmetric RSA wrap and
	// unwrap key exchange method into AWS Payment Cryptography. It expires after 7
	// days. You can use the same import token to import multiple keys to the same
	// service account.
	//
	// This member is required.
	ImportToken *string

	// The role of the key, the algorithm it supports, and the cryptographic
	// operations allowed with the key. This data is immutable after the key is
	// created.
	//
	// This member is required.
	KeyAttributes *KeyAttributes

	// The RSA wrapped key cryptogram under import.
	//
	// This member is required.
	WrappedKeyCryptogram *string

	// The wrapping spec for the wrapped key cryptogram.
	WrappingSpec WrappingKeySpec
	// contains filtered or unexported fields
}

Parameter information for key material import using asymmetric RSA wrap and unwrap key exchange method.

type ImportKeyMaterial 

type ImportKeyMaterial interface {
	// contains filtered or unexported methods
}

Parameter information for key material import into Amazon Web Services Payment Cryptography using TR-31 or TR-34 or RSA wrap and unwrap key exchange method.

The following types satisfy this interface: 

ImportKeyMaterialMemberKeyCryptogram
ImportKeyMaterialMemberRootCertificatePublicKey
ImportKeyMaterialMemberTr31KeyBlock
ImportKeyMaterialMemberTr34KeyBlock
ImportKeyMaterialMemberTrustedCertificatePublicKey
Example (OutputUsage) 
package main

import (
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/paymentcryptography/types"
)

func main() {
	var union types.ImportKeyMaterial
	// type switches can be used to check the union value
	switch v := union.(type) {
	case *types.ImportKeyMaterialMemberKeyCryptogram:
		_ = v.Value // Value is types.ImportKeyCryptogram

	case *types.ImportKeyMaterialMemberRootCertificatePublicKey:
		_ = v.Value // Value is types.RootCertificatePublicKey

	case *types.ImportKeyMaterialMemberTr31KeyBlock:
		_ = v.Value // Value is types.ImportTr31KeyBlock

	case *types.ImportKeyMaterialMemberTr34KeyBlock:
		_ = v.Value // Value is types.ImportTr34KeyBlock

	case *types.ImportKeyMaterialMemberTrustedCertificatePublicKey:
		_ = v.Value // Value is types.TrustedCertificatePublicKey

	case *types.UnknownUnionMember:
		fmt.Println("unknown tag:", v.Tag)

	default:
		fmt.Println("union is nil or unknown type")

	}
}

Output:

type ImportKeyMaterialMemberKeyCryptogram added in v1.7.0 

type ImportKeyMaterialMemberKeyCryptogram struct {
	Value ImportKeyCryptogram
	// contains filtered or unexported fields
}

Parameter information for key material import using asymmetric RSA wrap and unwrap key exchange method.

type ImportKeyMaterialMemberRootCertificatePublicKey 

type ImportKeyMaterialMemberRootCertificatePublicKey struct {
	Value RootCertificatePublicKey
	// contains filtered or unexported fields
}

Parameter information for root public key certificate import.

type ImportKeyMaterialMemberTr31KeyBlock 

type ImportKeyMaterialMemberTr31KeyBlock struct {
	Value ImportTr31KeyBlock
	// contains filtered or unexported fields
}

Parameter information for key material import using symmetric TR-31 key exchange method.

type ImportKeyMaterialMemberTr34KeyBlock 

type ImportKeyMaterialMemberTr34KeyBlock struct {
	Value ImportTr34KeyBlock
	// contains filtered or unexported fields
}

Parameter information for key material import using the asymmetric TR-34 key exchange method.

type ImportKeyMaterialMemberTrustedCertificatePublicKey 

type ImportKeyMaterialMemberTrustedCertificatePublicKey struct {
	Value TrustedCertificatePublicKey
	// contains filtered or unexported fields
}

Parameter information for trusted public key certificate import.

type ImportTr31KeyBlock 

type ImportTr31KeyBlock struct {

	// The TR-31 wrapped key block to import.
	//
	// This member is required.
	WrappedKeyBlock *string

	// The KeyARN of the key that will decrypt or unwrap a TR-31 key block during
	// import.
	//
	// This member is required.
	WrappingKeyIdentifier *string
	// contains filtered or unexported fields
}

Parameter information for key material import using symmetric TR-31 key exchange method.

type ImportTr34KeyBlock 

type ImportTr34KeyBlock struct {

	// The KeyARN of the certificate chain that signs the signing key certificate
	// during TR-34 key import.
	//
	// This member is required.
	CertificateAuthorityPublicKeyIdentifier *string

	// The import token that initiates key import using the asymmetric TR-34 key
	// exchange method into Amazon Web Services Payment Cryptography. It expires after
	// 7 days. You can use the same import token to import multiple keys to the same
	// service account.
	//
	// This member is required.
	ImportToken *string

	// The key block format to use during key import. The only value allowed is
	// X9_TR34_2012 .
	//
	// This member is required.
	KeyBlockFormat Tr34KeyBlockFormat

	// The public key component in PEM certificate format of the private key that
	// signs the KDH TR-34 WrappedKeyBlock.
	//
	// This member is required.
	SigningKeyCertificate *string

	// The TR-34 wrapped key block to import.
	//
	// This member is required.
	WrappedKeyBlock *string

	// A random number value that is unique to the TR-34 key block generated using 2
	// pass. The operation will fail, if a random nonce value is not provided for a
	// TR-34 key block generated using 2 pass.
	RandomNonce *string
	// contains filtered or unexported fields
}

Parameter information for key material import using the asymmetric TR-34 key exchange method.

type InternalServerException 

type InternalServerException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The request processing has failed because of an unknown error, exception, or failure.

func (*InternalServerException) Error 

func (e *InternalServerException) Error() string

func (*InternalServerException) ErrorCode 

func (e *InternalServerException) ErrorCode() string

func (*InternalServerException) ErrorFault 

func (e *InternalServerException) ErrorFault() smithy.ErrorFault

func (*InternalServerException) ErrorMessage 

func (e *InternalServerException) ErrorMessage() string

type Key 

type Key struct {

	// The date and time when the key was created.
	//
	// This member is required.
	CreateTimestamp *time.Time

	// Specifies whether the key is enabled.
	//
	// This member is required.
	Enabled *bool

	// Specifies whether the key is exportable. This data is immutable after the key
	// is created.
	//
	// This member is required.
	Exportable *bool

	// The Amazon Resource Name (ARN) of the key.
	//
	// This member is required.
	KeyArn *string

	// The role of the key, the algorithm it supports, and the cryptographic
	// operations allowed with the key. This data is immutable after the key is
	// created.
	//
	// This member is required.
	KeyAttributes *KeyAttributes

	// The key check value (KCV) is used to check if all parties holding a given key
	// have the same key or to detect that a key has changed.
	//
	// This member is required.
	KeyCheckValue *string

	// The algorithm that Amazon Web Services Payment Cryptography uses to calculate
	// the key check value (KCV). It is used to validate the key integrity.
	//
	// For TDES keys, the KCV is computed by encrypting 8 bytes, each with value of
	// zero, with the key to be checked and retaining the 3 highest order bytes of the
	// encrypted result. For AES keys, the KCV is computed using a CMAC algorithm where
	// the input data is 16 bytes of zero and retaining the 3 highest order bytes of
	// the encrypted result.
	//
	// This member is required.
	KeyCheckValueAlgorithm KeyCheckValueAlgorithm

	// The source of the key material. For keys created within Amazon Web Services
	// Payment Cryptography, the value is AWS_PAYMENT_CRYPTOGRAPHY . For keys imported
	// into Amazon Web Services Payment Cryptography, the value is EXTERNAL .
	//
	// This member is required.
	KeyOrigin KeyOrigin

	// The state of key that is being created or deleted.
	//
	// This member is required.
	KeyState KeyState

	// The date and time after which Amazon Web Services Payment Cryptography will
	// delete the key. This value is present only when KeyState is DELETE_PENDING and
	// the key is scheduled for deletion.
	DeletePendingTimestamp *time.Time

	// The date and time after which Amazon Web Services Payment Cryptography will
	// delete the key. This value is present only when when the KeyState is
	// DELETE_COMPLETE and the Amazon Web Services Payment Cryptography key is deleted.
	DeleteTimestamp *time.Time

	// The date and time after which Amazon Web Services Payment Cryptography will
	// start using the key material for cryptographic operations.
	UsageStartTimestamp *time.Time

	// The date and time after which Amazon Web Services Payment Cryptography will
	// stop using the key material for cryptographic operations.
	UsageStopTimestamp *time.Time
	// contains filtered or unexported fields
}

Metadata about an Amazon Web Services Payment Cryptography key.

type KeyAlgorithm 

type KeyAlgorithm string
const (
	KeyAlgorithmTdes2key KeyAlgorithm = "TDES_2KEY"
	KeyAlgorithmTdes3key KeyAlgorithm = "TDES_3KEY"
	KeyAlgorithmAes128   KeyAlgorithm = "AES_128"
	KeyAlgorithmAes192   KeyAlgorithm = "AES_192"
	KeyAlgorithmAes256   KeyAlgorithm = "AES_256"
	KeyAlgorithmRsa2048  KeyAlgorithm = "RSA_2048"
	KeyAlgorithmRsa3072  KeyAlgorithm = "RSA_3072"
	KeyAlgorithmRsa4096  KeyAlgorithm = "RSA_4096"
)

Enum values for KeyAlgorithm

func (KeyAlgorithm) Values 

func (KeyAlgorithm) Values() []KeyAlgorithm

Values returns all known values for KeyAlgorithm. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type KeyAttributes 

type KeyAttributes struct {

	// The key algorithm to be use during creation of an Amazon Web Services Payment
	// Cryptography key.
	//
	// For symmetric keys, Amazon Web Services Payment Cryptography supports AES and
	// TDES algorithms. For asymmetric keys, Amazon Web Services Payment Cryptography
	// supports RSA and ECC_NIST algorithms.
	//
	// This member is required.
	KeyAlgorithm KeyAlgorithm

	// The type of Amazon Web Services Payment Cryptography key to create, which
	// determines the classification of the cryptographic method and whether Amazon Web
	// Services Payment Cryptography key contains a symmetric key or an asymmetric key
	// pair.
	//
	// This member is required.
	KeyClass KeyClass

	// The list of cryptographic operations that you can perform using the key.
	//
	// This member is required.
	KeyModesOfUse *KeyModesOfUse

	// The cryptographic usage of an Amazon Web Services Payment Cryptography key as
	// defined in section A.5.2 of the TR-31 spec.
	//
	// This member is required.
	KeyUsage KeyUsage
	// contains filtered or unexported fields
}

The role of the key, the algorithm it supports, and the cryptographic operations allowed with the key. This data is immutable after the key is created.

type KeyBlockHeaders added in v1.10.0 

type KeyBlockHeaders struct {

	// Specifies subsequent exportability of the key within the key block after it is
	// received by the receiving party. It can be used to further restrict
	// exportability of the key after export from Amazon Web Services Payment
	// Cryptography.
	//
	// When set to EXPORTABLE , the key can be subsequently exported by the receiver
	// under a KEK using TR-31 or TR-34 key block export only. When set to
	// NON_EXPORTABLE , the key cannot be subsequently exported by the receiver. When
	// set to SENSITIVE , the key can be exported by the receiver under a KEK using
	// TR-31, TR-34, RSA wrap and unwrap cryptogram or using a symmetric cryptogram key
	// export method. For further information refer to [ANSI X9.143-2022].
	//
	// [ANSI X9.143-2022]: https://webstore.ansi.org/standards/ascx9/ansix91432022
	KeyExportability KeyExportability

	// The list of cryptographic operations that you can perform using the key. The
	// modes of use are defined in section A.5.3 of the TR-31 spec.
	KeyModesOfUse *KeyModesOfUse

	// Parameter used to indicate the version of the key carried in the key block or
	// indicate the value carried in the key block is a component of a key.
	KeyVersion *string

	// Parameter used to indicate the type of optional data in key block headers.
	// Refer to [ANSI X9.143-2022]for information on allowed data type for optional blocks.
	//
	// Optional block character limit is 112 characters. For each optional block, 2
	// characters are reserved for optional block ID and 2 characters reserved for
	// optional block length. More than one optional blocks can be included as long as
	// the combined length does not increase 112 characters.
	//
	// [ANSI X9.143-2022]: https://webstore.ansi.org/standards/ascx9/ansix91432022
	OptionalBlocks map[string]string
	// contains filtered or unexported fields
}

Optional metadata for export associated with the key material. This data is signed but transmitted in clear text.

type KeyCheckValueAlgorithm 

type KeyCheckValueAlgorithm string
const (
	KeyCheckValueAlgorithmCmac     KeyCheckValueAlgorithm = "CMAC"
	KeyCheckValueAlgorithmAnsiX924 KeyCheckValueAlgorithm = "ANSI_X9_24"
)

Enum values for KeyCheckValueAlgorithm

func (KeyCheckValueAlgorithm) Values 

func (KeyCheckValueAlgorithm) Values() []KeyCheckValueAlgorithm

Values returns all known values for KeyCheckValueAlgorithm. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type KeyClass 

type KeyClass string
const (
	KeyClassSymmetricKey      KeyClass = "SYMMETRIC_KEY"
	KeyClassAsymmetricKeyPair KeyClass = "ASYMMETRIC_KEY_PAIR"
	KeyClassPrivateKey        KeyClass = "PRIVATE_KEY"
	KeyClassPublicKey         KeyClass = "PUBLIC_KEY"
)

Enum values for KeyClass

func (KeyClass) Values 

func (KeyClass) Values() []KeyClass

Values returns all known values for KeyClass. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type KeyExportability added in v1.10.0 

type KeyExportability string
const (
	KeyExportabilityExportable    KeyExportability = "EXPORTABLE"
	KeyExportabilityNonExportable KeyExportability = "NON_EXPORTABLE"
	KeyExportabilitySensitive     KeyExportability = "SENSITIVE"
)

Enum values for KeyExportability

func (KeyExportability) Values added in v1.10.0 

func (KeyExportability) Values() []KeyExportability

Values returns all known values for KeyExportability. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type KeyMaterialType 

type KeyMaterialType string
const (
	KeyMaterialTypeTr34KeyBlock                KeyMaterialType = "TR34_KEY_BLOCK"
	KeyMaterialTypeTr31KeyBlock                KeyMaterialType = "TR31_KEY_BLOCK"
	KeyMaterialTypeRootPublicKeyCertificate    KeyMaterialType = "ROOT_PUBLIC_KEY_CERTIFICATE"
	KeyMaterialTypeTrustedPublicKeyCertificate KeyMaterialType = "TRUSTED_PUBLIC_KEY_CERTIFICATE"
	KeyMaterialTypeKeyCryptogram               KeyMaterialType = "KEY_CRYPTOGRAM"
)

Enum values for KeyMaterialType

func (KeyMaterialType) Values 

func (KeyMaterialType) Values() []KeyMaterialType

Values returns all known values for KeyMaterialType. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type KeyModesOfUse 

type KeyModesOfUse struct {

	// Specifies whether an Amazon Web Services Payment Cryptography key can be used to
	// decrypt data.
	Decrypt bool

	// Specifies whether an Amazon Web Services Payment Cryptography key can be used to
	// derive new keys.
	DeriveKey bool

	// Specifies whether an Amazon Web Services Payment Cryptography key can be used to
	// encrypt data.
	Encrypt bool

	// Specifies whether an Amazon Web Services Payment Cryptography key can be used to
	// generate and verify other card and PIN verification keys.
	Generate bool

	// Specifies whether an Amazon Web Services Payment Cryptography key has no special
	// restrictions other than the restrictions implied by KeyUsage .
	NoRestrictions bool

	// Specifies whether an Amazon Web Services Payment Cryptography key can be used
	// for signing.
	Sign bool

	// Specifies whether an Amazon Web Services Payment Cryptography key can be used to
	// unwrap other keys.
	Unwrap bool

	// Specifies whether an Amazon Web Services Payment Cryptography key can be used to
	// verify signatures.
	Verify bool

	// Specifies whether an Amazon Web Services Payment Cryptography key can be used to
	// wrap other keys.
	Wrap bool
	// contains filtered or unexported fields
}

The list of cryptographic operations that you can perform using the key. The modes of use are defined in section A.5.3 of the TR-31 spec.

type KeyOrigin 

type KeyOrigin string
const (
	KeyOriginExternal               KeyOrigin = "EXTERNAL"
	KeyOriginAwsPaymentCryptography KeyOrigin = "AWS_PAYMENT_CRYPTOGRAPHY"
)

Enum values for KeyOrigin

func (KeyOrigin) Values 

func (KeyOrigin) Values() []KeyOrigin

Values returns all known values for KeyOrigin. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type KeyState 

type KeyState string
const (
	KeyStateCreateInProgress KeyState = "CREATE_IN_PROGRESS"
	KeyStateCreateComplete   KeyState = "CREATE_COMPLETE"
	KeyStateDeletePending    KeyState = "DELETE_PENDING"
	KeyStateDeleteComplete   KeyState = "DELETE_COMPLETE"
)

Enum values for KeyState

func (KeyState) Values 

func (KeyState) Values() []KeyState

Values returns all known values for KeyState. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type KeySummary 

type KeySummary struct {

	// Specifies whether the key is enabled.
	//
	// This member is required.
	Enabled *bool

	// Specifies whether the key is exportable. This data is immutable after the key
	// is created.
	//
	// This member is required.
	Exportable *bool

	// The Amazon Resource Name (ARN) of the key.
	//
	// This member is required.
	KeyArn *string

	// The role of the key, the algorithm it supports, and the cryptographic
	// operations allowed with the key. This data is immutable after the key is
	// created.
	//
	// This member is required.
	KeyAttributes *KeyAttributes

	// The key check value (KCV) is used to check if all parties holding a given key
	// have the same key or to detect that a key has changed.
	//
	// This member is required.
	KeyCheckValue *string

	// The state of an Amazon Web Services Payment Cryptography that is being created
	// or deleted.
	//
	// This member is required.
	KeyState KeyState
	// contains filtered or unexported fields
}

Metadata about an Amazon Web Services Payment Cryptography key.

type KeyUsage 

type KeyUsage string
const (
	KeyUsageTr31B0BaseDerivationKey                KeyUsage = "TR31_B0_BASE_DERIVATION_KEY"
	KeyUsageTr31C0CardVerificationKey              KeyUsage = "TR31_C0_CARD_VERIFICATION_KEY"
	KeyUsageTr31D0SymmetricDataEncryptionKey       KeyUsage = "TR31_D0_SYMMETRIC_DATA_ENCRYPTION_KEY"
	KeyUsageTr31D1AsymmetricKeyForDataEncryption   KeyUsage = "TR31_D1_ASYMMETRIC_KEY_FOR_DATA_ENCRYPTION"
	KeyUsageTr31E0EmvMkeyAppCryptograms            KeyUsage = "TR31_E0_EMV_MKEY_APP_CRYPTOGRAMS"
	KeyUsageTr31E1EmvMkeyConfidentiality           KeyUsage = "TR31_E1_EMV_MKEY_CONFIDENTIALITY"
	KeyUsageTr31E2EmvMkeyIntegrity                 KeyUsage = "TR31_E2_EMV_MKEY_INTEGRITY"
	KeyUsageTr31E4EmvMkeyDynamicNumbers            KeyUsage = "TR31_E4_EMV_MKEY_DYNAMIC_NUMBERS"
	KeyUsageTr31E5EmvMkeyCardPersonalization       KeyUsage = "TR31_E5_EMV_MKEY_CARD_PERSONALIZATION"
	KeyUsageTr31E6EmvMkeyOther                     KeyUsage = "TR31_E6_EMV_MKEY_OTHER"
	KeyUsageTr31K0KeyEncryptionKey                 KeyUsage = "TR31_K0_KEY_ENCRYPTION_KEY"
	KeyUsageTr31K1KeyBlockProtectionKey            KeyUsage = "TR31_K1_KEY_BLOCK_PROTECTION_KEY"
	KeyUsageTr31K3AsymmetricKeyForKeyAgreement     KeyUsage = "TR31_K3_ASYMMETRIC_KEY_FOR_KEY_AGREEMENT"
	KeyUsageTr31M3Iso97973MacKey                   KeyUsage = "TR31_M3_ISO_9797_3_MAC_KEY"
	KeyUsageTr31M1Iso97971MacKey                   KeyUsage = "TR31_M1_ISO_9797_1_MAC_KEY"
	KeyUsageTr31M6Iso97975CmacKey                  KeyUsage = "TR31_M6_ISO_9797_5_CMAC_KEY"
	KeyUsageTr31M7HmacKey                          KeyUsage = "TR31_M7_HMAC_KEY"
	KeyUsageTr31P0PinEncryptionKey                 KeyUsage = "TR31_P0_PIN_ENCRYPTION_KEY"
	KeyUsageTr31P1PinGenerationKey                 KeyUsage = "TR31_P1_PIN_GENERATION_KEY"
	KeyUsageTr31S0AsymmetricKeyForDigitalSignature KeyUsage = "TR31_S0_ASYMMETRIC_KEY_FOR_DIGITAL_SIGNATURE"
	KeyUsageTr31V1Ibm3624PinVerificationKey        KeyUsage = "TR31_V1_IBM3624_PIN_VERIFICATION_KEY"
	KeyUsageTr31V2VisaPinVerificationKey           KeyUsage = "TR31_V2_VISA_PIN_VERIFICATION_KEY"
	KeyUsageTr31K2Tr34AsymmetricKey                KeyUsage = "TR31_K2_TR34_ASYMMETRIC_KEY"
)

Enum values for KeyUsage

func (KeyUsage) Values 

func (KeyUsage) Values() []KeyUsage

Values returns all known values for KeyUsage. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type ResourceNotFoundException 

type ResourceNotFoundException struct {
	Message *string

	ErrorCodeOverride *string

	ResourceId *string
	// contains filtered or unexported fields
}

The request was denied due to an invalid resource error.

func (*ResourceNotFoundException) Error 

func (e *ResourceNotFoundException) Error() string

func (*ResourceNotFoundException) ErrorCode 

func (e *ResourceNotFoundException) ErrorCode() string

func (*ResourceNotFoundException) ErrorFault 

func (e *ResourceNotFoundException) ErrorFault() smithy.ErrorFault

func (*ResourceNotFoundException) ErrorMessage 

func (e *ResourceNotFoundException) ErrorMessage() string

type RootCertificatePublicKey 

type RootCertificatePublicKey struct {

	// The role of the key, the algorithm it supports, and the cryptographic
	// operations allowed with the key. This data is immutable after the root public
	// key is imported.
	//
	// This member is required.
	KeyAttributes *KeyAttributes

	// Parameter information for root public key certificate import.
	//
	// This member is required.
	PublicKeyCertificate *string
	// contains filtered or unexported fields
}

Parameter information for root public key certificate import.

type ServiceQuotaExceededException 

type ServiceQuotaExceededException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

This request would cause a service quota to be exceeded.

func (*ServiceQuotaExceededException) Error 

func (e *ServiceQuotaExceededException) Error() string

func (*ServiceQuotaExceededException) ErrorCode 

func (e *ServiceQuotaExceededException) ErrorCode() string

func (*ServiceQuotaExceededException) ErrorFault 

func (e *ServiceQuotaExceededException) ErrorFault() smithy.ErrorFault

func (*ServiceQuotaExceededException) ErrorMessage 

func (e *ServiceQuotaExceededException) ErrorMessage() string

type ServiceUnavailableException 

type ServiceUnavailableException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The service cannot complete the request.

func (*ServiceUnavailableException) Error 

func (e *ServiceUnavailableException) Error() string

func (*ServiceUnavailableException) ErrorCode 

func (e *ServiceUnavailableException) ErrorCode() string

func (*ServiceUnavailableException) ErrorFault 

func (e *ServiceUnavailableException) ErrorFault() smithy.ErrorFault

func (*ServiceUnavailableException) ErrorMessage 

func (e *ServiceUnavailableException) ErrorMessage() string

type Tag 

type Tag struct {

	// The key of the tag.
	//
	// This member is required.
	Key *string

	// The value of the tag.
	Value *string
	// contains filtered or unexported fields
}

A structure that contains information about a tag.

type ThrottlingException 

type ThrottlingException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The request was denied due to request throttling.

func (*ThrottlingException) Error 

func (e *ThrottlingException) Error() string

func (*ThrottlingException) ErrorCode 

func (e *ThrottlingException) ErrorCode() string

func (*ThrottlingException) ErrorFault 

func (e *ThrottlingException) ErrorFault() smithy.ErrorFault

func (*ThrottlingException) ErrorMessage 

func (e *ThrottlingException) ErrorMessage() string

type Tr34KeyBlockFormat 

type Tr34KeyBlockFormat string
const (
	Tr34KeyBlockFormatX9Tr342012 Tr34KeyBlockFormat = "X9_TR34_2012"
)

Enum values for Tr34KeyBlockFormat

func (Tr34KeyBlockFormat) Values 

func (Tr34KeyBlockFormat) Values() []Tr34KeyBlockFormat

Values returns all known values for Tr34KeyBlockFormat. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type TrustedCertificatePublicKey 

type TrustedCertificatePublicKey struct {

	// The KeyARN of the root public key certificate or certificate chain that signs
	// the trusted public key certificate import.
	//
	// This member is required.
	CertificateAuthorityPublicKeyIdentifier *string

	// The role of the key, the algorithm it supports, and the cryptographic
	// operations allowed with the key. This data is immutable after a trusted public
	// key is imported.
	//
	// This member is required.
	KeyAttributes *KeyAttributes

	// Parameter information for trusted public key certificate import.
	//
	// This member is required.
	PublicKeyCertificate *string
	// contains filtered or unexported fields
}

Parameter information for trusted public key certificate import.

type UnknownUnionMember 

type UnknownUnionMember struct {
	Tag   string
	Value []byte
	// contains filtered or unexported fields
}

UnknownUnionMember is returned when a union member is returned over the wire, but has an unknown tag.

type ValidationException 

type ValidationException struct {
	Message *string

	ErrorCodeOverride *string
	// contains filtered or unexported fields
}

The request was denied due to an invalid request error.

func (*ValidationException) Error 

func (e *ValidationException) Error() string

func (*ValidationException) ErrorCode 

func (e *ValidationException) ErrorCode() string

func (*ValidationException) ErrorFault 

func (e *ValidationException) ErrorFault() smithy.ErrorFault

func (*ValidationException) ErrorMessage 

func (e *ValidationException) ErrorMessage() string

type WrappedKey 

type WrappedKey struct {

	// Parameter information for generating a wrapped key using TR-31 or TR-34 skey
	// exchange method.
	//
	// This member is required.
	KeyMaterial *string

	// The key block format of a wrapped key.
	//
	// This member is required.
	WrappedKeyMaterialFormat WrappedKeyMaterialFormat

	// The KeyARN of the wrapped key.
	//
	// This member is required.
	WrappingKeyArn *string

	// The key check value (KCV) is used to check if all parties holding a given key
	// have the same key or to detect that a key has changed.
	KeyCheckValue *string

	// The algorithm that Amazon Web Services Payment Cryptography uses to calculate
	// the key check value (KCV). It is used to validate the key integrity.
	//
	// For TDES keys, the KCV is computed by encrypting 8 bytes, each with value of
	// zero, with the key to be checked and retaining the 3 highest order bytes of the
	// encrypted result. For AES keys, the KCV is computed using a CMAC algorithm where
	// the input data is 16 bytes of zero and retaining the 3 highest order bytes of
	// the encrypted result.
	KeyCheckValueAlgorithm KeyCheckValueAlgorithm
	// contains filtered or unexported fields
}

Parameter information for generating a WrappedKeyBlock for key exchange.

type WrappedKeyMaterialFormat 

type WrappedKeyMaterialFormat string
const (
	WrappedKeyMaterialFormatKeyCryptogram WrappedKeyMaterialFormat = "KEY_CRYPTOGRAM"
	WrappedKeyMaterialFormatTr31KeyBlock  WrappedKeyMaterialFormat = "TR31_KEY_BLOCK"
	WrappedKeyMaterialFormatTr34KeyBlock  WrappedKeyMaterialFormat = "TR34_KEY_BLOCK"
)

Enum values for WrappedKeyMaterialFormat

func (WrappedKeyMaterialFormat) Values 

func (WrappedKeyMaterialFormat) Values() []WrappedKeyMaterialFormat

Values returns all known values for WrappedKeyMaterialFormat. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

type WrappingKeySpec added in v1.7.0 

type WrappingKeySpec string
const (
	WrappingKeySpecRsaOaepSha256 WrappingKeySpec = "RSA_OAEP_SHA_256"
	WrappingKeySpecRsaOaepSha512 WrappingKeySpec = "RSA_OAEP_SHA_512"
)

Enum values for WrappingKeySpec

func (WrappingKeySpec) Values added in v1.7.0 

func (WrappingKeySpec) Values() []WrappingKeySpec

Values returns all known values for WrappingKeySpec. Note that this can be expanded in the future, and so it is only as up to date as the client.

The ordering of this slice is not guaranteed to be stable across updates.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.