Überprüfung der Objektintegrität für Datenuploads in Amazon S3

Amazon S3 verwendet Prüfsummenwerte, um die Datenintegrität bei Upload- und Download-Vorgängen zu überprüfen. Wenn Sie Daten hochladen, AWS Management Console verwenden AWS SDK und sie den von Ihnen ausgewählten Prüfsummenalgorithmus, um vor der Datenübertragung einen Prüfsummenwert zu berechnen. S3 berechnet dann unabhängig eine Prüfsumme Ihrer Daten und validiert sie anhand des angegebenen Prüfsummenwerts. Objekte werden erst akzeptiert, nachdem bestätigt wurde, dass die Datenintegrität während der Übertragung gewahrt wurde. S3 speichert sowohl den Prüfsummenwert als Objektmetadaten als auch das Objekt selbst.

Um die Objektintegrität zu überprüfen, können Sie den Prüfsummenwert beim Herunterladen anfordern. Diese Überprüfung funktioniert konsistent für alle Verschlüsselungsmodi, Objektgrößen, Speicherklassen und sowohl für einteilige als auch für mehrteilige Uploads. Um den Prüfsummenalgorithmus für einen Upload zu ändern, können Sie ein einzelnes Objekt kopieren oder die Batch-Kopie für mehrere Objekte verwenden.

Bei Uploads einzelner Teile können Sie Prüfsummenwerte als Header angeben. Sie können entweder einen vorberechneten Wert angeben oder das AWS SDK einen Wert während des Uploads berechnen lassen. Wenn der von S3 berechnete Prüfsummenwert mit Ihrem angegebenen Wert übereinstimmt, wird die Anfrage akzeptiert. Wenn die Werte nicht übereinstimmen, wird die Anfrage abgelehnt.

AWS SDKs Kann bei mehrteiligen Uploads automatisch abschließende Prüfsummen für gestaffelte Uploads erstellen. Wenn Sie eine abschließende Prüfsumme verwenden, generiert Amazon S3 mithilfe Ihres angegebenen Algorithmus Prüfsummenwerte für jeden Teil und hängt den Prüfsummenwert an das Ende der aufgeteilten Upload-Anfrage an. S3 führt die Überprüfung und den Upload in einem einzigen Durchgang durch und verbessert so die Effizienz. Weitere Informationen hierzu finden Sie unter Verwenden von nachfolgenden Prüfsummen.

Verwenden unterstützter Prüfsummenalgorithmen

Mit Amazon S3 können Sie einen Prüfsummenalgorithmus wählen, um die Prüfsummenwerte bei Uploads zu berechnen. Der angegebene Prüfsummenalgorithmus wird dann zusammen mit Ihrem Objekt gespeichert und kann zur Überprüfung der Datenintegrität bei Downloads verwendet werden. Sie können einen der folgenden Secure Hash Algorithms (SHA)- oder Cyclic Redundancy Check (CRC)-Prüfsummenalgorithmen auswählen, um den Prüfsummenwert zu berechnen:

• CRC-64/NVME () CRC64NVME

• CRC-32 () CRC32

• CRC-32 C () CRC32C

• SHA-1 () SHA1

• SHA-256 () SHA256

• MD5 (MD5)

  Anmerkung

  Der content-MD5 Header ist nur mit S3 ETag für Objekte verfügbar, die in einem einteiligen Upload (PUTVorgang) hochgeladen wurden, der die SSE-S3-Verschlüsselung verwendet.

Darüber hinaus können Sie mit dem Content-Header bei jeder Anfrage eine Prüfsumme angeben. MD5

Wenn Sie ein Objekt hochladen, können Sie den Algorithmus angeben, den Sie verwenden möchten:

• Wenn Sie den verwenden AWS Management Console, wählen Sie den Prüfsummenalgorithmus aus, den Sie verwenden möchten. Sie können den Prüfsummenwert des Objekts optional angeben. Wenn Amazon S3 das Objekt erhält, berechnet es die Prüfsumme mithilfe des von Ihnen angegebenen Algorithmus. Wenn die beiden Prüfsummenwerte nicht übereinstimmen, generiert Amazon S3 einen Fehler.

• Wenn Sie ein SDK verwenden, beachten Sie Folgendes:

  • Legen Sie den ChecksumAlgorithm-Parameter auf den Algorithmus fest, den Amazon S3 verwenden soll. Wenn Sie bereits über eine vorberechnete Prüfsumme verfügen, übergeben Sie den Prüfsummenwert an das AWS SDK, und das SDK nimmt den Wert in die Anforderung auf. Wenn Sie keinen Prüfsummenwert übergeben oder keinen Prüfsummenalgorithmus angeben, berechnet das SDK automatisch einen Prüfsummenwert für Sie und fügt ihn zum Integritätsschutz in die Anforderung ein. Wenn der individuelle Prüfsummenwert nicht mit dem festgelegten Wert des Prüfsummenalgorithmus übereinstimmt, schlägt die Anforderung in Amazon S3 mit einem BadDigest-Fehler fehl.

  • Wenn Sie ein aktualisiertes AWS SDK verwenden, wählt das SDK einen Prüfsummenalgorithmus für Sie aus. Sie können jedoch diesen Prüfsummenalgorithmus außer Kraft setzen.

  • Wenn Sie keinen Prüfsummenalgorithmus angeben und das SDK auch keine Prüfsumme für Sie berechnet, wählt S3 automatisch den Prüfsummenalgorithmus CRC-64/NVME (). CRC64NVME

• Bei Verwendung der REST-API nutzen Sie den x-amz-sdk-checksum-algorithm-Parameter nicht. Verwenden Sie stattdessen einen der algorithmenspezifischen Header (z. B. x-amz-checksum-crc32).

Um einen dieser Prüfsummenwerte auf Objekte anzuwenden, die bereits in Amazon S3 hochgeladen wurden, können Sie das Objekt kopieren und angeben, ob Sie den bestehenden Prüfsummenalgorithmus oder einen neuen verwenden möchten. Wenn Sie keinen Algorithmus angeben, verwendet S3 den vorhandenen Algorithmus. Wenn das Quellobjekt keinen angegebenen Prüfsummenalgorithmus oder Prüfsummenwert hat, verwendet Amazon S3 den CRC-64/NVME-Algorithmus, um den Prüfsummenwert für das Zielobjekt zu berechnen. Sie können auch einen Prüfsummenalgorithmus angeben, wenn Sie Objekte mit S3 Batch Operations kopieren.

Wichtig

Wenn Sie einen mehrteiligen Upload mit Prüfsummen für zusammengesetzte Prüfsummen (oder Prüfsummen auf Teilebene) verwenden, müssen die Artikelnummern des mehrteiligen Uploads fortlaufend sein und mit 1 beginnen. Wenn Sie versuchen, eine mehrteilige Upload-Anforderung mit nicht aufeinanderfolgenden Teilenummern abzuschließen, generiert Amazon S3 einen HTTP 500 Internal Server-Fehler.

Vollständige Objekt- und zusammengesetzte Prüfsummentypen

In Amazon S3 gibt es zwei Arten von unterstützten Prüfsummen:

• Vollständige Objektprüfsummen: Eine vollständige Objektprüfsumme wird auf der Grundlage des gesamten Inhalts eines mehrteiligen Uploads berechnet und deckt alle Daten vom ersten Byte des ersten Teils bis zum letzten Byte des letzten Teils ab. Beachten Sie, dass beim Hochladen von Objekten AWS Management Console , die kleiner als 16 MB sind, nur der vollständige Objektprüfsummentyp unterstützt wird.

  Anmerkung

  Alle PUT-Anforderungen erfordern einen vollständigen Objektprüfsummentyp. Sie müssen einen vollständigen Objektprüfsummentyp angeben, wenn Sie Ihr Objekt per PUT-Anforderung hochladen.

• Zusammengesetzte Prüfsummen: Eine zusammengesetzte Prüfsumme wird auf der Grundlage der einzelnen Prüfsummen jedes Teils in einem mehrteiligen Upload berechnet. Anstatt eine Prüfsumme auf der Grundlage des gesamten Dateninhalts zu berechnen, aggregiert dieser Ansatz die Prüfsummen auf Teilebene (vom ersten bis zum letzten Teil), um eine einzige, kombinierte Prüfsumme für das gesamte Objekt zu erhalten. Wenn Sie einen mehrteiligen Upload verwenden, um Ihr Objekt hochzuladen, müssen Sie den Typ der zusammengesetzten Prüfsumme angeben.

  Anmerkung

  Wenn ein Objekt als mehrteiliger Upload hochgeladen wird, ist das Entity-Tag (ETag) für das Objekt kein MD5 Digest des gesamten Objekts. Stattdessen berechnet Amazon S3 den MD5 Digest jedes einzelnen Teils beim Hochladen. Die MD5 Digests werden verwendet, um den Wert ETag für das endgültige Objekt zu bestimmen. Amazon S3 verkettet die Bytes für die MD5 Digests miteinander und berechnet dann den Digest dieser verketteten MD5 Werte. Während des letzten ETag Erstellungsschritts fügt Amazon S3 am Ende einen Bindestrich mit der Gesamtzahl der Teile hinzu.

Amazon S3 unterstützt die folgenden Typen von vollständigen Objekt- und zusammengesetzten Prüfsummenalgorithmen:

• CRC-64/NVME (CRC64NVME): Unterstützt nur den vollständigen Objektprüfsummentyp.

• CRC-32 (CRC32): Unterstützt sowohl vollständige Objektprüfsummen als auch zusammengesetzte Prüfsummen.

• CRC-32C (CRC32C): Unterstützt sowohl vollständige Objekt- als auch zusammengesetzte Prüfsummentypen.

• SHA-1 (SHA1): Unterstützt sowohl vollständige Objekt- als auch zusammengesetzte Prüfsummentypen.

• SHA-256 (SHA256): Unterstützt sowohl vollständige Objekt- als auch zusammengesetzte Prüfsummentypen.

• MD5 (MD5): Unterstützt sowohl vollständige Objekt- als auch zusammengesetzte Prüfsummentypen.

Uploads einzelner Teile

Prüfsummen von Objekten, die in einem einzigen Teil (mit PutObject) hochgeladen werden, werden als vollständige Objektprüfsummen behandelt. Wenn Sie ein Objekt in die Amazon-S3-Konsole hochladen, können Sie den Prüfsummenalgorithmus auswählen, den S3 verwenden soll, und (optional) auch einen vorberechneten Wert angeben. Amazon S3 validiert dann den vorberechneten Prüfsummenwert, bevor das Objekt und sein Prüfsummenwert gespeichert werden. Sie können die Datenintegrität eines Objekts überprüfen, wenn Sie den Prüfsummenwert beim Herunterladen von Objekten anfordern.

Mehrteilige Uploads

Wenn Sie das Objekt mithilfe der MultipartUpload-API in mehreren Teilen hochladen, können Sie den Prüfsummenalgorithmus, den Amazon S3 verwenden soll, und den Prüfsummentyp (vollständiges Objekt oder zusammengesetzt) angeben.

Die folgende Tabelle zeigt, welcher Prüfsummenalgorithmus für jeden Prüfsummenalgorithmus in einem mehrteiligen Upload unterstützt wird:

Prüfsummenalgorithmus	Vollständiges Objekt	Zusammengesetzt
CRC64NVMECRC-64/NVME ()	Ja	Nein
CRC-32 () CRC32	Ja	Ja
CRC-32 C () CRC32C	Ja	Ja
SHA-1 () SHA1	Ja	Ja
SHA-256 () SHA256	Ja	Ja
MD5 (MD5)	Nein	Ja

Verwenden vollständiger Objektprüfsummen für den mehrteiligen Upload

Wenn Sie einen mehrteiligen Upload erstellen oder durchführen, können Sie vollständige Objektprüfsummen für die Validierung beim Upload verwenden. Das bedeutet, dass Sie den Prüfsummenalgorithmus für die MultipartUpload-API bereitstellen können, was Ihre Tools zur Integritätsprüfung vereinfacht, da Sie die Teilgrenzen für hochgeladene Objekte nicht mehr verfolgen müssen. Sie können die Prüfsumme des gesamten Objekts in der CompleteMultipartUpload-Anforderung zusammen mit der Objektgröße angeben.

Wenn Sie während eines mehrteiligen Uploads eine vollständige Objektprüfsumme angeben, übergibt das AWS SDK die Prüfsumme an Amazon S3, und S3 validiert die Objektintegrität serverseitig und vergleicht sie mit dem empfangenen Wert. Anschließend speichert Amazon S3 das Objekt, wenn die Werte übereinstimmen. Wenn die beiden Werte nicht übereinstimmen, schlägt S3 mit einem BadDigest-Fehler fehl. Die Prüfsumme Ihres Objekts wird auch in den Objektmetadaten gespeichert, die Sie später zur Validierung der Datenintegrität des Objekts verwenden.

Für vollständige Objektprüfsummen können Sie die Prüfsummenalgorithmen CRC-64/NVME (CRC64NVME), CRC-32 () oder CRC-32C () in S3 verwenden. CRC32 CRC32C Vollständige Objektprüfsummen in mehrteiligen Uploads sind nur für CRC-basierte Prüfsummen verfügbar, da sie zu einer vollständigen Objektprüfsumme linearisiert werden können. Diese Linearisierung ermöglicht es Amazon S3, Ihre Anfragen zu parallelisieren, um die Leistung zu verbessern. Insbesondere kann S3 die Prüfsumme des gesamten Objekts aus den Prüfsummen auf Teilebene berechnen. Diese Art der Überprüfung ist für andere Algorithmen wie SHA und nicht verfügbar. MD5 Da S3 über standardmäßige Integritätsschutzmaßnahmen verfügt, hängt S3, wenn Objekte ohne Prüfsumme hochgeladen werden, automatisch den empfohlenen CRC-64/NVME () -Prüfsummenalgorithmus für das vollständige Objekt an das Objekt an. CRC64NVME

Anmerkung

Um den mehrteiligen Upload zu initiieren, können Sie den Prüfsummenalgorithmus und den vollständigen Objektprüfsummentyp angeben. Nachdem Sie den Prüfsummenalgorithmus und den Prüfsummentyp für das vollständige Objekt angegeben haben, können Sie den vollständigen Objektprüfsummenwert für den mehrteiligen Upload angeben.

Verwenden von Prüfsummen auf Teilebene für mehrteilige Uploads

Wenn Objekte zu Amazon S3 hochgeladen werden, können sie entweder als einzelnes Objekt oder mithilfe des mehrteiligen Upload-Prozesses in Teilen hochgeladen werden. Sie können einen Prüfsummentyp für Ihren mehrteiligen Upload wählen. Für mehrteilige Uploads mit Prüfsummen auf Teilebene (oder zusammengesetzte Prüfsummen) berechnet Amazon S3 die Prüfsumme für jeden einzelnen Teil mithilfe des angegebenen Prüfsummenalgorithmus. Sie können UploadPart verwenden, um die Prüfsummenwerte für jeden Teil anzugeben. Wenn das Objekt, das Sie in die Amazon S3 S3-Konsole hochladen möchten, auf die Verwendung des CRC-64/NVME (CRC64NVME) -Prüfsummenalgorithmus eingestellt ist und 16 MB überschreitet, wird es automatisch als vollständige Objektprüfsumme ausgewiesen.

Amazon S3 verwendet dann die gespeicherten Prüfsummenwerte auf Teilebene, um zu bestätigen, dass jeder Teil korrekt hochgeladen wurde. Wenn die Prüfsumme jedes Teils (für das gesamte Objekt) angegeben wird, verwendet S3 die gespeicherten Prüfsummenwerte der einzelnen Teile, um intern die vollständige Objektprüfsumme zu berechnen und sie mit dem angegebenen Prüfsummenwert zu vergleichen. Dadurch werden die Rechenkosten minimiert, da S3 anhand der Prüfsumme der Teile eine Prüfsumme des gesamten Objekts berechnen kann. Weitere Informationen über mehrteilige Uploads finden Sie unter Hochladen und Kopieren von Objekten mit mehrteiligen Uploads in Amazon S3 und Verwenden vollständiger Objektprüfsummen für den mehrteiligen Upload.

Wenn das Objekt vollständig hochgeladen ist, können Sie die endgültige berechnete Prüfsumme verwenden, um die Datenintegrität des Objekts zu überprüfen.

Beachten Sie Folgendes beim Hochladen eines Teils des mehrteiligen Uploads:

• Um Informationen über das Objekt abzurufen, einschließlich der Anzahl der Teile, aus denen das gesamte Objekt besteht, können Sie die GetObjectAttributes-Operation verwenden. Mit zusätzlichen Prüfsummen können Sie auch Informationen für jeden einzelnen Teil wiederherstellen, der den Prüfsummenwert jedes Teils enthält.

• Alternativ können Sie die Prüfsumme eines einzelnen Teils abrufen, indem Sie die GetObject- oder HeadObject-Operation verwenden und eine Teilenummer oder einen Bytebereich angeben, der an einem einzelnen Teil ausgerichtet ist. Wenn Sie die Prüfsummenwerte für einzelne Teile von mehrteiligen Uploads abrufen möchten, die noch in Bearbeitung sind, können Sie ListParts verwenden.

• Aufgrund der Art und Weise, wie Amazon S3 die Prüfsumme für mehrteilige Objekte berechnet, kann sich der Prüfsummenwert für das Objekt ändern, wenn Sie es kopieren. Wenn Sie ein SDK oder die REST-API verwenden und CopyObject aufrufen, kopiert Amazon S3 jedes Objekt bis zu den Größenbeschränkungen der CopyObject-API-Operation. Amazon S3 führt diese Kopie als einzelne Aktion aus, unabhängig davon, ob das Objekt in einer einzigen Anforderung oder im Rahmen eines mehrteiligen Uploads hochgeladen wurde. Mit einem Kopierbefehl ist die Prüfsumme des Objekts eine direkte Prüfsumme des vollständigen Objekts. Wenn das Objekt ursprünglich mithilfe eines mehrteiligen Uploads hochgeladen wurde, ändert sich der Prüfsummenwert, obwohl die Daten unverändert bleiben.

• Objekte, die die Größenbeschränkungen der CopyObject-API-Operation überschreiten, müssen mehrteilige Upload-Kopierbefehle verwenden.

• Wenn Sie einige Operationen mit dem ausführen AWS Management Console, verwendet Amazon S3 einen mehrteiligen Upload, wenn das Objekt größer als 16 MB ist.

Prüfsummenmethoden

Nach dem Hochladen von Objekten können Sie den Prüfsummenwert abrufen und ihn mit einem vorberechneten oder zuvor gespeicherten Prüfsummenwert desselben Prüfsummenalgorithmustyps vergleichen. Die folgenden Beispiele zeigen Ihnen, mit welchen Methoden zur Prüfsummenberechnung Sie die Datenintegrität überprüfen können.

Verwenden der S3-Konsole

Weitere Informationen zur Verwendung der Konsole und zum Angeben von Prüfsummenalgorithmen, die beim Hochladen von Objekten verwendet werden, finden Sie unter Objekte hochladen und unter Tutorial: Überprüfen der Integrität von Daten in Amazon S3 mit zusätzlichen Prüfsummen.

Mit dem AWS SDKs

Das folgende Beispiel zeigt, wie Sie mithilfe von SHA-256 für die AWS SDKs Dateiüberprüfung eine große Datei hochladen, eine große Datei herunterladen und eine mehrteilige Upload-Datei validieren können.

Java

Beispiel: Hochladen, Herunterladen und Verifizieren einer großen Datei mit SHA-256

Anweisungen zum Erstellen und Testen eines Arbeitsbeispiels finden Sie unter Erste Schritte im Entwicklerhandbuch. AWS SDK für Java

    import software.amazon.awssdk.auth.credentials.AwsCredentials;
    import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider;
    import software.amazon.awssdk.core.ResponseInputStream;
    import software.amazon.awssdk.core.sync.RequestBody;
    import software.amazon.awssdk.regions.Region;
    import software.amazon.awssdk.services.s3.S3Client;
    import software.amazon.awssdk.services.s3.model.AbortMultipartUploadRequest;
    import software.amazon.awssdk.services.s3.model.ChecksumAlgorithm;
    import software.amazon.awssdk.services.s3.model.ChecksumMode;
    import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadRequest;
    import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadResponse;
    import software.amazon.awssdk.services.s3.model.CompletedMultipartUpload;
    import software.amazon.awssdk.services.s3.model.CompletedPart;
    import software.amazon.awssdk.services.s3.model.CreateMultipartUploadRequest;
    import software.amazon.awssdk.services.s3.model.CreateMultipartUploadResponse;
    import software.amazon.awssdk.services.s3.model.GetObjectAttributesRequest;
    import software.amazon.awssdk.services.s3.model.GetObjectAttributesResponse;
    import software.amazon.awssdk.services.s3.model.GetObjectRequest;
    import software.amazon.awssdk.services.s3.model.GetObjectResponse;
    import software.amazon.awssdk.services.s3.model.GetObjectTaggingRequest;
    import software.amazon.awssdk.services.s3.model.ObjectAttributes;
    import software.amazon.awssdk.services.s3.model.PutObjectTaggingRequest;
    import software.amazon.awssdk.services.s3.model.Tag;
    import software.amazon.awssdk.services.s3.model.Tagging;
    import software.amazon.awssdk.services.s3.model.UploadPartRequest;
    import software.amazon.awssdk.services.s3.model.UploadPartResponse;
     
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.nio.ByteBuffer;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    import java.util.ArrayList;
    import java.util.Base64;
    import java.util.List;
     
    public class LargeObjectValidation {
        private static String FILE_NAME = "sample.file";
        private static String BUCKET = "sample-bucket";
        //Optional, if you want a method of storing the full multipart object checksum in S3.
        private static String CHECKSUM_TAG_KEYNAME = "fullObjectChecksum";
        //If you have existing full-object checksums that you need to validate against, you can do the full object validation on a sequential upload.
        private static String SHA256_FILE_BYTES = "htCM5g7ZNdoSw8bN/mkgiAhXt5MFoVowVg+LE9aIQmI=";
        //Example Chunk Size - this must be greater than or equal to 5MB.
        private static int CHUNK_SIZE = 5 * 1024 * 1024;
     
        public static void main(String[] args) {
            S3Client s3Client = S3Client.builder()
                    .region(Region.US_EAST_1)
                    .credentialsProvider(new AwsCredentialsProvider() {
                        @Override
                        public AwsCredentials resolveCredentials() {
                            return new AwsCredentials() {
                                @Override
                                public String accessKeyId() {
                                    return Constants.ACCESS_KEY;
                                }
     
                                @Override
                                public String secretAccessKey() {
                                    return Constants.SECRET;
                                }
                            };
                        }
                    })
                    .build();
            uploadLargeFileBracketedByChecksum(s3Client);
            downloadLargeFileBracketedByChecksum(s3Client);
            validateExistingFileAgainstS3Checksum(s3Client);
        }
     
        public static void uploadLargeFileBracketedByChecksum(S3Client s3Client) {
            System.out.println("Starting uploading file validation");
            File file = new File(FILE_NAME);
            try (InputStream in = new FileInputStream(file)) {
                MessageDigest sha256 = MessageDigest.getInstance("SHA-256");
                CreateMultipartUploadRequest createMultipartUploadRequest = CreateMultipartUploadRequest.builder()
                        .bucket(BUCKET)
                        .key(FILE_NAME)
                        .checksumAlgorithm(ChecksumAlgorithm.SHA256)
                        .build();
                CreateMultipartUploadResponse createdUpload = s3Client.createMultipartUpload(createMultipartUploadRequest);
                List<CompletedPart> completedParts = new ArrayList<CompletedPart>();
                int partNumber = 1;
                byte[] buffer = new byte[CHUNK_SIZE];
                int read = in.read(buffer);
                while (read != -1) {
                    UploadPartRequest uploadPartRequest = UploadPartRequest.builder()
                            .partNumber(partNumber).uploadId(createdUpload.uploadId()).key(FILE_NAME).bucket(BUCKET).checksumAlgorithm(ChecksumAlgorithm.SHA256).build();
                    UploadPartResponse uploadedPart = s3Client.uploadPart(uploadPartRequest, RequestBody.fromByteBuffer(ByteBuffer.wrap(buffer, 0, read)));
                    CompletedPart part = CompletedPart.builder().partNumber(partNumber).checksumSHA256(uploadedPart.checksumSHA256()).eTag(uploadedPart.eTag()).build();
                    completedParts.add(part);
                    sha256.update(buffer, 0, read);
                    read = in.read(buffer);
                    partNumber++;
                }
                String fullObjectChecksum = Base64.getEncoder().encodeToString(sha256.digest());
                if (!fullObjectChecksum.equals(SHA256_FILE_BYTES)) {
                    //Because the SHA256 is uploaded after the part is uploaded; the upload is bracketed and the full object can be fully validated.
                    s3Client.abortMultipartUpload(AbortMultipartUploadRequest.builder().bucket(BUCKET).key(FILE_NAME).uploadId(createdUpload.uploadId()).build());
                    throw new IOException("Byte mismatch between stored checksum and upload, do not proceed with upload and cleanup");
                }
                CompletedMultipartUpload completedMultipartUpload = CompletedMultipartUpload.builder().parts(completedParts).build();
                CompleteMultipartUploadResponse completedUploadResponse = s3Client.completeMultipartUpload(
                        CompleteMultipartUploadRequest.builder().bucket(BUCKET).key(FILE_NAME).uploadId(createdUpload.uploadId()).multipartUpload(completedMultipartUpload).build());
                Tag checksumTag = Tag.builder().key(CHECKSUM_TAG_KEYNAME).value(fullObjectChecksum).build();
                //Optionally, if you need the full object checksum stored with the file; you could add it as a tag after completion.
                s3Client.putObjectTagging(PutObjectTaggingRequest.builder().bucket(BUCKET).key(FILE_NAME).tagging(Tagging.builder().tagSet(checksumTag).build()).build());
            } catch (IOException | NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            GetObjectAttributesResponse
                    objectAttributes = s3Client.getObjectAttributes(GetObjectAttributesRequest.builder().bucket(BUCKET).key(FILE_NAME)
                    .objectAttributes(ObjectAttributes.OBJECT_PARTS, ObjectAttributes.CHECKSUM).build());
            System.out.println(objectAttributes.objectParts().parts());
            System.out.println(objectAttributes.checksum().checksumSHA256());
        }
     
        public static void downloadLargeFileBracketedByChecksum(S3Client s3Client) {
            System.out.println("Starting downloading file validation");
            File file = new File("DOWNLOADED_" + FILE_NAME);
            try (OutputStream out = new FileOutputStream(file)) {
                GetObjectAttributesResponse
                        objectAttributes = s3Client.getObjectAttributes(GetObjectAttributesRequest.builder().bucket(BUCKET).key(FILE_NAME)
                        .objectAttributes(ObjectAttributes.OBJECT_PARTS, ObjectAttributes.CHECKSUM).build());
                //Optionally if you need the full object checksum, you can grab a tag you added on the upload
                List<Tag> objectTags = s3Client.getObjectTagging(GetObjectTaggingRequest.builder().bucket(BUCKET).key(FILE_NAME).build()).tagSet();
                String fullObjectChecksum = null;
                for (Tag objectTag : objectTags) {
                    if (objectTag.key().equals(CHECKSUM_TAG_KEYNAME)) {
                        fullObjectChecksum = objectTag.value();
                        break;
                    }
                }
                MessageDigest sha256FullObject = MessageDigest.getInstance("SHA-256");
                MessageDigest sha256ChecksumOfChecksums = MessageDigest.getInstance("SHA-256");
     
                //If you retrieve the object in parts, and set the ChecksumMode to enabled, the SDK will automatically validate the part checksum
                for (int partNumber = 1; partNumber <= objectAttributes.objectParts().totalPartsCount(); partNumber++) {
                    MessageDigest sha256Part = MessageDigest.getInstance("SHA-256");
                    ResponseInputStream<GetObjectResponse> response = s3Client.getObject(GetObjectRequest.builder().bucket(BUCKET).key(FILE_NAME).partNumber(partNumber).checksumMode(ChecksumMode.ENABLED).build());
                    GetObjectResponse getObjectResponse = response.response();
                    byte[] buffer = new byte[CHUNK_SIZE];
                    int read = response.read(buffer);
                    while (read != -1) {
                        out.write(buffer, 0, read);
                        sha256FullObject.update(buffer, 0, read);
                        sha256Part.update(buffer, 0, read);
                        read = response.read(buffer);
                    }
                    byte[] sha256PartBytes = sha256Part.digest();
                    sha256ChecksumOfChecksums.update(sha256PartBytes);
                    //Optionally, you can do an additional manual validation again the part checksum if needed in addition to the SDK check
                    String base64PartChecksum = Base64.getEncoder().encodeToString(sha256PartBytes);
                    String base64PartChecksumFromObjectAttributes = objectAttributes.objectParts().parts().get(partNumber - 1).checksumSHA256();
                    if (!base64PartChecksum.equals(getObjectResponse.checksumSHA256()) || !base64PartChecksum.equals(base64PartChecksumFromObjectAttributes)) {
                        throw new IOException("Part checksum didn't match for the part");
                    }
                    System.out.println(partNumber + " " + base64PartChecksum);
                }
                //Before finalizing, do the final checksum validation.
                String base64FullObject = Base64.getEncoder().encodeToString(sha256FullObject.digest());
                String base64ChecksumOfChecksums = Base64.getEncoder().encodeToString(sha256ChecksumOfChecksums.digest());
                if (fullObjectChecksum != null && !fullObjectChecksum.equals(base64FullObject)) {
                    throw new IOException("Failed checksum validation for full object");
                }
                System.out.println(fullObjectChecksum);
                String base64ChecksumOfChecksumFromAttributes = objectAttributes.checksum().checksumSHA256();
                if (base64ChecksumOfChecksumFromAttributes != null && !base64ChecksumOfChecksums.equals(base64ChecksumOfChecksumFromAttributes)) {
                    throw new IOException("Failed checksum validation for full object checksum of checksums");
                }
                System.out.println(base64ChecksumOfChecksumFromAttributes);
                out.flush();
            } catch (IOException | NoSuchAlgorithmException e) {
                //Cleanup bad file
                file.delete();
                e.printStackTrace();
            }
        }
     
        public static void validateExistingFileAgainstS3Checksum(S3Client s3Client) {
            System.out.println("Starting existing file validation");
            File file = new File("DOWNLOADED_" + FILE_NAME);
            GetObjectAttributesResponse
                    objectAttributes = s3Client.getObjectAttributes(GetObjectAttributesRequest.builder().bucket(BUCKET).key(FILE_NAME)
                    .objectAttributes(ObjectAttributes.OBJECT_PARTS, ObjectAttributes.CHECKSUM).build());
            try (InputStream in = new FileInputStream(file)) {
                MessageDigest sha256ChecksumOfChecksums = MessageDigest.getInstance("SHA-256");
                MessageDigest sha256Part = MessageDigest.getInstance("SHA-256");
                byte[] buffer = new byte[CHUNK_SIZE];
                int currentPart = 0;
                int partBreak = objectAttributes.objectParts().parts().get(currentPart).size();
                int totalRead = 0;
                int read = in.read(buffer);
                while (read != -1) {
                    totalRead += read;
                    if (totalRead >= partBreak) {
                        int difference = totalRead - partBreak;
                        byte[] partChecksum;
                        if (totalRead != partBreak) {
                            sha256Part.update(buffer, 0, read - difference);
                            partChecksum = sha256Part.digest();
                            sha256ChecksumOfChecksums.update(partChecksum);
                            sha256Part.reset();
                            sha256Part.update(buffer, read - difference, difference);
                        } else {
                            sha256Part.update(buffer, 0, read);
                            partChecksum = sha256Part.digest();
                            sha256ChecksumOfChecksums.update(partChecksum);
                            sha256Part.reset();
                        }
                        String base64PartChecksum = Base64.getEncoder().encodeToString(partChecksum);
                        if (!base64PartChecksum.equals(objectAttributes.objectParts().parts().get(currentPart).checksumSHA256())) {
                            throw new IOException("Part checksum didn't match S3");
                        }
                        currentPart++;
                        System.out.println(currentPart + " " + base64PartChecksum);
                        if (currentPart < objectAttributes.objectParts().totalPartsCount()) {
                            partBreak += objectAttributes.objectParts().parts().get(currentPart - 1).size();
                        }
                    } else {
                        sha256Part.update(buffer, 0, read);
                    }
                    read = in.read(buffer);
                }
                if (currentPart != objectAttributes.objectParts().totalPartsCount()) {
                    currentPart++;
                    byte[] partChecksum = sha256Part.digest();
                    sha256ChecksumOfChecksums.update(partChecksum);
                    String base64PartChecksum = Base64.getEncoder().encodeToString(partChecksum);
                    System.out.println(currentPart + " " + base64PartChecksum);
                }
     
                String base64CalculatedChecksumOfChecksums = Base64.getEncoder().encodeToString(sha256ChecksumOfChecksums.digest());
                System.out.println(base64CalculatedChecksumOfChecksums);
                System.out.println(objectAttributes.checksum().checksumSHA256());
                if (!base64CalculatedChecksumOfChecksums.equals(objectAttributes.checksum().checksumSHA256())) {
                    throw new IOException("Full object checksum of checksums don't match S3");
                }
     
            } catch (IOException | NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
        }
    }

Verwenden der REST-API

Sie können REST-Anfragen senden, um ein Objekt mit einem Prüfsummenwert hochzuladen, mit PutObjectdem die Integrität der Daten überprüft werden kann. Sie können den Prüfsummenwert für Objekte auch mit GetObjectoder abrufen. HeadObject

Mit dem AWS CLI

Sie können eine PUT-Anforderung zum Hochladen eines Objekts von bis zu 5 GB in einem einzigen Vorgang senden. Weitere Informationen finden Sie unter PutObject in der AWS CLI -Befehlszeilenreferenz. Sie können auch get-object und head-object verwenden, um die Prüfsumme eines bereits hochgeladenen Objekts abzurufen und die Integrität der Daten zu überprüfen.

Weitere Informationen finden Sie unter Häufig gestellte Fragen zur Amazon-S3-CLI im AWS Command Line Interface -Benutzerhandbuch.

Inhalte verwenden — MD5 beim Hochladen von Objekten

Eine weitere Möglichkeit, die Integrität Ihres Objekts nach dem Hochladen zu überprüfen, besteht darin, MD5 beim Hochladen eine Zusammenfassung des Objekts bereitzustellen. Wenn Sie den MD5 Digest für Ihr Objekt berechnen, können Sie den Digest mit dem PUT Befehl bereitstellen, indem Sie den Header verwenden. Content-MD5

Nach dem Hochladen des Objekts berechnet Amazon S3 den MD5 Digest des Objekts und vergleicht ihn mit dem von Ihnen angegebenen Wert. Die Anforderung ist nur erfolgreich, wenn die beiden Digests übereinstimmen.

Die Angabe eines MD5 Digest ist nicht erforderlich, Sie können ihn jedoch verwenden, um die Integrität des Objekts im Rahmen des Upload-Vorgangs zu überprüfen.

Verwenden Sie Content- MD5 und the, um hochgeladene ETag Objekte zu verifizieren

Das Entity-Tag (ETag) für ein Objekt steht für eine bestimmte Version dieses Objekts. Beachten Sie, dass dies ETag nur Änderungen am Inhalt eines Objekts widerspiegelt, keine Änderungen an seinen Metadaten. Wenn sich nur die Metadaten eines Objekts ändern, ETag bleiben die gleichen.

Je nach Objekt kann es sich ETag bei dem Objekt um eine MD5 Zusammenfassung der Objektdaten handeln:

• Wenn ein Objekt durch die CopyObject OperationPutObject,PostObject, oder durch die AWS Management Console, erstellt wird und dieses Objekt auch Klartext oder durch serverseitige Verschlüsselung mit Amazon S3 S3-verwalteten Schlüsseln (SSE-S3) verschlüsselt ist, hat dieses Objekt eine ETag MD5 Zusammenfassung seiner Objektdaten.

• Wenn ein Objekt durch die CopyObject OperationPutObject,PostObject, oder durch die AWS Management Console, erstellt wird und dieses Objekt durch serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C) oder serverseitige Verschlüsselung mit AWS Key Management Service (AWS KMS) Schlüsseln (SSE-KMS) verschlüsselt wird, hat dieses Objekt eine, ETag die kein MD5 Digest seiner Objektdaten ist.

• Wenn ein Objekt entweder durch den mehrteiligen Upload-Prozess oder durch den UploadPartCopy Vorgang erstellt wird, ETag handelt es sich bei dem Objekt unabhängig von der Verschlüsselungsmethode nicht um einen MD5 Digest. Wenn ein Objekt größer als 16 MB ist, wird dieses Objekt als mehrteiliger AWS Management Console Upload hochgeladen oder kopiert, es handelt sich also ETag nicht um einen Digest. MD5

Bei Objekten, bei denen ETag es sich um den Content-MD5 Digest des Objekts handelt, können Sie den ETag Wert des Objekts mit einem berechneten oder zuvor gespeicherten Digest vergleichen. Content-MD5

Verwenden von nachfolgenden Prüfsummen

Wenn Sie große Objekte auf Amazon S3 hochladen, können Sie entweder eine vorberechnete Prüfsumme für das Objekt angeben oder ein AWS SDK verwenden, um in Ihrem Namen automatisch abschließende Prüfsummen für aufgeteilte Uploads zu erstellen. Wenn Sie eine abschließende Prüfsumme verwenden, generiert Amazon S3 automatisch den Prüfsummenwert mithilfe Ihres angegebenen Algorithmus, um die Integrität des Objekts in aufgeteilten Uploads zu überprüfen, wenn Sie ein Objekt hochladen.

Um bei der Verwendung eines AWS SDK eine abschließende Prüfsumme zu erstellen, füllen Sie den Parameter mit Ihrem bevorzugten Algorithmus auf. ChecksumAlgorithm Das SDK verwendet diesen Algorithmus, um den Prüfsummenwert für Ihr Objekt (oder Ihre Objektteile) zu berechnen, und hängt ihn automatisch an das Ende Ihrer Anfrage für den blockierten Upload an. Dank dieser Funktionsweise sparen Sie Zeit, da Amazon S3 sowohl die Überprüfung als auch das Hochladen Ihrer Daten in einem einzigen Durchgang durchführt.

Wichtig

Wenn Sie S3 Object Lambda verwenden, werden alle Anfragen an S3 Object Lambda mit s3-object-lambda anstelle von s3 signiert. Dieses Verhalten wirkt sich auf die Signatur der nachfolgenden Prüfsummenwerte aus. Weitere Informationen zu S3 Object Lambda finden Sie unter Transformieren von Objekten mit S3 Object Lambda.

Nachfolgende Prüfsummen-Header

Um eine Anfrage zur Codierung von Chunked Content zu stellen, verlangt Amazon S3 von den Client-Servern, dass sie mehrere Header enthalten, um die Anfrage korrekt zu analysieren. Client-Server müssen die folgenden Header enthalten:

• x-amz-decoded-content-length: Dieser Header gibt die Klartextgröße der tatsächlichen Daten an, die mit der Anfrage auf Amazon S3 hochgeladen werden.

• x-amz-content-sha256: Dieser Header gibt den Typ des blockierten Uploads an, der in der Anfrage enthalten ist. Bei Chunk-Uploads mit abschließenden Prüfsummen gilt der Header-Wert für Anfragen, die keine Nutzlastsignatur verwenden, und STREAMING-UNSIGNED-PAYLOAD-TRAILER STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER für Anfragen, die SigV4-Nutzlastsignatur verwenden. (Weitere Informationen zur Implementierung signierter Payloads finden Sie unter Signaturberechnungen für den Autorisierungsheader: Payload in mehreren Chunks übertragen.)

• x-amz-trailer: Dieser Header gibt den Namen des nachfolgenden Headers in der Anfrage an. Wenn abschließende Prüfsummen existieren (wobei Prüfsummen an die codierten Anforderungstexte AWS SDKs angehängt werden), enthält der x-amz-trailer Header-Wert das x-amz-checksum- Präfix und endet mit dem Namen des Algorithmus. Die folgenden Werte werden derzeit unterstützt: x-amz-trailer

  • x-amz-checksum-crc32

  • x-amz-checksum-crc32c

  • x-amz-checksum-crc64nvme

  • x-amz-checksum-sha1

  • x-amz-checksum-sha256

Anmerkung

Sie können auch den Content-Encoding Header mit dem aufgeteilten Wert in Ihre Anfrage aufnehmen. Dieser Header ist zwar nicht erforderlich, aber durch die Aufnahme dieses Headers können HTTP-Proxyprobleme bei der Übertragung codierter Daten minimiert werden. Wenn in der Anfrage ein anderer Content-Encoding Header (z. B. gzip) vorhanden ist, enthält der Content-Encoding Header den aufgeteilten Wert in einer durch Kommas getrennten Liste von Kodierungen. Beispiel, Content-Encoding: aws-chunked, gzip.

In Teile gegliederte Teile

Wenn Sie ein Objekt mit Chunked-Codierung auf Amazon S3 hochladen, umfasst die Upload-Anfrage die folgenden Arten von Chunks (in der angegebenen Reihenfolge formatiert):

• Textteile des Objekts: Einer Upload-Anfrage können ein, mehrere oder keine Textteile zugeordnet sein.

• Abschlussteile: Einer Upload-Anfrage in Teilen können ein, mehrere oder keine Textteile zugeordnet sein.

• Nachfolgende Chunks: Die abschließende Prüfsumme wird nach dem Abschluss-Chunk aufgeführt. Nur ein abschließender Chunk ist zulässig.

Anmerkung

Jeder Chunk-Upload muss mit einer abschließenden CRLF (z. B.\r\n) enden, die das Ende der Anfrage anzeigt.

Beispiele für die Formatierung in Teilen finden Sie unter. Beispiele: Aufgeteilte Uploads mit abschließenden Prüfsummen

Teile des Objektkörpers

Objektkörper-Chunks sind die Chunks, die die eigentlichen Objektdaten enthalten, die auf S3 hochgeladen werden. Für diese Chunks gelten konsistente Größen- und Formatbeschränkungen.

Größe des Objektkörpers (Chunks)

Diese Blöcke müssen mindestens 8.192 Byte (oder 8 KiB) an Objektdaten enthalten, mit Ausnahme des letzten Body-Chunks, der kleiner sein kann. Es gibt keine explizite maximale Chunk-Größe, aber Sie können davon ausgehen, dass alle Chunks kleiner als die maximale Upload-Größe von 5 GB sind. Die Chunk-Größe kann je nach Ihrer Client-Server-Implementierung von einem Chunk zum nächsten variieren.

Format des Objektkörpers (Chunk-Format)

Objekttextblöcke beginnen mit der hexadezimalen Kodierung der Anzahl der Byte im Textteil des Objektkörpers, gefolgt von einer CRLF (Carriage Return Line Feed), den Objektbytes für diesen Abschnitt und einer weiteren CRLF.

Zum Beispiel:

hex-encoding-of-object-bytes-in-chunk\r\n
chunk-object-bytes\r\n

Wenn der Abschnitt jedoch signiert ist, folgt der Objekttextabschnitt einem anderen Format, bei dem die Signatur mit einem Semikolon-Trennzeichen an die Chunk-Größe angehängt wird. Zum Beispiel:

hex-encoding-of-object-bytes-in-chunk;chunk-signature\r\n
 chunk-object-bytes\r\n

Weitere Informationen zur Blocksignierung finden Sie unter Signaturberechnungen für den Authorization Header: Übertragung einer Nutzlast in mehreren Abschnitten (Signature Version 4).AWS Weitere Informationen zur Chunk-Formatierung finden Sie unter Chunked Transfer Encoding auf der RFC Editor-Website.

Blöcke zur Fertigstellung

Abschluss-Chunks müssen der letzte Teil des Objekttextes jedes Chunk-Uploads sein. Das Format eines Completion-Chunks ähnelt einem Body-Chunk, enthält aber immer null Byte an Objektdaten. (Die Null Byte der Objektdaten geben an, dass alle Daten hochgeladen wurden.) Aufgeteilte Uploads müssen einen Abschlussteil als abschließenden Abschnitt des Hauptteils des Objekts enthalten, und zwar in einem Format wie dem folgenden:

0\r\n

Wenn die Inhaltscodierungsanforderung jedoch Nutzlastsignatur verwendet, folgt sie stattdessen diesem Format:

0;chunk-signature\r\n

Teile des Trailers

Trailer-Chunks enthalten die berechnete Prüfsumme für alle S3-Upload-Anfragen. Trailer-Chunks enthalten zwei Felder: ein Header-Namensfeld und ein Header-Wertefeld. Das Header-Namensfeld für eine Upload-Anfrage muss mit dem Wert übereinstimmen, der in den x-amz-trailer Anforderungsheader übergeben wurde. Wenn eine Anfrage beispielsweise den Header-Namen enthält x-amz-trailer: x-amz-checksum-crc32 und der Trailer-Chunk den Header-Namen hatx-amz-checksum-sha1, schlägt die Anfrage fehl. Das Wertfeld im Trailer-Chunk enthält eine Base64-Kodierung des Big-Endian-Prüfsummenwerts für dieses Objekt. (Bei der Big-Endian-Reihenfolge wird das höchstwertige Datenbyte an der niedrigsten Speicheradresse und das niedrigstwertige Byte an der größten Speicheradresse gespeichert.) Der zur Berechnung dieser Prüfsumme verwendete Algorithmus entspricht dem Suffix für den Header-Namen (z. B.). crc32

Format des Trailer-Chunks

Trailer-Chunks verwenden das folgende Format für unsignierte Payload-Anfragen:

x-amz-checksum-lowercase-checksum-algorithm-name:base64-checksum-value\n\r\n\r\n

Bei Anfragen mit SigV4-signierten Payloads enthält der Trailer-Chunk nach dem Trailer-Chunk eine Trailer-Signatur.

trailer-checksum\n\r\n
trailer-signature\r\n

Sie können die CRLF auch direkt am Ende des Base64-Prüfsummenwerts hinzufügen. Zum Beispiel:

x-amz-checksum-lowercase-checksum-algorithm-name:base64-checksum-value\r\n\r\n

Beispiele: Aufgeteilte Uploads mit abschließenden Prüfsummen

Amazon S3 unterstützt blockierte Uploads, die aws-chunked Inhaltskodierung verwenden, PutObject und UploadPart Anfragen mit abschließenden Prüfsummen.

Beispiel 1 — Unsignierte blockierte Anfrage mit einer abschließenden CRC-32-Prüfsumme PutObject

Im Folgenden finden Sie ein Beispiel für eine abgeschnittene Anfrage mit einer abschließenden CRC-32-Prüfsumme. PutObject In diesem Beispiel lädt der Client ein 17-KB-Objekt in drei unsignierten Chunks hoch und fügt mithilfe des Headers einen abschließenden CRC-32-Prüfsummenblock an. x-amz-checksum-crc32

PUT /Key+ HTTP/1.1
Host: amzn-s3-demo-bucket
Content-Encoding: aws-chunked
x-amz-decoded-content-length: 17408
x-amz-content-sha256: STREAMING-UNSIGNED-PAYLOAD-TRAILER
x-amz-trailer: x-amz-checksum-crc32

2000\r\n                                   // Object body chunk 1 (8192 bytes)
object-bytes\r\n
2000\r\n                                   // Object body chunk 2 (8192 bytes)
object-bytes\r\n
400\r\n                                    // Object body chunk 3 (1024 bytes)
object-bytes\r\n
0\r\n                                      // Completion chunk
x-amz-checksum-crc32:YABb/g==\n\r\n\r\n    // Trailer chunk (note optional \n character)
\r\n                                         // CRLF

Hier ist ein Beispiel für eine Antwort:

HTTP/1.1 200
ETag: ETag
x-amz-checksum-crc32: YABb/g==

Anmerkung

Die Verwendung des Zeilenvorschubs \n am Ende des Prüfsummenwerts kann je nach Client variieren.

Beispiel 2 — SigV4-signierte PutObject Chunk-Anfrage mit abschließender CRC-32 () -Prüfsumme CRC32

Das Folgende ist ein Beispiel für eine abschnittsweise Anfrage mit einer abschließenden CRC-32-Prüfsumme. PutObject Diese Anfrage verwendet die SigV4-Nutzlastsignatur. In diesem Beispiel lädt der Client ein 17-KB-Objekt in drei signierten Abschnitten hoch. Zusätzlich zu den object body Chunks sind auch die und signiertcompletion chunk. trailer chunk

PUT /Key+ HTTP/1.1
Host: amzn-s3-demo-bucket.s3.amazonaws.com
Content-Encoding: aws-chunked
x-amz-decoded-content-length: 17408
x-amz-content-sha256: STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER
x-amz-trailer: x-amz-checksum-crc32
		
authorization-code                            // SigV4 headers authorization

2000;chunk-signature=signature-value...\r\n   // Object body chunk 1 (8192 bytes)
object-bytes\r\n
2000;chunk-signature\r\n                      // Object body chunk 2 (8192 bytes)
object-bytes\r\n
400;chunk-signature\r\n                       // Object body chunk 3 (1024 bytes)
object-bytes\r\n
0;chunk-signature\r\n                         // Completion chunk
x-amz-checksum-crc32:YABb/g==\n\r\n            // Trailer chunk (note optional \n character)
trailer-signature\r\n
\r\n                                           // CRLF

Hier ist ein Beispiel für eine Antwort:

HTTP/1.1 200
ETag: ETag
x-amz-checksum-crc32: YABb/g==