Add bounded sources and strict YAML parsing
This commit is contained in:
274
internal/yaml/parse.go
Normal file
274
internal/yaml/parse.go
Normal file
@@ -0,0 +1,274 @@
|
||||
// Package yaml adapts the private upstream parser to ConfigKit's document model.
|
||||
package yaml
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"io"
|
||||
"regexp"
|
||||
"strings"
|
||||
|
||||
"go.yaml.in/yaml/v4"
|
||||
"go.yaml.in/yaml/v4/plugin/limit"
|
||||
|
||||
"gitea.maximumdirect.net/eric/ConfigKit/internal/document"
|
||||
)
|
||||
|
||||
const (
|
||||
codeInvalid = "yaml.invalid"
|
||||
codeEmpty = "yaml.empty"
|
||||
codeMultipleDocuments = "yaml.multiple_documents"
|
||||
codeRootType = "yaml.root_type"
|
||||
codeDuplicateKey = "yaml.duplicate_key"
|
||||
codeTag = "yaml.tag"
|
||||
codeAnchor = "yaml.anchor"
|
||||
codeAlias = "yaml.alias"
|
||||
codeMergeKey = "yaml.merge_key"
|
||||
codeScalar = "yaml.scalar"
|
||||
codeDepthLimit = "yaml.depth_limit"
|
||||
codeNodeLimit = "yaml.node_limit"
|
||||
)
|
||||
|
||||
var (
|
||||
jsonNumberPattern = regexp.MustCompile(`^-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?$`)
|
||||
decimalLikePattern = regexp.MustCompile(`^[+-]?[0-9][0-9_]*(\.[0-9_]*)?([eE][+-]?[0-9_]*)?$`)
|
||||
prefixedNumberPattern = regexp.MustCompile(`^[+-]?0[xXoO][0-9A-Fa-f_]+$`)
|
||||
leadingDecimalPattern = regexp.MustCompile(`^[+-]?\.[0-9_]+$`)
|
||||
nonFiniteNumberPattern = regexp.MustCompile(`(?i)^[+-]?\.(inf|nan)$`)
|
||||
errParserDepth = errors.New("configkit yaml parser depth limit")
|
||||
)
|
||||
|
||||
// Limits controls private parser and translated-tree resource bounds.
|
||||
type Limits struct {
|
||||
Depth int
|
||||
Nodes int
|
||||
ParserDepth int
|
||||
}
|
||||
|
||||
// Issue is a parser-independent, value-free YAML diagnostic.
|
||||
type Issue struct {
|
||||
Code string
|
||||
Message string
|
||||
Line int
|
||||
Column int
|
||||
Related []document.Location
|
||||
}
|
||||
|
||||
// Parse loads exactly one policy-valid mapping document.
|
||||
func Parse(input io.Reader, sourceID string, limits Limits) (*document.Node, []Issue) {
|
||||
parserDepth := limits.ParserDepth
|
||||
if parserDepth <= 0 {
|
||||
parserDepth = limits.Depth + 2
|
||||
}
|
||||
depthExceeded := false
|
||||
plugin := limit.New(limit.DepthFunc(func(depth int, _ *limit.DepthContext) error {
|
||||
if depth > parserDepth {
|
||||
depthExceeded = true
|
||||
return errParserDepth
|
||||
}
|
||||
return nil
|
||||
}))
|
||||
loader, err := yaml.NewLoader(input, yaml.WithPlugin(plugin))
|
||||
if err != nil {
|
||||
return nil, []Issue{{Code: codeInvalid, Message: "YAML parser could not be initialized"}}
|
||||
}
|
||||
|
||||
var parsed yaml.Node
|
||||
if err := loader.Load(&parsed); err != nil {
|
||||
if errors.Is(err, io.EOF) {
|
||||
return nil, []Issue{{Code: codeEmpty, Message: "configuration input is empty"}}
|
||||
}
|
||||
return nil, []Issue{parserIssue(err, depthExceeded)}
|
||||
}
|
||||
var trailing yaml.Node
|
||||
if err := loader.Load(&trailing); err == nil {
|
||||
return nil, []Issue{{Code: codeMultipleDocuments, Message: "configuration input must contain exactly one document", Line: trailing.Line, Column: trailing.Column}}
|
||||
} else if !errors.Is(err, io.EOF) {
|
||||
return nil, []Issue{parserIssue(err, depthExceeded)}
|
||||
}
|
||||
|
||||
root := documentRoot(&parsed)
|
||||
if root == nil || (root.Kind == yaml.ScalarNode && root.Value == "" && root.ShortTag() == "!!null") {
|
||||
return nil, []Issue{{Code: codeEmpty, Message: "configuration document is empty", Line: parsed.Line, Column: parsed.Column}}
|
||||
}
|
||||
if root.Kind != yaml.MappingNode {
|
||||
return nil, []Issue{{Code: codeRootType, Message: "configuration document root must be a mapping", Line: root.Line, Column: root.Column}}
|
||||
}
|
||||
|
||||
state := translationState{sourceID: sourceID, limits: limits}
|
||||
translated, issue := state.translate(root, 0)
|
||||
if issue != nil {
|
||||
return nil, []Issue{*issue}
|
||||
}
|
||||
return translated, nil
|
||||
}
|
||||
|
||||
type translationState struct {
|
||||
sourceID string
|
||||
limits Limits
|
||||
nodes int
|
||||
}
|
||||
|
||||
func (s *translationState) translate(node *yaml.Node, depth int) (*document.Node, *Issue) {
|
||||
if depth > s.limits.Depth {
|
||||
return nil, nodeIssue(codeDepthLimit, "configuration exceeds the nesting depth limit", node)
|
||||
}
|
||||
if node.Style&yaml.TaggedStyle != 0 {
|
||||
return nil, nodeIssue(codeTag, "explicit YAML tags are not supported", node)
|
||||
}
|
||||
if node.Anchor != "" {
|
||||
return nil, nodeIssue(codeAnchor, "YAML anchors are not supported", node)
|
||||
}
|
||||
if node.Kind == yaml.AliasNode || node.Alias != nil {
|
||||
return nil, nodeIssue(codeAlias, "YAML aliases are not supported", node)
|
||||
}
|
||||
if issue := s.chargeNode(node); issue != nil {
|
||||
return nil, issue
|
||||
}
|
||||
|
||||
location := document.Location{SourceID: s.sourceID, Line: node.Line, Column: node.Column}
|
||||
switch node.Kind {
|
||||
case yaml.MappingNode:
|
||||
if len(node.Content)%2 != 0 {
|
||||
return nil, nodeIssue(codeInvalid, "mapping structure is invalid", node)
|
||||
}
|
||||
result := &document.Node{Kind: document.Mapping, Location: location, Mapping: make([]document.Entry, 0, len(node.Content)/2)}
|
||||
seen := make(map[string]document.Location, len(node.Content)/2)
|
||||
for i := 0; i < len(node.Content); i += 2 {
|
||||
keyNode, valueNode := node.Content[i], node.Content[i+1]
|
||||
if issue := s.chargeNode(keyNode); issue != nil {
|
||||
return nil, issue
|
||||
}
|
||||
key, issue := mappingKey(keyNode)
|
||||
if issue != nil {
|
||||
return nil, issue
|
||||
}
|
||||
if key == "<<" {
|
||||
return nil, nodeIssue(codeMergeKey, "YAML merge keys are not supported", keyNode)
|
||||
}
|
||||
keyLocation := document.Location{SourceID: s.sourceID, Line: keyNode.Line, Column: keyNode.Column}
|
||||
if previous, ok := seen[key]; ok {
|
||||
issue := nodeIssue(codeDuplicateKey, "mapping key is defined more than once", keyNode)
|
||||
issue.Related = []document.Location{previous}
|
||||
return nil, issue
|
||||
}
|
||||
seen[key] = keyLocation
|
||||
value, issue := s.translate(valueNode, depth+1)
|
||||
if issue != nil {
|
||||
return nil, issue
|
||||
}
|
||||
result.Mapping = append(result.Mapping, document.Entry{
|
||||
Key: key,
|
||||
KeyLocation: keyLocation,
|
||||
ValueLocation: value.Location,
|
||||
Value: value,
|
||||
})
|
||||
}
|
||||
return result, nil
|
||||
case yaml.SequenceNode:
|
||||
result := &document.Node{Kind: document.Sequence, Location: location, Sequence: make([]*document.Node, 0, len(node.Content))}
|
||||
for _, child := range node.Content {
|
||||
translated, issue := s.translate(child, depth+1)
|
||||
if issue != nil {
|
||||
return nil, issue
|
||||
}
|
||||
result.Sequence = append(result.Sequence, translated)
|
||||
}
|
||||
return result, nil
|
||||
case yaml.ScalarNode:
|
||||
kind, text, issue := scalar(node)
|
||||
if issue != nil {
|
||||
return nil, issue
|
||||
}
|
||||
return &document.Node{Kind: kind, Location: location, Text: text}, nil
|
||||
default:
|
||||
return nil, nodeIssue(codeInvalid, "YAML node kind is not supported", node)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *translationState) chargeNode(node *yaml.Node) *Issue {
|
||||
s.nodes++
|
||||
if s.limits.Nodes >= 0 && s.nodes > s.limits.Nodes {
|
||||
return nodeIssue(codeNodeLimit, "configuration exceeds the node limit", node)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func mappingKey(node *yaml.Node) (string, *Issue) {
|
||||
if node.Kind == yaml.AliasNode || node.Alias != nil {
|
||||
return "", nodeIssue(codeAlias, "YAML aliases are not supported", node)
|
||||
}
|
||||
if node.Kind != yaml.ScalarNode {
|
||||
return "", nodeIssue(codeScalar, "mapping keys must be strings", node)
|
||||
}
|
||||
if node.Style&yaml.TaggedStyle != 0 {
|
||||
return "", nodeIssue(codeTag, "explicit YAML tags are not supported", node)
|
||||
}
|
||||
if node.Anchor != "" {
|
||||
return "", nodeIssue(codeAnchor, "YAML anchors are not supported", node)
|
||||
}
|
||||
kind, text, issue := scalar(node)
|
||||
if issue != nil {
|
||||
return "", issue
|
||||
}
|
||||
if kind != document.String {
|
||||
return "", nodeIssue(codeScalar, "mapping keys must be strings", node)
|
||||
}
|
||||
return text, nil
|
||||
}
|
||||
|
||||
func scalar(node *yaml.Node) (document.Kind, string, *Issue) {
|
||||
if node.Style&(yaml.DoubleQuotedStyle|yaml.SingleQuotedStyle|yaml.LiteralStyle|yaml.FoldedStyle) != 0 {
|
||||
return document.String, node.Value, nil
|
||||
}
|
||||
value := node.Value
|
||||
switch value {
|
||||
case "":
|
||||
if node.ShortTag() == "!!null" {
|
||||
return document.Null, "", nil
|
||||
}
|
||||
case "null", "~":
|
||||
return document.Null, "", nil
|
||||
case "true", "false":
|
||||
return document.Boolean, value, nil
|
||||
}
|
||||
lower := strings.ToLower(value)
|
||||
if lower == "true" || lower == "false" || lower == "null" || lower == "yes" || lower == "no" || lower == "on" || lower == "off" {
|
||||
return 0, "", nodeIssue(codeScalar, "plain scalar uses an unsupported reserved form", node)
|
||||
}
|
||||
if jsonNumberPattern.MatchString(value) {
|
||||
return document.Number, value, nil
|
||||
}
|
||||
if decimalLikePattern.MatchString(value) || prefixedNumberPattern.MatchString(value) ||
|
||||
leadingDecimalPattern.MatchString(value) || nonFiniteNumberPattern.MatchString(value) {
|
||||
return 0, "", nodeIssue(codeScalar, "plain scalar uses an unsupported numeric form", node)
|
||||
}
|
||||
if tag := node.ShortTag(); tag == "!!int" || tag == "!!float" {
|
||||
return 0, "", nodeIssue(codeScalar, "plain scalar uses an unsupported numeric form", node)
|
||||
}
|
||||
return document.String, value, nil
|
||||
}
|
||||
|
||||
func documentRoot(node *yaml.Node) *yaml.Node {
|
||||
if node.Kind == yaml.DocumentNode && len(node.Content) == 1 {
|
||||
return node.Content[0]
|
||||
}
|
||||
return node
|
||||
}
|
||||
|
||||
func parserIssue(err error, depthExceeded bool) Issue {
|
||||
code := codeInvalid
|
||||
if depthExceeded || errors.Is(err, errParserDepth) {
|
||||
code = codeDepthLimit
|
||||
}
|
||||
issue := Issue{Code: code, Message: "configuration contains invalid YAML"}
|
||||
var loadError *yaml.LoadError
|
||||
if errors.As(err, &loadError) {
|
||||
issue.Line = loadError.Mark.Line
|
||||
issue.Column = loadError.Mark.Column
|
||||
}
|
||||
return issue
|
||||
}
|
||||
|
||||
func nodeIssue(code, message string, node *yaml.Node) *Issue {
|
||||
return &Issue{Code: code, Message: message, Line: node.Line, Column: node.Column}
|
||||
}
|
||||
Reference in New Issue
Block a user