Fuzzing message and metadata packages

.fleece.yaml

@@ -0,0 +1,2 @@
+fleece-dir: fleece
+repo-root: .

fleece/docker/go-fuzz.dockerfile

@@ -0,0 +1,14 @@
+FROM golang:1.14-alpine
+
+# Install deps and useful things
+RUN apk add build-base pkgconfig bash vim git
+
+# Install go-fuzz
+RUN GO111MODULE=off go get -u github.com/dvyukov/go-fuzz/go-fuzz github.com/dvyukov/go-fuzz/go-fuzz-build
+WORKDIR /tmp/fuzzing
+
+# NB: for use with docker-compose
+COPY ./go-fuzz.sh /go-fuzz.sh
+RUN chmod 755 /go-fuzz.sh
+
+CMD bash

fleece/docker/go-fuzz.sh

@@ -0,0 +1,60 @@
+#! /usr/bin/env bash
+set -e
+
+# TODO: replace this shell script
+# $1 - fuzzer package
+# $2 - name of the fuzzer function (will be used for the `workdir` argument to `go-fuzz`).
+# `--build` - (optional) builds fuzzer package before being run.
+# Additional args following `--` are passed directly to `go-fuzz`.
+
+if [[ $# -lt 2 ]]; then
+  echo "usage: entrypoint.sh <fuzzer package path> <fuzzer func name> [-b|--build] [-- [go-fuzz arg[, ...]]]"
+fi
+
+snake_case() {
+  echo $1 | sed 's,/,_,g'
+}
+
+pkg=$1
+shift
+name=$1
+shift
+# TODO: this hack breaks support for global --config flag
+workdir=$(cat .fleece.yaml |grep fleece-dir|sed -E 's,.+:\s(.+),\1,')/workdirs/${name}
+bin=$(snake_case "${pkg:2}")-fuzz.zip
+bin_path=${workdir}/${bin}
+
+has_built=false
+build() {
+  mkdir -p "${workdir}"
+  go-fuzz-build -o "${bin_path}" "${pkg}"
+  echo "build done"
+}
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+  -b | --build)
+    echo "Building fuzz binary..."
+    build
+    has_built=true
+    shift
+    ;;
+  --)
+    shift
+    rest_args=$@
+    break
+    ;;
+  *)
+    shift
+    ;;
+  esac
+done
+
+if [[ $has_built == "false" && ! -e $bin_path ]]; then
+  echo "Fuzz binary not found; building..."
+  build
+fi
+
+rest_args=$@
+
+go-fuzz -bin="${bin_path}" -func="${name}" -workdir="${workdir}" $rest_args

fleece/workdirs/.gitignore

@@ -0,0 +1 @@
+*.zip

message/message_fuzz.go

@@ -0,0 +1,66 @@
+//+build gofuzz
+
+package message
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+
+	gofuzz "github.com/google/gofuzz"
+	fleece "github.com/leastauthority/fleece/fuzzing"
+)
+
+func FuzzFromNetToNet(data []byte) int {
+	buf1 := bytes.NewBuffer(data)
+	msg1, err := FromNet(buf1)
+	if err != nil {
+		return fleece.FuzzNormal
+	}
+
+	buf2 := new(bytes.Buffer)
+	if err := msg1.ToNet(buf2); err != nil {
+		//return fleece.FuzzNormal
+		panic(fmt.Errorf("unable to serialize message: %w", err))
+	}
+
+	msg2, err := FromNet(buf2)
+	if err != nil {
+		panic(fmt.Errorf("unable to deserialize message: %w", err))
+	}
+
+	if !reflect.DeepEqual(msg1, msg2) {
+		panic("deserialized messages are not deeply equal!")
+	}
+	return fleece.FuzzInteresting
+}
+
+func FuzzFromNetToNetStructural(data []byte) int {
+	msg1 := New()
+	f := gofuzz.NewFromGoFuzz(data).NilChance(0).NumElements(3, 20)
+	f.Fuzz(&msg1)
+
+	buf1 := bytes.NewBuffer(data)
+	if err := msg1.ToNet(buf1); err != nil {
+		return fleece.FuzzNormal
+	}
+
+	msg2, err := FromNet(buf1)
+	if err != nil {
+		panic(fmt.Errorf("unable to deserialize message: %w", err))
+	}
+
+	buf2 := new(bytes.Buffer)
+	if err := msg2.ToNet(buf2); err != nil {
+		panic(fmt.Errorf("unable to serialize message: %w", err))
+	}
+
+	if !reflect.DeepEqual(msg1, msg2) {
+		panic("deserialized messages are not deeply equal!")
+	}
+
+	if bytes.Equal(buf1.Bytes(), buf2.Bytes()) {
+		panic("serialized messages are not equal!")
+	}
+	return fleece.FuzzInteresting
+}

message/message_fuzz_test.go

@@ -0,0 +1,63 @@
+//+build gofuzz
+
+package message
+
+import (
+	"flag"
+	"os"
+	"testing"
+
+	fleece "github.com/leastauthority/fleece/fuzzing"
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	crashLimit           int
+	fleeceDir            string
+	skipPattern          string
+	skipPatternDelimiter string
+	safe, verbose        bool
+
+	env     *fleece.Env
+	filters []fleece.IterFilter
+)
+
+func init() {
+	flag.IntVar(&crashLimit, "crash-limit", 1000, "number of crashing inputs to test before stopping")
+	flag.StringVar(&fleeceDir, "fleece-dir", "fleece", "path to fleece dir relative to repo/module root")
+	flag.StringVar(&skipPattern, "skip", "", "if provided, crashers with recorded outputs which match the pattern will be skipped")
+	flag.StringVar(&skipPatternDelimiter, "skip-delimiter", "", "delimiter used to split skip pattern")
+	flag.BoolVar(&safe, "safe", true, "\"if true, skips crashers with recorded outputs that timed-out or ran out of memory\"")
+	flag.BoolVar(&verbose, "verbose", false, "if true, logs each skip")
+}
+
+func TestMain(m *testing.M) {
+	flag.Parse()
+	env = fleece.NewEnv(fleeceDir)
+
+	skipFilter := fleece.SkipFilter(skipPattern, skipPatternDelimiter, verbose)
+	filters = []fleece.IterFilter{skipFilter}
+	if safe {
+		filters = append(filters,
+			fleece.SkipTimedOut,
+			fleece.SkipOutOfMemory)
+	}
+
+	os.Exit(m.Run())
+}
+
+func TestFuzzFromNetToNet(t *testing.T) {
+	_, panics, _ := fleece.
+		MustNewCrasherIterator(env, FuzzFromNetToNet, filters...).
+		TestFailingLimit(t, crashLimit)
+
+	require.Zero(t, panics)
+}
+
+func TestFuzzFromNetToNetStructural(t *testing.T) {
+	_, panics, _ := fleece.
+		MustNewCrasherIterator(env, FuzzFromNetToNetStructural, filters...).
+		TestFailingLimit(t, crashLimit)
+
+	require.Zero(t, panics)
+}

metadata/metadata_fuzz.go

@@ -0,0 +1,43 @@
+//+build gofuzz
+
+package metadata
+
+import (
+	"bytes"
+	"fmt"
+	fleece "github.com/leastauthority/fleece/fuzzing"
+	"reflect"
+)
+
+// FuzzDecodeMetadata fuzzes the decode metadata function
+func FuzzDecodeEncodeMetadata(data []byte) int {
+	metadata1, err := DecodeMetadata(data)
+	if err != nil {
+		return fleece.FuzzNormal
+	}
+
+	data1, err := EncodeMetadata(metadata1)
+	if err != nil {
+		panic(fmt.Errorf("unable to encode metadata: %w", err))
+	}
+
+	metadata2, err := DecodeMetadata(data1)
+	if err != nil {
+		panic(fmt.Errorf("unable to decode metadata: %w", err))
+	}
+
+	data2, err := EncodeMetadata(metadata2)
+	if err != nil {
+		panic(fmt.Errorf("unable to re-encode metadata: %w", err))
+	}
+
+	if !reflect.DeepEqual(metadata1, metadata2) {
+		panic("deserialized metadata are not deeply equal!")
+	}
+
+	if bytes.Equal(data1, data2) {
+		panic("serialized metadata are not deeply equal!")
+	}
+	return fleece.FuzzInteresting
+}
+

metadata/metadata_fuzz_test.go

@@ -0,0 +1,55 @@
+//+build gofuzz
+
+package metadata
+
+import (
+	"flag"
+	"os"
+	"testing"
+
+	fleece "github.com/leastauthority/fleece/fuzzing"
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	crashLimit           int
+	fleeceDir            string
+	skipPattern          string
+	skipPatternDelimiter string
+	safe, verbose        bool
+
+	env    *fleece.Env
+	filters []fleece.IterFilter
+)
+
+func init() {
+	flag.IntVar(&crashLimit, "crash-limit", 1000, "number of crashing inputs to test before stopping")
+	flag.StringVar(&fleeceDir, "fleece-dir", "fleece", "path to fleece dir relative to repo/module root")
+	flag.StringVar(&skipPattern, "skip", "", "if provided, crashers with recorded outputs which match the pattern will be skipped")
+	flag.StringVar(&skipPatternDelimiter, "skip-delimiter", "", "delimiter used to split skip pattern")
+	flag.BoolVar(&safe, "safe", true, "\"if true, skips crashers with recorded outputs that timed-out or ran out of memory\"")
+	flag.BoolVar(&verbose, "verbose", false, "if true, logs each skip")
+}
+
+func TestMain(m *testing.M) {
+	flag.Parse()
+	env = fleece.NewEnv(fleeceDir)
+
+	skipFilter := fleece.SkipFilter(skipPattern, skipPatternDelimiter, verbose)
+	filters = []fleece.IterFilter{skipFilter}
+	if safe {
+		filters = append(filters,
+			fleece.SkipTimedOut,
+			fleece.SkipOutOfMemory)
+	}
+
+	os.Exit(m.Run())
+}
+
+func TestFuzzDecodeEncodeMetadata(t *testing.T) {
+	_, panics, _ := fleece.
+		MustNewCrasherIterator(env, FuzzDecodeEncodeMetadata, filters...).
+		TestFailingLimit(t, crashLimit)
+
+	require.Zero(t, panics)
+}