Utiliser une clé KMS pour la signature et la vérification de signature - Key Management Service

Utilisez le client SDK Python de l'instance KMS pour signer des données et vérifier les signatures numériques avec une clé asymétrique. Cette rubrique présente un exemple fonctionnel complet, suivi d'une explication détaillée étape par étape.

Tous les exemples utilisent sign_with_options et verify_with_options pour envoyer des requêtes via un client configuré.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

Le client SDK de l'instance KMS est initialisé. Consultez la section Initialiser le client.
Un ID de clé asymétrique (key_id) et un algorithme de signature pris en charge.

Exemple complet

# -*- coding: utf-8 -*-
import os

from openapi.models import Config
from openapi_util.models import RuntimeOptions
from sdk.client import Client
from sdk.models import SignRequest, VerifyRequest

config = Config()
# KMS instance service only allows HTTPS access.
config.protocol = "https"
# Path to the Client Key file.
config.client_key_file = "<CLIENT_KEY_FILE>"
# Client Key decryption password, loaded from an environment variable.
config.password = os.getenv('CLIENT_KEY_PASSWORD')
# Endpoint format: <KMS_INSTANCE_ID>.cryptoservice.kms.aliyuncs.com
config.endpoint = "<ENDPOINT>"
client = Client(config)

class SignContext(object):
    """Stores sign response fields needed for subsequent verification."""

    def __init__(self, key_id, message_type, signature, algorithm):
        self.key_id = key_id
        self.message_type = message_type
        self.signature = signature
        # If algorithm is not set, the default value is used.
        self.algorithm = algorithm

def sign(key_id, message, message_type, algorithm):
    request = SignRequest()
    request.key_id = key_id
    request.message = message
    request.message_type = message_type
    request.algorithm = algorithm
    runtime_options = RuntimeOptions()
    # Uncomment the line below to skip server certificate verification.
    # runtime_options.ignore_ssl = True
    # Path to the instance CA certificate.
    runtime_options.verify = "<CA_CERTIFICATE_FILE_PATH>"
    resp = client.sign_with_options(request, runtime_options)
    print(resp)
    return SignContext(resp.key_id, resp.message_type, resp.signature, resp.algorithm)

def verify(context, message):
    request = VerifyRequest()
    request.key_id = context.key_id
    request.message_type = context.message_type
    request.signature = context.signature
    request.algorithm = context.algorithm
    request.message = message
    runtime_options = RuntimeOptions()
    # Uncomment the line below to skip server certificate verification.
    # runtime_options.ignore_ssl = True
    # Path to the instance CA certificate.
    runtime_options.verify = "<CA_CERTIFICATE_FILE_PATH>"
    resp = client.verify_with_options(request, runtime_options)
    print(resp)

key_id = "<KEY_ID>"
algorithm = "<ALGORITHM>"
message = "<MESSAGE>".encode("utf-8")
# RAW: pass the raw message. DIGEST: pass the digest of the message.
message_type = "RAW"
context = sign(key_id, message, message_type, algorithm)
verify(context, message)

Remplacez les espaces réservés suivants avant d'exécuter le code :

Espace réservé	Description	Exemple
`<CLIENT_KEY_FILE>`	Chemin vers le fichier Client Key	`/path/to/clientKey.json`
`<ENDPOINT>`	Endpoint de l'instance KMS	`kst-example.cryptoservice.kms.aliyuncs.com`
`<CA_CERTIFICATE_FILE_PATH>`	Chemin vers le certificat CA de l'instance	`/path/to/ca.pem`
`<KEY_ID>`	ID de la clé asymétrique	`key-12345abcde`
`<ALGORITHM>`	Algorithme de signature pris en charge par la clé	`RSA_PKCS1_SHA_256`
`<MESSAGE>`	Données à signer	`hello`

Explication détaillée étape par étape

Initialiser le client

Consultez la section Initialiser le client pour obtenir les instructions complètes de configuration. Définissez config.protocol sur "https" ; le service d'instance KMS n'accepte que les connexions HTTPS.

# -*- coding: utf-8 -*-
import os

from openapi.models import Config
from sdk.client import Client

config = Config()
config.protocol = "https"
config.client_key_file = "<CLIENT_KEY_FILE>"
config.password = os.getenv('CLIENT_KEY_PASSWORD')
# Format: <KMS_INSTANCE_ID>.cryptoservice.kms.aliyuncs.com
config.endpoint = "<ENDPOINT>"
client = Client(config)

Signer des données avec une clé asymétrique

Appelez l'API Sign pour générer une signature numérique.

Définissez message_type sur "RAW" pour signer le message brut, ou sur "DIGEST" pour signer un condensé de message précalculé.

def sign(key_id, message, message_type, algorithm):
    request = SignRequest()
    request.key_id = key_id          # ID of the asymmetric key to use
    request.message = message        # Data to sign (bytes)
    request.message_type = message_type  # "RAW" or "DIGEST"
    request.algorithm = algorithm    # Signing algorithm the key supports
    runtime_options = RuntimeOptions()
    # runtime_options.ignore_ssl = True  # Uncomment to skip certificate verification
    runtime_options.verify = "<CA_CERTIFICATE_FILE_PATH>"
    resp = client.sign_with_options(request, runtime_options)
    print(resp)
    return SignContext(resp.key_id, resp.message_type, resp.signature, resp.algorithm)

La réponse de l'opération Sign inclut les éléments suivants :

Champ	Description
`resp.key_id`	ID de la clé ayant généré la signature
`resp.signature`	La signature numérique (octets)
`resp.algorithm`	L'algorithme de signature utilisé
`resp.message_type`	Le type de message (`RAW` ou `DIGEST`)

SignContext stocke ces champs afin que vous puissiez les transmettre directement à verify().

Vérifier une signature numérique

Appelez l'API Verify pour valider une signature par rapport au message d'origine.

def verify(context, message):
    request = VerifyRequest()
    request.key_id = context.key_id          # Must match the key used to sign
    request.message_type = context.message_type
    request.signature = context.signature    # Signature from the Sign response
    request.algorithm = context.algorithm    # Must match the algorithm used to sign
    request.message = message                # Original data (same as what was signed)
    runtime_options = RuntimeOptions()
    # runtime_options.ignore_ssl = True  # Uncomment to skip certificate verification
    runtime_options.verify = "<CA_CERTIFICATE_FILE_PATH>"
    resp = client.verify_with_options(request, runtime_options)
    print(resp)

Key Management Service:Exemple de code pour la signature et la vérification