Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Implémentations personnalisées de validation de l'intégrité des fichiers CloudTrail journaux

Grâce à l' CloudTrail utilisation d'algorithmes cryptographiques et de fonctions de hachage conformes aux normes du secteur et librement disponibles, vous pouvez créer vos propres outils pour valider l'intégrité des fichiers CloudTrail journaux. Lorsque la validation de l'intégrité des fichiers journaux est activée, CloudTrail les fichiers de synthèse sont envoyés à votre compartiment Amazon S3. Vous pouvez utiliser ces fichiers pour implémenter votre propre solution de validation. Pour plus d'informations sur les fichiers de valeur de hachage, consultez la page CloudTrail structure du fichier digest.

Cette rubrique explique comment les fichiers de valeur de hachage sont signées, puis détaille les étapes nécessaires pour implémenter une solution qui valide les fichiers de valeur de hachage et les fichiers journaux auxquels ils font référence.

Comprendre comment les CloudTrail fichiers de synthèse sont signés

CloudTrail les fichiers de synthèse sont signés avec des signatures RSA numériques. Pour chaque fichier de résumé, CloudTrail effectue les opérations suivantes :

Contenu de la chaîne de signature des données

Les CloudTrail objets suivants sont inclus dans la chaîne pour la signature des données :

Le format pour le calcul de cette chaîne et un exemple de chaîne sont fournis ultérieurement dans ce document.

Étapes d'implémentation de la validation personnalisée

Lors de l'implémentation d'une solution de validation personnalisée, vous devez d'abord valider le fichier de valeur de hachage, puis les fichiers journaux auxquels il fait référence.

Valider le fichier de valeur de hachage

Afin de valider un fichier de valeur de hachage, vous avez besoin de sa signature, de la clé publique dont la clé privée a été utilisée pour le signer et d'une chaîne de signature des données que vous calculez.

Valider les fichiers-journaux

Si le fichier de valeur de hachage est valide, valider chacun des fichiers journaux auquel le fichier de valeur de hachage fait référence.

Les sections suivantes décrivent ces étapes en détail.

Obtenir le fichier de valeur de hachage.

Les premières étapes consistent à obtenir le fichier de valeur de hachage le plus récent, vérifier que vous l'avez récupéré de son emplacement d'origine, vérifier sa signature numérique et obtenir l'empreinte de la clé publique.

B. Récupérer la clé publique pour valider le fichier de valeur de hachage

Pour obtenir la clé publique permettant de valider le fichier condensé, vous pouvez utiliser le AWS CLI ou le CloudTrail API. Dans les deux cas, vous spécifiez une plage de temps (c'est-à-dire, une heure de début et une heure de fin) pour les fichiers de valeur de hachage que vous voulez valider. Une ou plusieurs clés publiques peuvent être retournées pour l'intervalle de temps que vous spécifiez. Les clés renvoyées peuvent avoir des plages de temps de validité qui se chevauchent.

Utilisez le AWS CLI pour récupérer les clés publiques

Pour récupérer les clés publiques des fichiers de synthèse à l'aide de AWS CLI, utilisez la cloudtrail list-public-keys commande. La commande a le format suivant :

aws cloudtrail list-public-keys [--start-time <start-time>] [--end-time <end-time>]

Les paramètres d'heure de début et de fin sont des UTC horodatages et sont facultatifs. S'ils ne sont pas spécifiés, l'heure actuelle est utilisée et la ou les clés publiques actives sont renvoyées.

Exemple de réponse

La réponse sera une liste d'JSONobjets représentant la clé (ou les clés) renvoyée :

{
    "publicKeyList": [
        {
            "ValidityStartTime": "1436317441.0",
            "ValidityEndTime": "1438909441.0",
            "Value": "MIIBCgKCAQEAn11L2YZ9h7onug2ILi1MWyHiMRsTQjfWE+pHVRLk1QjfWhirG+lpOa8NrwQ/r7Ah5bNL6HepznOU9XTDSfmmnP97mqyc7z/upfZdS/AHhYcGaz7n6Wc/RRBU6VmiPCrAUojuSk6/GjvA8iOPFsYDuBtviXarvuLPlrT9kAd4Lb+rFfR5peEgBEkhlzc5HuWO7S0y+KunqxX6jQBnXGMtxmPBPP0FylgWGNdFtks/4YSKcgqwH0YDcawP9GGGDAeCIqPWIXDLG1jOjRRzWfCmD0iJUkz8vTsn4hq/5ZxRFE7UBAUiVcGbdnDdvVfhF9C3dQiDq3k7adQIziLT0cShgQIDAQAB",
            "Fingerprint": "8eba5db5bea9b640d1c96a77256fe7f2"
        },
        {
            "ValidityStartTime": "1434589460.0",
            "ValidityEndTime": "1437181460.0",
            "Value": "MIIBCgKCAQEApfYL2FiZhpN74LNWVUzhR+VheYhwhYm8w0n5Gf6i95ylW5kBAWKVEmnAQG7BvS5g9SMqFDQx52fW7NWV44IvfJ2xGXT+wT+DgR6ZQ+6yxskQNqV5YcXj4Aa5Zz4jJfsYjDuO2MDTZNIzNvBNzaBJ+r2WIWAJ/Xq54kyF63B6WE38vKuDE7nSd1FqQuEoNBFLPInvgggYe2Ym1Refe2z71wNcJ2kY+q0h1BSHrSM8RWuJIw7MXwF9iQncg9jYzUlNJomozQzAG5wSRfbplcCYNY40xvGd/aAmO0m+Y+XFMrKwtLCwseHPvj843qVno6x4BJN9bpWnoPo9sdsbGoiK3QIDAQAB",
            "Fingerprint": "8933b39ddc64d26d8e14ffbf6566fee4"
        },
        {
            "ValidityStartTime": "1434589370.0",
            "ValidityEndTime": "1437181370.0",
            "Value": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqlzPJbvZJ42UdcmLfPUqXYNfOs6I8lCfao/tOs8CmzPOEdtLWugB9xoIUz78qVHdKIqxbaG4jWHfJBiOSSFBM0lt8cdVo4TnRa7oG9io5pysS6DJhBBAeXsicufsiFJR+wrUNh8RSLxL4k6G1+BhLX20tJkZ/erT97tDGBujAelqseGg3vPZbTx9SMfOLN65PdLFudLP7Gat0Z9p5jw/rjpclKfo9Bfc3heeBxWGKwBBOKnFAaN9V57pOaosCvPKmHd9bg7jsQkI9Xp22IzGLsTFJZYVA3KiTAElDMu80iFXPHEq9hKNbt9e4URFam+1utKVEiLkR2disdCmPTK0VQIDAQAB",
            "Fingerprint": "31e8b5433410dfb61a9dc45cc65b22ff"
        }
    ]
}

Utiliser la CloudTrail API pour récupérer des clés publiques

Pour récupérer les clés publiques des fichiers de synthèse à l'aide de CloudTrail API, transmettez les valeurs d'heure de début et de fin au ListPublicKeysAPI. ListPublicKeysAPIRenvoie les clés publiques dont les clés privées ont été utilisées pour signer les fichiers de synthèse dans le délai spécifié. Pour chaque clé publique, le renvoie API également l'empreinte digitale correspondante.

ListPublicKeys

Cette section décrit les paramètres de demande et les éléments de réponse pour ListPublicKeysAPI.

Paramètres de requête

Éléments de réponse

PublicKeyList, un tableau des objets PublicKey qui contient les éléments suivants :

C. Sélectionner la clé publique à utiliser pour la validation

Parmi les clés publiques récupérées par list-public-keys ou ListPublicKeys, sélectionnez la clé publique renvoyée dont l'empreinte correspond à l'empreinte enregistrée dans le champ du fichier de valeur de hachage digestPublicKeyFingerprint. C'est la clé publique que vous utiliserez pour valider le fichier de valeur de hachage.

D. Recréer la chaîne de signature des données

Maintenant que vous avez la signature du fichier de valeur de hachage et la clé publique associée, vous devez calculer la chaîne de signature des données. Une fois que vous aurez calculé les chaîne de signature des données, vous aurez les entrées nécessaires pour vérifier la signature.

La chaîne de signature des données possède le format suivant :

Data_To_Sign_String = 
  Digest_End_Timestamp_in_UTC_Extended_format + '\n' +
  Current_Digest_File_S3_Path + '\n' +
  Hex(Sha256(current-digest-file-content)) + '\n' +
  Previous_digest_signature_in_hex 
            

Un exemple de Data_To_Sign_String suit.

2015-08-12T04:01:31Z
amzn-s3-demo-bucket/AWSLogs/111122223333/CloudTrail-Digest/us-east-2/2015/08/12/111122223333_us-east-2_CloudTrail-Digest_us-east-2_20150812T040131Z.json.gz
4ff08d7c6ecd6eb313257e839645d20363ee3784a2328a7d76b99b53cc9bcacd
6e8540b83c3ac86a0312d971a225361d28ed0af20d70c211a2d405e32abf529a8145c2966e3bb47362383a52441545ed091fb81
d4c7c09dd152b84e79099ce7a9ec35d2b264eb92eb6e090f1e5ec5d40ec8a0729c02ff57f9e30d5343a8591638f8b794972ce15bb3063a01972
98b0aee2c1c8af74ec620261529265e83a9834ebef6054979d3e9a6767dfa6fdb4ae153436c567d6ae208f988047ccfc8e5e41f7d0121e54ed66b1b904f80fb2ce304458a2a6b91685b699434b946c52589e9438f8ebe5a0d80522b2f043b3710b87d2cda43e5c1e0db921d8d540b9ad5f6d4$31b1f4a8ef2d758424329583897339493a082bb36e782143ee5464b4e3eb4ef6

Une fois que vous avez recréé cette chaîne, vous pouvez valider le fichier de valeur de hachage.

E. Valider le fichier de valeur de hachage

Transmettez le hachage SHA -256 de la chaîne de signature des données, de la signature numérique et de la clé publique recréées à l'algorithme de vérification de RSA signature. Si le résultat est true, la signature du fichier de valeur de hachage est vérifiée et le fichier de valeur de hachage est valide.

F. Valider les fichiers-journaux

Une fois que vous avez validé le fichier de valeur de hachage, vous pouvez valider les fichiers-journaux auquel il fait référence. Le fichier de résumé contient les SHA -256 hachages des fichiers journaux. Si l'un des fichiers journaux a été modifié après l'avoir CloudTrail livré, les hachages SHA -256 seront modifiés et la signature du fichier condensé ne correspondra pas.

La section suivante montre comment valider les fichiers journaux :

G. Valider des fichiers de valeur de hachage et des fichiers journaux supplémentaires

Dans chaque fichier de valeur de hachage, les champs suivants fournissent l'emplacement et la signature du fichier de valeur de hachage précédent :

Utilisez ces informations pour consulter les fichiers de valeur de hachage précédents dans l'ordre, en validant la signature de chacun et les fichiers journaux auxquels ils font référence en appliquant la procédure présentée dans les sections précédentes. La seule différence est que pour les fichiers de valeur de hachage précédents, vous n'aviez pas besoin de récupérer la signature numérique depuis les propriétés de métadonnées Amazon S3 de l'objet du fichier de valeur de hachage. La signature du fichier de valeur de hachage précédent est fournie dans le champ previousDigestSignature.

Vous pouvez retourner en arrière jusqu'au fichier de valeur de hachage de départ ou jusqu'à ce que la chaîne de fichiers de valeur de hachage soit rompue, selon la première de ces deux éventualités.

Validation des fichiers de valeur de hachage et des fichiers journaux hors connexion

Lors de la validation des fichiers de valeur de hachage et des fichiers journaux hors connexion, vous pouvez généralement suivre les procédures décrites dans les sections précédentes. Cependant, vous devez prendre en compte les points suivants :

Gestion du fichier de valeur de hachage le plus récent

La signature numérique du fichier de valeur de hachage le plus récent (c'est-à-dire, « actuel ») est contenue dans les propriétés de métadonnées Amazon S3 de l'objet du fichier de valeur de hachage. Dans un scénario hors connexion, la signature numérique du fichier de valeur de hachage actuel n'est pas disponible.

Il existe deux façons de gérer cette situation :

Résolution du chemin

Les champs des fichiers de valeur de hachage téléchargés tels que s3Object et previousDigestS3Object continuent de pointer vers les emplacements en ligne Amazon S3 des fichiers journaux et des fichiers de valeur de hachage. Une solution hors connexion doit trouver un moyen de les réacheminer vers le chemin actuel du journal et des fichiers de valeur de hachage téléchargés.

Clés publiques

Pour effectuer une validation hors connexion, vous devez dans un premier temps obtenir toutes les clés publiques dont vous avez besoin pour valider les fichiers journaux dans une plage de temps donnée (en appelant ListPublicKeys, par exemple), puis les stocker en toute sécurité hors connexion. Cette étape doit être répétée chaque fois que vous souhaitez valider des fichiers supplémentaires en dehors de la plage de temps que vous avez spécifiée au départ.

Extrait de code de validation

L'exemple d'extrait suivant fournit un code squelette pour valider les fichiers de CloudTrail résumé et de journal. Ce squelette de code peut aussi bien être implémenter avec ou sans connexion à AWS ; c'est à vous de décider. L'implémentation suggérée utilise l'extension de cryptographie Java (JCE) et Bouncy Castle comme fournisseur de sécurité.

L'exemple d'extrait de code montre :

import java.util.Arrays;
import java.security.MessageDigest;
import java.security.KeyFactory;
import java.security.PublicKey;
import java.security.Security;
import java.security.Signature;
import java.security.spec.X509EncodedKeySpec;
import org.json.JSONObject;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.apache.commons.codec.binary.Hex;

public class DigestFileValidator {

    public void validateDigestFile(String digestS3Bucket, String digestS3Object, String digestSignature) {
 
        // Using the Bouncy Castle provider as a JCE security provider - http://www.bouncycastle.org/
        Security.addProvider(new BouncyCastleProvider());
 
        // Load the digest file from S3 (using Amazon S3 Client) or from your local copy
        JSONObject digestFile = loadDigestFileInMemory(digestS3Bucket, digestS3Object);
 
        // Check that the digest file has been retrieved from its original location
        if (!digestFile.getString("digestS3Bucket").equals(digestS3Bucket) ||
                !digestFile.getString("digestS3Object").equals(digestS3Object)) {
            System.err.println("Digest file has been moved from its original location.");
        } else {
            // Compute digest file hash
            MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
            messageDigest.update(convertToByteArray(digestFile));
            byte[] digestFileHash = messageDigest.digest();
            messageDigest.reset();
 
            // Compute the data to sign
            String dataToSign = String.format("%s%n%s/%s%n%s%n%s",
                                digestFile.getString("digestEndTime"),
                                digestFile.getString("digestS3Bucket"), digestFile.getString("digestS3Object"), // Constructing the S3 path of the digest file as part of the data to sign
                                Hex.encodeHexString(digestFileHash),
                                digestFile.getString("previousDigestSignature"));
 
            byte[] signatureContent = Hex.decodeHex(digestSignature);
 
            /*
                NOTE: 
                To find the right public key to verify the signature, call CloudTrail ListPublicKey API to get a list 
                of public keys, then match by the publicKeyFingerprint in the digest file. Also, the public key bytes 
                returned from ListPublicKey API are DER encoded in PKCS#1 format:
 
                PublicKeyInfo ::= SEQUENCE {
                    algorithm       AlgorithmIdentifier,
                    PublicKey       BIT STRING
                }
 
                AlgorithmIdentifier ::= SEQUENCE {
                    algorithm       OBJECT IDENTIFIER,
                    parameters      ANY DEFINED BY algorithm OPTIONAL
                }                
            */
            pkcs1PublicKeyBytes = getPublicKey(digestFile.getString("digestPublicKeyFingerprint")));
 
            // Transform the PKCS#1 formatted public key to x.509 format.
            RSAPublicKey rsaPublicKey = RSAPublicKey.getInstance(pkcs1PublicKeyBytes);
            AlgorithmIdentifier rsaEncryption = new AlgorithmIdentifier(PKCSObjectIdentifiers.rsaEncryption, null);
            SubjectPublicKeyInfo publicKeyInfo = new SubjectPublicKeyInfo(rsaEncryption, rsaPublicKey);
 
            // Create the PublicKey object needed for the signature validation
            PublicKey publicKey = KeyFactory.getInstance("RSA", "BC").generatePublic(new X509EncodedKeySpec(publicKeyInfo.getEncoded()));
 
            // Verify signature
            Signature signature = Signature.getInstance("SHA256withRSA", "BC");
            signature.initVerify(publicKey);
            signature.update(dataToSign.getBytes("UTF-8"));
 
            if (signature.verify(signatureContent)) {
                System.out.println("Digest file signature is valid, validating log files…");
                for (int i = 0; i < digestFile.getJSONArray("logFiles").length(); i++) {
 
                    JSONObject logFileMetadata = digestFile.getJSONArray("logFiles").getJSONObject(i);
 
                    // Compute log file hash
                    byte[] logFileContent = loadUncompressedLogFileInMemory(
                                                logFileMetadata.getString("s3Bucket"),
                                                logFileMetadata.getString("s3Object")
                                            );
                    messageDigest.update(logFileContent);
                     byte[] logFileHash = messageDigest.digest();
                    messageDigest.reset();
 
                    // Retrieve expected hash for the log file being processed
                    byte[] expectedHash = Hex.decodeHex(logFileMetadata.getString("hashValue"));
 
                    boolean signaturesMatch = Arrays.equals(expectedHash, logFileHash);
                    if (!signaturesMatch) {
                        System.err.println(String.format("Log file: %s/%s hash doesn't match.\tExpected: %s Actual: %s",
                               logFileMetadata.getString("s3Bucket"), logFileMetadata.getString("s3Object"),
                               Hex.encodeHexString(expectedHash), Hex.encodeHexString(logFileHash)));
                    } else {
                        System.out.println(String.format("Log file: %s/%s hash match",
                               logFileMetadata.getString("s3Bucket"), logFileMetadata.getString("s3Object")));
                    }
                }
 
            } else {
                System.err.println("Digest signature failed validation.");
            }
 
            System.out.println("Digest file validation completed.");
 
            if (chainValidationIsEnabled()) {
                // This enables the digests' chain validation
                validateDigestFile(
                        digestFile.getString("previousDigestS3Bucket"),
                        digestFile.getString("previousDigestS3Object"),
                        digestFile.getString("previousDigestSignature"));
            }
        }
    }
}