402 lines
14 KiB
Nim
402 lines
14 KiB
Nim
|
# Procedures dealing with serialization from/to libFuzzer's input buffer. Since the custom
|
||
|
|
# mutator is in control of the process, there should be no errors. And if there are, they
|
||
|
|
# should be fatal and the code should be fixed. User may also run the fuzzer without any
|
||
|
|
# sanitizer, which means that errors should always be detected.
|
||
|
|
import std/[options, tables, sets, macros]
|
||
|
|
from typetraits import supportsCopyMem, distinctBase
|
||
|
|
|
||
|
|
template getFieldValue(mFunc, tmpSym, fieldSym) =
|
||
|
|
mFunc(tmpSym.fieldSym)
|
||
|
|
|
||
|
|
template getKindValue(mFunc, tmpSym, kindSym) =
|
||
|
|
var kindTmp = tmpSym.kindSym
|
||
|
|
mFunc(kindTmp)
|
||
|
|
{.cast(uncheckedAssign).}:
|
||
|
|
tmpSym.kindSym = kindTmp
|
||
|
|
|
||
|
|
proc foldObjectBody(tmpSym, typeNode, mFunc: NimNode): NimNode =
|
||
|
|
case typeNode.kind
|
||
|
|
of nnkEmpty:
|
||
|
|
result = newNimNode(nnkNone)
|
||
|
|
of nnkRecList:
|
||
|
|
result = newStmtList()
|
||
|
|
for it in typeNode:
|
||
|
|
let x = foldObjectBody(tmpSym, it, mFunc)
|
||
|
|
if x.kind != nnkNone: result.add x
|
||
|
|
of nnkIdentDefs:
|
||
|
|
expectLen(typeNode, 3)
|
||
|
|
let fieldSym = typeNode[0]
|
||
|
|
result = getAst(getFieldValue(mFunc, tmpSym, fieldSym))
|
||
|
|
of nnkRecCase:
|
||
|
|
let kindSym = typeNode[0][0]
|
||
|
|
result = newStmtList(getAst(getKindValue(mFunc, tmpSym, kindSym)))
|
||
|
|
let inner = nnkCaseStmt.newTree(nnkDotExpr.newTree(tmpSym, kindSym))
|
||
|
|
for i in 1..<typeNode.len:
|
||
|
|
let x = foldObjectBody(tmpSym, typeNode[i], mFunc)
|
||
|
|
if x.kind != nnkNone: inner.add x
|
||
|
|
result.add inner
|
||
|
|
of nnkOfBranch, nnkElse:
|
||
|
|
result = copyNimNode(typeNode)
|
||
|
|
for i in 0..typeNode.len-2:
|
||
|
|
result.add copyNimTree(typeNode[i])
|
||
|
|
let inner = newNimNode(nnkStmtListExpr)
|
||
|
|
let x = foldObjectBody(tmpSym, typeNode[^1], mFunc)
|
||
|
|
if x.kind != nnkNone: inner.add x
|
||
|
|
result.add inner
|
||
|
|
of nnkObjectTy:
|
||
|
|
expectKind(typeNode[0], nnkEmpty)
|
||
|
|
expectKind(typeNode[1], {nnkEmpty, nnkOfInherit})
|
||
|
|
result = newNimNode(nnkNone)
|
||
|
|
if typeNode[1].kind == nnkOfInherit:
|
||
|
|
let base = typeNode[1][0]
|
||
|
|
var impl = getTypeImpl(base)
|
||
|
|
while impl.kind in {nnkRefTy, nnkPtrTy}:
|
||
|
|
impl = getTypeImpl(impl[0])
|
||
|
|
result = foldObjectBody(tmpSym, impl, mFunc)
|
||
|
|
let body = typeNode[2]
|
||
|
|
let x = foldObjectBody(tmpSym, body, mFunc)
|
||
|
|
if result.kind != nnkNone:
|
||
|
|
if x.kind != nnkNone:
|
||
|
|
for i in 0..<result.len: x.add(result[i])
|
||
|
|
result = x
|
||
|
|
else: result = x
|
||
|
|
else:
|
||
|
|
error("unhandled kind: " & $typeNode.kind, typeNode)
|
||
|
|
|
||
|
|
macro assignObjectImpl*(output, mFunc: typed): untyped =
|
||
|
|
## This macro is used for safely mutating object fields with `mFunc`.
|
||
|
|
## For case discriminators it makes a temporary and assigns it inside a
|
||
|
|
## cast uncheckedAssign section. This ensures a =destroy call is generated.
|
||
|
|
let typeSym = getTypeInst(output)
|
||
|
|
result = newStmtList()
|
||
|
|
let x = foldObjectBody(output, typeSym.getTypeImpl, mFunc)
|
||
|
|
if x.kind != nnkNone: result.add x
|
||
|
|
|
||
|
|
type
|
||
|
|
EncodingDefect = object of Defect
|
||
|
|
DecodingDefect = object of Defect
|
||
|
|
|
||
|
|
proc raiseEncoding() {.noinline, noreturn.} =
|
||
|
|
raise newException(EncodingDefect, "Can't write bytes to buffer.")
|
||
|
|
|
||
|
|
proc raiseDecoding() {.noinline, noreturn.} =
|
||
|
|
raise newException(DecodingDefect, "Can't read bytes from buffer.")
|
||
|
|
|
||
|
|
proc equals*(a, b: openArray[byte]): bool =
|
||
|
|
if a.len != b.len:
|
||
|
|
result = false
|
||
|
|
else: result = equalMem(addr a, addr b, a.len)
|
||
|
|
|
||
|
|
proc byteSize*(x: string): int {.inline.}
|
||
|
|
proc byteSize*[S, T](x: array[S, T]): int {.inline.}
|
||
|
|
proc byteSize*[T](x: seq[T]): int {.inline.}
|
||
|
|
proc byteSize*[T](o: SomeSet[T]): int {.inline.}
|
||
|
|
proc byteSize*[K, V](o: (Table[K, V]|OrderedTable[K, V])): int {.inline.}
|
||
|
|
proc byteSize*[T](o: ref T): int {.inline.}
|
||
|
|
proc byteSize*[T](o: Option[T]): int {.inline.}
|
||
|
|
proc byteSize*[T: tuple](o: T): int {.inline.}
|
||
|
|
proc byteSize*[T: object](o: T): int {.inline.}
|
||
|
|
proc byteSize*[T: distinct](x: T): int {.inline.}
|
||
|
|
|
||
|
|
proc byteSize*(x: bool): int {.inline.} = sizeof(x)
|
||
|
|
proc byteSize*(x: char): int {.inline.} = sizeof(x)
|
||
|
|
proc byteSize*[T: SomeNumber](x: T): int {.inline.} = sizeof(x)
|
||
|
|
proc byteSize*[T: enum](x: T): int {.inline.} = sizeof(x)
|
||
|
|
proc byteSize*[T](x: set[T]): int {.inline.} = sizeof(x)
|
||
|
|
proc byteSize*(x: string): int = sizeof(int32) + x.len
|
||
|
|
|
||
|
|
proc byteSize*[S, T](x: array[S, T]): int =
|
||
|
|
when supportsCopyMem(T):
|
||
|
|
result = sizeof(x)
|
||
|
|
else:
|
||
|
|
result = 0
|
||
|
|
for elem in x.items: result.inc byteSize(elem)
|
||
|
|
|
||
|
|
proc byteSize*[T](x: seq[T]): int =
|
||
|
|
when supportsCopyMem(T):
|
||
|
|
result = sizeof(int32) + x.len * sizeof(T)
|
||
|
|
else:
|
||
|
|
result = sizeof(int32)
|
||
|
|
for elem in x.items: result.inc byteSize(elem)
|
||
|
|
|
||
|
|
proc byteSize*[T](o: SomeSet[T]): int =
|
||
|
|
result = sizeof(int32)
|
||
|
|
for elem in o.items: result.inc byteSize(elem)
|
||
|
|
|
||
|
|
proc byteSize*[K, V](o: (Table[K, V]|OrderedTable[K, V])): int =
|
||
|
|
result = sizeof(int32)
|
||
|
|
for k, v in o.pairs:
|
||
|
|
result.inc byteSize(k)
|
||
|
|
result.inc byteSize(v)
|
||
|
|
|
||
|
|
proc byteSize*[T](o: ref T): int =
|
||
|
|
result = sizeof(bool)
|
||
|
|
if o != nil: result.inc byteSize(o[])
|
||
|
|
|
||
|
|
proc byteSize*[T](o: Option[T]): int =
|
||
|
|
result = sizeof(bool)
|
||
|
|
if isSome(o): result.inc byteSize(get(o))
|
||
|
|
|
||
|
|
proc byteSize*[T: tuple](o: T): int =
|
||
|
|
when supportsCopyMem(T):
|
||
|
|
result = sizeof(o)
|
||
|
|
else:
|
||
|
|
result = 0
|
||
|
|
for v in o.fields: result.inc byteSize(v)
|
||
|
|
|
||
|
|
proc byteSize*[T: object](o: T): int =
|
||
|
|
when supportsCopyMem(T):
|
||
|
|
result = sizeof(o)
|
||
|
|
else:
|
||
|
|
result = 0
|
||
|
|
for v in o.fields: result.inc byteSize(v)
|
||
|
|
|
||
|
|
proc byteSize*[T: distinct](x: T): int = byteSize(x.distinctBase)
|
||
|
|
|
||
|
|
proc writeData*(data: var openArray[byte], pos: var int, buffer: pointer, bufLen: int) =
|
||
|
|
if bufLen <= 0:
|
||
|
|
return
|
||
|
|
if pos + bufLen > data.len:
|
||
|
|
raiseEncoding()
|
||
|
|
else:
|
||
|
|
copyMem(data[pos].addr, buffer, bufLen)
|
||
|
|
inc(pos, bufLen)
|
||
|
|
|
||
|
|
proc write*[T](data: var openArray[byte], pos: var int, input: T) =
|
||
|
|
writeData(data, pos, input.unsafeAddr, sizeof(input))
|
||
|
|
|
||
|
|
proc readData*(data: openArray[byte], pos: var int, buffer: pointer, bufLen: int): int =
|
||
|
|
result = min(bufLen, data.len - pos)
|
||
|
|
if result > 0:
|
||
|
|
copyMem(buffer, data[pos].addr, result)
|
||
|
|
inc(pos, result)
|
||
|
|
else:
|
||
|
|
result = 0
|
||
|
|
|
||
|
|
proc read*[T](data: openArray[byte], pos: var int, output: var T) =
|
||
|
|
if readData(data, pos, output.addr, sizeof(output)) != sizeof(output):
|
||
|
|
raiseDecoding()
|
||
|
|
|
||
|
|
proc readChar*(data: openArray[byte], pos: var int): char {.inline.} =
|
||
|
|
read(data, pos, result)
|
||
|
|
|
||
|
|
proc readBool*(data: openArray[byte], pos: var int): bool {.inline.} =
|
||
|
|
read(data, pos, result)
|
||
|
|
|
||
|
|
proc readInt8*(data: openArray[byte], pos: var int): int8 {.inline.} =
|
||
|
|
read(data, pos, result)
|
||
|
|
|
||
|
|
proc readInt16*(data: openArray[byte], pos: var int): int16 {.inline.} =
|
||
|
|
read(data, pos, result)
|
||
|
|
|
||
|
|
proc readInt32*(data: openArray[byte], pos: var int): int32 {.inline.} =
|
||
|
|
read(data, pos, result)
|
||
|
|
|
||
|
|
proc readInt64*(data: openArray[byte], pos: var int): int64 {.inline.} =
|
||
|
|
read(data, pos, result)
|
||
|
|
|
||
|
|
proc readUint8*(data: openArray[byte], pos: var int): uint8 {.inline.} =
|
||
|
|
read(data, pos, result)
|
||
|
|
|
||
|
|
proc readUint16*(data: openArray[byte], pos: var int): uint16 {.inline.} =
|
||
|
|
read(data, pos, result)
|
||
|
|
|
||
|
|
proc readUint32*(data: openArray[byte], pos: var int): uint32 {.inline.} =
|
||
|
|
read(data, pos, result)
|
||
|
|
|
||
|
|
proc readUint64*(data: openArray[byte], pos: var int): uint64 {.inline.} =
|
||
|
|
read(data, pos, result)
|
||
|
|
|
||
|
|
proc readFloat32*(data: openArray[byte], pos: var int): float32 {.inline.} =
|
||
|
|
read(data, pos, result)
|
||
|
|
|
||
|
|
proc readFloat64*(data: openArray[byte], pos: var int): float64 {.inline.} =
|
||
|
|
read(data, pos, result)
|
||
|
|
|
||
|
|
proc fromData*(data: openArray[byte]; pos: var int; output: var string)
|
||
|
|
proc fromData*[S, T](data: openArray[byte]; pos: var int; output: var array[S, T])
|
||
|
|
proc fromData*[T](data: openArray[byte]; pos: var int; output: var seq[T])
|
||
|
|
proc fromData*[T](data: openArray[byte]; pos: var int; output: var SomeSet[T])
|
||
|
|
proc fromData*[K, V](data: openArray[byte]; pos: var int; output: var (Table[K, V]|OrderedTable[K, V]))
|
||
|
|
proc fromData*[T](data: openArray[byte]; pos: var int; output: var ref T)
|
||
|
|
proc fromData*[T](data: openArray[byte]; pos: var int; output: var Option[T])
|
||
|
|
proc fromData*[T: tuple](data: openArray[byte]; pos: var int; output: var T)
|
||
|
|
proc fromData*[T: object](data: openArray[byte]; pos: var int; output: var T) {.nodestroy.}
|
||
|
|
proc fromData*[T: distinct](data: openArray[byte]; pos: var int; output: var T) {.inline.}
|
||
|
|
|
||
|
|
proc toData*(data: var openArray[byte]; pos: var int; input: string)
|
||
|
|
proc toData*[S, T](data: var openArray[byte]; pos: var int; input: array[S, T])
|
||
|
|
proc toData*[T](data: var openArray[byte]; pos: var int; input: seq[T])
|
||
|
|
proc toData*[T](data: var openArray[byte]; pos: var int; input: SomeSet[T])
|
||
|
|
proc toData*[K, V](data: var openArray[byte]; pos: var int; input: (Table[K, V]|OrderedTable[K, V]))
|
||
|
|
proc toData*[T](data: var openArray[byte]; pos: var int; input: ref T)
|
||
|
|
proc toData*[T](data: var openArray[byte]; pos: var int; input: Option[T])
|
||
|
|
proc toData*[T: tuple](data: var openArray[byte]; pos: var int; input: T)
|
||
|
|
proc toData*[T: object](data: var openArray[byte]; pos: var int; input: T)
|
||
|
|
proc toData*[T: distinct](data: var openArray[byte]; pos: var int; input: T) {.inline.}
|
||
|
|
|
||
|
|
proc toData*(data: var openArray[byte]; pos: var int; input: bool) =
|
||
|
|
write(data, pos, input)
|
||
|
|
|
||
|
|
proc fromData*(data: openArray[byte]; pos: var int; output: var bool) =
|
||
|
|
read(data, pos, output)
|
||
|
|
|
||
|
|
proc toData*(data: var openArray[byte]; pos: var int; input: char) =
|
||
|
|
write(data, pos, input)
|
||
|
|
|
||
|
|
proc fromData*(data: openArray[byte]; pos: var int; output: var char) =
|
||
|
|
read(data, pos, output)
|
||
|
|
|
||
|
|
proc toData*[T: SomeNumber](data: var openArray[byte]; pos: var int; input: T) =
|
||
|
|
write(data, pos, input)
|
||
|
|
|
||
|
|
proc fromData*[T: SomeNumber](data: openArray[byte]; pos: var int; output: var T) =
|
||
|
|
read(data, pos, output)
|
||
|
|
|
||
|
|
proc toData*[T: enum](data: var openArray[byte]; pos: var int; input: T) =
|
||
|
|
write(data, pos, input)
|
||
|
|
|
||
|
|
proc fromData*[T: enum](data: openArray[byte]; pos: var int; output: var T) =
|
||
|
|
read(data, pos, output)
|
||
|
|
|
||
|
|
proc toData*[T](data: var openArray[byte]; pos: var int; input: set[T]) =
|
||
|
|
write(data, pos, input)
|
||
|
|
|
||
|
|
proc fromData*[T](data: openArray[byte]; pos: var int; output: var set[T]) =
|
||
|
|
read(data, pos, output)
|
||
|
|
|
||
|
|
proc toData*(data: var openArray[byte]; pos: var int; input: string) =
|
||
|
|
write(data, pos, int32(input.len))
|
||
|
|
writeData(data, pos, cstring(input), input.len)
|
||
|
|
|
||
|
|
proc fromData*(data: openArray[byte]; pos: var int; output: var string) =
|
||
|
|
let len = readInt32(data, pos).int
|
||
|
|
output.setLen(len)
|
||
|
|
if readData(data, pos, cstring(output), len) != len:
|
||
|
|
raiseDecoding()
|
||
|
|
|
||
|
|
proc toData*[S, T](data: var openArray[byte]; pos: var int; input: array[S, T]) =
|
||
|
|
when supportsCopyMem(T):
|
||
|
|
writeData(data, pos, input.unsafeAddr, sizeof(input))
|
||
|
|
else:
|
||
|
|
for elem in input.items:
|
||
|
|
toData(data, pos, elem)
|
||
|
|
|
||
|
|
proc fromData*[S, T](data: openArray[byte]; pos: var int; output: var array[S, T]) =
|
||
|
|
when supportsCopyMem(T):
|
||
|
|
if readData(data, pos, output.addr, sizeof(output)) != sizeof(output):
|
||
|
|
raiseDecoding()
|
||
|
|
else:
|
||
|
|
for i in low(output)..high(output):
|
||
|
|
fromData(data, pos, output[i])
|
||
|
|
|
||
|
|
proc toData*[T](data: var openArray[byte]; pos: var int; input: seq[T]) =
|
||
|
|
write(data, pos, int32(input.len))
|
||
|
|
when supportsCopyMem(T):
|
||
|
|
if input.len > 0:
|
||
|
|
writeData(data, pos, input[0].unsafeAddr, input.len * sizeof(T))
|
||
|
|
else:
|
||
|
|
for elem in input.items:
|
||
|
|
toData(data, pos, elem)
|
||
|
|
|
||
|
|
proc fromData*[T](data: openArray[byte]; pos: var int; output: var seq[T]) =
|
||
|
|
let len = readInt32(data, pos).int
|
||
|
|
output.setLen(len)
|
||
|
|
when supportsCopyMem(T):
|
||
|
|
if len > 0:
|
||
|
|
let bLen = len * sizeof(T)
|
||
|
|
if readData(data, pos, output[0].addr, bLen) != bLen:
|
||
|
|
raiseDecoding()
|
||
|
|
else:
|
||
|
|
for i in 0..<len:
|
||
|
|
fromData(data, pos, output[i])
|
||
|
|
|
||
|
|
proc toData*[T](data: var openArray[byte]; pos: var int; input: SomeSet[T]) =
|
||
|
|
write(data, pos, int32(input.len))
|
||
|
|
for elem in input.items:
|
||
|
|
toData(data, pos, elem)
|
||
|
|
|
||
|
|
proc fromData*[T](data: openArray[byte]; pos: var int; output: var SomeSet[T]) =
|
||
|
|
let len = readInt32(data, pos).int
|
||
|
|
for i in 0..<len:
|
||
|
|
var tmp: T
|
||
|
|
fromData(data, pos, tmp)
|
||
|
|
output.incl(tmp)
|
||
|
|
|
||
|
|
proc toData*[K, V](data: var openArray[byte]; pos: var int; input: (Table[K, V]|OrderedTable[K, V])) =
|
||
|
|
write(data, pos, int32(input.len))
|
||
|
|
for k, v in input.pairs:
|
||
|
|
toData(data, pos, k)
|
||
|
|
toData(data, pos, v)
|
||
|
|
|
||
|
|
proc fromData*[K, V](data: openArray[byte]; pos: var int; output: var (Table[K, V]|OrderedTable[K, V])) =
|
||
|
|
let len = readInt32(data, pos).int
|
||
|
|
for i in 0 ..< len:
|
||
|
|
var key: K
|
||
|
|
fromData(data, pos, key)
|
||
|
|
fromData(data, pos, mgetOrPut(output, key, default(V)))
|
||
|
|
|
||
|
|
proc toData*[T](data: var openArray[byte]; pos: var int; input: ref T) =
|
||
|
|
let isSome = input != nil
|
||
|
|
toData(data, pos, isSome)
|
||
|
|
if isSome:
|
||
|
|
toData(data, pos, input[])
|
||
|
|
|
||
|
|
proc fromData*[T](data: openArray[byte]; pos: var int; output: var ref T) =
|
||
|
|
let isSome = readBool(data, pos)
|
||
|
|
if isSome:
|
||
|
|
new(output)
|
||
|
|
fromData(data, pos, output[])
|
||
|
|
else:
|
||
|
|
output = nil
|
||
|
|
|
||
|
|
proc toData*[T](data: var openArray[byte]; pos: var int; input: Option[T]) =
|
||
|
|
let isSome = isSome(input)
|
||
|
|
toData(data, pos, isSome)
|
||
|
|
if isSome:
|
||
|
|
toData(data, pos, get(input))
|
||
|
|
|
||
|
|
proc fromData*[T](data: openArray[byte]; pos: var int; output: var Option[T]) =
|
||
|
|
let isSome = readBool(data, pos)
|
||
|
|
if isSome:
|
||
|
|
var tmp: T
|
||
|
|
fromData(data, pos, tmp)
|
||
|
|
output = some(tmp)
|
||
|
|
else:
|
||
|
|
output = none[T]()
|
||
|
|
|
||
|
|
proc toData*[T: tuple](data: var openArray[byte]; pos: var int; input: T) =
|
||
|
|
when supportsCopyMem(T):
|
||
|
|
write(data, pos, input)
|
||
|
|
else:
|
||
|
|
for v in input.fields:
|
||
|
|
toData(data, pos, v)
|
||
|
|
|
||
|
|
proc toData*[T: object](data: var openArray[byte]; pos: var int; input: T) =
|
||
|
|
when supportsCopyMem(T):
|
||
|
|
write(data, pos, input)
|
||
|
|
else:
|
||
|
|
for v in input.fields:
|
||
|
|
toData(data, pos, v)
|
||
|
|
|
||
|
|
proc fromData*[T: tuple](data: openArray[byte]; pos: var int; output: var T) =
|
||
|
|
when supportsCopyMem(T):
|
||
|
|
read(data, pos, output)
|
||
|
|
else:
|
||
|
|
for v in output.fields:
|
||
|
|
fromData(data, pos, v)
|
||
|
|
|
||
|
|
proc fromData*[T: object](data: openArray[byte]; pos: var int; output: var T) =
|
||
|
|
when supportsCopyMem(T):
|
||
|
|
read(data, pos, output)
|
||
|
|
else:
|
||
|
|
template fromDataFunc(x: untyped) =
|
||
|
|
fromData(data, pos, x)
|
||
|
|
assignObjectImpl(output, fromDataFunc)
|
||
|
|
|
||
|
|
proc toData*[T: distinct](data: var openArray[byte]; pos: var int; input: T) =
|
||
|
|
toData(data, pos, input.distinctBase)
|
||
|
|
|
||
|
|
proc fromData*[T: distinct](data: openArray[byte]; pos: var int; output: var T) =
|
||
|
|
fromData(data, pos, output.distinctBase)
|