823 lines
33 KiB
C#
823 lines
33 KiB
C#
/*
|
|
* Copyright 2014 Google Inc. All rights reserved.
|
|
*
|
|
* 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.
|
|
*/
|
|
using System;
|
|
using System.Reflection;using System.Collections.Generic;
|
|
using System.IO;
|
|
|
|
namespace Google.FlatBuffers
|
|
{
|
|
|
|
/// <summary>
|
|
/// The Class of the Verifier Options
|
|
/// </summary>
|
|
public class Options
|
|
{
|
|
public const int DEFAULT_MAX_DEPTH = 64;
|
|
public const int DEFAULT_MAX_TABLES = 1000000;
|
|
|
|
private int max_depth = 0;
|
|
private int max_tables = 0;
|
|
private bool string_end_check = false;
|
|
private bool alignment_check = false;
|
|
|
|
public Options()
|
|
{
|
|
max_depth = DEFAULT_MAX_DEPTH;
|
|
max_tables = DEFAULT_MAX_TABLES;
|
|
string_end_check = true;
|
|
alignment_check = true;
|
|
}
|
|
|
|
public Options(int maxDepth, int maxTables, bool stringEndCheck, bool alignmentCheck)
|
|
{
|
|
max_depth = maxDepth;
|
|
max_tables = maxTables;
|
|
string_end_check = stringEndCheck;
|
|
alignment_check = alignmentCheck;
|
|
}
|
|
/// <summary> Maximum depth of nested tables allowed in a valid flatbuffer. </summary>
|
|
public int maxDepth
|
|
{
|
|
get { return max_depth; }
|
|
set { max_depth = value; }
|
|
}
|
|
/// <summary> Maximum number of tables allowed in a valid flatbuffer. </summary>
|
|
public int maxTables
|
|
{
|
|
get { return max_tables; }
|
|
set { max_tables = value; }
|
|
}
|
|
/// <summary> Check that string contains its null terminator </summary>
|
|
public bool stringEndCheck
|
|
{
|
|
get { return string_end_check; }
|
|
set { string_end_check = value; }
|
|
}
|
|
/// <summary> Check alignment of elements </summary>
|
|
public bool alignmentCheck
|
|
{
|
|
get { return alignment_check; }
|
|
set { alignment_check = value; }
|
|
}
|
|
}
|
|
|
|
public struct checkElementStruct
|
|
{
|
|
public bool elementValid;
|
|
public uint elementOffset;
|
|
}
|
|
|
|
public delegate bool VerifyTableAction(Verifier verifier, uint tablePos);
|
|
public delegate bool VerifyUnionAction(Verifier verifier, byte typeId, uint tablePos);
|
|
|
|
/// <summary>
|
|
/// The Main Class of the FlatBuffer Verifier
|
|
/// </summary>
|
|
public class Verifier
|
|
{
|
|
private ByteBuffer verifier_buffer = null;
|
|
private Options verifier_options = null;
|
|
private int depth_cnt = 0;
|
|
private int num_tables_cnt = 0;
|
|
|
|
public const int SIZE_BYTE = 1;
|
|
public const int SIZE_INT = 4;
|
|
public const int SIZE_U_OFFSET = 4;
|
|
public const int SIZE_S_OFFSET = 4;
|
|
public const int SIZE_V_OFFSET = 2;
|
|
public const int SIZE_PREFIX_LENGTH = FlatBufferConstants.SizePrefixLength; // default size = 4
|
|
public const int FLATBUFFERS_MAX_BUFFER_SIZE = System.Int32.MaxValue; // default size = 2147483647
|
|
public const int FILE_IDENTIFIER_LENGTH = FlatBufferConstants.FileIdentifierLength; // default size = 4
|
|
|
|
/// <summary> The Base Constructor of the Verifier object </summary>
|
|
public Verifier()
|
|
{
|
|
// Verifier buffer
|
|
verifier_buffer = null;
|
|
// Verifier settings
|
|
verifier_options = null;
|
|
// Depth counter
|
|
depth_cnt = 0;
|
|
// Tables counter
|
|
num_tables_cnt = 0;
|
|
}
|
|
|
|
/// <summary> The Constructor of the Verifier object with input parameters: ByteBuffer and/or Options </summary>
|
|
/// <param name="buf"> Input flat byte buffer defined as ByteBuffer type</param>
|
|
/// <param name="options"> Options object with settings for the coniguration the Verifier </param>
|
|
public Verifier(ByteBuffer buf, Options options = null)
|
|
{
|
|
verifier_buffer = buf;
|
|
verifier_options = options ?? new Options();
|
|
depth_cnt = 0;
|
|
num_tables_cnt = 0;
|
|
}
|
|
|
|
/// <summary> Bytes Buffer for Verify</summary>
|
|
public ByteBuffer Buf
|
|
{
|
|
get { return verifier_buffer; }
|
|
set { verifier_buffer = value; }
|
|
}
|
|
/// <summary> Options of the Verifier </summary>
|
|
public Options options
|
|
{
|
|
get { return verifier_options; }
|
|
set { verifier_options = value; }
|
|
}
|
|
/// <summary> Counter of tables depth in a tested flatbuffer </summary>
|
|
public int depth
|
|
{
|
|
get { return depth_cnt; }
|
|
set { depth_cnt = value; }
|
|
}
|
|
/// <summary> Counter of tables in a tested flatbuffer </summary>
|
|
public int numTables
|
|
{
|
|
get { return num_tables_cnt; }
|
|
set { num_tables_cnt = value; }
|
|
}
|
|
|
|
|
|
/// <summary> Method set maximum tables depth of valid structure</summary>
|
|
/// <param name="value"> Specify Value of the maximum depth of the structure</param>
|
|
public Verifier SetMaxDepth(int value)
|
|
{
|
|
verifier_options.maxDepth = value;
|
|
return this;
|
|
}
|
|
/// <summary> Specify maximum number of tables in structure </summary>
|
|
/// <param name="value"> Specify Value of the maximum number of the tables in the structure</param>
|
|
public Verifier SetMaxTables(int value)
|
|
{
|
|
verifier_options.maxTables = value;
|
|
return this;
|
|
}
|
|
/// <summary> Enable/disable buffer content alignment check </summary>
|
|
/// <param name="value"> Value of the State for buffer content alignment check (Enable = true) </param>
|
|
public Verifier SetAlignmentCheck(bool value)
|
|
{
|
|
verifier_options.alignmentCheck = value;
|
|
return this;
|
|
}
|
|
/// <summary> Enable/disable checking of string termination '0' character </summary>
|
|
/// <param name="value"> Value of the option for string termination '0' character check (Enable = true)</param>
|
|
public Verifier SetStringCheck(bool value)
|
|
{
|
|
verifier_options.stringEndCheck = value;
|
|
return this;
|
|
}
|
|
|
|
/// <summary> Check if there is identifier in buffer </summary>
|
|
/// <param name="buf"> Input flat byte buffer defined as ByteBuffer type </param>
|
|
/// <param name="startPos">Start position of data in the Byte Buffer</param>
|
|
/// <param name="identifier"> Identifier for the Byte Buffer</param>
|
|
/// <returns> Return True when the Byte Buffer Identifier is present</returns>
|
|
private bool BufferHasIdentifier(ByteBuffer buf, uint startPos, string identifier)
|
|
{
|
|
if (identifier.Length != FILE_IDENTIFIER_LENGTH)
|
|
{
|
|
throw new ArgumentException("FlatBuffers: file identifier must be length" + Convert.ToString(FILE_IDENTIFIER_LENGTH));
|
|
}
|
|
for (int i = 0; i < FILE_IDENTIFIER_LENGTH; i++)
|
|
{
|
|
if ((sbyte)identifier[i] != verifier_buffer.GetSbyte(Convert.ToInt32(SIZE_S_OFFSET + i + startPos)))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary> Get UOffsetT from buffer at given position - it must be verified before read </summary>
|
|
/// <param name="buf"> Input flat byte buffer defined as ByteBuffer type </param>
|
|
/// <param name="pos"> Position of data in the Byte Buffer</param>
|
|
/// <returns> Return the UOffset Value (Unsigned Integer type - 4 bytes) in pos </returns>
|
|
private uint ReadUOffsetT(ByteBuffer buf, uint pos)
|
|
{
|
|
return buf.GetUint(Convert.ToInt32(pos));
|
|
}
|
|
/// <summary> Get SOffsetT from buffer at given position - it must be verified before read </summary>
|
|
/// <param name="buf"> Input flat byte buffer defined as ByteBuffer type </param>
|
|
/// <param name="pos"> Position of data in the Byte Buffer</param>
|
|
/// <returns> Return the SOffset Value (Signed Integer type - 4 bytes) in pos </returns>
|
|
private int ReadSOffsetT(ByteBuffer buf, int pos)
|
|
{
|
|
return buf.GetInt(pos);
|
|
}
|
|
/// <summary> Get VOffsetT from buffer at given position - it must be verified before read </summary>
|
|
/// <param name="buf"> Input flat byte buffer defined as ByteBuffer type </param>
|
|
/// <param name="pos"> Position of data in the Byte Buffer</param>
|
|
/// <returns> Return the VOffset Value (Short type - 2 bytes) in pos </returns>
|
|
private short ReadVOffsetT(ByteBuffer buf, int pos)
|
|
{
|
|
return buf.GetShort(pos);
|
|
}
|
|
|
|
/// <summary> Get table data area relative offset from vtable. Result is relative to table start
|
|
/// Fields which are deprecated are ignored by checking against the vtable's length. </summary>
|
|
/// <param name="pos"> Position of data in the Byte Buffer </param>
|
|
/// <param name="vtableOffset"> offset of value in the Table</param>
|
|
/// <returns> Return the relative VOffset Value (Short type - 2 bytes) in calculated offset </returns>
|
|
private short GetVRelOffset(int pos, short vtableOffset)
|
|
{
|
|
short VOffset = 0;
|
|
// Used try/catch because pos typa as int 32bit
|
|
try
|
|
{
|
|
// First, get vtable offset
|
|
short vtable = Convert.ToInt16(pos - ReadSOffsetT(verifier_buffer, pos));
|
|
// Check that offset points to vtable area (is smaller than vtable size)
|
|
if (vtableOffset < ReadVOffsetT(verifier_buffer, vtable))
|
|
{
|
|
// Now, we can read offset value - TODO check this value against size of table data
|
|
VOffset = ReadVOffsetT(verifier_buffer, vtable + vtableOffset);
|
|
}
|
|
else
|
|
{
|
|
VOffset = 0;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine("Exception: {0}", e);
|
|
return VOffset;
|
|
}
|
|
return VOffset;
|
|
|
|
}
|
|
/// <summary> Get table data area absolute offset from vtable. Result is the absolute buffer offset.
|
|
/// The result value offset cannot be '0' (pointing to itself) so after validation this method returnes '0'
|
|
/// value as a marker for missing optional entry </summary>
|
|
/// <param name="tablePos"> Table Position value in the Byte Buffer </param>
|
|
/// <param name="vtableOffset"> offset value in the Table</param>
|
|
/// <returns> Return the absolute UOffset Value </returns>
|
|
private uint GetVOffset(uint tablePos, short vtableOffset)
|
|
{
|
|
uint UOffset = 0;
|
|
// First, get vtable relative offset
|
|
short relPos = GetVRelOffset(Convert.ToInt32(tablePos), vtableOffset);
|
|
if (relPos != 0)
|
|
{
|
|
// Calculate offset based on table postion
|
|
UOffset = Convert.ToUInt32(tablePos + relPos);
|
|
}
|
|
else
|
|
{
|
|
UOffset = 0;
|
|
}
|
|
return UOffset;
|
|
}
|
|
|
|
/// <summary> Check flatbuffer complexity (tables depth, elements counter and so on) </summary>
|
|
/// <returns> If complexity is too high function returns false as verification error </returns>
|
|
private bool CheckComplexity()
|
|
{
|
|
return ((depth <= options.maxDepth) && (numTables <= options.maxTables));
|
|
}
|
|
|
|
/// <summary> Check alignment of element. </summary>
|
|
/// <returns> Return True when alignment of the element is correct</returns>
|
|
private bool CheckAlignment(uint element, ulong align)
|
|
{
|
|
return (((element & (align - 1)) == 0) || (!options.alignmentCheck));
|
|
}
|
|
|
|
/// <summary> Check if element is valid in buffer area. </summary>
|
|
/// <param name="pos"> Value defines the offset/position to element</param>
|
|
/// <param name="elementSize"> Size of element</param>
|
|
/// <returns> Return True when Element is correct </returns>
|
|
private bool CheckElement(uint pos, ulong elementSize)
|
|
{
|
|
return ((elementSize < Convert.ToUInt64(verifier_buffer.Length)) && (pos <= (Convert.ToUInt32(verifier_buffer.Length) - elementSize)));
|
|
}
|
|
/// <summary> Check if element is a valid scalar. </summary>
|
|
/// <param name="pos"> Value defines the offset to scalar</param>
|
|
/// <param name="elementSize"> Size of element</param>
|
|
/// <returns> Return True when Scalar Element is correct </returns>
|
|
private bool CheckScalar(uint pos, ulong elementSize)
|
|
{
|
|
return ((CheckAlignment(pos, elementSize)) && (CheckElement(pos, elementSize)));
|
|
}
|
|
/// <summary> Check offset. It is a scalar with size of UOffsetT. </summary>
|
|
private bool CheckOffset(uint offset)
|
|
{
|
|
return (CheckScalar(offset, SIZE_U_OFFSET));
|
|
}
|
|
|
|
private checkElementStruct CheckVectorOrString(uint pos, ulong elementSize)
|
|
{
|
|
var result = new checkElementStruct
|
|
{
|
|
elementValid = false,
|
|
elementOffset = 0
|
|
};
|
|
|
|
uint vectorPos = pos;
|
|
// Check we can read the vector/string size field (it is of uoffset size)
|
|
if (!CheckScalar(vectorPos, SIZE_U_OFFSET))
|
|
{
|
|
// result.elementValid = false; result.elementOffset = 0;
|
|
return result;
|
|
}
|
|
// Check the whole array. If this is a string, the byte past the array
|
|
// must be 0.
|
|
uint size = ReadUOffsetT(verifier_buffer, vectorPos);
|
|
ulong max_elements = (FLATBUFFERS_MAX_BUFFER_SIZE / elementSize);
|
|
if (size >= max_elements)
|
|
{
|
|
// Protect against byte_size overflowing.
|
|
// result.elementValid = false; result.elementOffset = 0;
|
|
return result;
|
|
}
|
|
|
|
uint bytes_size = SIZE_U_OFFSET + (Convert.ToUInt32(elementSize) * size);
|
|
uint buffer_end_pos = vectorPos + bytes_size;
|
|
result.elementValid = CheckElement(vectorPos, bytes_size);
|
|
result.elementOffset = buffer_end_pos;
|
|
return (result);
|
|
}
|
|
|
|
/// <summary>Verify a string at given position.</summary>
|
|
private bool CheckString(uint pos)
|
|
{
|
|
var result = CheckVectorOrString(pos, SIZE_BYTE);
|
|
if (options.stringEndCheck)
|
|
{
|
|
result.elementValid = result.elementValid && CheckScalar(result.elementOffset, 1); // Must have terminator
|
|
result.elementValid = result.elementValid && (verifier_buffer.GetSbyte(Convert.ToInt32(result.elementOffset)) == 0); // Terminating byte must be 0.
|
|
}
|
|
return result.elementValid;
|
|
}
|
|
|
|
/// <summary> Verify the vector of elements of given size </summary>
|
|
private bool CheckVector(uint pos, ulong elementSize)
|
|
{
|
|
var result = CheckVectorOrString(pos, elementSize);
|
|
return result.elementValid;
|
|
}
|
|
/// <summary> Verify table content using structure dependent generated function </summary>
|
|
private bool CheckTable(uint tablePos, VerifyTableAction verifyAction)
|
|
{
|
|
return verifyAction(this, tablePos);
|
|
}
|
|
|
|
/// <summary> String check wrapper function to be used in vector of strings check </summary>
|
|
private bool CheckStringFunc(Verifier verifier, uint pos)
|
|
{
|
|
return verifier.CheckString(pos);
|
|
}
|
|
|
|
/// <summary> Check vector of objects. Use generated object verification function </summary>
|
|
private bool CheckVectorOfObjects(uint pos, VerifyTableAction verifyAction)
|
|
{
|
|
if (!CheckVector(pos, SIZE_U_OFFSET))
|
|
{
|
|
return false;
|
|
}
|
|
uint size = ReadUOffsetT(verifier_buffer, pos);
|
|
// Vector data starts just after vector size/length
|
|
uint vecStart = pos + SIZE_U_OFFSET;
|
|
uint vecOff = 0;
|
|
// Iterate offsets and verify referenced objects
|
|
for (uint i = 0; i < size; i++)
|
|
{
|
|
vecOff = vecStart + (i * SIZE_U_OFFSET);
|
|
if (!CheckIndirectOffset(vecOff))
|
|
{
|
|
return false;
|
|
}
|
|
uint objOffset = GetIndirectOffset(vecOff);
|
|
if (!verifyAction(this, objOffset))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary> Check if the offset referenced by offsetPos is the valid offset pointing to buffer</summary>
|
|
// offsetPos - offset to offset data
|
|
private bool CheckIndirectOffset(uint pos)
|
|
{
|
|
// Check the input offset is valid
|
|
if(!CheckScalar(pos, SIZE_U_OFFSET))
|
|
{
|
|
return false;
|
|
}
|
|
// Get indirect offset
|
|
uint offset = ReadUOffsetT(verifier_buffer, pos);
|
|
// May not point to itself neither wrap around (buffers are max 2GB)
|
|
if ((offset == 0) || (offset >= FLATBUFFERS_MAX_BUFFER_SIZE))
|
|
{
|
|
return false;
|
|
}
|
|
// Must be inside the buffer
|
|
return CheckElement(pos + offset, 1);
|
|
}
|
|
|
|
/// <summary> Check flatbuffer content using generated object verification function </summary>
|
|
private bool CheckBufferFromStart(string identifier, uint startPos, VerifyTableAction verifyAction)
|
|
{
|
|
if ((identifier != null) &&
|
|
(identifier.Length == 0) &&
|
|
((verifier_buffer.Length < (SIZE_U_OFFSET + FILE_IDENTIFIER_LENGTH)) || (!BufferHasIdentifier(verifier_buffer, startPos, identifier))))
|
|
{
|
|
return false;
|
|
}
|
|
if(!CheckIndirectOffset(startPos))
|
|
{
|
|
return false;
|
|
}
|
|
uint offset = GetIndirectOffset(startPos);
|
|
return CheckTable(offset, verifyAction); // && GetComputedSize()
|
|
}
|
|
|
|
/// <summary> Get indirect offset. It is an offset referenced by offset Pos </summary>
|
|
private uint GetIndirectOffset(uint pos)
|
|
{
|
|
// Get indirect offset referenced by offsetPos
|
|
uint offset = pos + ReadUOffsetT(verifier_buffer, pos);
|
|
return offset;
|
|
}
|
|
|
|
/// <summary> Verify beginning of table </summary>
|
|
/// <param name="tablePos"> Position in the Table </param>
|
|
/// <returns> Return True when the verification of the beginning of the table is passed</returns>
|
|
// (this method is used internally by generated verification functions)
|
|
public bool VerifyTableStart(uint tablePos)
|
|
{
|
|
// Starting new table verification increases complexity of structure
|
|
depth_cnt++;
|
|
num_tables_cnt++;
|
|
|
|
if (!CheckScalar(tablePos, SIZE_S_OFFSET))
|
|
{
|
|
return false;
|
|
}
|
|
uint vtable = (uint)(tablePos - ReadSOffsetT(verifier_buffer, Convert.ToInt32(tablePos)));
|
|
return ((CheckComplexity()) && (CheckScalar(vtable, SIZE_V_OFFSET)) && (CheckAlignment(Convert.ToUInt32(ReadVOffsetT(verifier_buffer, Convert.ToInt32(vtable))), SIZE_V_OFFSET)) && (CheckElement(vtable, Convert.ToUInt64(ReadVOffsetT(verifier_buffer, Convert.ToInt32(vtable))))));
|
|
}
|
|
|
|
/// <summary> Verify end of table. In practice, this function does not check buffer but handles
|
|
/// verification statistics update </summary>
|
|
// (this method is used internally by generated verification functions)
|
|
public bool VerifyTableEnd(uint tablePos)
|
|
{
|
|
depth--;
|
|
return true;
|
|
}
|
|
|
|
/// <summary> Verifiy static/inlined data area field </summary>
|
|
/// <param name="tablePos"> Position in the Table</param>
|
|
/// <param name="offsetId"> Offset to the static/inlined data element </param>
|
|
/// <param name="elementSize"> Size of the element </param>
|
|
/// <param name="align"> Alignment bool value </param>
|
|
/// <param name="required"> Required Value when the offset == 0 </param>
|
|
/// <returns>Return True when the verification of the static/inlined data element is passed</returns>
|
|
// (this method is used internally by generated verification functions)
|
|
public bool VerifyField(uint tablePos, short offsetId, ulong elementSize, ulong align, bool required)
|
|
{
|
|
uint offset = GetVOffset(tablePos, offsetId);
|
|
if (offset != 0)
|
|
{
|
|
return ((CheckAlignment(offset, align)) && (CheckElement(offset, elementSize)));
|
|
}
|
|
return !required; // it is OK if field is not required
|
|
}
|
|
|
|
/// <summary> Verify string </summary>
|
|
/// <param name="tablePos"> Position in the Table</param>
|
|
/// <param name="vOffset"> Offset to the String element </param>
|
|
/// <param name="required"> Required Value when the offset == 0 </param>
|
|
/// <returns>Return True when the verification of the String is passed</returns>
|
|
// (this method is used internally by generated verification functions)
|
|
public bool VerifyString(uint tablePos, short vOffset, bool required)
|
|
{
|
|
var offset = GetVOffset(tablePos, vOffset);
|
|
if (offset == 0)
|
|
{
|
|
return !required;
|
|
}
|
|
if (!CheckIndirectOffset(offset))
|
|
{
|
|
return false;
|
|
}
|
|
var strOffset = GetIndirectOffset(offset);
|
|
return CheckString(strOffset);
|
|
}
|
|
|
|
/// <summary> Verify vector of fixed size structures and scalars </summary>
|
|
/// <param name="tablePos"> Position in the Table</param>
|
|
/// <param name="vOffset"> Offset to the Vector of Data </param>
|
|
/// <param name="elementSize"> Size of the element</param>
|
|
/// <param name="required"> Required Value when the offset == 0 </param>
|
|
/// <returns>Return True when the verification of the Vector of Data passed</returns>
|
|
// (this method is used internally by generated verification functions)
|
|
public bool VerifyVectorOfData(uint tablePos, short vOffset, ulong elementSize, bool required)
|
|
{
|
|
var offset = GetVOffset(tablePos, vOffset);
|
|
if (offset == 0)
|
|
{
|
|
return !required;
|
|
}
|
|
if (!CheckIndirectOffset(offset))
|
|
{
|
|
return false;
|
|
}
|
|
var vecOffset = GetIndirectOffset(offset);
|
|
return CheckVector(vecOffset, elementSize);
|
|
}
|
|
|
|
/// <summary> Verify array of strings </summary>
|
|
/// <param name="tablePos"> Position in the Table</param>
|
|
/// <param name="offsetId"> Offset to the Vector of String </param>
|
|
/// <param name="required"> Required Value when the offset == 0 </param>
|
|
/// <returns>Return True when the verification of the Vector of String passed</returns>
|
|
// (this method is used internally by generated verification functions)
|
|
public bool VerifyVectorOfStrings(uint tablePos, short offsetId, bool required)
|
|
{
|
|
var offset = GetVOffset(tablePos, offsetId);
|
|
if (offset == 0)
|
|
{
|
|
return !required;
|
|
}
|
|
if (!CheckIndirectOffset(offset))
|
|
{
|
|
return false;
|
|
}
|
|
var vecOffset = GetIndirectOffset(offset);
|
|
return CheckVectorOfObjects(vecOffset, CheckStringFunc);
|
|
}
|
|
|
|
/// <summary> Verify vector of tables (objects). Tables are verified using generated verifyObjFunc </summary>
|
|
/// <param name="tablePos"> Position in the Table</param>
|
|
/// <param name="offsetId"> Offset to the Vector of Table </param>
|
|
/// <param name="verifyAction"> Method used to the verification Table </param>
|
|
/// <param name="required"> Required Value when the offset == 0 </param>
|
|
/// <returns>Return True when the verification of the Vector of Table passed</returns>
|
|
// (this method is used internally by generated verification functions)
|
|
public bool VerifyVectorOfTables(uint tablePos, short offsetId, VerifyTableAction verifyAction, bool required)
|
|
{
|
|
var offset = GetVOffset(tablePos, offsetId);
|
|
if (offset == 0)
|
|
{
|
|
return !required;
|
|
}
|
|
if (!CheckIndirectOffset(offset))
|
|
{
|
|
return false;
|
|
}
|
|
var vecOffset = GetIndirectOffset(offset);
|
|
return CheckVectorOfObjects(vecOffset, verifyAction);
|
|
}
|
|
|
|
/// <summary> Verify table object using generated verification function. </summary>
|
|
/// <param name="tablePos"> Position in the Table</param>
|
|
/// <param name="offsetId"> Offset to the Table </param>
|
|
/// <param name="verifyAction"> Method used to the verification Table </param>
|
|
/// <param name="required"> Required Value when the offset == 0 </param>
|
|
/// <returns>Return True when the verification of the Table passed</returns>
|
|
// (this method is used internally by generated verification functions)
|
|
public bool VerifyTable(uint tablePos, short offsetId, VerifyTableAction verifyAction, bool required)
|
|
{
|
|
var offset = GetVOffset(tablePos, offsetId);
|
|
if (offset == 0)
|
|
{
|
|
return !required;
|
|
}
|
|
if (!CheckIndirectOffset(offset))
|
|
{
|
|
return false;
|
|
}
|
|
var tabOffset = GetIndirectOffset(offset);
|
|
return CheckTable(tabOffset, verifyAction);
|
|
}
|
|
|
|
/// <summary> Verify nested buffer object. When verifyObjFunc is provided, it is used to verify object structure. </summary>
|
|
/// <param name="tablePos"> Position in the Table </param>
|
|
/// <param name="offsetId"> Offset to the Table </param>
|
|
/// <param name="verifyAction"> Method used to the verification Table </param>
|
|
/// <param name="required"> Required Value when the offset == 0 </param>
|
|
// (this method is used internally by generated verification functions)
|
|
public bool VerifyNestedBuffer(uint tablePos, short offsetId, VerifyTableAction verifyAction, bool required)
|
|
{
|
|
var offset = GetVOffset(tablePos, offsetId);
|
|
if (offset == 0)
|
|
{
|
|
return !required;
|
|
}
|
|
uint vecOffset = GetIndirectOffset(offset);
|
|
if (!CheckVector(vecOffset, SIZE_BYTE))
|
|
{
|
|
return false;
|
|
}
|
|
if (verifyAction != null)
|
|
{
|
|
var vecLength = ReadUOffsetT(verifier_buffer, vecOffset);
|
|
// Buffer begins after vector length
|
|
var vecStart = vecOffset + SIZE_U_OFFSET;
|
|
// Create and Copy nested buffer bytes from part of Verify Buffer
|
|
var nestedByteBuffer = new ByteBuffer(verifier_buffer.ToArray(Convert.ToInt32(vecStart), Convert.ToInt32(vecLength)));
|
|
var nestedVerifyier = new Verifier(nestedByteBuffer, options);
|
|
// There is no internal identifier - use empty one
|
|
if (!nestedVerifyier.CheckBufferFromStart("", 0, verifyAction))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary> Verifiy static/inlined data area at absolute offset </summary>
|
|
/// <param name="pos"> Position of static/inlined data area in the Byte Buffer</param>
|
|
/// <param name="elementSize"> Size of the union data</param>
|
|
/// <param name="align"> Alignment bool value </param>
|
|
/// <returns>Return True when the verification of the Union Data is passed</returns>
|
|
// (this method is used internally by generated verification functions)
|
|
public bool VerifyUnionData(uint pos, ulong elementSize, ulong align)
|
|
{
|
|
bool result = ((CheckAlignment(pos, align)) && (CheckElement(pos, elementSize)));
|
|
return result;
|
|
}
|
|
|
|
/// <summary> Verify string referenced by absolute offset value </summary>
|
|
/// <param name="pos"> Position of Union String in the Byte Buffer</param>
|
|
/// <returns>Return True when the verification of the Union String is passed</returns>
|
|
// (this method is used internally by generated verification functions)
|
|
public bool VerifyUnionString(uint pos)
|
|
{
|
|
bool result = CheckString(pos);
|
|
return result;
|
|
}
|
|
|
|
/// <summary> Method verifies union object using generated verification function </summary>
|
|
/// <param name="tablePos"> Position in the Table</param>
|
|
/// <param name="typeIdVOffset"> Offset in the Table</param>
|
|
/// <param name="valueVOffset"> Offset to Element</param>
|
|
/// <param name="verifyAction"> Verification Method used for Union</param>
|
|
/// <param name="required"> Required Value when the offset == 0 </param>
|
|
// (this method is used internally by generated verification functions)
|
|
public bool VerifyUnion(uint tablePos, short typeIdVOffset, short valueVOffset, VerifyUnionAction verifyAction, bool required)
|
|
{
|
|
// Check the union type index
|
|
var offset = GetVOffset(tablePos, typeIdVOffset);
|
|
if (offset == 0)
|
|
{
|
|
return !required;
|
|
}
|
|
if (!((CheckAlignment(offset, SIZE_BYTE)) && (CheckElement(offset, SIZE_BYTE))))
|
|
{
|
|
return false;
|
|
}
|
|
// Check union data
|
|
offset = GetVOffset(tablePos, valueVOffset);
|
|
// Take type id
|
|
var typeId = verifier_buffer.Get(Convert.ToInt32(offset));
|
|
if (offset == 0)
|
|
{
|
|
// When value data is not present, allow union verification function to deal with illegal offset
|
|
return verifyAction(this, typeId, Convert.ToUInt32(verifier_buffer.Length));
|
|
}
|
|
if (!CheckIndirectOffset(offset))
|
|
{
|
|
return false;
|
|
}
|
|
// Take value offset and validate union structure
|
|
uint unionOffset = GetIndirectOffset(offset);
|
|
return verifyAction(this, typeId, unionOffset);
|
|
}
|
|
|
|
/// <summary> Verify vector of unions (objects). Unions are verified using generated verifyObjFunc </summary>
|
|
/// <param name="tablePos"> Position of the Table</param>
|
|
/// <param name="typeOffsetId"> Offset in the Table (Union type id)</param>
|
|
/// <param name="offsetId"> Offset to vector of Data Stucture offset</param>
|
|
/// <param name="verifyAction"> Verification Method used for Union</param>
|
|
/// <param name="required"> Required Value when the offset == 0 </param>
|
|
/// <returns>Return True when the verification of the Vector of Unions passed</returns>
|
|
// (this method is used internally by generated verification functions)
|
|
public bool VerifyVectorOfUnion(uint tablePos, short typeOffsetId, short offsetId, VerifyUnionAction verifyAction, bool required)
|
|
{
|
|
// type id offset must be valid
|
|
var offset = GetVOffset(tablePos, typeOffsetId);
|
|
if (offset == 0)
|
|
{
|
|
return !required;
|
|
}
|
|
if (!CheckIndirectOffset(offset))
|
|
{
|
|
return false;
|
|
}
|
|
// Get type id table absolute offset
|
|
var typeIdVectorOffset = GetIndirectOffset(offset);
|
|
// values offset must be valid
|
|
offset = GetVOffset(tablePos, offsetId);
|
|
if (!CheckIndirectOffset(offset))
|
|
{
|
|
return false;
|
|
}
|
|
var valueVectorOffset = GetIndirectOffset(offset);
|
|
// validate referenced vectors
|
|
if(!CheckVector(typeIdVectorOffset, SIZE_BYTE) ||
|
|
!CheckVector(valueVectorOffset, SIZE_U_OFFSET))
|
|
{
|
|
return false;
|
|
}
|
|
// Both vectors should have the same length
|
|
var typeIdVectorLength = ReadUOffsetT(verifier_buffer, typeIdVectorOffset);
|
|
var valueVectorLength = ReadUOffsetT(verifier_buffer, valueVectorOffset);
|
|
if (typeIdVectorLength != valueVectorLength)
|
|
{
|
|
return false;
|
|
}
|
|
// Verify each union from vectors
|
|
var typeIdStart = typeIdVectorOffset + SIZE_U_OFFSET;
|
|
var valueStart = valueVectorOffset + SIZE_U_OFFSET;
|
|
for (uint i = 0; i < typeIdVectorLength; i++)
|
|
{
|
|
// Get type id
|
|
byte typeId = verifier_buffer.Get(Convert.ToInt32(typeIdStart + i * SIZE_U_OFFSET));
|
|
// get offset to vector item
|
|
uint off = valueStart + i * SIZE_U_OFFSET;
|
|
// Check the vector item has a proper offset
|
|
if (!CheckIndirectOffset(off))
|
|
{
|
|
return false;
|
|
}
|
|
uint valueOffset = GetIndirectOffset(off);
|
|
// Verify object
|
|
if (!verifyAction(this, typeId, valueOffset))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Method verifies flatbuffer data using generated Table verification function.
|
|
// The data buffer is already provided when creating [Verifier] object (see [NewVerifier])
|
|
//
|
|
// - identifier - the expected identifier of buffer data.
|
|
// When empty identifier is provided the identifier validation is skipped.
|
|
// - sizePrefixed - this flag should be true when buffer is prefixed with content size
|
|
// - verifyObjFunc - function to be used for verification. This function is generated by compiler and included in each table definition file with name "<Tablename>Verify"
|
|
//
|
|
// Example:
|
|
//
|
|
// /* Verify Monster table. Ignore buffer name and assume buffer does not contain data length prefix */
|
|
// isValid = verifier.verifyBuffer(bb, false, MonsterVerify)
|
|
//
|
|
// /* Verify Monster table. Buffer name is 'MONS' and contains data length prefix */
|
|
// isValid = verifier.verifyBuffer("MONS", true, MonsterVerify)
|
|
/// <summary> Method verifies flatbuffer data using generated Table verification function </summary>
|
|
///
|
|
/// <param name="identifier"> The expected identifier of buffer data</param>
|
|
/// <param name="sizePrefixed"> Flag should be true when buffer is prefixed with content size</param>
|
|
/// <param name="verifyAction"> Function to be used for verification. This function is generated by compiler and included in each table definition file</param>
|
|
/// <returns> Return True when verification of FlatBuffer passed</returns>
|
|
/// <example>
|
|
/// Example 1. Verify Monster table. Ignore buffer name and assume buffer does not contain data length prefix
|
|
/// <code> isValid = verifier.VerifyBuffer(bb, false, MonsterVerify)</code>
|
|
/// Example 2. Verify Monster table. Buffer name is 'MONS' and contains data length prefix
|
|
/// <code> isValid = verifier.VerifyBuffer("MONS", true, MonsterVerify)</code>
|
|
/// </example>
|
|
public bool VerifyBuffer(string identifier, bool sizePrefixed, VerifyTableAction verifyAction)
|
|
{
|
|
// Reset counters - starting verification from beginning
|
|
depth = 0;
|
|
numTables = 0;
|
|
|
|
var start = (uint)(verifier_buffer.Position);
|
|
if (sizePrefixed)
|
|
{
|
|
start = (uint)(verifier_buffer.Position) + SIZE_PREFIX_LENGTH;
|
|
if(!CheckScalar((uint)(verifier_buffer.Position), SIZE_PREFIX_LENGTH))
|
|
{
|
|
return false;
|
|
}
|
|
uint size = ReadUOffsetT(verifier_buffer, (uint)(verifier_buffer.Position));
|
|
if (size != ((uint)(verifier_buffer.Length) - start))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return CheckBufferFromStart(identifier, start, verifyAction);
|
|
}
|
|
}
|
|
|
|
}
|