internal/detrand: new package for deterministically random functionality

The use of math/rand in serialization is to provide some form of instability
to the output to provide a clear signal to the user that the should not
depend on the the property of stability. However, it is reasonable that users
expect the output for these to be deterministic.

As such, add a detrand package that provides deterministic, yet unstable
randomization functionality.

Since this package hashes the binary, it does impose a small initialization cost:
	Benchmark    100000    20712 ns/op    480 B/op    6 allocs/op

Change-Id: I232d0fea1789a4278079837a67ee2f63474a4364
Reviewed-on: https://go-review.googlesource.com/c/151340
Reviewed-by: Herbie Ong <herbie@google.com>

internal/detrand/rand.go

@@ -0,0 +1,63 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package detrand provides deterministically random functionality.
+//
+// The pseudo-randomness of these functions is seeded by the program binary
+// itself and guarantees that the output does not change within a program,
+// while ensuring that the output is unstable across different builds.
+package detrand
+
+import (
+	"encoding/binary"
+	"hash/fnv"
+	"os"
+)
+
+// Bool returns a deterministically random boolean.
+func Bool() bool {
+	return binHash%2 == 0
+}
+
+// Intn returns a deterministically random integer within [0,n).
+func Intn(n int) int {
+	if n <= 0 {
+		panic("invalid argument to Intn")
+	}
+	return int(binHash % uint64(n))
+}
+
+// binHash is a best-effort at an approximate hash of the Go binary.
+var binHash = binaryHash()
+
+func binaryHash() uint64 {
+	// Open the Go binary.
+	s, err := os.Executable()
+	if err != nil {
+		return 0
+	}
+	f, err := os.Open(s)
+	if err != nil {
+		return 0
+	}
+	defer f.Close()
+
+	// Hash the size and several samples of the Go binary.
+	const numSamples = 8
+	var buf [64]byte
+	h := fnv.New64()
+	fi, err := f.Stat()
+	if err != nil {
+		return 0
+	}
+	binary.LittleEndian.PutUint64(buf[:8], uint64(fi.Size()))
+	h.Write(buf[:8])
+	for i := int64(0); i < numSamples; i++ {
+		if _, err := f.ReadAt(buf[:], i*fi.Size()/numSamples); err != nil {
+			return 0
+		}
+		h.Write(buf[:])
+	}
+	return h.Sum64()
+}

internal/detrand/rand_test.go

@@ -0,0 +1,14 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package detrand
+
+import "testing"
+
+func Benchmark(b *testing.B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		binaryHash()
+	}
+}

internal/encoding/text/encode.go

@@ -6,9 +6,9 @@ package text
 
 import (
 	"bytes"
-	"math/rand"
 	"strings"
 
+	"github.com/golang/protobuf/v2/internal/detrand"
 	"github.com/golang/protobuf/v2/internal/errors"
 )
 
@@ -105,7 +105,6 @@ func (p *encoder) marshalMessage(v Value, emitDelims bool) error {
 			p.out = append(p.out, p.newline...)
 		}
 	}
-	spaceAdded := false
 	for i, item := range items {
 		p.out = append(p.out, p.indents...)
 		if err := p.marshalKey(item[0]); !p.nerr.Merge(err) {
@@ -117,9 +116,8 @@ func (p *encoder) marshalMessage(v Value, emitDelims bool) error {
 		}
 		// For multi-line output, add a random extra space after key: per message to
 		// make output unstable.
-		if !spaceAdded && len(p.indent) > 0 && rand.Intn(2) == 1 {
+		if len(p.indent) > 0 && detrand.Bool() {
 			p.out = append(p.out, ' ')
-			spaceAdded = true
 		}
 
 		if err := p.marshalValue(item[1]); !p.nerr.Merge(err) {
@@ -130,9 +128,8 @@ func (p *encoder) marshalMessage(v Value, emitDelims bool) error {
 		}
 		// For single-line output, add a random extra space after a field per message to
 		// make output unstable.
-		if !spaceAdded && len(p.indent) == 0 && i != len(items)-1 && rand.Intn(2) == 1 {
+		if len(p.indent) == 0 && detrand.Bool() && i != len(items)-1 {
 			p.out = append(p.out, ' ')
-			spaceAdded = true
 		}
 		p.out = append(p.out, p.newline...)
 	}

reflect/prototype/stringer.go

@@ -7,11 +7,11 @@ package prototype
 import (
 	"fmt"
 	"io"
-	"math/rand"
 	"reflect"
 	"strconv"
 	"strings"
 
+	"github.com/golang/protobuf/v2/internal/detrand"
 	"github.com/golang/protobuf/v2/internal/pragma"
 	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
 )
@@ -256,5 +256,5 @@ func joinStrings(ss []string, isMulti bool) string {
 // These makes it harder for people to depend on the debug string as stable
 // and provides us the flexibility to make changes.
 func randomSpace() string {
-	return " "[:rand.Intn(2)]
+	return " "[:detrand.Intn(2)]
 }