wehub-resource-sync
144 lines
3.8 KiB
Go
144 lines
3.8 KiB
Go
package shellsafe
|
|
|
|
import (
|
|
"sort"
|
|
"strings"
|
|
|
|
"mvdan.cc/sh/v3/syntax"
|
|
|
|
"reasonix/internal/shellparse"
|
|
)
|
|
|
|
// NormalizeBashSafeRedirectsForMatch returns a copy of subject with redirect
|
|
// syntax removed only when the redirect cannot write to a real file. It is used
|
|
// for shell safety matching, never for execution.
|
|
//
|
|
// Supported safe forms are fd duplication/close (`2>&1`, `>&2`, `2>&-`,
|
|
// `0<&1`) and output redirects to a null sink (`>/dev/null`, `>$null`,
|
|
// `>nul`, `2> /dev/null`, `>>/dev/null`, `&>/dev/null`, `&>>/dev/null`).
|
|
// The shell execution layer normalizes these null-sink spellings to the actual
|
|
// sink for the resolved shell. Other redirections are left unnormalized so the
|
|
// usual shell-syntax guard keeps prefix/read-only matching conservative.
|
|
func NormalizeBashSafeRedirectsForMatch(subject string) (string, bool) {
|
|
file, err := shellparse.ParseBash(subject)
|
|
if err != nil || shellparse.HasHereDoc(file) {
|
|
return "", false
|
|
}
|
|
spans, ok := safeRedirectSpans(subject, file.Stmts)
|
|
if !ok {
|
|
return "", false
|
|
}
|
|
if len(spans) == 0 {
|
|
return subject, true
|
|
}
|
|
sort.Slice(spans, func(i, j int) bool { return spans[i].start < spans[j].start })
|
|
|
|
var out strings.Builder
|
|
last := 0
|
|
for _, span := range spans {
|
|
if span.start < last || span.end > len(subject) {
|
|
return "", false
|
|
}
|
|
out.WriteString(subject[last:span.start])
|
|
last = span.end
|
|
}
|
|
out.WriteString(subject[last:])
|
|
return strings.TrimSpace(out.String()), true
|
|
}
|
|
|
|
type redirectSpan struct {
|
|
start int
|
|
end int
|
|
}
|
|
|
|
func safeRedirectSpans(source string, stmts []*syntax.Stmt) ([]redirectSpan, bool) {
|
|
var spans []redirectSpan
|
|
for _, stmt := range stmts {
|
|
if !appendSafeRedirectSpans(source, stmt, &spans) {
|
|
return nil, false
|
|
}
|
|
}
|
|
return spans, true
|
|
}
|
|
|
|
func appendSafeRedirectSpans(source string, stmt *syntax.Stmt, spans *[]redirectSpan) bool {
|
|
if stmt == nil {
|
|
return true
|
|
}
|
|
for _, redir := range stmt.Redirs {
|
|
span, ok := safeRedirectSpan(source, redir)
|
|
if !ok {
|
|
return false
|
|
}
|
|
*spans = append(*spans, span)
|
|
}
|
|
if binary, ok := stmt.Cmd.(*syntax.BinaryCmd); ok {
|
|
return appendSafeRedirectSpans(source, binary.X, spans) &&
|
|
appendSafeRedirectSpans(source, binary.Y, spans)
|
|
}
|
|
return true
|
|
}
|
|
|
|
func safeRedirectSpan(source string, redir *syntax.Redirect) (redirectSpan, bool) {
|
|
if redir == nil {
|
|
return redirectSpan{}, false
|
|
}
|
|
switch redir.Op {
|
|
case syntax.DplOut, syntax.DplIn:
|
|
if !isSafeFDDupWord(source, redir.Word) {
|
|
return redirectSpan{}, false
|
|
}
|
|
case syntax.RdrOut, syntax.AppOut, syntax.RdrClob, syntax.AppClob, syntax.RdrAll, syntax.AppAll, syntax.RdrAllClob, syntax.AppAllClob:
|
|
if !isNullRedirectWord(source, redir.Word) {
|
|
return redirectSpan{}, false
|
|
}
|
|
default:
|
|
return redirectSpan{}, false
|
|
}
|
|
start := int(redir.OpPos.Offset())
|
|
if redir.N != nil && redir.N.Pos().IsValid() {
|
|
start = int(redir.N.Pos().Offset())
|
|
}
|
|
end := int(redir.End().Offset())
|
|
if start < 0 || end < start || end > len(source) {
|
|
return redirectSpan{}, false
|
|
}
|
|
return redirectSpan{start: start, end: end}, true
|
|
}
|
|
|
|
func isSafeFDDupWord(source string, word *syntax.Word) bool {
|
|
value := redirectWordSource(source, word)
|
|
if value == "-" {
|
|
return true
|
|
}
|
|
if value == "" {
|
|
return false
|
|
}
|
|
for i := 0; i < len(value); i++ {
|
|
if value[i] < '0' || value[i] > '9' {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func isNullRedirectWord(source string, word *syntax.Word) bool {
|
|
value := redirectWordSource(source, word)
|
|
if value == "/dev/null" {
|
|
return true
|
|
}
|
|
return strings.EqualFold(value, "$null") || strings.EqualFold(value, "nul")
|
|
}
|
|
|
|
func redirectWordSource(source string, word *syntax.Word) string {
|
|
if word == nil || !word.Pos().IsValid() || !word.End().IsValid() {
|
|
return ""
|
|
}
|
|
start := int(word.Pos().Offset())
|
|
end := int(word.End().Offset())
|
|
if start < 0 || end < start || end > len(source) {
|
|
return ""
|
|
}
|
|
return strings.TrimSpace(source[start:end])
|
|
}
|