diff --git a/CHANGELOG.md b/CHANGELOG.md index 7c25b42..e70f6e4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,3 +11,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Declaring a repeated field of a non-packable type (string, bytes, message) as `packed: true` now throws `Exception\InvalidSchema` when the type is created. It used to produce output that no parser reads correctly. +- Serializing a value that its protobuf type cannot represent now throws `Exception\ValueOutOfRange` instead of + wrapping it or writing a broken varint: `int32`/`sint32`/`sfixed32`/enum outside [-2^31, 2^31-1] (e.g. + `int32Of(2 ** 31)` used to wrap to a negative number), `uint32`/`fixed32` outside [0, 2^32-1], and + `uint64`/`fixed64` that are negative, above 2^64-1 or fractional. +- Serializing a string-backed PHP enum as a protobuf enum throws `Exception\InvalidSchema` instead of + `\InvalidArgumentException`. + +### Fixed + +- Negative enum numbers are encoded as 10-byte sign-extended varints, as protobuf requires. They used to be + written as a truncated varint that no parser, including this one, could read. diff --git a/src/Exception/ValueOutOfRange.php b/src/Exception/ValueOutOfRange.php new file mode 100644 index 0000000..dc0163e --- /dev/null +++ b/src/Exception/ValueOutOfRange.php @@ -0,0 +1,29 @@ + self::INT32_MAX) { + throw new ValueOutOfRange($type, $value, \sprintf('[%d, %d]', self::INT32_MIN, self::INT32_MAX)); + } + + return $value; + } + + /** + * @param non-empty-string $type + * @throws ValueOutOfRange + */ + public static function uint32(int $value, string $type): int + { + if ($value < 0 || $value > self::UINT32_MAX) { + throw new ValueOutOfRange($type, $value, \sprintf('[0, %d]', self::UINT32_MAX)); + } + + return $value; + } + + /** + * @param non-empty-string $type + * @throws ValueOutOfRange + */ + public static function uint64(Number $value, string $type): Number + { + if ($value->compare(0) < 0 || $value->compare(self::UINT64_MAX) > 0 || $value->compare($value->floor()) !== 0) { + throw new ValueOutOfRange($type, $value, \sprintf('[0, %s]', self::UINT64_MAX)); + } + + return $value; + } +} diff --git a/src/Internal/Serde/SerdeFixed32.php b/src/Internal/Serde/SerdeFixed32.php index 7324103..145fcbf 100644 --- a/src/Internal/Serde/SerdeFixed32.php +++ b/src/Internal/Serde/SerdeFixed32.php @@ -22,7 +22,7 @@ enum SerdeFixed32 implements #[\Override] public function serialize(WriteBuffer $buffer, mixed $value): void { - $buffer->write(Endian\Order::Little->packUint32($value)); + $buffer->write(Endian\Order::Little->packUint32(Range::uint32($value, 'fixed32'))); } #[\Override] diff --git a/src/Internal/Serde/SerdeFixed64.php b/src/Internal/Serde/SerdeFixed64.php index 52c76fe..a3947fb 100644 --- a/src/Internal/Serde/SerdeFixed64.php +++ b/src/Internal/Serde/SerdeFixed64.php @@ -23,7 +23,7 @@ enum SerdeFixed64 implements #[\Override] public function serialize(WriteBuffer $buffer, mixed $value): void { - $buffer->write(Endian\Order::Little->packUint64($value)); + $buffer->write(Endian\Order::Little->packUint64(Range::uint64($value, 'fixed64'))); } #[\Override] diff --git a/src/Internal/Serde/SerdeInt32.php b/src/Internal/Serde/SerdeInt32.php index 40f7d41..1e80167 100644 --- a/src/Internal/Serde/SerdeInt32.php +++ b/src/Internal/Serde/SerdeInt32.php @@ -22,25 +22,8 @@ enum SerdeInt32 implements #[\Override] public function serialize(WriteBuffer $buffer, mixed $value): void { - /** @var ?Number $p32 */ - static $p32; - $p32 ??= new Number(2)->pow(32); - - /** @var ?Number $p64 */ - static $p64; - $p64 ??= new Number(2)->pow(64); - - $num = new Number($value)->mod($p32); - - if ($num->compare($p32->div(2)) >= 0) { - $num -= $p32; - } - - if ($num->compare(0) < 0) { - $num += $p64; - } - - SerdeVarint::T->serialize($buffer, $num); + // A negative int32 is encoded as its 64-bit sign extension, exactly like an int64. + SerdeInt64::T->serialize($buffer, Range::int32($value, 'int32')); } #[\Override] diff --git a/src/Internal/Serde/SerdeSFixed32.php b/src/Internal/Serde/SerdeSFixed32.php index 57a2682..ac7d7a6 100644 --- a/src/Internal/Serde/SerdeSFixed32.php +++ b/src/Internal/Serde/SerdeSFixed32.php @@ -22,7 +22,7 @@ enum SerdeSFixed32 implements #[\Override] public function serialize(WriteBuffer $buffer, mixed $value): void { - $buffer->write(Endian\Order::Little->packInt32($value)); + $buffer->write(Endian\Order::Little->packInt32(Range::int32($value, 'sfixed32'))); } #[\Override] diff --git a/src/Internal/Serde/SerdeSInt32.php b/src/Internal/Serde/SerdeSInt32.php index 0f1cfaf..6744cd9 100644 --- a/src/Internal/Serde/SerdeSInt32.php +++ b/src/Internal/Serde/SerdeSInt32.php @@ -22,22 +22,8 @@ enum SerdeSInt32 implements #[\Override] public function serialize(WriteBuffer $buffer, mixed $value): void { - /** @var ?Number $p31 */ - static $p31; - - /** @var ?Number $p32 */ - static $p32; - - $p31 ??= new Number(2)->pow(31); - $p32 ??= new Number(2)->pow(32); - - $num = new Number($value)->mod($p32); - - if ($num->compare($p31) >= 0) { - $num -= $p32; - } - - SerdeSInt64::T->serialize($buffer, (int) $num->value); + // For values in the int32 range ZigZag-64 gives the same number as ZigZag-32. + SerdeSInt64::T->serialize($buffer, Range::int32($value, 'sint32')); } #[\Override] diff --git a/src/Internal/Serde/SerdeUint32.php b/src/Internal/Serde/SerdeUint32.php index a60f335..8540095 100644 --- a/src/Internal/Serde/SerdeUint32.php +++ b/src/Internal/Serde/SerdeUint32.php @@ -22,11 +22,7 @@ enum SerdeUint32 implements #[\Override] public function serialize(WriteBuffer $buffer, mixed $value): void { - /** @var ?Number $p32 */ - static $p32; - $p32 ??= new Number(2)->pow(32); - - SerdeVarint::T->serialize($buffer, new Number($value)->mod($p32)); + SerdeVarint::T->serialize($buffer, new Number(Range::uint32($value, 'uint32'))); } #[\Override] diff --git a/src/Internal/Serde/SerdeUint64.php b/src/Internal/Serde/SerdeUint64.php index 4597e28..0f088a5 100644 --- a/src/Internal/Serde/SerdeUint64.php +++ b/src/Internal/Serde/SerdeUint64.php @@ -22,7 +22,7 @@ enum SerdeUint64 implements #[\Override] public function serialize(WriteBuffer $buffer, mixed $value): void { - SerdeVarint::T->serialize($buffer, $value); + SerdeVarint::T->serialize($buffer, Range::uint64($value, 'uint64')); } #[\Override] diff --git a/src/Internal/Serde/SerializeEnum.php b/src/Internal/Serde/SerializeEnum.php index d53bf90..56f9a16 100644 --- a/src/Internal/Serde/SerializeEnum.php +++ b/src/Internal/Serde/SerializeEnum.php @@ -4,7 +4,7 @@ namespace Thesis\Protobuf\Internal\Serde; -use BcMath\Number; +use Thesis\Protobuf\Exception\InvalidSchema; use Thesis\Protobuf\Internal\Buffer\WriteBuffer; /** @@ -20,9 +20,10 @@ public function serialize(WriteBuffer $buffer, mixed $value): void { $case = $value->value; if (!\is_int($case)) { - throw new \InvalidArgumentException('BackedEnum should be integer.'); + throw new InvalidSchema(\sprintf('Enum "%s" must be int-backed to be a protobuf enum.', $value::class)); } - SerdeVarint::T->serialize($buffer, new Number($case)); + // Enum numbers are int32: a negative one is sign-extended to 64 bits. + SerdeInt64::T->serialize($buffer, Range::int32($case, 'enum')); } } diff --git a/tests/ValueRangeTest.php b/tests/ValueRangeTest.php new file mode 100644 index 0000000..1a632cf --- /dev/null +++ b/tests/ValueRangeTest.php @@ -0,0 +1,160 @@ + $field + * @param non-empty-string $type + */ + #[DataProvider('provideOutOfRangeValuesAreRejectedCases')] + public function testOutOfRangeValuesAreRejected(FieldDescriptor $field, string $type, string $shown): void + { + try { + new Serializer()->serialize(message($field)); + self::fail('Serialization must fail.'); + } catch (ValueOutOfRange $e) { + self::assertSame($type, $e->type); + self::assertSame($shown, (string) $e->value); + self::assertStringContainsString("{$shown} is out of range for {$type}", $e->getMessage()); + } + } + + /** + * @return iterable, non-empty-string, string}> + */ + public static function provideOutOfRangeValuesAreRejectedCases(): iterable + { + yield 'int32 above max' => [fieldOf(1, int32Of(2 ** 31)), 'int32', '2147483648']; + yield 'int32 below min' => [fieldOf(1, int32Of(-2 ** 31 - 1)), 'int32', '-2147483649']; + yield 'sint32 above max' => [fieldOf(1, sint32Of(2 ** 31)), 'sint32', '2147483648']; + yield 'sint32 below min' => [fieldOf(1, sint32Of(-2 ** 31 - 1)), 'sint32', '-2147483649']; + yield 'sfixed32 above max' => [fieldOf(1, sfixed32Of(2 ** 31)), 'sfixed32', '2147483648']; + yield 'sfixed32 below min' => [fieldOf(1, sfixed32Of(-2 ** 31 - 1)), 'sfixed32', '-2147483649']; + yield 'uint32 negative' => [fieldOf(1, uint32Of(-1)), 'uint32', '-1']; + yield 'uint32 above max' => [fieldOf(1, uint32Of(2 ** 32)), 'uint32', '4294967296']; + yield 'fixed32 negative' => [fieldOf(1, fixed32Of(-1)), 'fixed32', '-1']; + yield 'fixed32 above max' => [fieldOf(1, fixed32Of(2 ** 32)), 'fixed32', '4294967296']; + yield 'uint64 negative' => [fieldOf(1, uint64Of(new Number(-1))), 'uint64', '-1']; + yield 'uint64 above max' => [fieldOf(1, uint64Of(new Number('18446744073709551616'))), 'uint64', '18446744073709551616']; + yield 'uint64 fractional' => [fieldOf(1, uint64Of(new Number('1.5'))), 'uint64', '1.5']; + yield 'fixed64 negative' => [fieldOf(1, fixed64Of(new Number(-1))), 'fixed64', '-1']; + yield 'fixed64 above max' => [fieldOf(1, fixed64Of(new Number('18446744073709551616'))), 'fixed64', '18446744073709551616']; + yield 'fixed64 fractional' => [fieldOf(1, fixed64Of(new Number('1.5'))), 'fixed64', '1.5']; + yield 'enum above max' => [fieldOf(1, enumOf(ValueRangeTestEnum::TooBig)), 'enum', '2147483648']; + yield 'enum below min' => [fieldOf(1, enumOf(ValueRangeTestEnum::TooSmall)), 'enum', '-2147483649']; + yield 'packed list element' => [fieldOf(1, listOf(int32T, [1, 2 ** 31], true)), 'int32', '2147483648']; + yield 'unpacked list element' => [fieldOf(1, listOf(uint32T, [1, -1], false)), 'uint32', '-1']; + yield 'map key' => [fieldOf(1, mapOf(uint32T, stringT, Map::fromArray([-1 => 'a']))), 'uint32', '-1']; + yield 'map value' => [fieldOf(1, mapOf(stringT, sint32T, Map::fromArray(['a' => 2 ** 31]))), 'sint32', '2147483648']; + } + + /** + * @param FieldDescriptor<*> $field + * @param non-empty-string $hex + */ + #[DataProvider('provideBoundaryValuesAreEncodedCases')] + public function testBoundaryValuesAreEncoded(FieldDescriptor $field, string $hex): void + { + self::assertSame($hex, bin2hex(new Serializer()->serialize(message($field)))); + } + + /** + * @return iterable, non-empty-string}> + */ + public static function provideBoundaryValuesAreEncodedCases(): iterable + { + yield 'int32 max' => [fieldOf(1, int32Of(2 ** 31 - 1)), '08ffffffff07']; + yield 'int32 min' => [fieldOf(1, int32Of(-2 ** 31)), '0880808080f8ffffffff01']; + yield 'sint32 max' => [fieldOf(1, sint32Of(2 ** 31 - 1)), '08feffffff0f']; + yield 'sint32 min' => [fieldOf(1, sint32Of(-2 ** 31)), '08ffffffff0f']; + yield 'sfixed32 max' => [fieldOf(1, sfixed32Of(2 ** 31 - 1)), '0dffffff7f']; + yield 'sfixed32 min' => [fieldOf(1, sfixed32Of(-2 ** 31)), '0d00000080']; + yield 'uint32 max' => [fieldOf(1, uint32Of(2 ** 32 - 1)), '08ffffffff0f']; + yield 'fixed32 max' => [fieldOf(1, fixed32Of(2 ** 32 - 1)), '0dffffffff']; + yield 'uint64 max' => [fieldOf(1, uint64Of(new Number('18446744073709551615'))), '08ffffffffffffffffff01']; + yield 'uint64 integral with a scale' => [fieldOf(1, uint64Of(new Number('5.0'))), '0805']; + yield 'fixed64 max' => [fieldOf(1, fixed64Of(new Number('18446744073709551615'))), '09ffffffffffffffff']; + yield 'fixed64 integral with a scale' => [fieldOf(1, fixed64Of(new Number('5.0'))), '090500000000000000']; + yield 'enum -1 is sign-extended' => [fieldOf(1, enumOf(ValueRangeTestEnum::MinusOne)), '08ffffffffffffffffff01']; + yield 'enum int32 min' => [fieldOf(1, enumOf(ValueRangeTestEnum::Min)), '0880808080f8ffffffff01']; + yield 'enum int32 max' => [fieldOf(1, enumOf(ValueRangeTestEnum::Max)), '08ffffffff07']; + } + + public function testNegativeEnumRoundTrips(): void + { + $serializer = new Serializer(); + $bytes = $serializer->serialize(message(fieldOf(1, enumOf(ValueRangeTestEnum::MinusOne)))); + + $decoded = $serializer->deserialize(messageT(fieldT(1, enumT(ValueRangeTestEnum::class))), $bytes); + + self::assertSame(ValueRangeTestEnum::MinusOne, ($decoded->fields[1] ?? null)?->value->value); + } + + public function testStringBackedEnumIsRejected(): void + { + $this->expectException(InvalidSchema::class); + $this->expectExceptionMessage(\sprintf('Enum "%s" must be int-backed', ValueRangeTestStringEnum::class)); + + new Serializer()->serialize(message(fieldOf(1, enumOf(ValueRangeTestStringEnum::A)))); + } + + public function testEncoderReportsOutOfRangeValues(): void + { + $this->expectException(ValueOutOfRange::class); + + Encoder\Builder::buildDefault()->encode(new ValueRangeTestMessage(2 ** 31)); + } +} + +enum ValueRangeTestEnum: int +{ + case Zero = 0; + case MinusOne = -1; + case Min = -2147483648; + case Max = 2147483647; + case TooBig = 2147483648; + case TooSmall = -2147483649; +} + +enum ValueRangeTestStringEnum: string +{ + case A = 'a'; +} + +final readonly class ValueRangeTestMessage +{ + public function __construct( + #[Reflection\Field(1, Reflection\Int32T::T)] + public int $value = 0, + ) {} +}