Cleanup of remaing extension hashing

extension hashing is now accurate across the v2 and v3 low level models.

datamodel/low/v2/items.go

@@ -10,6 +10,7 @@ import (
 	"github.com/pb33f/libopenapi/index"
 	"github.com/pb33f/libopenapi/utils"
 	"gopkg.in/yaml.v3"
+	"sort"
 	"strings"
 )
 
@@ -72,17 +73,26 @@ func (i *Items) Hash() [32]byte {
 	if i.Pattern.Value != "" {
 		f = append(f, fmt.Sprintf("%x", sha256.Sum256([]byte(fmt.Sprint(i.Pattern.Value)))))
 	}
-	if len(i.Enum.Value) > 0 {
+	keys := make([]string, len(i.Enum.Value))
+	z := 0
 	for k := range i.Enum.Value {
-			f = append(f, fmt.Sprint(i.Enum.Value[k].Value))
+		keys[z] = fmt.Sprint(i.Enum.Value[k].Value)
-		}
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
+
 	if i.Items.Value != nil {
-		f = append(f, fmt.Sprintf("%x", i.Items.Value.Hash()))
+		f = append(f, low.GenerateHashString(i.Items.Value))
 	}
+	keys = make([]string, len(i.Extensions))
+	z = 0
 	for k := range i.Extensions {
-		f = append(f, fmt.Sprintf("%s-%v", k.Value, i.Extensions[k].Value))
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(i.Extensions[k].Value))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }
 

datamodel/low/v2/parameter.go

@@ -11,6 +11,7 @@ import (
 	"github.com/pb33f/libopenapi/index"
 	"github.com/pb33f/libopenapi/utils"
 	"gopkg.in/yaml.v3"
+	"sort"
 	"strings"
 )
 
@@ -169,14 +170,24 @@ func (p *Parameter) Hash() [32]byte {
 	if p.Pattern.Value != "" {
 		f = append(f, fmt.Sprintf("%x", sha256.Sum256([]byte(fmt.Sprint(p.Pattern.Value)))))
 	}
-	if len(p.Enum.Value) > 0 {
+
+	keys := make([]string, len(p.Enum.Value))
+	z := 0
 	for k := range p.Enum.Value {
-			f = append(f, fmt.Sprint(p.Enum.Value[k].Value))
+		keys[z] = fmt.Sprint(p.Enum.Value[k].Value)
-		}
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
+
+	keys = make([]string, len(p.Extensions))
+	z = 0
 	for k := range p.Extensions {
-		f = append(f, fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(p.Extensions[k].Value)))))
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(p.Extensions[k].Value))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
 	if p.Items.Value != nil {
 		f = append(f, fmt.Sprintf("%x", p.Items.Value.Hash()))
 	}

datamodel/low/v2/path_item.go

@@ -213,9 +213,13 @@ func (p *PathItem) Hash() [32]byte {
 	}
 	sort.Strings(keys)
 	f = append(f, keys...)
+	keys = make([]string, len(p.Extensions))
+	z := 0
 	for k := range p.Extensions {
-		f = append(f, fmt.Sprintf("%s-%x", k.Value,
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(p.Extensions[k].Value))))
-			sha256.Sum256([]byte(fmt.Sprint(p.Extensions[k].Value)))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }

datamodel/low/v2/paths.go

@@ -125,9 +125,13 @@ func (p *Paths) Hash() [32]byte {
 	for k := range l {
 		f = append(f, low.GenerateHashString(keys[l[k]].Value))
 	}
+	ekeys := make([]string, len(p.Extensions))
+	z = 0
 	for k := range p.Extensions {
-		f = append(f, fmt.Sprintf("%s-%x", k.Value,
+		ekeys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(p.Extensions[k].Value))))
-			sha256.Sum256([]byte(fmt.Sprint(p.Extensions[k].Value)))))
+		z++
 	}
+	sort.Strings(ekeys)
+	f = append(f, ekeys...)
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }

datamodel/low/v2/response.go

@@ -10,6 +10,7 @@ import (
 	"github.com/pb33f/libopenapi/datamodel/low/base"
 	"github.com/pb33f/libopenapi/index"
 	"gopkg.in/yaml.v3"
+	"sort"
 	"strings"
 )
 
@@ -82,9 +83,13 @@ func (r *Response) Hash() [32]byte {
 			f = append(f, low.GenerateHashString(r.Examples.Value.Values[k].Value))
 		}
 	}
+	keys := make([]string, len(r.Extensions))
+	z := 0
 	for k := range r.Extensions {
-		f = append(f, fmt.Sprintf("%s-%x", k.Value,
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(r.Extensions[k].Value))))
-			sha256.Sum256([]byte(fmt.Sprint(r.Extensions[k].Value)))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }

datamodel/low/v2/responses.go

@@ -101,9 +101,13 @@ func (r *Responses) Hash() [32]byte {
 	if !r.Default.IsEmpty() {
 		f = append(f, low.GenerateHashString(r.Default.Value))
 	}
+	keys = make([]string, len(r.Extensions))
+	z = 0
 	for k := range r.Extensions {
-		f = append(f, fmt.Sprintf("%s-%x", k.Value,
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(r.Extensions[k].Value))))
-			sha256.Sum256([]byte(fmt.Sprint(r.Extensions[k].Value)))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }

datamodel/low/v2/scopes.go

@@ -67,8 +67,13 @@ func (s *Scopes) Hash() [32]byte {
 	for k := range keys {
 		f = append(f, fmt.Sprintf("%s-%s", keys[k], vals[keys[k]].Value))
 	}
+	keys = make([]string, len(s.Extensions))
+	z = 0
 	for k := range s.Extensions {
-		f = append(f, fmt.Sprintf("%s-%v", k.Value, s.Extensions[k].Value))
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(s.Extensions[k].Value))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }

datamodel/low/v2/security_scheme.go

@@ -9,6 +9,7 @@ import (
 	"github.com/pb33f/libopenapi/datamodel/low"
 	"github.com/pb33f/libopenapi/index"
 	"gopkg.in/yaml.v3"
+	"sort"
 	"strings"
 )
 
@@ -69,8 +70,13 @@ func (ss *SecurityScheme) Hash() [32]byte {
 	if !ss.Scopes.IsEmpty() {
 		f = append(f, low.GenerateHashString(ss.Scopes.Value))
 	}
+	keys := make([]string, len(ss.Extensions))
+	z := 0
 	for k := range ss.Extensions {
-		f = append(f, fmt.Sprintf("%s-%v", k.Value, ss.Extensions[k].Value))
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(ss.Extensions[k].Value))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }

datamodel/low/v3/callback.go

@@ -5,6 +5,7 @@ package v3
 
 import (
 	"crypto/sha256"
+	"fmt"
 	"github.com/pb33f/libopenapi/datamodel/low"
 	"github.com/pb33f/libopenapi/index"
 	"gopkg.in/yaml.v3"
@@ -75,5 +76,15 @@ func (cb *Callback) Hash() [32]byte {
 	}
 	sort.Strings(keys)
 	f = append(f, keys...)
+
+	keys = make([]string, len(cb.Extensions))
+	z = 0
+	for k := range cb.Extensions {
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(cb.Extensions[k].Value))))
+		z++
+	}
+	sort.Strings(keys)
+	f = append(f, keys...)
+
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }

datamodel/low/v3/header.go

@@ -11,6 +11,7 @@ import (
 	"github.com/pb33f/libopenapi/index"
 	"github.com/pb33f/libopenapi/utils"
 	"gopkg.in/yaml.v3"
+	"sort"
 	"strings"
 )
 
@@ -76,9 +77,14 @@ func (h *Header) Hash() [32]byte {
 			f = append(f, fmt.Sprintf("%s-%x", k.Value, h.Content.Value[k].Value.Hash()))
 		}
 	}
+	keys := make([]string, len(h.Extensions))
+	z := 0
 	for k := range h.Extensions {
-		f = append(f, fmt.Sprintf("%s-%v", k.Value, h.Extensions[k].Value))
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(h.Extensions[k].Value))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }
 

datamodel/low/v3/link.go

@@ -85,9 +85,13 @@ func (l *Link) Hash() [32]byte {
 	}
 	sort.Strings(keys)
 	f = append(f, keys...)
+	keys = make([]string, len(l.Extensions))
+	z = 0
 	for k := range l.Extensions {
-		f = append(f, fmt.Sprintf("%s-%x", k.Value,
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(l.Extensions[k].Value))))
-			sha256.Sum256([]byte(fmt.Sprint(l.Extensions[k].Value)))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }

datamodel/low/v3/media_type.go

@@ -118,8 +118,13 @@ func (mt *MediaType) Hash() [32]byte {
 	}
 	sort.Strings(keys)
 	f = append(f, keys...)
+	keys = make([]string, len(mt.Extensions))
+	z = 0
 	for k := range mt.Extensions {
-		f = append(f, fmt.Sprintf("%s-%v", k.Value, mt.Extensions[k].Value))
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(mt.Extensions[k].Value))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }

datamodel/low/v3/oauth_flows.go

@@ -9,6 +9,7 @@ import (
 	"github.com/pb33f/libopenapi/datamodel/low"
 	"github.com/pb33f/libopenapi/index"
 	"gopkg.in/yaml.v3"
+	"sort"
 	"strings"
 )
 
@@ -116,11 +117,21 @@ func (o *OAuthFlow) Hash() [32]byte {
 	if !o.RefreshUrl.IsEmpty() {
 		f = append(f, o.RefreshUrl.Value)
 	}
-	for i := range o.Scopes.Value {
+	keys := make([]string, len(o.Scopes.Value))
-		f = append(f, fmt.Sprintf("%s-%s", i.Value, o.Scopes.Value[i].Value))
+	z := 0
+	for k := range o.Scopes.Value {
+		keys[z] = fmt.Sprintf("%s-%s", k.Value, sha256.Sum256([]byte(fmt.Sprint(o.Scopes.Value[k].Value))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
+	keys = make([]string, len(o.Extensions))
+	z = 0
 	for k := range o.Extensions {
-		f = append(f, fmt.Sprintf("%s-%v", k.Value, o.Extensions[k].Value))
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(o.Extensions[k].Value))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }

datamodel/low/v3/operation.go

@@ -194,10 +194,15 @@ func (o *Operation) Hash() [32]byte {
 	sort.Strings(keys)
 	f = append(f, keys...)
 
+	keys = make([]string, len(o.Extensions))
+	z = 0
 	for k := range o.Extensions {
-		f = append(f, fmt.Sprintf("%s-%x", k.Value,
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(o.Extensions[k].Value))))
-			sha256.Sum256([]byte(fmt.Sprint(o.Extensions[k].Value)))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
+
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }
 

datamodel/low/v3/parameter.go

@@ -140,11 +140,14 @@ func (p *Parameter) Hash() [32]byte {
 	}
 	sort.Strings(keys)
 	f = append(f, keys...)
-	if len(p.Extensions) > 0 {
+	keys = make([]string, len(p.Extensions))
+	z = 0
 	for k := range p.Extensions {
-			f = append(f, fmt.Sprintf("%v-%x", k.Value, p.Extensions[k].Value))
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(p.Extensions[k].Value))))
-		}
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
 
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }

datamodel/low/v3/path_item.go

@@ -82,10 +82,15 @@ func (p *PathItem) Hash() [32]byte {
 	}
 	sort.Strings(keys)
 	f = append(f, keys...)
+
+	keys = make([]string, len(p.Extensions))
+	z := 0
 	for k := range p.Extensions {
-		f = append(f, fmt.Sprintf("%s-%x", k.Value,
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(p.Extensions[k].Value))))
-			sha256.Sum256([]byte(fmt.Sprint(p.Extensions[k].Value)))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }
 

datamodel/low/v3/paths.go

@@ -150,9 +150,13 @@ func (p *Paths) Hash() [32]byte {
 	for k := range l {
 		f = append(f, low.GenerateHashString(keys[l[k]].Value))
 	}
+	ekeys := make([]string, len(p.Extensions))
+	z = 0
 	for k := range p.Extensions {
-		f = append(f, fmt.Sprintf("%s-%x", k.Value,
+		ekeys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(p.Extensions[k].Value))))
-			sha256.Sum256([]byte(fmt.Sprint(p.Extensions[k].Value)))))
+		z++
 	}
+	sort.Strings(ekeys)
+	f = append(f, ekeys...)
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }

datamodel/low/v3/request_body.go

@@ -9,6 +9,7 @@ import (
 	"github.com/pb33f/libopenapi/datamodel/low"
 	"github.com/pb33f/libopenapi/index"
 	"gopkg.in/yaml.v3"
+	"sort"
 	"strings"
 )
 
@@ -62,10 +63,15 @@ func (rb *RequestBody) Hash() [32]byte {
 	for k := range rb.Content.Value {
 		f = append(f, low.GenerateHashString(rb.Content.Value[k].Value))
 	}
+
+	keys := make([]string, len(rb.Extensions))
+	z := 0
 	for k := range rb.Extensions {
-		f = append(f, fmt.Sprintf("%s-%x", k.Value,
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(rb.Extensions[k].Value))))
-			sha256.Sum256([]byte(fmt.Sprint(rb.Extensions[k].Value)))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
+
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }
-

datamodel/low/v3/responses.go

@@ -126,9 +126,13 @@ func (r *Responses) Hash() [32]byte {
 	if !r.Default.IsEmpty() {
 		f = append(f, low.GenerateHashString(r.Default.Value))
 	}
+	keys = make([]string, len(r.Extensions))
+	z = 0
 	for k := range r.Extensions {
-		f = append(f, fmt.Sprintf("%s-%x", k.Value,
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(r.Extensions[k].Value))))
-			sha256.Sum256([]byte(fmt.Sprint(r.Extensions[k].Value)))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }

datamodel/low/v3/security_scheme.go

@@ -9,6 +9,7 @@ import (
 	"github.com/pb33f/libopenapi/datamodel/low"
 	"github.com/pb33f/libopenapi/index"
 	"gopkg.in/yaml.v3"
+	"sort"
 	"strings"
 )
 
@@ -98,8 +99,13 @@ func (ss *SecurityScheme) Hash() [32]byte {
 	if !ss.OpenIdConnectUrl.IsEmpty() {
 		f = append(f, ss.OpenIdConnectUrl.Value)
 	}
+	keys := make([]string, len(ss.Extensions))
+	z := 0
 	for k := range ss.Extensions {
-		f = append(f, fmt.Sprintf("%s-%v", k.Value, ss.Extensions[k].Value))
+		keys[z] = fmt.Sprintf("%s-%x", k.Value, sha256.Sum256([]byte(fmt.Sprint(ss.Extensions[k].Value))))
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
 	return sha256.Sum256([]byte(strings.Join(f, "|")))
 }