Merge pull request #302 from Warp-net/develop

Develop

Author: filinvadim

security/challenge.go

@@ -25,19 +25,18 @@ resulting from the use or misuse of this software.
 package security
 
 import (
-	"bufio"
 	"errors"
 	"fmt"
 	"io/fs"
 	"math/rand/v2" //#nosec
-	"path/filepath"
+	"path"
 	"sort"
 	"strconv"
 )
 
 type SampleLocation struct {
 	DirStack  []int // every index is level and value is dir num
-	FileStack []int // file index, line index, left line border, right line border
+	FileStack []int // file index
 }
 
 func ResolveChallenge(codebase FileSystem, location SampleLocation, nonce int64) ([]byte, error) {
@@ -60,10 +59,7 @@ func GenerateChallenge(codebase FileSystem, nonce int64) ([]byte, SampleLocation
 
 var (
 	ErrNoSampleFiles          = errors.New("challenge: no usable files or subdirectories")
-	ErrEmptySampleLine        = errors.New("empty sample line found")
-	ErrNoNonEmptySampleLines  = errors.New("no non-empty lines found")
 	ErrSampleIndexOutOfBounds = errors.New("sample index out of bounds")
-	ErrInvalidSubstringBounds = errors.New("invalid substring bounds")
 )
 
 func generateSample(codebase FileSystem, dir string, dirStack []int) (_ string, result SampleLocation, err error) {
@@ -85,79 +81,37 @@ func generateSample(codebase FileSystem, dir string, dirStack []int) (_ string,
 		}
 	}
 
-	perm := rand.Perm(len(dirs))
-	for _, dirIndex := range perm {
-		selectedDir := dirs[dirIndex]
-		subPath := filepath.Join(dir, selectedDir.Name())
-
-		subEntries, err := fs.ReadDir(codebase, subPath)
-		if err != nil {
-			continue
-		}
-
-		var fileCount int
-		for _, e := range subEntries {
-			if !e.IsDir() {
-				fileCount++
+	// Subdirectories and the files of this directory compete on equal footing,
+	// so files outside leaf directories are sampled too.
+	total := len(dirs) + len(files)
+	for _, c := range rand.Perm(total) {
+		if c < len(dirs) {
+			subPath := path.Join(dir, dirs[c].Name())
+			sample, subResult, err := generateSample(codebase, subPath, append(dirStack, c))
+			if err == nil {
+				return sample, subResult, nil
 			}
-		}
-		if fileCount == 0 {
 			continue
 		}
 
-		sample, subResult, err := generateSample(codebase, subPath, append(dirStack, dirIndex))
-		if err == nil {
-			return sample, subResult, nil
-		}
-	}
-
-	if len(files) == 0 {
-		return "", result, ErrNoSampleFiles
-	}
-
-	fileIndex := rand.IntN(len(files)) //#nosec
-	selectedFile := files[fileIndex]
-	fullPath := filepath.Join(dir, selectedFile.Name())
-
-	line, lineNum, err := getRandomLine(codebase, fullPath)
-	if err != nil {
-		return "", result, fmt.Errorf("challenge: read random line from %s: %w", fullPath, err)
-	}
-	if len(line) == 0 {
-		return "", result, fmt.Errorf("challenge: %w, path: %s", ErrEmptySampleLine, fullPath)
-	}
-
-	lineLen := len(line)
-	var left, right int
-	if lineLen == 1 {
-		left, right = 0, 1
-	} else {
-		left = rand.IntN(lineLen - 1)                //#nosec
-		right = left + 1 + rand.IntN(lineLen-left-1) //#nosec
-	}
-
-	sample := line[left:right]
+		fileIndex := c - len(dirs)
+		fullPath := path.Join(dir, files[fileIndex].Name())
 
-	return sample, SampleLocation{
-		DirStack:  dirStack,
-		FileStack: []int{fileIndex, lineNum, left, right},
-	}, nil
-}
+		content, err := fs.ReadFile(codebase, fullPath)
+		if err != nil || len(content) == 0 {
+			continue
+		}
 
-func getRandomLine(codebase FileSystem, path string) (string, int, error) {
-	lines, err := readLines(codebase, path)
-	if err != nil {
-		return "", 0, err
-	}
-	if len(lines) == 0 {
-		return "", 0, fmt.Errorf("challenge: %w, path %s", ErrNoNonEmptySampleLines, path)
+		return string(content), SampleLocation{
+			DirStack:  dirStack,
+			FileStack: []int{fileIndex},
+		}, nil
 	}
 
-	index := rand.IntN(len(lines)) //#nosec
-	return lines[index], index, nil
+	return "", result, ErrNoSampleFiles
 }
 
-var ErrInvalidStackSize = errors.New("challenge: invalid file stack size - expected 4 elements")
+var ErrInvalidStackSize = errors.New("challenge: invalid file stack size - expected at least 1 element")
 
 func findSample(codebase FileSystem, loc SampleLocation) (string, error) {
 	currentDir := "."
@@ -178,12 +132,12 @@ func findSample(codebase FileSystem, loc SampleLocation) (string, error) {
 				dirs = append(dirs, e)
 			}
 		}
-		if dirIndex >= len(dirs) {
+		if dirIndex < 0 || dirIndex >= len(dirs) {
 			return "", fmt.Errorf("challenge: dir index %d: level %d: %w", dirIndex, level, ErrSampleIndexOutOfBounds)
 		}
 
 		nextDir := dirs[dirIndex].Name()
-		currentDir = filepath.Join(currentDir, nextDir)
+		currentDir = path.Join(currentDir, nextDir)
 	}
 
 	entries, err := fs.ReadDir(codebase, currentDir)
@@ -201,56 +155,22 @@ func findSample(codebase FileSystem, loc SampleLocation) (string, error) {
 			regularFiles = append(regularFiles, e)
 		}
 	}
-	if len(loc.FileStack) != 4 {
+	if len(loc.FileStack) < 1 {
 		return "", ErrInvalidStackSize
 	}
 
 	fileIndex := loc.FileStack[0]
-	lineIndex := loc.FileStack[1]
-	left := loc.FileStack[2]
-	right := loc.FileStack[3]
-
-	if fileIndex >= len(regularFiles) {
+	if fileIndex < 0 || fileIndex >= len(regularFiles) {
 		return "", fmt.Errorf("challenge: %d %w - found %d files", fileIndex, ErrSampleIndexOutOfBounds, len(regularFiles))
 	}
 
 	targetFile := regularFiles[fileIndex].Name()
-	fullPath := filepath.Join(currentDir, targetFile)
+	fullPath := path.Join(currentDir, targetFile)
 
-	lines, err := readLines(codebase, fullPath)
+	content, err := fs.ReadFile(codebase, fullPath)
 	if err != nil {
-		return "", fmt.Errorf("challenge: read lines from %s: %w", fullPath, err)
-	}
-	if lineIndex >= len(lines) {
-		return "", fmt.Errorf("challenge: %d %w, len=%d", lineIndex, ErrSampleIndexOutOfBounds, len(lines))
+		return "", fmt.Errorf("challenge: read file %s: %w", fullPath, err)
 	}
 
-	line := lines[lineIndex]
-	if left > right || left < 0 || right > len(line) {
-		return "", fmt.Errorf("challenge: %w: [%d:%d] on len=%d", ErrInvalidSubstringBounds, left, right, len(line))
-	}
-
-	return line[left:right], nil
-}
-
-func readLines(codebase FileSystem, path string) ([]string, error) {
-	f, err := codebase.Open(path)
-	if err != nil {
-		return nil, err
-	}
-
-	var lines []string
-	scanner := bufio.NewScanner(f)
-	for scanner.Scan() {
-		text := scanner.Text()
-		if len(text) <= 2 { // drop '}',')', '\t', '\n' etc.
-			continue
-		}
-
-		lines = append(lines, text)
-	}
-
-	_ = f.Close()
-
-	return lines, scanner.Err()
+	return string(content), nil
 }

security/challenge_test.go

@@ -26,7 +26,11 @@ resulting from the use or misuse of this software.
 package security
 
 import (
+	"bytes"
+	"errors"
+	"strconv"
 	"testing"
+	"testing/fstest"
 
 	root "github.com/Warp-net/warpnet"
 )
@@ -50,3 +54,152 @@ func TestChallengeResolve_Success(t *testing.T) {
 		}
 	}
 }
+
+const (
+	rootGo = "package main\n\nfunc Root() {}\n"
+	aGo    = "package a\n\nfunc A() {}\n"
+	bGo    = "package b\n\nfunc B() {}\n"
+	cGo    = "package c\n\nfunc C() {}\n"
+	dGo    = "package d\n\nfunc D() {}\n"
+	zGo    = "package z\n\nfunc Z() {}\n"
+)
+
+// sampleTestFS is a tree with files at every depth: the root, intermediate
+// directories that also contain subdirectories, and leaves.
+func sampleTestFS() fstest.MapFS {
+	return fstest.MapFS{
+		"rootfile.go":    {Data: []byte(rootGo)},
+		"a/afile.go":     {Data: []byte(aGo)},
+		"a/b/bfile.go":   {Data: []byte(bGo)},
+		"a/b/c/cfile.go": {Data: []byte(cGo)},
+		"a/b/d/dfile.go": {Data: []byte(dGo)},
+		"x/y/z/zfile.go": {Data: []byte(zGo)},
+	}
+}
+
+func allContents() map[string]bool {
+	return map[string]bool{rootGo: true, aGo: true, bGo: true, cGo: true, dGo: true, zGo: true}
+}
+
+// TestGenerateResolve_RoundTrip guards the DirStack/FileStack contract: a
+// generated location must resolve back to the same challenge on the same tree.
+func TestGenerateResolve_RoundTrip(t *testing.T) {
+	codebase := sampleTestFS()
+	for i := 0; i < 500; i++ {
+		nonce := int64(i)
+		gen, loc, err := GenerateChallenge(codebase, nonce)
+		if err != nil {
+			t.Fatalf("generate (i=%d): %v", i, err)
+		}
+		res, err := ResolveChallenge(codebase, loc, nonce)
+		if err != nil {
+			t.Fatalf("resolve (i=%d, loc=%+v): %v", i, loc, err)
+		}
+		if !bytes.Equal(gen, res) {
+			t.Fatalf("round-trip mismatch at i=%d, loc=%+v", i, loc)
+		}
+	}
+}
+
+// TestGenerateSample_WholeFile asserts every sample is a complete file's
+// contents, never a substring (regression for the 1-char substring bug).
+func TestGenerateSample_WholeFile(t *testing.T) {
+	codebase := sampleTestFS()
+	contents := allContents()
+	for i := 0; i < 500; i++ {
+		sample, _, err := generateSample(codebase, ".", []int{})
+		if err != nil {
+			t.Fatalf("generateSample (i=%d): %v", i, err)
+		}
+		if !contents[sample] {
+			t.Fatalf("sample is not a whole file: %q", sample)
+		}
+	}
+}
+
+// TestGenerateSample_SamplesAllLevels asserts files at every depth get
+// sampled, not just leaves (regression for the leaf-biased traversal bug).
+func TestGenerateSample_SamplesAllLevels(t *testing.T) {
+	codebase := sampleTestFS()
+	seen := map[string]bool{}
+	for i := 0; i < 5000; i++ {
+		sample, _, err := generateSample(codebase, ".", []int{})
+		if err != nil {
+			t.Fatalf("generateSample (i=%d): %v", i, err)
+		}
+		seen[sample] = true
+	}
+	for content := range allContents() {
+		if !seen[content] {
+			t.Errorf("file at content %q was never sampled - traversal still biased", content)
+		}
+	}
+}
+
+// TestResolveChallenge_WholeFileHash locks in the wire contract: the resolved
+// challenge is SHA256(wholeFileContents + nonce).
+func TestResolveChallenge_WholeFileHash(t *testing.T) {
+	codebase := sampleTestFS()
+	loc := SampleLocation{FileStack: []int{0}} // root, first regular file = rootfile.go
+	nonce := int64(7)
+
+	got, err := ResolveChallenge(codebase, loc, nonce)
+	if err != nil {
+		t.Fatalf("resolve: %v", err)
+	}
+	want := ConvertToSHA256([]byte(rootGo + strconv.FormatInt(nonce, 10)))
+	if !bytes.Equal(got, want) {
+		t.Fatalf("challenge is not SHA256(wholeFile + nonce)")
+	}
+}
+
+func TestResolveChallenge_Deterministic(t *testing.T) {
+	codebase := sampleTestFS()
+	loc := SampleLocation{FileStack: []int{0}}
+
+	r1, err := ResolveChallenge(codebase, loc, 42)
+	if err != nil {
+		t.Fatal(err)
+	}
+	r2, err := ResolveChallenge(codebase, loc, 42)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(r1, r2) {
+		t.Fatal("same location and nonce produced different challenges")
+	}
+
+	r3, err := ResolveChallenge(codebase, loc, 43)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if bytes.Equal(r1, r3) {
+		t.Fatal("different nonce produced identical challenge")
+	}
+}
+
+func TestResolveChallenge_Errors(t *testing.T) {
+	codebase := sampleTestFS()
+
+	if _, err := ResolveChallenge(codebase, SampleLocation{}, 1); !errors.Is(err, ErrInvalidStackSize) {
+		t.Fatalf("empty FileStack: want ErrInvalidStackSize, got %v", err)
+	}
+	if _, err := ResolveChallenge(codebase, SampleLocation{FileStack: []int{999}}, 1); !errors.Is(err, ErrSampleIndexOutOfBounds) {
+		t.Fatalf("file index out of bounds: want ErrSampleIndexOutOfBounds, got %v", err)
+	}
+	if _, err := ResolveChallenge(codebase, SampleLocation{DirStack: []int{999}, FileStack: []int{0}}, 1); !errors.Is(err, ErrSampleIndexOutOfBounds) {
+		t.Fatalf("dir index out of bounds: want ErrSampleIndexOutOfBounds, got %v", err)
+	}
+	if _, err := ResolveChallenge(codebase, SampleLocation{FileStack: []int{-1}}, 1); !errors.Is(err, ErrSampleIndexOutOfBounds) {
+		t.Fatalf("negative file index: want ErrSampleIndexOutOfBounds, got %v", err)
+	}
+	if _, err := ResolveChallenge(codebase, SampleLocation{DirStack: []int{-1}, FileStack: []int{0}}, 1); !errors.Is(err, ErrSampleIndexOutOfBounds) {
+		t.Fatalf("negative dir index: want ErrSampleIndexOutOfBounds, got %v", err)
+	}
+}
+
+func TestGenerateChallenge_NoFiles(t *testing.T) {
+	if _, _, err := GenerateChallenge(fstest.MapFS{}, 1); !errors.Is(err, ErrNoSampleFiles) {
+		t.Fatalf("empty codebase: want ErrNoSampleFiles, got %v", err)
+	}
+}

version

@@ -1 +1 @@
-0.7.329
+0.7.338