wasi: Implement random_get function

wasi/testdata/random.wat

@@ -0,0 +1,24 @@
+;; This is a wat file to just export clock WASI API to the host environment for testing the APIs.
+;; This is currently separated as a wat file and pre-compiled because our text parser doesn't
+;; implement 'memory' yet. After it supports 'memory', we can remove this file and embed this
+;; wat file in the Go test code.
+;;
+;; Note: Although this is a raw wat file which should be moved under /tests/wasi in principle,
+;; this file is put here for now, because this is a temporary file until the parser supports
+;; the enough syntax, and this file will be embedded in unit test codes after that.
+(module
+  (import "wasi_snapshot_preview1" "random_get"
+    (func $wasi.random_get  (param $buf i32) (param $buf_len i32) (result (;errno;) i32)))
+  (memory 1)  ;; just an arbitrary size big enough for tests
+  (export "memory" (memory 0))
+  ;; Define wrapper functions instead of just exporting the imported WASI APIS for now
+  ;; because wazero's interpreter has a bug that it crashes when an imported-and-exported host function
+  ;; is called from the host environment, which will be fixed soon.
+  ;; After it's fixed, these wrapper functions are no longer necessary.
+  (func $random_get (param i32 i32) (result i32)
+        local.get 0
+        local.get 1
+        call $wasi.random_get
+        )
+  (export "random_get" (func $random_get))
+  )

wasi/wasi.go

@@ -1,6 +1,7 @@
 package wasi
 
 import (
+	crand "crypto/rand"
 	"encoding/binary"
 	"errors"
 	"io"
@@ -143,7 +144,24 @@ type API interface {
 	// TODO: ProcExit
 	// TODO: ProcRaise
 	// TODO: SchedYield
-	// TODO: RandomGet
+
+	// RandomGet is a WASI function that write random data in buffer (rand.Read()).
+	//
+	// * buf - is a offset to write random values
+	// * bufLen - size of random data in bytes
+	//
+	// For example, if `HostFunctionCallContext.Randomizer` initialized
+	// with random seed `rand.NewSource(42)`, we expect `ctx.Memory.Buffer` to contain:
+	//
+	//                             bufLen (5)
+	//                    +--------------------------+
+	//                    |                        	 |
+	//          []byte{?, 0x53, 0x8c, 0x7f, 0x96, 0xb1, ?}
+	//              buf --^
+	//
+	// See https://github.com/WebAssembly/WASI/blob/snapshot-01/phases/snapshot/docs.md#-random_getbuf-pointeru8-bufLen-size---errno
+	RandomGet(ctx *wasm.HostFunctionCallContext, buf, bufLen uint32) Errno
+
 	// TODO: SockRecv
 	// TODO: SockSend
 	// TODO: SockShutdown
@@ -154,6 +172,17 @@ const (
 	wasiSnapshotPreview1Name = "wasi_snapshot_preview1"
 )
 
+type RandomSource interface {
+	Read([]byte) (int, error)
+}
+
+// Non-deterministic random source using crypto/rand
+type CryptoRandomSource struct{}
+
+func (c *CryptoRandomSource) Read(p []byte) (n int, err error) {
+	return crand.Read(p)
+}
+
 type api struct {
 	args  *nullTerminatedStrings
 	stdin io.Reader
@@ -162,6 +191,7 @@ type api struct {
 	opened map[uint32]fileEntry
 	// timeNowUnixNano is mutable for testing
 	timeNowUnixNano func() uint64
+	randSource      RandomSource
 }
 
 func (a *api) register(store *wasm.Store) (err error) {
@@ -212,7 +242,7 @@ func (a *api) register(store *wasm.Store) (err error) {
 		{FunctionProcExit, proc_exit},
 		// TODO: FunctionProcRaise
 		// TODO: FunctionSchedYield
-		// TODO: FunctionRandomGet
+		{FunctionRandomGet, a.RandomGet},
 		// TODO: FunctionSockRecv
 		// TODO: FunctionSockSend
 		// TODO: FunctionSockShutdown
@@ -345,6 +375,7 @@ func newAPI(opts ...Option) *api {
 		timeNowUnixNano: func() uint64 {
 			return uint64(time.Now().UnixNano())
 		},
+		randSource: &CryptoRandomSource{},
 	}
 
 	// apply functional options
@@ -355,7 +386,8 @@ func newAPI(opts ...Option) *api {
 }
 
 func (a *api) randUnusedFD() uint32 {
-	fd := uint32(rand.Int31())
+	v := rand.Int31()
+	fd := uint32(v)
 	for {
 		if _, ok := a.opened[fd]; !ok {
 			return fd
@@ -503,6 +535,23 @@ func (a *api) fd_close(ctx *wasm.HostFunctionCallContext, fd uint32) (err Errno)
 	return ErrnoSuccess
 }
 
+// RandomGet implements API.RandomGet
+func (a *api) RandomGet(ctx *wasm.HostFunctionCallContext, buf uint32, bufLen uint32) (errno Errno) {
+	if !ctx.Memory.ValidateAddrRange(buf, uint64(bufLen)) {
+		return ErrnoInval
+	}
+
+	random_bytes := make([]byte, bufLen)
+	_, err := a.randSource.Read(random_bytes)
+	if err != nil {
+		return ErrnoInval
+	}
+
+	copy(ctx.Memory.Buffer[buf:buf+bufLen], random_bytes)
+
+	return ErrnoSuccess
+}
+
 func proc_exit(*wasm.HostFunctionCallContext, uint32) {
 	// TODO: implement
 }

wasi/wasi_test.go

@@ -3,6 +3,7 @@ package wasi
 import (
 	"context"
 	_ "embed"
+	mrand "math/rand"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -312,7 +313,88 @@ func TestAPI_ClockTimeGet_Errors(t *testing.T) {
 // TODO: TestAPI_ProcExit TestAPI_ProcExit_Errors
 // TODO: TestAPI_ProcRaise TestAPI_ProcRaise_Errors
 // TODO: TestAPI_SchedYield TestAPI_SchedYield_Errors
-// TODO: TestAPI_RandomGet TestAPI_RandomGet_Errors
+
+// randomWat is a wasm module to call random_get.
+//go:embed testdata/random.wat
+var randomWat []byte
+
+// Non-deterministic random rource using crypto/rand
+type DummyRandomSource struct {
+	rng *mrand.Rand
+}
+
+func (d *DummyRandomSource) Read(p []byte) (n int, err error) {
+	return d.rng.Read(p)
+}
+
+func NewDummyRandomSource(seed int64) RandomSource {
+	s := mrand.NewSource(seed)
+
+	return &DummyRandomSource{
+		rng: mrand.New(s),
+	}
+}
+
+func TestAPI_RandomGet(t *testing.T) {
+	store, wasiAPI := instantiateWasmStore(t, randomWat, "test")
+	maskLength := 7 // number of bytes to write '?' to tell what we've written
+	expectedMemory := []byte{
+		'?',                          // random bytes in `buf` is after this
+		0x53, 0x8c, 0x7f, 0x96, 0xb1, // random data from seed value of 42
+		'?', // stopped after encoding
+	} // tr
+
+	var bufLen = uint32(5) // arbitrary buffer size,
+	var buf = uint32(1)    // offset,
+	var seed = int64(42)   // and seed value
+
+	wasiAPI.(*api).randSource = NewDummyRandomSource(seed)
+
+	t.Run("API.RandomGet", func(t *testing.T) {
+		maskMemory(store, maskLength)
+		// provide a host context with a seed value for random generator
+		hContext := wasm.NewHostFunctionCallContext(context.Background(), store.Memories[0])
+
+		errno := wasiAPI.RandomGet(hContext, buf, bufLen)
+		require.Equal(t, ErrnoSuccess, errno)
+		require.Equal(t, expectedMemory, store.Memories[0].Buffer[0:maskLength])
+	})
+}
+
+func TestAPI_RandomGet_Errors(t *testing.T) {
+	store, _ := instantiateWasmStore(t, randomWat, "test")
+
+	memorySize := uint32(len(store.Memories[0].Buffer))
+	validAddress := uint32(0) // arbitrary valid address as arguments to args_sizes_get. We chose 0 here.
+	tests := []struct {
+		name   string
+		buf    uint32
+		bufLen uint32
+	}{
+		{
+			name:   "random buffer out-of-memory",
+			buf:    memorySize,
+			bufLen: 1,
+		},
+
+		{
+			name:   "random buffer size exceeds the maximum valid address by 1",
+			buf:    validAddress,
+			bufLen: memorySize + 1,
+		},
+	}
+
+	for _, tt := range tests {
+		tc := tt
+
+		t.Run(tc.name, func(t *testing.T) {
+			ret, _, err := store.CallFunction(context.Background(), "test", FunctionRandomGet, uint64(tc.buf), uint64(tc.bufLen))
+			require.NoError(t, err)
+			require.Equal(t, uint64(ErrnoInval), ret[0]) // ret[0] is returned errno
+		})
+	}
+}
+
 // TODO: TestAPI_SockRecv TestAPI_SockRecv_Errors
 // TODO: TestAPI_SockSend TestAPI_SockSend_Errors
 // TODO: TestAPI_SockShutdown TestAPI_SockShutdown_Errors