mirror of
https://github.com/R0m1k3/Loki.git
synced 2026-10-15 11:19:07 +02:00
90 lines
3.0 KiB
Go
90 lines
3.0 KiB
Go
package ajean
|
|
|
|
import (
|
|
"path/filepath"
|
|
"runtime"
|
|
"testing"
|
|
)
|
|
|
|
func TestNodeCapIntersect(t *testing.T) {
|
|
got := nodeCapIntersect(
|
|
[]string{nodeCapShell, nodeCapRead, nodeCapWrite}, // autorisées par le propriétaire
|
|
[]string{nodeCapRead, nodeCapList}, // déclarées par le poste
|
|
)
|
|
// Seul read est dans les deux ; l'ordre doit être canonique.
|
|
if len(got) != 1 || got[0] != nodeCapRead {
|
|
t.Fatalf("intersection attendue [read], obtenu %v", got)
|
|
}
|
|
}
|
|
|
|
func TestNodeSanitizeCapsDropsUnknown(t *testing.T) {
|
|
got := nodeSanitizeCaps([]string{"write", "danger", "read", "read"})
|
|
// Ordre canonique (read avant write), doublon et inconnu retirés.
|
|
want := []string{nodeCapRead, nodeCapWrite}
|
|
if len(got) != len(want) || got[0] != want[0] || got[1] != want[1] {
|
|
t.Fatalf("attendu %v, obtenu %v", want, got)
|
|
}
|
|
}
|
|
|
|
func TestNodeToolNameRoundTrip(t *testing.T) {
|
|
name := nodeToolName("mon_poste", nodeCapShell)
|
|
if !isNodeTool(name) {
|
|
t.Fatalf("%s devrait être reconnu comme outil de poste", name)
|
|
}
|
|
slug, cap, ok := parseNodeToolName(name)
|
|
if !ok || slug != "mon_poste" || cap != nodeCapShell {
|
|
t.Fatalf("parse: ok=%v slug=%q cap=%q", ok, slug, cap)
|
|
}
|
|
}
|
|
|
|
func TestNodeToolNameSlugWithDoubleUnderscore(t *testing.T) {
|
|
// Un slug contenant « __ » ne doit pas casser la reconstitution : on coupe
|
|
// sur le DERNIER séparateur, et la capacité n'en contient jamais.
|
|
name := nodeToolName("a__b", nodeCapWrite)
|
|
slug, cap, ok := parseNodeToolName(name)
|
|
if !ok || slug != "a__b" || cap != nodeCapWrite {
|
|
t.Fatalf("parse: ok=%v slug=%q cap=%q", ok, slug, cap)
|
|
}
|
|
}
|
|
|
|
func TestNodeResolvePathConfinement(t *testing.T) {
|
|
root := t.TempDir()
|
|
|
|
// Chemin relatif normal : accepté, sous la racine.
|
|
got, err := nodeResolvePath(root, "sous/dossier/f.txt")
|
|
if err != nil {
|
|
t.Fatalf("chemin relatif refusé à tort: %v", err)
|
|
}
|
|
if want := filepath.Join(root, "sous", "dossier", "f.txt"); got != want {
|
|
t.Fatalf("attendu %q, obtenu %q", want, got)
|
|
}
|
|
|
|
// Traversée « .. » : refusée.
|
|
if _, err := nodeResolvePath(root, "../evade.txt"); err == nil {
|
|
t.Fatal("la traversée .. aurait dû être refusée")
|
|
}
|
|
if _, err := nodeResolvePath(root, "a/../../evade.txt"); err == nil {
|
|
t.Fatal("la traversée imbriquée aurait dû être refusée")
|
|
}
|
|
|
|
// Chemin absolu hors racine : refusé.
|
|
outside := filepath.Join(filepath.Dir(root), "ailleurs.txt")
|
|
if runtime.GOOS == "windows" {
|
|
outside = `C:\Windows\System32\evil.txt`
|
|
}
|
|
if _, err := nodeResolvePath(root, outside); err == nil {
|
|
t.Fatalf("un chemin absolu hors racine (%s) aurait dû être refusé", outside)
|
|
}
|
|
|
|
// Chemin absolu SOUS la racine : accepté.
|
|
inside := filepath.Join(root, "ok.txt")
|
|
if _, err := nodeResolvePath(root, inside); err != nil {
|
|
t.Fatalf("un chemin absolu sous la racine refusé à tort: %v", err)
|
|
}
|
|
|
|
// Racine vide : refusée (aucun dossier autorisé = aucun accès).
|
|
if _, err := nodeResolvePath("", "f.txt"); err == nil {
|
|
t.Fatal("une racine vide aurait dû refuser tout chemin")
|
|
}
|
|
}
|