checksum algo prog

Author: push2stack

src/main/java/io/github/jpmorganchase/fusion/api/request/PartFetcher.java

@@ -5,6 +5,7 @@
 import io.github.jpmorganchase.fusion.api.response.GetPartResponse;
 import io.github.jpmorganchase.fusion.api.response.Head;
 import io.github.jpmorganchase.fusion.api.stream.IntegrityCheckingInputStream;
+import io.github.jpmorganchase.fusion.digest.PartChecker;
 import io.github.jpmorganchase.fusion.http.Client;
 import io.github.jpmorganchase.fusion.http.HttpResponse;
 import io.github.jpmorganchase.fusion.oauth.provider.FusionTokenProvider;
@@ -55,6 +56,7 @@ private IntegrityCheckingInputStream getIntegrityCheckingInputStream(
         return IntegrityCheckingInputStream.builder()
                 .part(response.getBody())
                 .checksum(head.getChecksum())
+                .partChecker(PartChecker.builder())
                 .build();
     }
 

src/main/java/io/github/jpmorganchase/fusion/api/response/Head.java

@@ -18,15 +18,18 @@
 @EqualsAndHashCode
 public class Head {
 
-    private static String CHECKSUM_HEADER = "x-jpmc-checksum-sha256";
+    private static String CHECKSUM_HEADER = "x-jpmc-checksum";
+    private static String CHECKSUM_SHA256_HEADER = "x-jpmc-checksum-sha256";
     private static String VERSION_HEADER = "x-jpmc-version-id";
     private static String PART_COUNT_HEADER = "x-jpmc-mp-parts-count";
     private static String CONTENT_LENGTH_HEADER = "Content-Length";
     private static String CONTENT_RANGE_HEADER = "Content-Range";
     private static String CHECKSUM_SEPARATOR = "-";
+    private  static  String DEFAULT_ALGORITHM = "SHA-256";
 
     private String version;
     private String checksum;
+    private String checksumAlgorithm;
     private int partCount;
     private long contentLength;
     private ContentRange contentRange;
@@ -58,10 +61,11 @@ public Head build() {
                 handlePartCountHeader();
                 handleChecksumHeader();
                 handleVersionHeader();
+                handleChecksumAlgorithmHeader();
                 handleContentLength();
                 handleContentRangeHeader();
             }
-            return new Head(version, checksum, partCount, contentLength, contentRange, isMultipart);
+            return new Head(version, checksum, checksumAlgorithm, partCount, contentLength, contentRange, isMultipart);
         }
 
         private void handleContentLength() {
@@ -89,6 +93,28 @@ private void handleChecksumHeader() {
                     this.checksum = values.get(0).split(CHECKSUM_SEPARATOR)[0];
                 }
             }
+            else {
+                List<String> values = this.headers.get(CHECKSUM_SHA256_HEADER);
+                if (nonNull(values) && !values.isEmpty() && nonNull(values.get(0))){
+                    this.checksum = values.get(0).split(CHECKSUM_SEPARATOR)[0];
+                }
+
+            }
+
+        }
+
+        private void handleChecksumAlgorithmHeader() {
+            if(this.headers.containsKey(CHECKSUM_AlGO_HEADER)){
+                List<String> values = this.headers.get(CHECKSUM_ALGO_HEADER);
+                if(!values.isEmpty() && nonNull(values.get(0))) {
+                    this.checksumAlgorithm = values.get(0);
+                }
+            } else
+            {
+                this.checksumALgorithm = DEFAULT_ALGORITHM;
+            }
+
+
         }
 
         private void handlePartCountHeader() {

src/main/java/io/github/jpmorganchase/fusion/digest/PartChecker.java

@@ -20,26 +20,39 @@ public class PartChecker {
 
     MessageDigest digest;
 
-    String digestAlgo;
+    private DigestProvider digestProvider;
+    private String digestAlgo;
+    private boolean skipChecksum;
+    private DigestProviderService digestProviderService;
 
-    public PartChecker(String digestAlgo) {
+
+
+    public PartChecker(String digestAlgo, DigestProviderService digestProviderService) {
         this.digestAlgo = digestAlgo;
+        this.digestProviderService = digestProviderService;
     }
 
     public void update(int bytesRead) throws IOException {
-        if (Objects.isNull(digest)) {
+        if (Objects.isNull(digestProvider)) {
             init();
         }
-        digest.update(Integer.valueOf(bytesRead).byteValue());
+        digestProvider.update(Integer.valueOf(bytesRead).byteValue());
     }
 
-    public void verify(String checksum) throws IOException {
+    public void verify(String expectedChecksum) throws IOException {
         String encodedDigest = Base64.getEncoder().encodeToString(digest.digest());
-        if (!Objects.isNull(checksum) && !checksum.equals(encodedDigest)) {
+        if (skipChecksum) {
+            return;
+        }
+
+        String calculatedChecksum = digestProvider.getDigest();
+
+
+        if (!Objects.equals(expectedChecksum, calculatedChecksum)) {
             log.error(
                     "Corrupted stream encountered, failed to verify checksum [{}] against calculated checksum [{}]",
-                    checksum,
-                    encodedDigest);
+                    expectedChecksum,
+                    calculatedChecksum);
             throw new IOException("Corrupted stream, verification of checksum failed");
         }
     }
@@ -53,11 +66,13 @@ private void init() throws IOException {
     }
 
     public static class PartCheckerBuilder {
+
+        DigestProviderService digestProviderService = new DigestProviderService();
         public PartChecker build() {
             if (digestAlgo == null) {
                 digestAlgo = DEFAULT_DIGEST_ALGO;
             }
-            return new PartChecker(digestAlgo);
+            return new PartChecker(digestAlgo, skipChecksum, digestProviderService);
         }
     }
 }

src/main/java/io/github/jpmorganchase/fusion/digest/checksum/CRC32CProvider.java

@@ -0,0 +1,28 @@
+package io.github.jpmorganchase.fusion.digest.checksum;
+
+import java.util.Base64;
+import java.util.zip.Checksum;
+import java.util.zip.checksum;
+import software.amazon.awssdk.crt.checksums.CRC32C;
+
+
+public class CRC32CProvider implements DigestProvider {
+
+    private final Checksum checksum;
+
+    public CRC32CProvider()
+    {
+        this.checksum = newCRC32C();
+    }
+
+    @Override
+    public String getDigest(){
+        long checksumValue = checksum.getValue();
+        return Base64.getEncoder().encodeToString(longToBytes(checksumValue));
+    }
+
+    private byte[] longToBytes(long value)
+    {
+        return new byte[] {(byte) (value >>> 24), (byte) (value>>> 16), (byte) (value >>> 8), (byte) value};
+    }
+}