JAVA-1900: Ensure that BSON binary values of subtype 3 or 4 (UUID_LEGACY and UUID_STANDARD) can be decoded even if they have an unexpected size.

   BSON binary representations of UUID should be 16 bytes, but the server doesn't enforce that constraint.  Rather than throw an exception when decoding a
   UUID value with length other than 16, the driver should instead decode it to an instance of org.bson.Binary rather than the expected java.util.UUID.

  This way, clients expecting a UUID instance will still fail if casting to UUID, but at least they have the ability to control this behavior by doing type tests.
  And clients that don't care one way or the other will continue to function in the face of bad data.

Author: jyemin

bson/src/main/org/bson/AbstractBsonReader.java

@@ -120,6 +120,14 @@ protected boolean isClosed() {
      */
     protected abstract byte doPeekBinarySubType();
 
+    /**
+     * Handles the logic to peek at the binary size.
+     *
+     * @return the binary size
+     * @since 3.4
+     */
+    protected abstract int doPeekBinarySize();
+
     /**
      * Handles the logic to read booleans
      *
@@ -283,6 +291,12 @@ public byte peekBinarySubType() {
         return doPeekBinarySubType();
     }
 
+    @Override
+    public int peekBinarySize() {
+        checkPreconditions("readBinaryData", BsonType.BINARY);
+        return doPeekBinarySize();
+    }
+
     @Override
     public boolean readBoolean() {
         checkPreconditions("readBoolean", BsonType.BOOLEAN);

bson/src/main/org/bson/BsonBinaryReader.java

@@ -153,6 +153,14 @@ protected byte doPeekBinarySubType() {
         return type;
     }
 
+    @Override
+    protected int doPeekBinarySize() {
+        mark();
+        int size = readSize();
+        reset();
+        return size;
+    }
+
     @Override
     protected boolean doReadBoolean() {
         byte booleanByte = bsonInput.readByte();

bson/src/main/org/bson/BsonBinarySubType.java

@@ -59,6 +59,17 @@ public enum BsonBinarySubType {
 
     private final byte value;
 
+    /**
+     * Returns true if the given value is a UUID subtype
+     *
+     * @param value the subtype value as a byte
+     * @return true if value is a UUID subtype
+     * @since 3.4
+     */
+    public static boolean isUuid(final byte value) {
+        return value == UUID_LEGACY.getValue() || value == UUID_STANDARD.getValue();
+    }
+
     BsonBinarySubType(final byte value) {
         this.value = value;
     }
@@ -71,5 +82,4 @@ public enum BsonBinarySubType {
     public byte getValue() {
         return value;
     }
-
 }

bson/src/main/org/bson/BsonDocumentReader.java

@@ -58,6 +58,11 @@ protected byte doPeekBinarySubType() {
         return currentValue.asBinary().getType();
     }
 
+    @Override
+    protected int doPeekBinarySize() {
+        return currentValue.asBinary().getData().length;
+    }
+
     @Override
     protected boolean doReadBoolean() {
         return currentValue.asBoolean().getValue();

bson/src/main/org/bson/BsonReader.java

@@ -52,6 +52,15 @@ public interface BsonReader {
      */
     byte peekBinarySubType();
 
+    /**
+     * Peeks the size of the binary data that the reader is positioned at.  This operation is not permitted if the mark is already set.
+     *
+     * @return the size of the binary data
+     * @see #mark()
+     * @since 3.4
+     */
+    int peekBinarySize();
+
     /**
      * Reads a BSON Binary data element from the reader.
      *

bson/src/main/org/bson/codecs/DocumentCodec.java

@@ -205,12 +205,9 @@ private Object readValue(final BsonReader reader, final DecoderContext decoderCo
             reader.readNull();
             return null;
         } else if (bsonType == BsonType.ARRAY) {
-           return readList(reader, decoderContext);
-        } else if (bsonType == BsonType.BINARY) {
-            byte bsonSubType = reader.peekBinarySubType();
-            if (bsonSubType == BsonBinarySubType.UUID_STANDARD.getValue() || bsonSubType == BsonBinarySubType.UUID_LEGACY.getValue()) {
-                return registry.get(UUID.class).decode(reader, decoderContext);
-            }
+            return readList(reader, decoderContext);
+        } else if (bsonType == BsonType.BINARY && BsonBinarySubType.isUuid(reader.peekBinarySubType()) && reader.peekBinarySize() == 16) {
+            return registry.get(UUID.class).decode(reader, decoderContext);
         }
         return valueTransformer.transform(bsonTypeCodecMap.get(bsonType).decode(reader, decoderContext));
     }

bson/src/main/org/bson/json/JsonReader.java

@@ -86,6 +86,11 @@ protected byte doPeekBinarySubType() {
        return doReadBinaryData().getType();
     }
 
+    @Override
+    protected int doPeekBinarySize() {
+        return doReadBinaryData().getData().length;
+    }
+
     @Override
     protected boolean doReadBoolean() {
         return (Boolean) currentValue;

bson/src/test/unit/org/bson/BsonBinarySubTypeSpecification.groovy

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2016 MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+package org.bson
+
+import spock.lang.Specification
+
+class BsonBinarySubTypeSpecification extends Specification {
+
+    def 'should be uuid only for legacy and uuid types'() {
+        expect:
+        BsonBinarySubType.isUuid(value as byte) == isUuid
+
+        where:
+        value | isUuid
+        1     | false
+        2     | false
+        3     | true
+        4     | true
+        5     | false
+    }
+}

bson/src/test/unit/org/bson/LimitedLookaheadMarkSpecification.groovy

@@ -242,7 +242,7 @@ class LimitedLookaheadMarkSpecification extends Specification {
         ]
     }
 
-    def 'should peek binary subtype'(BsonWriter writer) {
+    def 'should peek binary subtype and size'(BsonWriter writer) {
         given:
         writer.with {
             writeStartDocument()
@@ -265,12 +265,14 @@ class LimitedLookaheadMarkSpecification extends Specification {
         reader.readStartDocument()
         reader.readName()
         def subType = reader.peekBinarySubType()
+        def size = reader.peekBinarySize()
         def binary = reader.readBinaryData()
         def longValue = reader.readInt64('int64')
         reader.readEndDocument()
 
         then:
         subType == BsonBinarySubType.UUID_LEGACY.value
+        size == 16
         binary == new BsonBinary(BsonBinarySubType.UUID_LEGACY, new byte[16])
         longValue == 52L
 

bson/src/test/unit/org/bson/codecs/DocumentCodecSpecification.groovy

@@ -139,6 +139,25 @@ class DocumentCodecSpecification extends Specification {
         ]
     }
 
+    @SuppressWarnings(['LineLength'])
+    def 'should decode binary subtypes for UUID'() {
+        given:
+        def reader = new BsonBinaryReader(ByteBuffer.wrap(bytes as byte[]))
+
+        when:
+        def document = new DocumentCodec().decode(reader, DecoderContext.builder().build())
+
+        then:
+        value == document.get('f')
+
+        where:
+        value                                                   | bytes
+        new Binary((byte) 0x03, (byte[]) [115, 116, 11])        | [16, 0, 0, 0, 5, 102, 0, 3, 0, 0, 0, 3, 115, 116, 11, 0]
+        new Binary((byte) 0x04, (byte[]) [115, 116, 11])        | [16, 0, 0, 0, 5, 102, 0, 3, 0, 0, 0, 4, 115, 116, 11, 0]
+        UUID.fromString('08070605-0403-0201-100f-0e0d0c0b0a09') | [29, 0, 0, 0, 5, 102, 0, 16, 0, 0, 0, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0]
+        UUID.fromString('01020304-0506-0708-090a-0b0c0d0e0f10') | [29, 0, 0, 0, 5, 102, 0, 16, 0, 0, 0, 4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0]
+    }
+
     def 'should respect encodeIdFirst property in encoder context'() {
         given:
         def originalDocument = new Document('x', 2)