--- CBOR-XS/XS.pm 2013/11/28 16:09:04 1.28 +++ CBOR-XS/XS.pm 2016/07/27 05:40:29 1.61 @@ -50,9 +50,9 @@ L. In addition to the core CBOR data format, this module implements a -number of extensions, to support cyclic and shared data structures (see -C), string deduplication (see C) and scalar -references (always enabled). +number of extensions, to support cyclic and shared data structures +(see C and C), string deduplication (see +C) and scalar references (always enabled). The primary goal of this module is to be I and the secondary goal is to be I. To reach the latter goal it was written in C. @@ -66,7 +66,7 @@ use common::sense; -our $VERSION = '1.0'; +our $VERSION = 1.5; our @ISA = qw(Exporter); our @EXPORT = qw(encode_cbor decode_cbor); @@ -182,7 +182,8 @@ This means that such values will only be encoded once, and will not result in a deep cloning of the value on decode, in decoders supporting the value sharing extension. This also makes it possible to encode cyclic data -structures. +structures (which need C to ne enabled to be decoded by this +module). It is recommended to leave it off unless you know your communication partner supports the value sharing extensions to CBOR @@ -192,7 +193,7 @@ Detecting shared values incurs a runtime overhead when values are encoded that have a reference counter large than one, and might unnecessarily increase the encoded size, as potentially shared values are encode as -sharable whether or not they are actually shared. +shareable whether or not they are actually shared. At the moment, only targets of references can be shared (e.g. scalars, arrays or hashes pointed to by a reference). Weirder constructs, such as @@ -207,6 +208,26 @@ This option does not affect C in any way - shared values and references will always be decoded properly if present. +=item $cbor = $cbor->allow_cycles ([$enable]) + +=item $enabled = $cbor->get_allow_cycles + +If C<$enable> is true (or missing), then C will happily decode +self-referential (cyclic) data structures. By default these will not be +decoded, as they need manual cleanup to avoid memory leaks, so code that +isn't prepared for this will not leak memory. + +If C<$enable> is false (the default), then C will throw an error +when it encounters a self-referential/cyclic data structure. + +FUTURE DIRECTION: the motivation behind this option is to avoid I +cycles - future versions of this module might chose to decode cyclic data +structures using weak references when this option is off, instead of +throwing an error. + +This option does not affect C in any way - shared values and +references will always be encoded properly if present. + =item $cbor = $cbor->pack_strings ([$enable]) =item $enabled = $cbor->get_pack_strings @@ -228,6 +249,75 @@ This option does not affect C in any way - string references will always be decoded properly if present. +=item $cbor = $cbor->text_keys ([$enable]) + +=item $enabled = $cbor->get_text_keys + +If C<$enabled> is true (or missing), then C will encode all +perl hash keys as CBOR text strings/UTF-8 string, upgrading them as needed. + +If C<$enable> is false (the default), then C will encode hash keys +normally - upgraded perl strings (strings internally encoded as UTF-8) as +CBOR text strings, and downgraded perl strings as CBOR byte strings. + +This option does not affect C in any way. + +This option is useful for interoperability with CBOR decoders that don't +treat byte strings as a form of text. It is especially useful as Perl +gives very little control over hash keys. + +Enabling this option can be slow, as all downgraded hash keys that are +encoded need to be scanned and converted to UTF-8. + +=item $cbor = $cbor->text_strings ([$enable]) + +=item $enabled = $cbor->get_text_strings + +This option works similar to C, above, but works on all strings +(including hash keys), so C has no further effect after +enabling C. + +If C<$enabled> is true (or missing), then C will encode all perl +strings as CBOR text strings/UTF-8 strings, upgrading them as needed. + +If C<$enable> is false (the default), then C will encode strings +normally (but see C) - upgraded perl strings (strings +internally encoded as UTF-8) as CBOR text strings, and downgraded perl +strings as CBOR byte strings. + +This option does not affect C in any way. + +This option has similar advantages and disadvantages as C. In +addition, this option effectively removes the ability to encode byte +strings, which might break some C and C methods that rely +on this, such as bignum encoding, so this option is mainly useful for very +simple data. + +=item $cbor = $cbor->validate_utf8 ([$enable]) + +=item $enabled = $cbor->get_validate_utf8 + +If C<$enable> is true (or missing), then C will validate that +elements (text strings) containing UTF-8 data in fact contain valid UTF-8 +data (instead of blindly accepting it). This validation obviously takes +extra time during decoding. + +The concept of "valid UTF-8" used is perl's concept, which is a superset +of the official UTF-8. + +If C<$enable> is false (the default), then C will blindly accept +UTF-8 data, marking them as valid UTF-8 in the resulting data structure +regardless of whether that's true or not. + +Perl isn't too happy about corrupted UTF-8 in strings, but should +generally not crash or do similarly evil things. Extensions might be not +so forgiving, so it's recommended to turn on this setting if you receive +untrusted CBOR. + +This option does not affect C in any way - strings that are +supposedly valid UTF-8 will simply be dumped into the resulting CBOR +string without checking whether that is, in fact, true or not. + =item $cbor = $cbor->filter ([$cb->($tag, $value)]) =item $cb_or_undef = $cbor->get_filter @@ -294,6 +384,70 @@ =back +=head2 INCREMENTAL PARSING + +In some cases, there is the need for incremental parsing of JSON +texts. While this module always has to keep both CBOR text and resulting +Perl data structure in memory at one time, it does allow you to parse a +CBOR stream incrementally, using a similar to using "decode_prefix" to see +if a full CBOR object is available, but is much more efficient. + +It basically works by parsing as much of a CBOR string as possible - if +the CBOR data is not complete yet, the pasrer will remember where it was, +to be able to restart when more data has been accumulated. Once enough +data is available to either decode a complete CBOR value or raise an +error, a real decode will be attempted. + +A typical use case would be a network protocol that consists of sending +and receiving CBOR-encoded messages. The solution that works with CBOR and +about anything else is by prepending a length to every CBOR value, so the +receiver knows how many octets to read. More compact (and slightly slower) +would be to just send CBOR values back-to-back, as C knows where +a CBOR value ends, and doesn't need an explicit length. + +The following methods help with this: + +=over 4 + +=item @decoded = $cbor->incr_parse ($buffer) + +This method attempts to decode exactly one CBOR value from the beginning +of the given C<$buffer>. The value is removed from the C<$buffer> on +success. When C<$buffer> doesn't contain a complete value yet, it returns +nothing. Finally, when the C<$buffer> doesn't start with something +that could ever be a valid CBOR value, it raises an exception, just as +C would. In the latter case the decoder state is undefined and +must be reset before being able to parse further. + +This method modifies the C<$buffer> in place. When no CBOR value can be +decoded, the decoder stores the current string offset. On the next call, +continues decoding at the place where it stopped before. For this to make +sense, the C<$buffer> must begin with the same octets as on previous +unsuccessful calls. + +You can call this method in scalar context, in which case it either +returns a decoded value or C. This makes it impossible to +distinguish between CBOR null values (which decode to C) and an +unsuccessful decode, which is often acceptable. + +=item @decoded = $cbor->incr_parse_multiple ($buffer) + +Same as C, but attempts to decode as many CBOR values as +possible in one go, instead of at most one. Calls to C and +C can be interleaved. + +=item $cbor->incr_reset + +Resets the incremental decoder. This throws away any saved state, so that +subsequent calls to C or C start to parse +a new CBOR value from the beginning of the C<$buffer> again. + +This method can be called at any time, but it I be called if you want +to change your C<$buffer> or there was a decoding error and you want to +reuse the C<$cbor> object for future incremental parsings. + +=back + =head1 MAPPING @@ -373,7 +527,7 @@ Perl hash references become CBOR maps. As there is no inherent ordering in hash keys (or CBOR maps), they will usually be encoded in a pseudo-random -order. This order can be different each time a hahs is encoded. +order. This order can be different each time a hash is encoded. Currently, tied hashes will use the indefinite-length format, while normal hashes will use the fixed-length format. @@ -436,15 +590,16 @@ $x .= ""; # another, more awkward way to stringify print $x; # perl does it for you, too, quite often -You can force whether a string ie encoded as byte or text string by using -C and C): +You can force whether a string is encoded as byte or text string by using +C and C (if C is disabled): utf8::upgrade $x; # encode $x as text string utf8::downgrade $x; # encode $x as byte string Perl doesn't define what operations up- and downgrade strings, so if the difference between byte and text is important, you should up- or downgrade -your string as late as possible before encoding. +your string as late as possible before encoding. You can also force the +use of CBOR text strings by using C or C. You can force the type to be a CBOR number by numifying it: @@ -467,10 +622,16 @@ =head2 OBJECT SERIALISATION +This module implements both a CBOR-specific and the generic +L object serialisation protocol. The following +subsections explain both methods. + +=head3 ENCODING + This module knows two way to serialise a Perl object: The CBOR-specific way, and the generic way. -Whenever the encoder encounters a Perl object that it cnanot serialise +Whenever the encoder encounters a Perl object that it cannot serialise directly (most of them), it will first look up the C method on it. @@ -486,11 +647,18 @@ more). These will be encoded as CBOR perl object, together with the classname. +These methods I change the data structure that is being +serialised. Failure to comply to this can result in memory corruption - +and worse. + If an object supports neither C nor C, encoding will fail with an error. -Objects encoded via C cannot be automatically decoded, but -objects encoded via C can be decoded using the following protocol: +=head3 DECODING + +Objects encoded via C cannot (normally) be automatically decoded, +but objects encoded via C can be decoded using the following +protocol: When an encoded CBOR perl object is encountered by the decoder, it will look up the C method, by using the stored classname, and will fail @@ -500,7 +668,7 @@ as first argument, the constant string C as second argument, and all values returned by C as remaining arguments. -=head4 EXAMPLES +=head3 EXAMPLES Here is an example C method: @@ -542,7 +710,6 @@ sub URI::THAW { my ($class, $serialiser, $uri) = @_; - $class->new ($uri) } @@ -683,7 +850,7 @@ =head2 ENFORCED TAGS These tags are always handled when decoding, and their handling cannot be -overriden by the user. +overridden by the user. =over 4 @@ -693,13 +860,27 @@ objects using the C methods (the L object serialisation protocol). See L for details. -=item 28, 29 (sharable, sharedref, L ) +=item 28, 29 (shareable, sharedref, L) -These tags are automatically decoded when encountered, resulting in +These tags are automatically decoded when encountered (and they do not +result in a cyclic data structure, see C), resulting in shared values in the decoded object. They are only encoded, however, when -C is enabled. +C is enabled. + +Not all shared values can be successfully decoded: values that reference +themselves will I decode as C (this is not the same +as a reference pointing to itself, which will be represented as a value +that contains an indirect reference to itself - these will be decoded +properly). + +Note that considerably more shared value data structures can be decoded +than will be encoded - currently, only values pointed to by references +will be shared, others will not. While non-reference shared values can be +generated in Perl with some effort, they were considered too unimportant +to be supported in the encoder. The decoder, however, will decode these +values as shared values. -=item 256, 25 (stringref-namespace, stringref, L ) +=item 256, 25 (stringref-namespace, stringref, L) These tags are automatically decoded when encountered. They are only encoded, however, when C is enabled. @@ -707,7 +888,7 @@ =item 22098 (indirection, L) This tag is automatically generated when a reference are encountered (with -the exception of hash and array refernces). It is converted to a reference +the exception of hash and array references). It is converted to a reference when decoding. =item 55799 (self-describe CBOR, RFC 7049) @@ -720,7 +901,7 @@ =head2 NON-ENFORCED TAGS These tags have default filters provided when decoding. Their handling can -be overriden by changing the C<%CBOR::XS::FILTER> entry for the tag, or by +be overridden by changing the C<%CBOR::XS::FILTER> entry for the tag, or by providing a custom C callback when decoding. When they result in decoding into a specific Perl class, the module @@ -733,22 +914,40 @@ =over 4 +=item 0, 1 (date/time string, seconds since the epoch) + +These tags are decoded into L objects. The corresponding +C method always encodes into tag 1 values currently. + +The L API is generally surprisingly bad, and fractional +seconds are only accidentally kept intact, so watch out. On the plus side, +the module comes with perl since 5.10, which has to count for something. + =item 2, 3 (positive/negative bignum) These tags are decoded into L objects. The corresponding C method encodes "small" bigints into normal CBOR integers, and others into positive/negative CBOR bignums. -=item 4, 5 (decimal fraction/bigfloat) +=item 4, 5, 264, 265 (decimal fraction/bigfloat) Both decimal fractions and bigfloats are decoded into L objects. The corresponding C method I -encodes into a decimal fraction. +encodes into a decimal fraction (either tag 4 or 264). + +NaN and infinities are not encoded properly, as they cannot be represented +in CBOR. -CBOR cannot represent bigfloats with I large exponents - conversion -of such big float objects is undefined. +See L for more info. -Also, NaN and infinities are not encoded properly. +=item 30 (rational numbers) + +These tags are decoded into L objects. The corresponding +C method encodes rational numbers with denominator +C<1> via their numerator only, i.e., they become normal integers or +C. + +See L for more info. =item 21, 22, 23 (expected later JSON conversion) @@ -764,48 +963,6 @@ =cut -our %FILTER = ( - # 0 # rfc4287 datetime, utf-8 - # 1 # unix timestamp, any - - 2 => sub { # pos bigint - require Math::BigInt; - Math::BigInt->new ("0x" . unpack "H*", pop) - }, - - 3 => sub { # neg bigint - require Math::BigInt; - -Math::BigInt->new ("0x" . unpack "H*", pop) - }, - - 4 => sub { # decimal fraction, array - require Math::BigFloat; - Math::BigFloat->new ($_[1][1] . "E" . $_[1][0]) - }, - - 5 => sub { # bigfloat, array - require Math::BigFloat; - scalar Math::BigFloat->new ($_[1][1])->blsft ($_[1][0], 2) - }, - - 21 => sub { pop }, # expected conversion to base64url encoding - 22 => sub { pop }, # expected conversion to base64 encoding - 23 => sub { pop }, # expected conversion to base16 encoding - - # 24 # embedded cbor, byte string - - 32 => sub { - require URI; - URI->new (pop) - }, - - # 33 # base64url rfc4648, utf-8 - # 34 # base64 rfc46484, utf-8 - # 35 # regex pcre/ecma262, utf-8 - # 36 # mime message rfc2045, utf-8 -); - - =head1 CBOR and JSON CBOR is supposed to implement a superset of the JSON data model, and is, @@ -856,6 +1013,39 @@ information you might want to make sure that exceptions thrown by CBOR::XS will not end up in front of untrusted eyes. + +=head1 BIGNUM SECURITY CONSIDERATIONS + +CBOR::XS provides a C method for both L and +L that tries to encode the number in the simplest possible +way, that is, either a CBOR integer, a CBOR bigint/decimal fraction (tag +4) or an arbitrary-exponent decimal fraction (tag 264). Rational numbers +(L, tag 30) can also contain bignums as members. + +CBOR::XS will also understand base-2 bigfloat or arbitrary-exponent +bigfloats (tags 5 and 265), but it will never generate these on its own. + +Using the built-in L support, encoding and decoding +decimal fractions is generally fast. Decoding bigints can be slow for very +big numbers (tens of thousands of digits, something that could potentially +be caught by limiting the size of CBOR texts), and decoding bigfloats or +arbitrary-exponent bigfloats can be I slow (minutes, decades) +for large exponents (roughly 40 bit and longer). + +Additionally, L can take advantage of other bignum +libraries, such as L, which cannot handle big floats with large +exponents, and might simply abort or crash your program, due to their code +quality. + +This can be a concern if you want to parse untrusted CBOR. If it is, you +might want to disable decoding of tag 2 (bigint) and 3 (negative bigint) +types. You should also disable types 5 and 265, as these can be slow even +without bigints. + +Disabling bigints will also partially or fully disable types that rely on +them, e.g. rational numbers that use bignums. + + =head1 CBOR IMPLEMENTATION NOTES This section contains some random implementation notes. They do not @@ -875,6 +1065,16 @@ Strict mode and canonical mode are not implemented. +=head1 LIMITATIONS ON PERLS WITHOUT 64-BIT INTEGER SUPPORT + +On perls that were built without 64 bit integer support (these are rare +nowadays, even on 32 bit architectures, as all major Perl distributions +are built with 64 bit integer support), support for any kind of 64 bit +integer in CBOR is very limited - most likely, these 64 bit values will +be truncated, corrupted, or otherwise not decoded correctly. This also +includes string, array and map sizes that are stored as 64 bit integers. + + =head1 THREADS This module is I guaranteed to be thread safe and there are no @@ -897,8 +1097,33 @@ =cut our %FILTER = ( - # 0 # rfc4287 datetime, utf-8 - # 1 # unix timestamp, any + 0 => sub { # rfc4287 datetime, utf-8 + require Time::Piece; + # Time::Piece::Strptime uses the "incredibly flexible date parsing routine" + # from FreeBSD, which can't parse ISO 8601, RFC3339, RFC4287 or much of anything + # else either. Whats incredibe over standard strptime totally escapes me. + # doesn't do fractional times, either. sigh. + # In fact, it's all a lie, it uses whatever strptime it wants, and of course, + # they are all incompatible. The openbsd one simply ignores %z (but according to the + # docs, it would be much more incredibly flexible indeed. If it worked, that is.). + scalar eval { + my $s = $_[1]; + + $s =~ s/Z$/+00:00/; + $s =~ s/(\.[0-9]+)?([+-][0-9][0-9]):([0-9][0-9])$// + or die; + + my $b = $1 - ($2 * 60 + $3) * 60; # fractional part + offset. hopefully + my $d = Time::Piece->strptime ($s, "%Y-%m-%dT%H:%M:%S"); + + Time::Piece::gmtime ($d->epoch + $b) + } || die "corrupted CBOR date/time string ($_[0])"; + }, + + 1 => sub { # seconds since the epoch, possibly fractional + require Time::Piece; + scalar Time::Piece::gmtime (pop) + }, 2 => sub { # pos bigint require Math::BigInt; @@ -915,9 +1140,24 @@ Math::BigFloat->new ($_[1][1] . "E" . $_[1][0]) }, + 264 => sub { # decimal fraction with arbitrary exponent + require Math::BigFloat; + Math::BigFloat->new ($_[1][1] . "E" . $_[1][0]) + }, + 5 => sub { # bigfloat, array require Math::BigFloat; - scalar Math::BigFloat->new ($_[1][1])->blsft ($_[1][0], 2) + scalar Math::BigFloat->new ($_[1][1]) * Math::BigFloat->new (2)->bpow ($_[1][0]) + }, + + 265 => sub { # bigfloat with arbitrary exponent + require Math::BigFloat; + scalar Math::BigFloat->new ($_[1][1]) * Math::BigFloat->new (2)->bpow ($_[1][0]) + }, + + 30 => sub { # rational number + require Math::BigRat; + Math::BigRat->new ("$_[1][0]/$_[1][1]") # separate parameters only work in recent versons }, 21 => sub { pop }, # expected conversion to base64url encoding @@ -944,22 +1184,39 @@ sub URI::TO_CBOR { my $uri = $_[0]->as_string; utf8::upgrade $uri; - CBOR::XS::tag 32, $uri + tag 32, $uri } sub Math::BigInt::TO_CBOR { - if ($_[0] >= -2147483648 && $_[0] <= 2147483647) { + if (-2147483648 <= $_[0] && $_[0] <= 2147483647) { $_[0]->numify } else { my $hex = substr $_[0]->as_hex, 2; $hex = "0$hex" if 1 & length $hex; # sigh - CBOR::XS::tag $_[0] >= 0 ? 2 : 3, pack "H*", $hex + tag $_[0] >= 0 ? 2 : 3, pack "H*", $hex } } sub Math::BigFloat::TO_CBOR { my ($m, $e) = $_[0]->parts; - CBOR::XS::tag 4, [$e->numify, $m] + + -9223372036854775808 <= $e && $e <= 18446744073709551615 + ? tag 4, [$e->numify, $m] + : tag 264, [$e, $m] +} + +sub Math::BigRat::TO_CBOR { + my ($n, $d) = $_[0]->parts; + + # older versions of BigRat need *1, as they not always return numbers + + $d*1 == 1 + ? $n*1 + : tag 30, [$n*1, $d*1] +} + +sub Time::Piece::TO_CBOR { + tag 1, 0 + $_[0]->epoch } XSLoader::load "CBOR::XS", $VERSION;