Version 1.4.1 uses ByteBuffers in a backwards compatible way. (#107)

* Version 1.4.1 uses ByteBuffers in a backwards compatible way.

Java 9 introduced a change in ByteBuffers causing some methods to fail
when compiled with Java 9 (or newer) but executed on Java 8 (or older)
regardless of compatability levels applied.
See mongodb/mongo-java-driver@21c91bd

* Fix comment spacing

Author: SalusaSecondus

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 1.4.1 -- 2019-05-10
+
+### Patches
+* Cast ByteBuffer to Buffer prior to using some methods so that it works properly in Java 8.
+
 ## 1.4.0 -- 2019-05-10
 
 ### Minor Changes

README.md

@@ -45,7 +45,7 @@ You can get the latest release from Maven:
 <dependency>
   <groupId>com.amazonaws</groupId>
   <artifactId>aws-encryption-sdk-java</artifactId>
-  <version>1.4.0</version>
+  <version>1.4.1</version>
 </dependency>
 ```
 

pom.xml

@@ -4,7 +4,7 @@
 
     <groupId>com.amazonaws</groupId>
     <artifactId>aws-encryption-sdk-java</artifactId>
-    <version>1.4.0</version>
+    <version>1.4.1</version>
     <packaging>jar</packaging>
 
     <name>aws-encryption-sdk-java</name>

src/main/java/com/amazonaws/encryptionsdk/internal/EncryptionContextSerializer.java

@@ -113,7 +113,7 @@ public static byte[] serialize(Map<String, String> encryptionContext) {
             }
 
             // get and return the bytes that have been serialized
-            result.flip();
+            Utils.flip(result);
             final byte[] encryptionContextBytes = new byte[result.limit()];
             result.get(encryptionContextBytes);
 
@@ -173,8 +173,8 @@ public static Map<String, String> deserialize(final byte[] b) {
                 }
 
                 final ByteBuffer keyBytes = encryptionContextBytes.slice();
-                keyBytes.limit(keyLen);
-                encryptionContextBytes.position(encryptionContextBytes.position() + keyLen);
+                Utils.limit(keyBytes, keyLen);
+                Utils.position(encryptionContextBytes, encryptionContextBytes.position() + keyLen);
 
                 final int valueLen = encryptionContextBytes.getShort();
                 if (valueLen <= 0 || valueLen > Short.MAX_VALUE) {
@@ -184,8 +184,8 @@ public static Map<String, String> deserialize(final byte[] b) {
 
                 // retrieve value
                 final ByteBuffer valueBytes = encryptionContextBytes.slice();
-                valueBytes.limit(valueLen);
-                encryptionContextBytes.position(encryptionContextBytes.position() + valueLen);
+                Utils.limit(valueBytes, valueLen);
+                Utils.position(encryptionContextBytes, encryptionContextBytes.position() + valueLen);
 
                 final CharBuffer keyChars = decoder.decode(keyBytes);
                 final CharBuffer valueChars = decoder.decode(valueBytes);

src/main/java/com/amazonaws/encryptionsdk/internal/FrameEncryptionHandler.java

@@ -359,7 +359,7 @@ private byte[] getNonce() {
         // We technically only allocate the low 32 bits for the frame number, and the other bits are defined to be
         // zero. However, since MAX_FRAME_NUMBER is 2^32-1, the high-order four bytes of the long will be zero, so the
         // big-endian representation will also have zeros in that position.
-        buf.position(buf.limit() - Long.BYTES);
+        Utils.position(buf, buf.limit() - Long.BYTES);
         buf.putLong(frameNumber_);
 
         return nonce;

src/main/java/com/amazonaws/encryptionsdk/internal/Utils.java

@@ -14,6 +14,7 @@
 package com.amazonaws.encryptionsdk.internal;
 
 import java.io.Serializable;
+import java.nio.Buffer;
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.security.SecureRandom;
@@ -220,4 +221,40 @@ static byte[] generateContentAad(final byte[] messageId, final String idString,
     static IllegalArgumentException cannotBeNegative(String field) {
         return new IllegalArgumentException(field + " cannot be negative");
     }
+
+    /**
+     * Equivalent to calling {@link ByteBuffer#flip()} but in a manner which is
+     * safe when compiled on Java 9 or newer but used on Java 8 or older.
+     */
+    public static ByteBuffer flip(final ByteBuffer buff) {
+        ((Buffer) buff).flip();
+        return buff;
+    }
+
+    /**
+     * Equivalent to calling {@link ByteBuffer#clear()} but in a manner which is
+     * safe when compiled on Java 9 or newer but used on Java 8 or older.
+     */
+    public static ByteBuffer clear(final ByteBuffer buff) {
+        ((Buffer) buff).clear();
+        return buff;
+    }
+
+    /**
+     * Equivalent to calling {@link ByteBuffer#position(int)} but in a manner which is
+     * safe when compiled on Java 9 or newer but used on Java 8 or older.
+     */
+    public static ByteBuffer position(final ByteBuffer buff, final int newPosition) {
+        ((Buffer) buff).position(newPosition);
+        return buff;
+    }
+
+    /**
+     * Equivalent to calling {@link ByteBuffer#limit(int)} but in a manner which is
+     * safe when compiled on Java 9 or newer but used on Java 8 or older.
+     */
+    public static ByteBuffer limit(final ByteBuffer buff, final int newLimit) {
+        ((Buffer) buff).limit(newLimit);
+        return buff;
+    }
 }

src/test/java/com/amazonaws/encryptionsdk/internal/FrameEncryptionHandlerVeryLongTest.java

@@ -38,7 +38,7 @@ public void exhaustiveIVCheck() throws Exception {
         long lastIndex = 1; // starting index for the test
         long lastTS = System.nanoTime();
         for (long i = lastIndex; i <= Constants.MAX_FRAME_NUMBER; i++) {
-            expectedNonce.clear();
+            Utils.clear(expectedNonce);
             expectedNonce.order(ByteOrder.BIG_ENDIAN);
             expectedNonce.putInt(0);
             expectedNonce.putLong(i);