nimbus-eth2/beacon_chain/ssz/bytes_reader.nim

265 lines
10 KiB
Nim
Raw Normal View History

# beacon_chain
# Copyright (c) 2018-2021 Status Research & Development GmbH
# Licensed and distributed under either of
# * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
# * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
# at your option. This file may not be copied, modified, or distributed except according to those terms.
{.push raises: [Defect].}
{.pragma: raisesssz, raises: [Defect, MalformedSszError, SszSizeMismatchError].}
import
std/[typetraits, options],
stew/[endians2, objects],
../spec/digest, ./types, ./spec_types, ./merkleization,
../spec/datatypes/[phase0, altair]
template raiseIncorrectSize(T: type) =
const typeName = name(T)
raise newException(MalformedSszError,
"SSZ " & typeName & " input of incorrect size")
2020-01-24 18:35:15 +00:00
template setOutputSize[R, T](a: var array[R, T], length: int) =
if length != a.len:
raiseIncorrectSize a.type
2020-01-24 18:35:15 +00:00
proc setOutputSize(list: var List, length: int) {.raisesssz.} =
if not list.setLen length:
raise newException(MalformedSszError, "SSZ list maximum size exceeded")
2020-01-24 18:35:15 +00:00
# fromSszBytes copies the wire representation to a Nim variable,
# assuming there's enough data in the buffer
2020-10-28 18:35:31 +00:00
func fromSszBytes*(T: type UintN, data: openArray[byte]): T {.raisesssz.} =
## Convert directly to bytes the size of the int. (e.g. ``uint16 = 2 bytes``)
## All integers are serialized as **little endian**.
if data.len != sizeof(result):
raiseIncorrectSize T
2020-01-24 18:35:15 +00:00
2020-03-05 00:29:27 +00:00
T.fromBytesLE(data)
2020-10-28 18:35:31 +00:00
func fromSszBytes*(T: type bool, data: openArray[byte]): T {.raisesssz.} =
# Strict: only allow 0 or 1
if data.len != 1 or byte(data[0]) > byte(1):
2020-01-24 18:35:15 +00:00
raise newException(MalformedSszError, "invalid boolean value")
data[0] == 1
2020-10-28 18:35:31 +00:00
func fromSszBytes*(T: type Eth2Digest, data: openArray[byte]): T {.raisesssz.} =
if data.len != sizeof(result.data):
raiseIncorrectSize T
copyMem(result.data.addr, unsafeAddr data[0], sizeof(result.data))
2020-10-28 18:35:31 +00:00
func fromSszBytes*(T: type GraffitiBytes, data: openArray[byte]): T {.raisesssz.} =
if data.len != sizeof(result):
raiseIncorrectSize T
copyMem(result.addr, unsafeAddr data[0], sizeof(result))
template fromSszBytes*(T: type Slot, bytes: openArray[byte]): T =
T fromSszBytes(uint64, bytes)
template fromSszBytes*(T: type Epoch, bytes: openArray[byte]): T =
T fromSszBytes(uint64, bytes)
template fromSszBytes*(T: type ParticipationFlags, bytes: openArray[byte]): T =
T fromSszBytes(uint8, bytes)
2020-10-28 18:35:31 +00:00
func fromSszBytes*(T: type ForkDigest, bytes: openArray[byte]): T {.raisesssz.} =
if bytes.len != sizeof(result):
raiseIncorrectSize T
copyMem(result.addr, unsafeAddr bytes[0], sizeof(result))
2020-10-28 18:35:31 +00:00
func fromSszBytes*(T: type Version, bytes: openArray[byte]): T {.raisesssz.} =
if bytes.len != sizeof(result):
raiseIncorrectSize T
copyMem(result.addr, unsafeAddr bytes[0], sizeof(result))
2020-10-28 18:35:31 +00:00
template fromSszBytes*(T: type BitSeq, bytes: openArray[byte]): auto =
BitSeq @bytes
proc `[]`[T, U, V](s: openArray[T], x: HSlice[U, V]) {.error:
2020-10-28 18:35:31 +00:00
"Please don't use openArray's [] as it allocates a result sequence".}
template checkForForbiddenBits(ResulType: type,
2020-10-28 18:35:31 +00:00
input: openArray[byte],
expectedBits: static int64) =
## This checks if the input contains any bits set above the maximum
## sized allowed. We only need to check the last byte to verify this:
const bitsInLastByte = (expectedBits mod 8)
when bitsInLastByte != 0:
# As an example, if there are 3 bits expected in the last byte,
# we calculate a bitmask equal to 11111000. If the input has any
# raised bits in range of the bitmask, this would be a violation
# of the size of the BitArray:
const forbiddenBitsMask = byte(byte(0xff) shl bitsInLastByte)
if (input[^1] and forbiddenBitsMask) != 0:
raiseIncorrectSize ResulType
2020-10-28 18:35:31 +00:00
func readSszValue*[T](input: openArray[byte],
val: var T, updateRoot: bool = true) {.raisesssz.} =
mixin fromSszBytes, toSszType
2020-06-09 11:44:40 +00:00
template readOffsetUnchecked(n: int): uint32 {.used.}=
fromSszBytes(uint32, input.toOpenArray(n, n + offsetSize - 1))
template readOffset(n: int): int {.used.} =
let offset = readOffsetUnchecked(n)
2020-06-09 11:44:40 +00:00
if offset > input.len.uint32:
raise newException(MalformedSszError, "SSZ list element offset points past the end of the input")
2020-06-09 11:44:40 +00:00
int(offset)
#when result is List:
# result.setOutputSize input.len
# readOpenArray(toSeq result, input)
#elif result is array:
# result.checkOutputSize input.len
# readOpenArray(result, input)
2020-01-24 18:35:15 +00:00
2020-05-27 15:04:43 +00:00
when val is BitList:
if input.len == 0:
raise newException(MalformedSszError, "Invalid empty SSZ BitList value")
# Since our BitLists have an in-memory representation that precisely
# matches their SSZ encoding, we can deserialize them as regular Lists:
2020-05-27 15:04:43 +00:00
const maxExpectedSize = (val.maxLen div 8) + 1
type MatchingListType = List[byte, maxExpectedSize]
when false:
# TODO: Nim doesn't like this simple type coercion,
# we'll rely on `cast` for now (see below)
readSszValue(input, MatchingListType val)
else:
static:
# As a sanity check, we verify that the coercion is accepted by the compiler:
doAssert MatchingListType(val) is MatchingListType
readSszValue(input, cast[ptr MatchingListType](addr val)[])
2020-05-27 15:04:43 +00:00
let resultBytesCount = len bytes(val)
2020-05-27 15:04:43 +00:00
if bytes(val)[resultBytesCount - 1] == 0:
raise newException(MalformedSszError, "SSZ BitList is not properly terminated")
if resultBytesCount == maxExpectedSize:
checkForForbiddenBits(T, input, val.maxLen + 1)
elif val is HashList | HashArray:
readSszValue(input, val.data)
val.resetCache()
2020-05-27 15:04:43 +00:00
elif val is List|array:
type E = type val[0]
2020-06-09 11:44:40 +00:00
when E is byte:
2020-05-27 15:04:43 +00:00
val.setOutputSize input.len
if input.len > 0:
2020-05-27 15:04:43 +00:00
copyMem(addr val[0], unsafeAddr input[0], input.len)
elif isFixedSize(E):
const elemSize = fixedPortionSize(E)
if input.len mod elemSize != 0:
var ex = new SszSizeMismatchError
ex.deserializedType = cstring typetraits.name(T)
ex.actualSszSize = input.len
ex.elementSize = elemSize
raise ex
2020-05-27 15:04:43 +00:00
val.setOutputSize input.len div elemSize
for i in 0 ..< val.len:
let offset = i * elemSize
2020-05-27 15:04:43 +00:00
readSszValue(input.toOpenArray(offset, offset + elemSize - 1), val[i])
else:
if input.len == 0:
# This is an empty list.
# The default initialization of the return value is fine.
val.setOutputSize 0
return
2020-01-24 18:35:15 +00:00
elif input.len < offsetSize:
raise newException(MalformedSszError, "SSZ input of insufficient size")
var offset = readOffset 0
let resultLen = offset div offsetSize
if resultLen == 0:
# If there are too many elements, other constraints detect problems
# (not monotonically increasing, past end of input, or last element
# not matching up with its nextOffset properly)
raise newException(MalformedSszError, "SSZ list incorrectly encoded of zero length")
2020-05-27 15:04:43 +00:00
val.setOutputSize resultLen
for i in 1 ..< resultLen:
let nextOffset = readOffset(i * offsetSize)
2020-01-24 18:35:15 +00:00
if nextOffset <= offset:
raise newException(MalformedSszError, "SSZ list element offsets are not monotonically increasing")
else:
2020-05-27 15:04:43 +00:00
readSszValue(input.toOpenArray(offset, nextOffset - 1), val[i - 1])
offset = nextOffset
2020-05-27 15:04:43 +00:00
readSszValue(input.toOpenArray(offset, input.len - 1), val[resultLen - 1])
elif val is UintN|bool:
2020-05-28 12:36:37 +00:00
val = fromSszBytes(T, input)
2020-05-27 15:04:43 +00:00
elif val is BitArray:
if sizeof(val) != input.len:
raiseIncorrectSize(T)
checkForForbiddenBits(T, input, val.bits)
2020-05-27 15:04:43 +00:00
copyMem(addr val.bytes[0], unsafeAddr input[0], input.len)
elif val is object|tuple:
2020-06-09 11:44:40 +00:00
let inputLen = uint32 input.len
const minimallyExpectedSize = uint32 fixedPortionSize(T)
if inputLen < minimallyExpectedSize:
2020-01-24 18:35:15 +00:00
raise newException(MalformedSszError, "SSZ input of insufficient size")
2020-05-27 15:04:43 +00:00
enumInstanceSerializedFields(val, fieldName, field):
const boundingOffsets = getFieldBoundingOffsets(T, fieldName)
# type FieldType = type field # buggy
# For some reason, Nim gets confused about the alias here. This could be a
# generics caching issue caused by the use of distinct types. Such an
# issue is very scary in general.
# The bug can be seen with the two List[uint64, N] types that exist in
# the spec, with different N.
type SszType = type toSszType(declval type(field))
when isFixedSize(SszType):
const
startOffset = boundingOffsets[0]
endOffset = boundingOffsets[1]
else:
let
startOffset = readOffsetUnchecked(boundingOffsets[0])
2020-06-09 11:44:40 +00:00
endOffset = if boundingOffsets[1] == -1: inputLen
else: readOffsetUnchecked(boundingOffsets[1])
when boundingOffsets.isFirstOffset:
if startOffset != minimallyExpectedSize:
raise newException(MalformedSszError, "SSZ object dynamic portion starts at invalid offset")
2020-01-27 17:20:06 +00:00
if startOffset > endOffset:
2020-01-24 18:35:15 +00:00
raise newException(MalformedSszError, "SSZ field offsets are not monotonically increasing")
2020-06-09 11:44:40 +00:00
elif endOffset > inputLen:
2020-01-24 18:35:15 +00:00
raise newException(MalformedSszError, "SSZ field offset points past the end of the input")
elif startOffset < minimallyExpectedSize:
2020-04-16 19:21:28 +00:00
raise newException(MalformedSszError, "SSZ field offset points outside bounding offsets")
# TODO The extra type escaping here is a work-around for a Nim issue:
when type(field) is type(SszType):
2020-05-27 15:04:43 +00:00
readSszValue(
2020-06-09 11:44:40 +00:00
input.toOpenArray(int(startOffset), int(endOffset - 1)),
2020-05-27 15:04:43 +00:00
field)
else:
field = fromSszBytes(
type(field),
2020-06-09 11:44:40 +00:00
input.toOpenArray(int(startOffset), int(endOffset - 1)))
when val is phase0.SignedBeaconBlock | phase0.TrustedSignedBeaconBlock |
altair.SignedBeaconBlock | altair.TrustedSignedBeaconBlock:
if updateRoot:
val.root = hash_tree_root(val.message)
else:
unsupported T