@@ -190,6 +190,12 @@ class VariantUtil {
190190 // The size (in bytes) of a UUID.
191191 static final int UUID_SIZE = 16 ;
192192
193+ /**
194+ * Maximum permitted nesting depth of a Variant value.
195+ * same limit as in VariantJsonParser.
196+ */
197+ static final int MAX_VARIANT_DEPTH = 500 ;
198+
193199 // header bytes
194200 static final byte HEADER_NULL = primitiveHeader (NULL );
195201 static final byte HEADER_LONG_STRING = primitiveHeader (LONG_STR );
@@ -880,6 +886,160 @@ static HashMap<String, Integer> getMetadataMap(ByteBuffer metadata) {
880886 return result ;
881887 }
882888
889+ /**
890+ * Bounds-checks the metadata buffer: header version, dictionary offset table and string data
891+ * region all fit within the buffer extent. It does not perform any deep checks into
892+ * the metadata itself.
893+ *
894+ * @param metadata the variant metadata buffer
895+ * @return the dictionary size
896+ * @throws IllegalArgumentException if the metadata buffer is not well-formed
897+ */
898+ static int validateMetadata (ByteBuffer metadata ) {
899+ int pos = metadata .position ();
900+ Preconditions .checkArgument (pos >= 0 && pos < metadata .limit (), "variant metadata is empty" );
901+ int header = metadata .get (pos ) & 0xFF ;
902+ Preconditions .checkArgument (
903+ (header & VERSION_MASK ) == VERSION , "Unsupported variant metadata version: %s" , header & VERSION_MASK );
904+ int offsetSize = ((header >> 6 ) & 0x3 ) + 1 ;
905+ long remaining = (long ) metadata .limit () - pos ;
906+ long offsetListStart = 1L + offsetSize ;
907+ Preconditions .checkArgument (offsetListStart <= remaining , "variant metadata truncated" );
908+ int dictSize = readUnsigned (metadata , pos + 1 , offsetSize );
909+ long offsetBytes = (long ) (dictSize + 1 ) * offsetSize ;
910+ long dataStart = offsetListStart + offsetBytes ;
911+ Preconditions .checkArgument (
912+ dataStart <= remaining , "variant metadata dictionary table extends past buffer: dictSize=%s" , dictSize );
913+ return dictSize ;
914+ }
915+
916+ /**
917+ * Bounds-checks a single Variant value node against its buffer slot. Performs no recursion
918+ * into nested children: child nodes are checked on demand when callers descend into them.
919+ *
920+ * <p>Cost: O(1) for primitives and short strings, O(numElements) for objects and arrays.
921+ * Validation of nested structures is deferred so that opening a large well-formed Variant
922+ * is not penalised by sub-trees the caller never inspects.
923+ *
924+ * @param value the variant value buffer (position/limit define the extent of this node's slot)
925+ * @param dictSize the metadata dictionary size, used to bound object field ids
926+ * @throws IllegalArgumentException if the value header or container table does not fit within
927+ * the buffer slot, or if any object field id is out of range
928+ */
929+ static void validateValueShallow (ByteBuffer value , int dictSize ) {
930+ int s = value .position ();
931+ Preconditions .checkArgument (s >= 0 && s < value .limit (), "variant value is empty" );
932+ long slot = (long ) value .limit () - s ;
933+ int header = value .get (s ) & 0xFF ;
934+ int basicType = header & BASIC_TYPE_MASK ;
935+ int typeInfo = (header >> BASIC_TYPE_BITS ) & PRIMITIVE_TYPE_MASK ;
936+ switch (basicType ) {
937+ case SHORT_STR :
938+ Preconditions .checkArgument (1L + typeInfo <= slot , "variant short string extends past buffer" );
939+ return ;
940+ case OBJECT :
941+ validateContainerShallow (value , s , slot , dictSize , true , typeInfo );
942+ return ;
943+ case ARRAY :
944+ validateContainerShallow (value , s , slot , dictSize , false , typeInfo );
945+ return ;
946+ default :
947+ validatePrimitiveShallow (value , s , slot , typeInfo );
948+ }
949+ }
950+
951+ private static void validateContainerShallow (
952+ ByteBuffer value , int s , long slot , int dictSize , boolean isObject , int typeInfo ) {
953+ boolean largeSize ;
954+ int idSize ;
955+ if (isObject ) {
956+ largeSize = ((typeInfo >> 4 ) & 0x1 ) != 0 ;
957+ idSize = ((typeInfo >> 2 ) & 0x3 ) + 1 ;
958+ } else {
959+ largeSize = ((typeInfo >> 2 ) & 0x1 ) != 0 ;
960+ idSize = 0 ;
961+ }
962+ int offsetSize = (typeInfo & 0x3 ) + 1 ;
963+ int sizeBytes = largeSize ? U32_SIZE : 1 ;
964+ Preconditions .checkArgument (1L + sizeBytes <= slot , "variant container header truncated" );
965+ int numElements = readUnsigned (value , s + 1 , sizeBytes );
966+ long idStart = 1L + sizeBytes ;
967+ long idBytes = isObject ? (long ) numElements * idSize : 0L ;
968+ long offsetStart = idStart + idBytes ;
969+ long offsetBytes = (long ) (numElements + 1 ) * offsetSize ;
970+ long dataStart = offsetStart + offsetBytes ;
971+ Preconditions .checkArgument (
972+ dataStart <= slot , "variant container offset table extends past buffer: numElements=%s" , numElements );
973+ long dataLen = slot - dataStart ;
974+ if (isObject ) {
975+ for (int i = 0 ; i < numElements ; i ++) {
976+ int id = readUnsigned (value , s + (int ) idStart + i * idSize , idSize );
977+ Preconditions .checkArgument (
978+ id < dictSize , "variant object key id %s out of range (dictSize=%s)" , id , dictSize );
979+ }
980+ }
981+ // Each child offset must lie within the data region. Children may overlap or leave gaps;
982+ // the trailing terminator offset is range-checked for the same reason.
983+ for (int i = 0 ; i <= numElements ; i ++) {
984+ // O(elements)
985+ int off = readUnsigned (value , s + (int ) offsetStart + i * offsetSize , offsetSize );
986+ Preconditions .checkArgument (
987+ off <= dataLen , "variant child offset out of range: %s (data length %s)" , off , dataLen );
988+ }
989+ }
990+
991+ private static void validatePrimitiveShallow (ByteBuffer value , int s , long slot , int typeInfo ) {
992+ long size ;
993+ switch (typeInfo ) {
994+ case NULL :
995+ case TRUE :
996+ case FALSE :
997+ size = 1 ;
998+ break ;
999+ case INT8 :
1000+ size = 2 ;
1001+ break ;
1002+ case INT16 :
1003+ size = 3 ;
1004+ break ;
1005+ case INT32 :
1006+ case DATE :
1007+ case FLOAT :
1008+ size = 5 ;
1009+ break ;
1010+ case INT64 :
1011+ case DOUBLE :
1012+ case TIMESTAMP_TZ :
1013+ case TIMESTAMP_NTZ :
1014+ case TIME :
1015+ case TIMESTAMP_NANOS_TZ :
1016+ case TIMESTAMP_NANOS_NTZ :
1017+ size = 9 ;
1018+ break ;
1019+ case DECIMAL4 :
1020+ size = 6 ;
1021+ break ;
1022+ case DECIMAL8 :
1023+ size = 10 ;
1024+ break ;
1025+ case DECIMAL16 :
1026+ size = 18 ;
1027+ break ;
1028+ case BINARY :
1029+ case LONG_STR : {
1030+ Preconditions .checkArgument (1L + U32_SIZE <= slot , "variant string/binary length field truncated" );
1031+ size = 1L + U32_SIZE + readUnsigned (value , s + 1 , U32_SIZE );
1032+ break ;
1033+ }
1034+ case UUID :
1035+ size = 1L + UUID_SIZE ;
1036+ break ;
1037+ default :
1038+ throw new IllegalArgumentException (String .format ("Unknown primitive type in variant: %d" , typeInfo ));
1039+ }
1040+ Preconditions .checkArgument (size <= slot , "variant value extends past buffer" );
1041+ }
1042+
8831043 /**
8841044 * Computes the actual size (in bytes) of the Variant value.
8851045 * @param value The Variant value binary
0 commit comments