cddl 0.10.2 → 0.10.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33adef2ddb191ca70e7ad3742684cea679e675fe0169a139c9fa5bcc59abfaa6
-  data.tar.gz: 7b7b7d2cd0623645d6dca87c5c7a8a3d40540e7eec390411e9cbf3adcc6f7c9d
+  metadata.gz: 9e60b48882767d7e76926473b44c79369891e4203326d4e31f5693a3819f391d
+  data.tar.gz: 6ed2f45e7fa8468557e73c96a4dbfdd142d65fdebeeb362efeebec8007b7948f
 SHA512:
-  metadata.gz: b4a8ccd11e9dbf1b0ebf2541c03691a94a8430538fbe81db3bd178a2fab1732626114689d305048e88fb54c3336f0e95853c86f8336586d722df90639f82efa6
-  data.tar.gz: 1c6494a0fa4ead8ea548f61f3af5595dde99707359ce8aa8695c074288248334849f2452cae52620541bb762c9cf3979b159f415a1b787009d1061df54d849b5
+  metadata.gz: 2124a4fc046c3dc03d007ca949e4f9191497b359fe19fafe307ed2227c4b5654d909815575504e452add310dfc8487bfc13db94794d4b6c06a7af0bb2701e55f
+  data.tar.gz: 8a223332d81282eb9ad651dad887579ceb7b44a01d05ccff6458e271ea999a3c5fad5f81c87a6a2ccf927307b3bb9c4e06075361b0f8fc8b02005926a3d9a5b7

data/cddl.gemspec

@@ -1,6 +1,6 @@
 spec = Gem::Specification.new do |s|
   s.name = 'cddl'
-  s.version = '0.10.2'
+  s.version = '0.10.3'
   s.summary = "CDDL generator and validator."
   s.description = %{A parser, generator, and validator for CDDL}
   s.add_dependency('cbor-diag')

data/lib/base45_lite.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2022 Weihang Jian <https://tonytonyjan.net>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# An implementation of draft-faltstrom-base45-10, see
+# https://datatracker.ietf.org/doc/draft-faltstrom-base45/
+module Base45Lite
+  class Error < ::StandardError; end
+  class OverflowError < Error; end
+  class InvalidCharacterError < Error; end
+  class ForbiddenLengthError < Error; end
+
+  MAX_UINT18 = 2**16 - 1
+  SQUARED_45 = 45**2
+  MAPPING = [
+    *'0'..'9',
+    *'A'..'Z',
+    ' ', '$', '%', '*', '+', '-', '.', '/', ':'
+  ].map!.with_index { |x, i| [i, x] }.to_h.freeze
+  REVERSE_MAPPING = MAPPING.invert.freeze
+
+  def self.encode(input)
+    sequence = []
+    input.unpack('n*').map! do |uint16|
+      i, c = uint16.divmod(45)
+      i, d = i.divmod(45)
+      _, e = i.divmod(45)
+      sequence.push(c, d, e)
+    end
+    if input.bytesize.odd?
+      i, c = input.getbyte(-1).divmod(45)
+      _, d = i.divmod(45)
+      sequence.push(c, d)
+    end
+    sequence.map!{ |n| MAPPING[n] }.join
+  end
+
+  def self.decode(input)
+    input
+      .chars.map! { |c| REVERSE_MAPPING[c] || raise(InvalidCharacterError) }
+      .each_slice(3).map do |slice|
+        c, d, e = slice
+        raise ForbiddenLengthError if d.nil?
+
+        sum = c + d * 45
+        sum += e * SQUARED_45 if e
+        raise OverflowError if sum > MAX_UINT18
+
+        sum
+      end
+      .pack((input.length % 3).zero? ? 'n*' : "n#{input.length / 3}C")
+  end
+end

data/lib/cddl.rb

@@ -2,11 +2,13 @@ require 'abnc'
 require 'pp'
 require 'pathname'
 require 'cbor-pure' unless defined?(CBOR::Tagged)
+require 'cbor-deterministic'
 require 'regexp-examples'
 require 'abnftt'
 require 'colorize'
 require 'base64'
 require 'base32'
+require 'base45_lite'
 
 module CDDL
 
@@ -267,6 +269,21 @@ module CDDL
       l.map {|l| l.sub(/^ {0,#{indent}}/, "")}.join
     end
 
+    def unpack_array_to_sequence(content, where)
+      # remove the first head
+      n = case content.getbyte(0) - (4 << 5)
+          when 0..23; 1
+          when 24; 2
+          when 25; 3
+          when 26; 5
+          when 27; 9      # unlikely :-)
+          else fail ".cborseq sequence for #{where} not an array"
+          end
+      content[0...n] = ''
+      content
+    end
+
+
     # Memoize a bit here
 
     REGEXP_FOR_STRING = Hash.new {|h, k|
@@ -561,22 +578,18 @@ module CDDL
           end
           enc = bytes ? Encoding::BINARY : Encoding::UTF_8
           out.force_encoding(enc)
-        when :cbor, :cborseq
+        when :cbor, :cborseq, :cbordet, :cborseqdet
           unless target == [:prim, 2]
             fail "Don't know yet how to generate #{where}"
           end
-          content = CBOR::encode(generate1(control))
-          if conop == :cborseq
+          input = generate1(control)
+          if conop == :cbordet || conop == :cborseqdet
+            input = input.cbor_prepare_deterministic
+          end
+          content = CBOR::encode(input)
+          if conop == :cborseq || conop == :cborseqdet
             # remove the first head
-            n = case content.getbyte(0) - (4 << 5)
-                when 0..23; 1
-                when 24; 2
-                when 25; 3
-                when 26; 5
-                when 27; 9      # unlikely :-)
-                else fail "Generated .cborseq sequence for #{where} not an array"
-                end
-            content[0...n] = ''
+            content = unpack_array_to_sequence(content, where)
           end
           content
         when :json
@@ -601,16 +614,19 @@ module CDDL
           end
           content = content.join
           content
-        when :b64u, :b64c, :b32, :h32, :hex, :hexlc, :hexuc
+        when :b64u, :"b64u-sloppy", :b64c, :"b64c-sloppy",
+             :b45, :b32, :h32, :hex, :hexlc, :hexuc
           content = generate1(control)
           unless String === content
             fail "Don't know yet how to generate #{where}"
           end
           content = case conop
-                    when :b64u
+                    when :b64u, :"b64u-sloppy"
                       Base64.urlsafe_encode64(content, padding: false)
-                    when :b64c
+                    when :b64c, :"b64c-sloppy"
                       Base64.strict_encode64(content)
+                    when :b45
+                      Base45Lite.encode(content)
                     when :b32
                       Base32.table = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
                       Base32.encode(content).gsub("=", "")
@@ -1040,6 +1056,22 @@ module CDDL
             ann if validate1((CBOR::decode(d) rescue :BAD_CBOR), control)
           when :cborseq
             ann if validate1((CBOR::decode("\x9f".b << d << "\xff".b) rescue :BAD_CBOR), control)
+          when :cbordet
+            decoded = CBOR::decode(d) rescue :BAD_CBOR
+            if d != decoded.to_deterministic_cbor
+              @last_message = "CBOR #{d.inspect} not deterministically encoded"
+              nil
+            else
+              ann if validate1(decoded, control)
+            end
+          when :cborseqdet
+            decoded = CBOR::decode("\x9f".b << d << "\xff".b) rescue :BAD_CBOR
+            if d != unpack_array_to_sequence(decoded.to_deterministic_cbor, d.inspect)
+              @last_message = "CBOR Sequence #{d.inspect} not deterministically encoded"
+              nil
+            else
+              ann if validate1(decoded, control)
+            end
           when :json
             ann if validate1((JSON::load(d) rescue :BAD_JSON), control)
           when :decimal
@@ -1060,19 +1092,26 @@ module CDDL
             else
               fail "Don't know yet how to validate against #{where}"
             end
-          when :b64u, :b64c, :b32, :h32, :hex, :hexlc, :hexuc
+          when :b64u, :"b64u-sloppy", :b64c, :"b64c-sloppy", :b45, :b32, :h32, :hex, :hexlc, :hexuc
             ann if (
                 String === d && (
                 decoded = case conop
                     when :b64u
                       /=/ !~ d &&
                       Base64.urlsafe_decode64(d)
+                    when :"b64u-sloppy"
+                      /[-_=]/ !~ d &&
+                      Base64.decode64(d.tr("+/", "-_"))
                     when :b64c
                       Base64.strict_decode64(d)
+                    when :"b64c-sloppy"
+                      Base64.decode64(d)
                     when :b32
                       /=/ !~ d &&
                         (Base32.table = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567") &&
                         Base32.decode(d)
+                    when :b45
+                      Base45Lite.decode(d)
                     when :h32
                       /=/ !~ d &&
                         (Base32.table = "0123456789ABCDEFGHIJKLMNOPQRSTUV") &&
@@ -1441,11 +1480,14 @@ module CDDL
 
     BRACE = {"{" => :map, "[" => :array}
     RANGE_EXCLUDE_END = {".." => false, "..." => true}
-    SUPPORTED_ANNOTATIONS = [:bits, :size, :regexp, :cbor, :cborseq, :within, :and,
+    SUPPORTED_ANNOTATIONS = [:bits, :size, :regexp,
+                             :cbor, :cborseq, :cbordet, :cborseqdet,
+                             :within, :and,
                              :default, :lt, :le, :gt, :ge, :eq, :ne,
                              :feature, :abnf, :abnfb, :det, :cat, :plus,
                              :json, :decimal, :join,
-                             :b64u, :b64c, :b32, :h32, :hex, :hexlc, :hexuc,
+                             :b64u, :"b64u-sloppy", :b64c, :"b64c-sloppy",
+                             :b45, :b32, :h32, :hex, :hexlc, :hexuc,
                             ]
 
     def type1(n, canbegroup = false)

data/test-data/b64c-sloppy.cddl

@@ -0,0 +1 @@
+a = text .b64c-sloppy 'mnoabcdue=='

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cddl
 version: !ruby/object:Gem::Version
-  version: 0.10.2
+  version: 0.10.3
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-25 00:00:00.000000000 Z
+date: 2023-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cbor-diag
@@ -119,6 +119,7 @@ files:
 - cddl.gemspec
 - data/cddl.abnf
 - data/prelude.cddl
+- lib/base45_lite.rb
 - lib/cbor-pp-play.rb
 - lib/cbor-pp.rb
 - lib/cddl.rb
@@ -133,6 +134,7 @@ files:
 - test-data/abnf3.cddl
 - test-data/ambig.cddl
 - test-data/b.cddl
+- test-data/b64c-sloppy.cddl
 - test-data/b64c.cddl
 - test-data/b64u.cddl
 - test-data/badaddr.cddl
@@ -245,7 +247,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.2
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: CDDL generator and validator.