From 492a476312755200fbec6fb289efcfa9918d228b Mon Sep 17 00:00:00 2001 From: Joe Tsai Date: Mon, 26 Nov 2018 17:16:32 -0800 Subject: [PATCH] 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 --- internal/detrand/rand.go | 63 ++++++++++++++++++++++++++++++++ internal/detrand/rand_test.go | 14 +++++++ internal/encoding/text/encode.go | 9 ++--- reflect/prototype/stringer.go | 4 +- 4 files changed, 82 insertions(+), 8 deletions(-) create mode 100644 internal/detrand/rand.go create mode 100644 internal/detrand/rand_test.go diff --git a/internal/detrand/rand.go b/internal/detrand/rand.go new file mode 100644 index 00000000..c702f8f8 --- /dev/null +++ b/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() +} diff --git a/internal/detrand/rand_test.go b/internal/detrand/rand_test.go new file mode 100644 index 00000000..68c55d28 --- /dev/null +++ b/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() + } +} diff --git a/internal/encoding/text/encode.go b/internal/encoding/text/encode.go index f7d185a3..3892eca0 100644 --- a/internal/encoding/text/encode.go +++ b/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...) } diff --git a/reflect/prototype/stringer.go b/reflect/prototype/stringer.go index aca6d7b4..84006892 100644 --- a/reflect/prototype/stringer.go +++ b/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)] }