safetext

Ceci n'est pas un produit officiellement pris en charge par Google.

Bibliothèques sûres par construction pour produire des formats comme YAML, afin de remplacer des bibliothèques ignorant la syntaxe comme text/template et sprintf qui présentent un risque de vulnérabilités par injection.

Exemple d'utilisation

Comme text/template ne connaît pas la syntaxe des formats qu'il produit, il n'offre aucune protection contre les vulnérabilités par injection.

Considérez la fonction produceConfig suivante qui utilise text/template pour générer du YAML :

package main

import (
        "bytes"
        "fmt"
        "text/template"
)

func produceConfig(params any) (error, string) {
        tmpl, _ := template.New("test").Parse("{ hello: {{ .addressee }} }")

        var buf bytes.Buffer
        err := tmpl.Execute(&buf, params)
        if err != nil {
                return err, ""
        }

        return nil, buf.String()
}

func main() {
        goodReplacements := map[string]interface{}{
                "addressee": "safe",
        }

        err, config := produceConfig(goodReplacements)

        if err == nil {
                fmt.Println(config)
        } else {
                fmt.Printf("Error: %v\n", err)
        }

        badReplacements := map[string]interface{}{
                "addressee": "world, oops: true",
        }

        err, config = produceConfig(badReplacements)

        if err == nil {
                fmt.Println(config)
        } else {
                fmt.Printf("Error: %v\n", err)
        }
}

Ce programme montre comment une entrée addressee malveillante peut provoquer l'injection de nouvelles clés YAML dans le résultat de l'exécution du modèle.

Avec text/template, aucune erreur ne sera rencontrée lorsque cela se produit, et la sortie du programme sera :

{ hello: safe }
{ hello: world, oops: true }

En passant plutôt de text/template à safetext/yamltemplate, l'injection aurait été empêchée, avec à la place la sortie suivante :

{ hello: safe }
Error: YAML Injection Detected

Instructions pour les remplacements de text/template

La détection d'injection est automatiquement appliquée lors de l'accès aux champs de données d'entrée.

• Elle peut également être activée manuellement sur le résultat de n'importe quel appel de fonction :

  root@kitploit:~

  {{ RetrieveUntrustedData | ApplyInjectionDetection }}
  

• La logique d'injection peut être désactivée sur certains champs en appliquant l'annotation StructuralData :

  root@kitploit:~

  {{ (StructuralData .x) }}
  

• L'annotation StructuralData est également nécessaire lorsque vous passez une entrée à une fonction où l'entrée ne doit pas être modifiée, par exemple pour effectuer une sorte de recherche :

  root@kitploit:~

  name: {{ readFile (StructuralData .pathToName) | ApplyInjectionDetection }}
  

• Il est recommandé d'utiliser pleinement les fonctionnalités de text/template comme les expressions conditionnelles, les boucles range, etc. pour éviter l'annotation StructuralData lorsque c'est possible. Par exemple, au lieu de :

  root@kitploit:~

  properties:
      {{ (StructuralData .PropertiesYaml) }}
  

  Considérez :

  root@kitploit:~

  properties:{{ range .Properties }}
      - {{ . }}{{ end }}
  

yamltemplate

L'intention de yamltemplate est de garantir que, par défaut, aucune des chaînes des données d'entrée n'affecte la structure du YAML résultant (uniquement les valeurs).

• Par exemple, le modèle ci-dessous serait compatible avec yamltemplate tel quel, tout en empêchant automatiquement toute injection provenant de l'entrée Name :

  root@kitploit:~

  name: {{.Name}}
  

• Cependant, tout nœud de modèle destiné à modifier la structure du YAML résultant, comme l'insertion d'une configuration YAML arbitraire, doit être annoté explicitement comme StructuralData :

  root@kitploit:~

  config: {{ (StructuralData .Config) }}
  

• Un autre cas nécessitant l'annotation StructuralData est celui où vous devez inclure une carte complète dans la structure YAML. L'utilisation de StructuralData seule peut laisser passer des injections via la clé, nous avons donc besoin d'une couche supplémentaire de validation ici :

  root@kitploit:~

  labels:
  {{- range $key, $value := .Labels }}
      {{ (StructuralData $key | MapKey) }}: {{ $value }}
  {{- end }}
  

  Le côté golang correspondant pourrait ressembler à ceci :

  root@kitploit:~

  func mapKeyFunc(data any) (string, error) {
      if v, ok := data.(string); ok {
          matched, err := regexp.MatchString(`^[a-zA-Z0-9/\-.]+$`, v)
          if err != nil {
              return "", err
          }
          if !matched {
              return "", fmt.Errorf("invalid characters in the key: %v", v)
          }
          return v, nil
      }
  
      return "", errors.New("invalid input")
  
  } ...
  
  tmp:= template.New("something")
  tmp.Funcs(map[string]any{"MapKey":mapKeyFunc})
  tmpl := template.Must(tmp.Parse(yamlTemplate))
  

Cas d'utilisation non pris en charge pour yamltemplate

• YAML avec des clés en double. Les clés en double ne sont pas du YAML standard et ne sont pas prises en charge par cette bibliothèque. Veuillez refactoriser votre modèle YAML pour supprimer les clés en double. Par exemple :

  root@kitploit:~

  - project:
     members: member-a
     members: member-b
  

  En :

  root@kitploit:~

  - project:
    members: member-b
  

shtemplate

shtemplate est conçu pour vous permettre de générer des scripts shell avec la garantie qu'aucune des chaînes de données d'entrée ne pourra injecter de nouvelles commandes ou options, sans annotation explicite.

• Par exemple, un script modèle conçu pour simplement afficher une chaîne échouera à son rendu si cette chaîne injecte une nouvelle commande `./evil` :

  root@kitploit:~

  echo "{{ .addressee }}"
  

• Pour autoriser explicitement une chaîne d'entrée à contenir de nouvelles commandes ne provenant pas de la chaîne du modèle, l'annotation StructuralData peut être utilisée :

  root@kitploit:~

  {{ (StructuralData .commands) }}
  

• Les options (arguments commençant par -) sont également interdites par défaut. Par exemple, le modèle ci-dessous ne pourra pas être rendu si Filename vaut --interactive :

  root@kitploit:~

  git add {{ .Filename }}
  

• Pour autoriser explicitement une chaîne d'entrée passée comme argument de commande à être une option, l'annotation AllowFlags peut être utilisée :

  root@kitploit:~

  git add {{ (AllowFlags .FilenameOrGitAddFlag) }}
  

• Plusieurs arguments provenant d'une seule chaîne d'entrée sont également interdits par défaut. Cette construction doit plutôt être implémentée à l'aide d'un tableau et d'une expression :

Cas d'utilisation non pris en charge pour les remplacements de text/template

• Logique d'échappement en dehors du système de modèles. Vous devez plutôt intégrer la logique d'échappement dans votre modèle (par ex. : .UntrustedField | escape).

• Formats partiels. Les bibliothèques sont conçues pour générer des fichiers complets. Si vous générez des segments puis les concaténez, vous devriez plutôt déplacer cette logique dans le système de modèles lui-même (avec des constructions comme if ou range).

• Fonctions avec effets de bord. Les bibliothèques fonctionnent en effectuant plusieurs exécutions de modèles. Si vous enregistrez des fonctions ayant des effets de bord, cela peut provoquer un comportement inattendu (par ex. : id: {{ AllocateID }}).

shsprintf

shsprintf est conçu pour vous permettre de générer des scripts shell avec la garantie qu'aucune des chaînes de données d'entrée ne pourra injecter de nouvelles commandes ou options, indépendamment d'un échappement potentiellement incorrect. Voir l'exemple ci-dessous, qui renverra l'erreur shsprintf.ErrShInjection au lieu du script avec une commande injectée :

message := "`whoami`"
result, err := shsprintf.Sprintf("git commit -m %s", message)

shsprintf.Sprintf ajoute une valeur de retour d'erreur par rapport à fmt.Sprintf, mais l'API est par ailleurs identique. shsprintf.MustSprintf est disponible pour les cas où un panic est acceptable.

shsprintf est fourni avec une fonction d'échappement dont l'utilisation est recommandée :

message := "`whoami`"
result := shsprintf.MustSprintf("git commit -m %s", shsprintf.EscapeDefaultContext(message))

Contrairement à text/template, il n'y a pas d'annotations spéciales. Si vous devez par exemple passer plusieurs arguments, cela doit être fait en modifiant la chaîne de format :

files := []any{ "file1", "file2", "file3" }
result, err := shsprintf.Sprintf("cat" + strings.Repeat(" %s", len(files)), files...)