cddlc 0.3.5 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d01061fd86124e6e68aae0a7ef043d23c9a2211992f9421e9333c50d8a870ee
-  data.tar.gz: 7efe567eeca90c756dac4354791583cae6da812b05eaf4074dfb953f71d09adb
+  metadata.gz: 0cf26993bc0f0556758da6e5567849461b1b6e2779c02e7a1bf8be89f3466747
+  data.tar.gz: 6d3a7a675a37815fc23fe4cbbe786698fc996cb6b7bb9cbfec5572bb74d50520
 SHA512:
-  metadata.gz: c051e4c6c4e319e223dc8126512ffe8c7368b985735c8b15b34ac3ae5dad183f7f80f74e3a4b90f1679877472c8c5a0968f38d73994fc4e3dbb8669a39938c09
-  data.tar.gz: 29fce82dbdfd0bf5e14184b8445d3281a648fdd3f1fb982e37020317c23b94100449d21fed9a609a2f041fdc4a035c7842e23f861b5730480f9a828963122fef
+  metadata.gz: cbbbd25e3cbd37740b856de841a844ce644ef5efc9a97e9966714810db7fb3b070821774a7da17a0d8e20c2047c591de0579d16ba5a12bf8b399578275862a21
+  data.tar.gz: 2fb8b0946855f67c1e6a17f13837cf6484bdc69e01e5f353c8815ceb9ca09f1fc42a5ac02c8449d79973ccac7b205b845716c48314668da9f76bbff986a63b16

data/bin/cddlc

@@ -44,7 +44,7 @@ require 'ostruct'
 $options = OpenStruct.new
 begin
   op = OptionParser.new do |opts|
-    opts.banner = "Usage: cddlc.rb [options] [-e cddl | file.cddl... | -]"
+    opts.banner = "Usage: cddlc [options] [-e cddl | file.cddl... | -]"
 
     opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
       $options.verbose = v
@@ -64,7 +64,23 @@ begin
     opts.on("-2", "--[no-]cddl2", "Perform some CDDL 2.0 processing") do |v|
       $options.cddl2 = v
     end
-    opts.on("-tFMT", "--to=FMT", [:basic, :neat, :json, :yaml, :const, :enum, :cddl], "Target format") do |v|
+    opts.on("-c", "--cbor-validate=FILE", "Validate CBOR file against CDDL grammar") do |v|
+      $options.validate = v
+      $options.source_format = :cbor
+    end
+    opts.on("-j", "--json-validate=FILE", "Validate JSON file against CDDL grammar") do |v|
+      $options.validate = v
+      $options.source_format = :json
+    end
+    opts.on("-d", "--diag-validate=FILE", "Validate EDN file against CDDL grammar") do |v|
+      $options.validate = v
+      $options.source_format = :diag
+    end
+    opts.on("--test", "Validate embedded EDN against CDDL grammar") do |v|
+      $options.validate = v
+      $options.source_format = :embedded
+    end
+    opts.on("-tFMT", "--to=FMT", [:basic, :neat, :json, :yaml, :const, :enum, :cddl, :diag, :edn, :cbor], "Target format") do |v|
       $options.target = v
     end
     opts.on("-sRULE", "--start=RULE", String, "Start rule name") do |v|
@@ -73,6 +89,9 @@ begin
     opts.on("-eCDDL", "CDDL model on command line") do |v|
       $options.model = v
     end
+    opts.on("--[no-]prelude", "Add (default)/do not add prelude") do |v|
+      $options.prelude = v
+    end
     opts.on("-iIMPORT", "--import=IMPORT", String, "Import [namespace=]reference") do |v|
       $options.import ||= []
       $options.import << v
@@ -83,11 +102,13 @@ begin
     end
   end
   op.parse!
-rescue Exception => e
+rescue StandardError => e
   warn e
   exit 1
 end
 
+$options.prelude = true if $options.validate # XXX
+
 if ($options.expand_generics || $options.flattening) && !$options.rules
   warn "** can't expand or flatten in tree; adding -r flag"
   $options.rules = true
@@ -131,8 +152,16 @@ else
   cddl_file << ARGF.read
 end
 
+if $options.validate
+  $options.expand_generics = true # for now
+  $options.rules = true
+  # manually select -f/--flattening if desired
+end
 
 cddl = CDDL.from_cddl(cddl_file)
+if $options.prelude
+  cddl.rules.merge! cddl.prelude.rules
+end
 result = if $options.rules
            if $options.expand_generics
              require_relative "../lib/processor/cddl-expander.rb"
@@ -150,6 +179,77 @@ result = if $options.rules
 
 warn "** can't note undefined for target != cddl" if $options.note_undefined && $options.target != :cddl
 
+embedded = $options.source_format == :embedded
+
+def parse_diag(data)
+  require 'cbor-diag-parser'
+  parser = CBOR_DIAGParser.new
+  if result = parser.parse(data)
+    result.to_rb
+  else
+    warn "*** can't parse #{data}"
+    warn "*** #{parser.failure_reason}"
+    exit 1
+  end
+end
+
+if fn = $options.validate
+  require "cbor-pure"
+  require "validator/validate"
+  data = fn == "-" ? STDIN.read : File.binread(fn) unless embedded
+  items = case $options.source_format
+         in :cbor
+           [[CBOR.decode(data), true]]
+         in :json
+           [[JSON.load(data), true]]
+         in :diag                      # XXX move to EDN, take diag2x options
+           [[parse_diag(data), true]]
+         in :embedded
+           input = cddl_file.lines(chomp: true)
+           tests = []
+           input.each do |l|
+             case l
+             when /\A;;([-+:]p?)\s*(.*)\z/
+               disc = $1
+               payload = $2
+               if disc == ':'
+                 if t = tests[-1]
+                   t[1] << payload
+                 else
+                   warn "*** : to what? #{l}"
+                 end
+               else
+                 tests << [disc, [payload]]
+               end
+             end
+           end
+           tests.map {|disc, lines|
+             [parse_diag(lines.join("\n")), disc == "+"]
+           }
+         else
+           fail $options.source_format
+          end
+  items.each do |item, expected|
+    warn [:ITEM, item, expected].inspect if CDDL::CDDLC_DEBUG
+    r = cddl.validate(item)
+    if r[0]
+      # TODO: build annotated output here!
+      warn r.inspect
+      if !expected
+        warn "*** should NOT have validated"
+        exit 1
+      end
+    else
+      puts r.to_yaml
+      if expected
+        warn "*** should have validated" if embedded
+        exit 1
+      end
+    end
+  end
+  exit
+end
+
 case $options.target
 when :basic, nil
   pp result
@@ -189,5 +289,5 @@ when :cddl
   end
   puts cddl.to_s
 else
-  warn ["Unknown target format: ", $options.target].inspect
+  warn ["Unknown target format for CDDL output: ", $options.target].inspect
 end

data/cddlc.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "cddlc"
-  s.version = "0.3.5"
+  s.version = "0.4.1"
   s.summary = "CDDL (Concise Data Definition Language) converters and miscellaneous tools"
   s.description = %q{cddlc implements converters and miscellaneous tools for CDDL, RFC 8610}
   s.author = "Carsten Bormann"

data/data/rfc9360.cddl

@@ -0,0 +1,2 @@
+COSE_X509 = bstr / [ 2*certs: bstr ]
+COSE_CertHash = [ hashAlg: (int / tstr), hashValue: bstr ]

data/data/rfc9431.cddl

@@ -0,0 +1,5 @@
+ AIF-MQTT = AIF-Generic<mqtt-topic-filter, mqtt-permissions>
+ AIF-Generic<Toid, Tperm> = [* [Toid, Tperm]]
+ mqtt-topic-filter = tstr ; as per Section 4.7 of MQTT v5.0
+ mqtt-permissions = [+permission]
+ permission = "pub"/"sub"

data/data/rfc9526.cddl

@@ -0,0 +1,12 @@
+hna-configuration = {
+  "registered_domain" : tstr,
+  "dm"                : tstr,
+  ? "dm_transport" : "DoT"
+  ? "dm_port"        : uint,
+  ? "dm_acl"         : hna-acl / [ +hna-acl ]
+  ? "hna_auth_method": hna-auth-method
+  ? "hna_certificate": tstr
+}
+
+hna-acl          = tstr
+hna-auth-method  /= "certificate"

data/data/rfc9528.cddl

@@ -0,0 +1,59 @@
+suites = [ 2* int ] / int
+
+ead = (
+  ead_label : int,
+  ? ead_value : bstr,
+)
+
+EAD_1 = (1* ead)
+EAD_2 = (1* ead)
+EAD_3 = (1* ead)
+EAD_4 = (1* ead)
+
+message_1 = (
+  METHOD : int,
+  SUITES_I : suites,
+  G_X : bstr,
+  C_I : bstr / -24..23,
+  ? EAD_1,
+)
+
+message_2 = (
+  G_Y_CIPHERTEXT_2 : bstr,
+)
+
+PLAINTEXT_2 = (
+  C_R : bstr / -24..23,
+  ID_CRED_R : header_map / bstr / -24..23,
+  Signature_or_MAC_2 : bstr,
+  ? EAD_2,
+)
+
+message_3 = (
+  CIPHERTEXT_3 : bstr,
+)
+
+PLAINTEXT_3 = (
+  ID_CRED_I : header_map / bstr / -24..23,
+  Signature_or_MAC_3 : bstr,
+  ? EAD_3,
+)
+
+message_4 = (
+  CIPHERTEXT_4 : bstr,
+)
+
+PLAINTEXT_4 = (
+  ? EAD_4,
+)
+
+error = (
+  ERR_CODE : int,
+  ERR_INFO : any,
+)
+
+info = (
+  info_label : int,
+  context : bstr,
+  length : uint,
+)

data/data/rfc9594-error-handling.cddl

@@ -0,0 +1,3 @@
+   ace-groupcomm-error = {
+     &(error-id: 0) => int
+   }

data/data/rfc9594-example-extended-scope-aif.cddl

@@ -0,0 +1,20 @@
+;# include rfc9237
+
+gname = tstr
+
+permissions = uint .bits roles
+
+roles = &(
+   Requester: 1,
+   Responder: 2,
+   Monitor: 3,
+   Verifier: 4
+)
+
+scope_entries = AIF-Generic<gname, permissions>
+
+scope = bstr .cbor scope_entries
+
+extended_scope = #6.<TAG_FOR_THIS_SEMANTICS>(scope)
+
+TAG_FOR_THIS_SEMANTICS = uint

data/data/rfc9594-example-extended-scope-text.cddl

@@ -0,0 +1,13 @@
+gname = tstr
+
+role = tstr
+
+scope_entry = [ gname , ? ( role / [ 2*role ] ) ]
+
+scope_entries = [ * scope_entry ]
+
+scope = bstr .cbor scope_entries
+
+extended_scope = #6.<TAG_FOR_THIS_SEMANTICS>(scope)
+
+TAG_FOR_THIS_SEMANTICS = uint

data/data/rfc9594-example-scope-aif.cddl

@@ -0,0 +1,16 @@
+;# include rfc9237
+
+gname = tstr
+
+permissions = uint .bits roles
+
+roles = &(
+   Requester: 1,
+   Responder: 2,
+   Monitor: 3,
+   Verifier: 4
+)
+
+scope_entries = AIF-Generic<gname, permissions>
+
+scope = bstr .cbor scope_entries

data/data/rfc9594-example-scope-text.cddl

@@ -0,0 +1,9 @@
+gname = tstr
+
+role = tstr
+
+scope_entry = [gname, ? ( role / [2* role] )]
+
+scope_entries = [* scope_entry]
+
+scope = bstr .cbor scope_entries

data/data/rfc9594-get_creds.cddl

@@ -0,0 +1,10 @@
+inclusion_flag = bool
+
+role = tstr
+comb_role = [2* role]
+role_filter = [* ( role / comb_role )]
+
+id = bstr
+id_filter = [* id]
+
+get_creds = null / [inclusion_flag, role_filter, id_filter]

data/data/rfc9594-sign_info-parameter.cddl

@@ -0,0 +1,18 @@
+sign_info = sign_info_req / sign_info_resp
+
+sign_info_req  = null                  ; in the Token Transfer
+                                       ; Request to the KDC
+
+sign_info_resp = [+ sign_info_entry]   ; in the Token Transfer
+                                       ; Response from the KDC
+
+sign_info_entry =
+[
+ id: gname / [+ gname],
+ sign_alg: int / tstr,
+ sign_parameters: [any],
+ sign_key_parameters: [+ parameter: any],
+ cred_fmt: int / null
+]
+
+gname = tstr

data/data/rfc9594-sign_info_entry-with-a-gene.cddl

@@ -0,0 +1,10 @@
+sign_info_entry =
+[
+    id : gname / [+ gname],
+    sign_alg : int / tstr,
+    sign_parameters : [* alg_capab : any],
+  * sign_capab : [* capab : any],
+    cred_fmt : int / null
+]
+
+gname = tstr

data/data/rfc9597.cddl

@@ -0,0 +1,5 @@
+CWT-Claims = {
+ * Claim-Label => any
+}
+
+Claim-Label = int / text

data/lib/validator/validate.rb

@@ -0,0 +1,343 @@
+# requires for CBOR
+
+require 'cbor-pure' unless defined?(CBOR::Tagged)
+require 'half'
+
+# requires for control operators
+require 'cbor-deterministic'
+require 'regexp-examples'
+require 'abnftt'
+require 'base64'
+require 'base32'
+require 'base45_lite'
+require 'scanf'
+
+# Hmm:
+#!/usr/bin/env RUBY_THREAD_VM_STACK_SIZE=5000000 ruby
+
+
+class CDDL
+
+#  DATA_DIR = Pathname.new(__FILE__).split[0] + '../../data'
+#  PRELUDE = File.read("#{DATA_DIR}/prelude.cddl") -> #prelude -- parsed
+
+  MANY = Float::INFINITY
+
+  MAX_RECURSE = 128              # XXX
+
+  CDDLC_INVENT = ENV["CDDLC_INVENT"]
+  CDDLC_DEBUG = ENV["CDDLC_DEBUG"]
+
+  # library:
+
+  def remove_indentation(s)
+    l = s.lines
+    indent = l.grep(/\S/).map {|l| l[/^\s*/].size}.min
+    l.map {|l| l.sub(/^ {0,#{indent}}/, "")}.join
+  end
+
+  # [success, item, info, sublist (a/m/t)]
+  # [true, item, annos, sub-results [kv]]
+  # [false, item, error, sub-results [kv]]
+  # separate bad specs (always fails) from non-matching specs
+
+  def validate(item)
+    @rootrule ||= @rules.keys.first
+    # boxify item
+    validate1(item, ["name", @rootrule])
+  end
+
+  def numval(s)
+    Integer(s) rescue Float(s)
+  end
+
+  def validate1(item, where)
+    pp [:VALIDATE1, item, where].inspect if CDDLC_DEBUG
+    anno = nil
+    case where
+    in ["name", name]
+      # invent or error out if !rules[name]
+      rhs = rules[name]
+      unless rhs
+        if s = CDDLC_INVENT
+          s = "_" if s == ""
+          rules[name] = rhs = ["text", "#{s}-#{name}"]
+        else
+          return [false, item, {undefined: [name]}, []]
+        end
+      end
+      r = validate1(item, rhs)
+      case r
+      in [true, item, _annos, _sub]
+        [true, item, {name: name}, [r]]
+      in [false, item, error, _sub]
+        [false, item, {nomatch: [name, error]}, [r]]
+      else
+        fail [:MALFORMED_R, r, item, rhs].inspect
+      end
+    in ["number", num]
+      val = numval(num)
+      if !(item.eql? val)            # TODO: 0.0 vs. -0.0
+        [false, item, {wrongnumber: [item, val, num]}, []]
+      else
+        [true, item, {}, []]
+      end
+    in ["text", val]
+      if !(item.eql? val)            # check text vs. bytes
+        [false, item, {wrongtext: [item, val]}, []]
+      else
+        [true, item, {}, []]
+      end
+    in ["bytes", val]
+      # XXX Need to fix abnftt to yield correct value
+      if !(item.eql? val)            # check text vs. bytes
+        [false, item, {wrongtext: [item, val]}, []]
+      else
+        [true, item, {}, []]
+      end
+    in ["tcho", *choices]
+      nomatches = []
+      choices.each do |where|
+        r = validate1(item, where)
+        if r[0]
+          pp [:TCHO, item, where, r] if CDDLC_DEBUG
+          return r
+        end
+        nomatches << r
+      end
+      [false, item, nomatches, [r]]
+    in ["prim"]
+      [true, item, {}, []]
+    in ["prim", 0]
+      simple_result(Integer === item && item >= 0 && item <= 0xffffffffffffffff,
+                    item, where, :wrongnumber)
+    in ["prim", 1]
+      simple_result(Integer === item && item < 0 && item >= -0x10000000000000000,
+                    item, where, :wrongnumber)
+    in ["prim", 2]
+      simple_result(String === item && item.encoding == Encoding::BINARY,
+                    item, where, :wrongbytes)
+    in ["prim", 3]
+      simple_result(String === item && item.encoding != Encoding::BINARY, # cheat
+                    item, where, :wrongtext)
+    in ["prim", 6, *wh2]
+      warn [:WH2, wh2].inspect
+      d = if Integer === item
+            biggify(item)
+          else
+            item
+          end
+      # XXX validate tag against headnum if present
+      if CBOR::Tagged === d
+        r0 = if Integer === wh2[0]
+               simple_result(d.tag == wh2[0], d.tag, wh2[0], :wrongtag)
+             else validate1(d.tag, wh2[0])
+             end
+        r1 = validate1(d.data, wh2[1])
+        if r0[0] && r1[0]
+          [true, item, {}, []]  # XXX add diagnosics
+        else
+          [false, item, {wrongtag: [item, where]}, [r0, r1]]
+        end
+      else
+        [false, item, {not_a_tag: [item, where]}, []]
+      end
+    in ["prim", 7, *ai]
+    # t, v = extract_value(where)  --           if t --             v.eql? d -- 
+      headnum = case item
+                when Float
+                  FLOAT_AI_FROM_SIZE[item.to_cbor.size]
+                when CBOR::Simple
+                  item.value
+                when false
+                  20
+                when true
+                  21
+                when nil
+                  22
+                end
+      if Array === ai[0]        # CDDL for head number
+        validate1(headnum, ai[0])
+      else
+        simple_result(
+          ai[0].nil? ||
+          ai[0] == headnum,
+          item, where, :wrong7)
+      end
+    in ["op", op, lhs, rhs]
+      case op
+      in ".." | "..."
+        rex = RANGE_EXCLUDE_END[op]
+        lhss, lhsv, lhst = extract_value(lhs)
+        rhss, rhsv, rhst = extract_value(rhs)
+        if !lhss || !rhss
+          [false, item, {UNSPECIFIC_RANGE: [op, lhs, rhs]}, []]
+        elsif lhst != rhst
+          [false, item, {INCOHERENT_RANGE: [op, lhs, rhs]}, []]
+        else
+          st = scalar_type(item)
+          if lhst != st
+            [false, item, {rangetype: [op, lhs, rhs]}, []]
+          else
+            rg = Range.new(lhsv, rhsv, rex)
+            simple_result(
+              rg.include?(item),
+              item, where, :out_of_range)
+          end
+        end
+      in ".cat" | ".det"
+        lhss, lhsv, lhst = extract_value(lhs)
+        rhss, rhsv, rhst = extract_value(rhs)
+        if !lhss || !rhss
+          [false, item, {UNSPECIFIC_STRING_CAT: [op, lhs, rhs]}, []]
+        elsif [lhsv, rhsv].any? {!(String === _1)}
+          [false, item, {NON_STRING_CAT: [op, lhs, rhs]}, []]
+        else
+          if op == ".det"
+            lhsv = remove_indentation(lhsv)
+            rhsv = remove_indentation(rhsv)
+          end
+          case [lhst, rhst]
+          in [:text, :text] | [:bytes, :bytes]
+            result = lhsv + rhsv
+          in [:bytes, :text]
+            result = (lhsv + rhsv.b).b
+          in [:text, :bytes]
+              result = lhsv + rhsv.force_encoding(Encoding::UTF_8)
+              unless result.valid_encoding?
+                return [false, item, {text_encoding_error: [lhst, lhsv, rhst, rhsv]}, []]
+              end
+          end
+          simple_result(scalar_type(item) == lhst && item == result,
+                        item, where, :no_match)
+        end
+      in ".plus"
+        lhss, lhsv, lhst = extract_value(lhs)
+        rhss, rhsv, rhst = extract_value(rhs)
+        if !lhss || !rhss
+          [false, item, {UNSPECIFIC_PLUS: [op, lhs, rhs]}, []]
+        elsif [lhsv, rhsv].any? {!(Numeric === _1)}
+          [false, item, {NON_NUMERIC_PLUS: [op, lhs, rhs]}, []]
+        else
+          if lhst == :int
+            result = lhsv + Integer(rhsv)
+          elsif lhst == :float
+            result = rbv + rhsv
+          end
+          simple_result(item.eql?(result),
+                        item, where, :no_match)
+        end
+      in ".size"
+        anno = :lhs
+        r = validate1(item, lhs)
+        if r[0]
+          case item
+            when Integer
+              ok, v, vt = extract_value(rhs)
+              if ok && vt == :int
+                simple_result((item >> (8*v)) == 0,
+                              item, where, :toolarge)
+              end
+            when String
+              validate1(item.bytesize, rhs)
+            else
+              false
+          end
+        end
+      in ".bits"
+        r = validate1(item, lhs)
+        if r[0]
+            if String === item
+              simple_result(
+                item.each_byte.with_index.all? { |b, i|
+                  bit = i << 3
+                  8.times.all? { |nb|
+                    b[nb] == 0 || validate1(bit+nb, rhs)[0] # collect
+                  }
+                },
+                item, where, :unwanted_bit_set)
+            elsif Integer === item
+              if item >= 0
+                ok = true
+                i = 0
+                d = item
+                while ok && d > 0
+                  if d.odd?
+                    ok &&= validate1(i, rhs)[0] # collect
+                  end
+                  d >>= 1; i += 1
+                end
+                simple_result(ok,
+                              item, where, :unwanted_bit_set)
+              end
+            end
+        end
+      else
+        fail [:CONTROL_UNIMPLEMENTED, op, item, where].inspect
+      end
+    else
+      warn [:UNIMPLEMENTED, item, where].inspect
+      exit 1
+    end || [false, item, {anno => [item, where]}, []]
+  end
+end
+
+def scalar_type(item)
+  case item
+  in NilClass
+    :null
+  in FalseClass | TrueClass
+    :bool
+  in Integer
+    :int
+  in Float
+    :float
+  in String if item.encoding == Encoding::BINARY
+    :bytes
+  in String
+    :text
+  else
+    nil
+  end
+end
+
+FLOAT_AI_FROM_SIZE = {3 => 25, 5 => 26, 9 => 27}
+SIMPLE_VALUE = {
+  [:prim, 7, 20] => [true, false, :bool],
+  [:prim, 7, 21] => [true, true, :bool],
+  [:prim, 7, 22] => [true, nil, :nil],
+}
+SIMPLE_VALUE_SIMPLE = Set[23] + (0..19) + (32..255)
+RANGE_EXCLUDE_END = {".." => false, "..." => true}
+
+def simple_result(check, item, where, anno)
+  if check
+    [true, item, {}, []]
+  else
+    [false, item, {anno => [item, where]}, []]
+  end
+end
+
+def biggify(d)                  # stand-in for real stand-ins
+  t = 2               # assuming only 2/3 match an Integer
+  if d < 0
+    d = ~d
+    t = 3
+  end
+  CBOR::Tagged.new(t, d == 0 ? "".b : d.digits(256).reverse!.pack("C*"))
+end
+
+def extract_value(wh)           # XXX complete: .cat/plus/det
+  case wh
+  in x if a = SIMPLE_VALUE[x]
+    SIMPLE_VALUE[x]
+  in ["number", num]
+    [true, Integer(num), :int] rescue [true, Float(num), :float]
+  in ["text", val]
+    [true, val, :text]
+  in ["bytes", val]             # TODO
+    [true, val, :bytes]
+  else
+    [false]
+  end
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: cddlc
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.4.1
 platform: ruby
 authors:
 - Carsten Bormann
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-09 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -83,12 +82,25 @@ files:
 - data/rfc9290.cddl
 - data/rfc9321.cddl
 - data/rfc9338.cddl
+- data/rfc9360.cddl
 - data/rfc9393-concise-swid-tag.cddl
 - data/rfc9393-sign.cddl
 - data/rfc9393-sign1.cddl
 - data/rfc9393-tags.cddl
 - data/rfc9393.cddl
+- data/rfc9431.cddl
+- data/rfc9526.cddl
+- data/rfc9528.cddl
 - data/rfc9581.cddl
+- data/rfc9594-error-handling.cddl
+- data/rfc9594-example-extended-scope-aif.cddl
+- data/rfc9594-example-extended-scope-text.cddl
+- data/rfc9594-example-scope-aif.cddl
+- data/rfc9594-example-scope-text.cddl
+- data/rfc9594-get_creds.cddl
+- data/rfc9594-sign_info-parameter.cddl
+- data/rfc9594-sign_info_entry-with-a-gene.cddl
+- data/rfc9597.cddl
 - lib/cddlc.rb
 - lib/parser/cddl-util.rb
 - lib/parser/cddlgrammar.rb
@@ -97,12 +109,12 @@ files:
 - lib/processor/cddl-flattening.rb
 - lib/processor/cddl-undefined.rb
 - lib/processor/cddl-visitor.rb
+- lib/validator/validate.rb
 - lib/writer/cddl-writer.rb
 homepage: http://github.com/cabo/cddlc
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -117,8 +129,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.14
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: CDDL (Concise Data Definition Language) converters and miscellaneous tools
 test_files: []