feat: add a Valid method to check a CMW

Also:
* add validation logic for monads
* fix validation logic for collections

This change also deprecates ValidateCollection.

Signed-off-by: Yogesh Deshpande <[email protected]>
Signed-off-by: Thomas Fossati <[email protected]>

Author: yogeshbdeshpande

cmw.go

@@ -153,13 +153,30 @@ func (o CMW) GetCollectionItem(key any) (*CMW, error) {
 	return o.collection.getItem(key)
 }
 
+// ValidateCollection checks whether a CMW collection is valid or not
+//
+// Deprecated: use Valid instead
 func (o CMW) ValidateCollection() error {
 	if o.kind != KindCollection {
 		return fmt.Errorf("want collection, got %q", o.kind)
 	}
 	return o.collection.validate()
 }
 
+// Valid checks whether a CMW is valid.
+// It works for both monad and collection kinds and recursively validates nested structures.
+// It returns nil if the CMW is valid, or an error describing the validation failure.
+func (o CMW) Valid() error {
+	switch o.kind {
+	case KindMonad:
+		return o.monad.validate()
+	case KindCollection:
+		return o.collection.validate()
+	default:
+		return fmt.Errorf("unknown kind: %s", o.kind.String())
+	}
+}
+
 type Meta struct {
 	Key  any
 	Kind Kind

cmw_test.go

@@ -180,3 +180,19 @@ func Test_GetCollectionGet(t *testing.T) {
 	assert.EqualError(t, err, `item not found for key "uh?"`)
 	assert.Nil(t, itemNotFound)
 }
+
+func Test_Valid(t *testing.T) {
+	typ := "text/plain; charset=utf-8"
+	val := []byte{0xff}
+	ind := Indicator(Evidence)
+
+	cmw, err := NewMonad(typ, val, ind)
+	require.NoError(t, err)
+	err = cmw.Valid()
+	require.NoError(t, err)
+
+	cmw = makeCMWCollection()
+	require.NoError(t, err)
+	err = cmw.Valid()
+	require.NoError(t, err)
+}

collection.go

@@ -30,8 +30,17 @@ func (o collection) validate() error {
 	}
 
 	for k, v := range o.cmap {
-		if err := v.validate(); err != nil {
-			return fmt.Errorf("invalid collection at key %q: %w", k, err)
+		switch v.kind {
+		case KindMonad:
+			if err := v.monad.validate(); err != nil {
+				return fmt.Errorf("invalid monad at key %q: %w", k, err)
+			}
+		case KindCollection:
+			if err := v.collection.validate(); err != nil {
+				return fmt.Errorf("invalid collection at key %q: %w", k, err)
+			}
+		default:
+			return fmt.Errorf("unknown CMW kind at key %q: %s", k, v.kind.String())
 		}
 	}
 

collection_test.go

@@ -79,7 +79,7 @@ func Test_Collection_JSON_Deserialize_fail_inner(t *testing.T) {
 	var actual CMW
 	err := actual.UnmarshalJSON(tv)
 	require.NoError(t, err)
-	err = actual.ValidateCollection()
+	err = actual.Valid()
 	assert.EqualError(t, err, `invalid collection at key "a": empty CMW collection`)
 }
 

example_test.go

@@ -147,7 +147,10 @@ func Example_roundtrip_JSON_collection() {
 	if err != nil {
 		log.Fatalf("unmarshal JSON collection failed: %v", err)
 	}
-
+	err = o.Valid()
+	if err != nil {
+		log.Fatalf("validate JSON collection failed: %v", err)
+	}
 	b, err := o.MarshalJSON()
 	if err != nil {
 		log.Fatalf("marshal collection to JSON failed: %v", err)

indicator.go

@@ -18,6 +18,7 @@ const (
 	AttestationResults
 	TrustAnchors
 )
+const MaxIndicatorValue = (TrustAnchors << 1) - 1
 
 const IndicatorNone = 0
 

monad.go

@@ -2,6 +2,7 @@ package cmw
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 
 	"github.com/fxamacker/cbor/v2"
@@ -62,6 +63,31 @@ func (o *monad) UnmarshalCBOR(b []byte) error {
 	return nil
 }
 
+// validate validates the monad according to draft-ietf-rats-msg-wrap-23 Section 3.1
+func (o monad) validate() error {
+	// Type field MUST be set (either media-type string or CoAP Content-Format ID)
+	if !o.typ.IsSet() {
+		return errors.New("type not set")
+	}
+
+	// Value field MUST be set and non-empty
+	// base64url-encoding for JSON already checked during unmarshaling
+	if !o.val.IsSet() {
+		return errors.New("value not set")
+	}
+
+	// - MUST be non-zero if present (this is already checked during unmarshaling)
+	// - Any combination between 1 and 2^32-1 is allowed
+	// - However, only bits 0-4 are currently registered (values 1-31)
+	if !o.ind.Empty() {
+		if uint(o.ind) > MaxIndicatorValue {
+			return fmt.Errorf("indicator value %d exceeds maximum %d", uint(o.ind), MaxIndicatorValue)
+		}
+	}
+
+	return nil
+}
+
 func (o monad) encodeCBORTag() ([]byte, error) {
 	var (
 		tag cbor.RawTag
@@ -143,6 +169,9 @@ func recordDecode[V json.RawMessage | cbor.RawMessage](
 		if err := dec(a[2], &o.ind); err != nil {
 			return fmt.Errorf("unmarshaling indicator: %w", err)
 		}
+		if o.ind == 0 {
+			return errors.New("indicator field, if present, MUST be non-zero")
+		}
 	}
 
 	return nil

monad_test.go

@@ -18,55 +18,53 @@ func Test_Deserialize_monad_ok(t *testing.T) {
 		tv   []byte
 		exp  monad
 	}{
-		/*
-			{
-				"JSON array with media type string",
-				[]byte(`["application/vnd.intel.sgx", "3q2-7w"]`),
-				monad{
-					typ:    Type{"application/vnd.intel.sgx"},
-					val:    []byte{0xde, 0xad, 0xbe, 0xef},
-					ind:    IndicatorNone,
-					format: FormatJSONRecord,
-				},
+		{
+			"JSON array with media type string",
+			[]byte(`["application/vnd.intel.sgx", "3q2-7w"]`),
+			monad{
+				typ:    Type{"application/vnd.intel.sgx"},
+				val:    []byte{0xde, 0xad, 0xbe, 0xef},
+				ind:    IndicatorNone,
+				format: FormatJSONRecord,
 			},
-			{
-				"JSON array with media type string and indicator",
-				[]byte(`["application/vnd.intel.sgx", "3q2-7w", 31]`),
-				monad{
-					Type{"application/vnd.intel.sgx"},
-					[]byte{0xde, 0xad, 0xbe, 0xef},
-					testIndicator,
-					FormatJSONRecord,
-				},
+		},
+		{
+			"JSON array with media type string and indicator",
+			[]byte(`["application/vnd.intel.sgx", "3q2-7w", 31]`),
+			monad{
+				Type{"application/vnd.intel.sgx"},
+				[]byte{0xde, 0xad, 0xbe, 0xef},
+				testIndicator,
+				FormatJSONRecord,
+			},
+		},
+		{
+			"CBOR array with CoAP C-F",
+			// echo "[30001, h'deadbeef']" | diag2cbor.rb | xxd -p -i
+			[]byte{0x82, 0x19, 0x75, 0x31, 0x44, 0xde, 0xad, 0xbe, 0xef},
+			monad{
+				Type{uint16(30001)},
+				[]byte{0xde, 0xad, 0xbe, 0xef},
+				IndicatorNone,
+				FormatCBORRecord,
 			},
-			{
-				"CBOR array with CoAP C-F",
-				// echo "[30001, h'deadbeef']" | diag2cbor.rb | xxd -p -i
-				[]byte{0x82, 0x19, 0x75, 0x31, 0x44, 0xde, 0xad, 0xbe, 0xef},
-				monad{
-					Type{uint16(30001)},
-					[]byte{0xde, 0xad, 0xbe, 0xef},
-					IndicatorNone,
-					FormatCBORRecord,
-				},
+		},
+		{
+			"CBOR array with media type string",
+			// echo "[\"application/vnd.intel.sgx\", h'deadbeef']" | diag2cbor.rb | xxd -p -i
+			[]byte{
+				0x82, 0x78, 0x19, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61,
+				0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x76, 0x6e, 0x64, 0x2e, 0x69,
+				0x6e, 0x74, 0x65, 0x6c, 0x2e, 0x73, 0x67, 0x78, 0x44, 0xde,
+				0xad, 0xbe, 0xef,
 			},
-			{
-				"CBOR array with media type string",
-				// echo "[\"application/vnd.intel.sgx\", h'deadbeef']" | diag2cbor.rb | xxd -p -i
-				[]byte{
-					0x82, 0x78, 0x19, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61,
-					0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x76, 0x6e, 0x64, 0x2e, 0x69,
-					0x6e, 0x74, 0x65, 0x6c, 0x2e, 0x73, 0x67, 0x78, 0x44, 0xde,
-					0xad, 0xbe, 0xef,
-				},
-				monad{
-					Type{string("application/vnd.intel.sgx")},
-					[]byte{0xde, 0xad, 0xbe, 0xef},
-					IndicatorNone,
-					FormatCBORRecord,
-				},
+			monad{
+				Type{string("application/vnd.intel.sgx")},
+				[]byte{0xde, 0xad, 0xbe, 0xef},
+				IndicatorNone,
+				FormatCBORRecord,
 			},
-		*/
+		},
 		{
 			"CBOR tag",
 			// echo "1668576818(h'deadbeef')" | diag2cbor.rb | xxd -p -i
@@ -88,7 +86,8 @@ func Test_Deserialize_monad_ok(t *testing.T) {
 
 			err := actual.Deserialize(tt.tv)
 			assert.NoError(t, err)
-
+			err = actual.monad.validate()
+			assert.NoError(t, err)
 			assert.Equal(t, KindMonad, actual.GetKind())
 			assert.Equal(t, tt.exp.format, actual.GetFormat())
 			assert.Equal(t, tt.exp, actual.monad)
@@ -464,3 +463,102 @@ func Test_NewMonad_fail_bad_type(t *testing.T) {
 	_, err := NewMonad(0xffffffff, []byte{0x00})
 	assert.EqualError(t, err, `unsupported type int for CMW type`)
 }
+func Test_Validate_monad_ok(t *testing.T) {
+	tests := []struct {
+		name string
+		typ  any
+		val  []byte
+		ind  []Indicator
+	}{
+		{
+			"minimal with string type",
+			"application/vnd.intel.sgx",
+			[]byte{0xde, 0xad, 0xbe, 0xef},
+			[]Indicator{},
+		},
+		{
+			"minimal with CoAP Content-Format",
+			uint16(30001),
+			[]byte{0xde, 0xad, 0xbe, 0xef},
+			[]Indicator{},
+		},
+		{
+			"with single indicator",
+			"application/eat+cwt",
+			[]byte{0xde, 0xad, 0xbe, 0xef},
+			[]Indicator{AttestationResults},
+		},
+		{
+			"with multiple indicators",
+			"application/corim+signed",
+			[]byte{0xde, 0xad, 0xbe, 0xef},
+			[]Indicator{ReferenceValues, Endorsements, TrustAnchors},
+		},
+		{
+			"with maximum valid indicator value (31)",
+			"application/evidence",
+			[]byte{0xff},
+			[]Indicator{Indicator(31)},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cmw, err := NewMonad(tt.typ, tt.val, tt.ind...)
+			require.NoError(t, err)
+
+			err = cmw.monad.validate()
+			assert.NoError(t, err)
+		})
+	}
+}
+
+func Test_Validate_monad_fails(t *testing.T) {
+	tests := []struct {
+		name        string
+		tv          *monad
+		expectedErr string
+	}{
+		{
+			"type not set",
+			&monad{
+				val: []byte{0xde, 0xad, 0xbe, 0xef},
+				ind: IndicatorNone,
+			},
+			"type not set",
+		},
+		{
+			"value not set",
+			&monad{
+				typ: Type{"application/evidence"},
+				ind: IndicatorNone,
+			},
+			"value not set",
+		},
+		{
+			"indicator exceeds maximum (32)",
+			&monad{
+				typ: Type{"application/evidence"},
+				val: []byte{0xde, 0xad, 0xbe, 0xef},
+				ind: Indicator(32),
+			},
+			"indicator value 32 exceeds maximum 31",
+		},
+		{
+			"indicator exceeds maximum (255)",
+			&monad{
+				typ: Type{"application/evidence"},
+				val: []byte{0xde, 0xad, 0xbe, 0xef},
+				ind: Indicator(255),
+			},
+			"indicator value 255 exceeds maximum 31",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.tv.validate()
+			assert.EqualError(t, err, tt.expectedErr)
+		})
+	}
+}