src/util/fipstools/acvp/acvptool/subprocess/subprocess.go - boringssl.git - Git at Google

 // Copyright (c) 2019, Google Inc.
 //
 // Permission to use, copy, modify, and/or distribute this software for any
 // purpose with or without fee is hereby granted, provided that the above
 // copyright notice and this permission notice appear in all copies.
 //
 // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 // SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
 // OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 // CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 // Package subprocess contains functionality to talk to a modulewrapper for
 // testing of various algorithm implementations.
 package subprocess

 import (
 	"encoding/binary"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"os"
 	"os/exec"
 )

 // Transactable provides an interface to allow test injection of transactions
 // that don't call a server.
 type Transactable interface {
 	Transact(cmd string, expectedResults int, args ...[]byte) ([][]byte, error)
 	TransactAsync(cmd string, expectedResults int, args [][]byte, callback func([][]byte) error)
 	Barrier(callback func()) error
 	Flush() error
 }

 // Subprocess is a "middle" layer that interacts with a FIPS module via running
 // a command and speaking a simple protocol over stdin/stdout.
 type Subprocess struct {
 	cmd        *exec.Cmd
 	stdin      io.WriteCloser
 	stdout     io.ReadCloser
 	primitives map[string]primitive
 	// supportsFlush is true if the modulewrapper indicated that it wants to receive flush commands.
 	supportsFlush bool
 	// pendingReads is a queue of expected responses. `readerRoutine` reads each response and calls the callback in the matching pendingRead.
 	pendingReads chan pendingRead
 	// readerFinished is a channel that is closed if `readerRoutine` has finished (e.g. because of a read error).
 	readerFinished chan struct{}
 }

 // pendingRead represents an expected response from the modulewrapper.
 type pendingRead struct {
 	// barrierCallback is called as soon as this pendingRead is the next in the queue, before any read from the modulewrapper.
 	barrierCallback func()

 	// callback is called with the result from the modulewrapper. If this is nil then no read is performed.
 	callback func(result [][]byte) error
 	// cmd is the command that requested this read for logging purposes.
 	cmd                string
 	expectedNumResults int
 }

 // New returns a new Subprocess middle layer that runs the given binary.
 func New(path string) (*Subprocess, error) {
 	cmd := exec.Command(path)
 	cmd.Stderr = os.Stderr
 	stdin, err := cmd.StdinPipe()
 	if err != nil {
 		return nil, err
 	}
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
 		return nil, err
 	}

 	if err := cmd.Start(); err != nil {
 		return nil, err
 	}

 	return NewWithIO(cmd, stdin, stdout), nil
 }

 // maxPending is the maximum number of requests that can be in the pipeline.
 const maxPending = 4096

 // NewWithIO returns a new Subprocess middle layer with the given ReadCloser and
 // WriteCloser. The returned Subprocess will call Wait on the Cmd when closed.
 func NewWithIO(cmd *exec.Cmd, in io.WriteCloser, out io.ReadCloser) *Subprocess {
 	m := &Subprocess{
 		cmd:            cmd,
 		stdin:          in,
 		stdout:         out,
 		pendingReads:   make(chan pendingRead, maxPending),
 		readerFinished: make(chan struct{}),
 	}

 	m.primitives = map[string]primitive{
 		"SHA-1":             &hashPrimitive{"SHA-1", 20},
 		"SHA2-224":          &hashPrimitive{"SHA2-224", 28},
 		"SHA2-256":          &hashPrimitive{"SHA2-256", 32},
 		"SHA2-384":          &hashPrimitive{"SHA2-384", 48},
 		"SHA2-512":          &hashPrimitive{"SHA2-512", 64},
 		"SHA2-512/256":      &hashPrimitive{"SHA2-512/256", 32},
 		"SHA3-224":          &hashPrimitive{"SHA3-224", 28},
 		"SHA3-256":          &hashPrimitive{"SHA3-256", 32},
 		"SHA3-384":          &hashPrimitive{"SHA3-384", 48},
 		"SHA3-512":          &hashPrimitive{"SHA3-512", 64},
 		"ACVP-AES-ECB":      &blockCipher{"AES", 16, 2, true, false, iterateAES},
 		"ACVP-AES-CBC":      &blockCipher{"AES-CBC", 16, 2, true, true, iterateAESCBC},
 		"ACVP-AES-CBC-CS3":  &blockCipher{"AES-CBC-CS3", 16, 1, false, true, iterateAESCBC},
 		"ACVP-AES-CTR":      &blockCipher{"AES-CTR", 16, 1, false, true, nil},
 		"ACVP-TDES-ECB":     &blockCipher{"3DES-ECB", 8, 3, true, false, iterate3DES},
 		"ACVP-TDES-CBC":     &blockCipher{"3DES-CBC", 8, 3, true, true, iterate3DESCBC},
 		"ACVP-AES-XTS":      &xts{},
 		"ACVP-AES-GCM":      &aead{"AES-GCM", false},
 		"ACVP-AES-GMAC":     &aead{"AES-GCM", false},
 		"ACVP-AES-CCM":      &aead{"AES-CCM", true},
 		"ACVP-AES-KW":       &aead{"AES-KW", false},
 		"ACVP-AES-KWP":      &aead{"AES-KWP", false},
 		"HMAC-SHA-1":        &hmacPrimitive{"HMAC-SHA-1", 20},
 		"HMAC-SHA2-224":     &hmacPrimitive{"HMAC-SHA2-224", 28},
 		"HMAC-SHA2-256":     &hmacPrimitive{"HMAC-SHA2-256", 32},
 		"HMAC-SHA2-384":     &hmacPrimitive{"HMAC-SHA2-384", 48},
 		"HMAC-SHA2-512":     &hmacPrimitive{"HMAC-SHA2-512", 64},
 		"HMAC-SHA2-512/256": &hmacPrimitive{"HMAC-SHA2-512/256", 32},
 		"HMAC-SHA3-224":     &hmacPrimitive{"HMAC-SHA3-224", 28},
 		"HMAC-SHA3-256":     &hmacPrimitive{"HMAC-SHA3-256", 32},
 		"HMAC-SHA3-384":     &hmacPrimitive{"HMAC-SHA3-384", 48},
 		"HMAC-SHA3-512":     &hmacPrimitive{"HMAC-SHA3-512", 64},
 		"ctrDRBG":           &drbg{"ctrDRBG", map[string]bool{"AES-128": true, "AES-192": true, "AES-256": true}},
 		"hmacDRBG":          &drbg{"hmacDRBG", map[string]bool{"SHA-1": true, "SHA2-224": true, "SHA2-256": true, "SHA2-384": true, "SHA2-512": true}},
 		"KDF":               &kdfPrimitive{},
 		"KDA":               &hkdf{},
 		"TLS-v1.2":          &tlsKDF{},
 		"TLS-v1.3":          &tls13{},
 		"CMAC-AES":          &keyedMACPrimitive{"CMAC-AES"},
 		"RSA":               &rsa{},
 		"KAS-ECC-SSC":       &kas{},
 		"KAS-FFC-SSC":       &kasDH{},
 	}
 	m.primitives["ECDSA"] = &ecdsa{"ECDSA", map[string]bool{"P-224": true, "P-256": true, "P-384": true, "P-521": true}, m.primitives}

 	go m.readerRoutine()
 	return m
 }

 // Close signals the child process to exit and waits for it to complete.
 func (m *Subprocess) Close() {
 	m.stdout.Close()
 	m.stdin.Close()
 	m.cmd.Wait()
 	close(m.pendingReads)
 	<-m.readerFinished
 }

 func (m *Subprocess) flush() error {
 	if !m.supportsFlush {
 		return nil
 	}

 	const cmd = "flush"
 	buf := make([]byte, 8, 8+len(cmd))
 	binary.LittleEndian.PutUint32(buf, 1)
 	binary.LittleEndian.PutUint32(buf[4:], uint32(len(cmd)))
 	buf = append(buf, []byte(cmd)...)

 	if _, err := m.stdin.Write(buf); err != nil {
 		return err
 	}
 	return nil
 }

 func (m *Subprocess) enqueueRead(pending pendingRead) error {
 	select {
 	case <-m.readerFinished:
 		panic("attempted to enqueue request after the reader failed")
 	default:
 	}

 	select {
 	case m.pendingReads <- pending:
 		break
 	default:
 		// `pendingReads` is full. Ensure that the modulewrapper will process
 		// some outstanding requests to free up space in the queue.
 		if err := m.flush(); err != nil {
 			return err
 		}
 		m.pendingReads <- pending
 	}

 	return nil
 }

 // TransactAsync performs a single request--response pair with the subprocess.
 // The callback will run at some future point, in a separate goroutine. All
 // callbacks will, however, be run in the order that TransactAsync was called.
 // Use Flush to wait for all outstanding callbacks.
 func (m *Subprocess) TransactAsync(cmd string, expectedNumResults int, args [][]byte, callback func(result [][]byte) error) {
 	if err := m.enqueueRead(pendingRead{nil, callback, cmd, expectedNumResults}); err != nil {
 		panic(err)
 	}

 	argLength := len(cmd)
 	for _, arg := range args {
 		argLength += len(arg)
 	}

 	buf := make([]byte, 4*(2+len(args)), 4*(2+len(args))+argLength)
 	binary.LittleEndian.PutUint32(buf, uint32(1+len(args)))
 	binary.LittleEndian.PutUint32(buf[4:], uint32(len(cmd)))
 	for i, arg := range args {
 		binary.LittleEndian.PutUint32(buf[4*(i+2):], uint32(len(arg)))
 	}
 	buf = append(buf, []byte(cmd)...)
 	for _, arg := range args {
 		buf = append(buf, arg...)
 	}

 	if _, err := m.stdin.Write(buf); err != nil {
 		panic(err)
 	}
 }

 // Flush tells the subprocess to complete all outstanding requests and waits
 // for all outstanding TransactAsync callbacks to complete.
 func (m *Subprocess) Flush() error {
 	if m.supportsFlush {
 		m.flush()
 	}

 	done := make(chan struct{})
 	if err := m.enqueueRead(pendingRead{barrierCallback: func() {
 		close(done)
 	}}); err != nil {
 		return err
 	}

 	<-done
 	return nil
 }

 // Barrier runs callback after all outstanding TransactAsync callbacks have
 // been run.
 func (m *Subprocess) Barrier(callback func()) error {
 	return m.enqueueRead(pendingRead{barrierCallback: callback})
 }

 func (m *Subprocess) Transact(cmd string, expectedNumResults int, args ...[]byte) ([][]byte, error) {
 	done := make(chan struct{})
 	var result [][]byte
 	m.TransactAsync(cmd, expectedNumResults, args, func(r [][]byte) error {
 		result = r
 		close(done)
 		return nil
 	})

 	if err := m.flush(); err != nil {
 		return nil, err
 	}

 	select {
 	case <-done:
 		return result, nil
 	case <-m.readerFinished:
 		panic("was still waiting for a result when the reader finished")
 	}
 }

 func (m *Subprocess) readerRoutine() {
 	defer close(m.readerFinished)

 	for pendingRead := range m.pendingReads {
 		if pendingRead.barrierCallback != nil {
 			pendingRead.barrierCallback()
 		}

 		if pendingRead.callback == nil {
 			continue
 		}

 		result, err := m.readResult(pendingRead.cmd, pendingRead.expectedNumResults)
 		if err != nil {
 			panic(fmt.Errorf("failed to read from subprocess: %w", err))
 		}

 		if err := pendingRead.callback(result); err != nil {
 			panic(fmt.Errorf("result from subprocess was rejected: %w", err))
 		}
 	}
 }

 func (m *Subprocess) readResult(cmd string, expectedNumResults int) ([][]byte, error) {
 	buf := make([]byte, 4)

 	if _, err := io.ReadFull(m.stdout, buf); err != nil {
 		return nil, err
 	}

 	numResults := binary.LittleEndian.Uint32(buf)
 	if int(numResults) != expectedNumResults {
 		return nil, fmt.Errorf("expected %d results from %q but got %d", expectedNumResults, cmd, numResults)
 	}

 	buf = make([]byte, 4*numResults)
 	if _, err := io.ReadFull(m.stdout, buf); err != nil {
 		return nil, err
 	}

 	var resultsLength uint64
 	for i := uint32(0); i < numResults; i++ {
 		resultsLength += uint64(binary.LittleEndian.Uint32(buf[4*i:]))
 	}

 	if resultsLength > (1 << 30) {
 		return nil, fmt.Errorf("results too large (%d bytes)", resultsLength)
 	}

 	results := make([]byte, resultsLength)
 	if _, err := io.ReadFull(m.stdout, results); err != nil {
 		return nil, err
 	}

 	ret := make([][]byte, 0, numResults)
 	var offset int
 	for i := uint32(0); i < numResults; i++ {
 		length := binary.LittleEndian.Uint32(buf[4*i:])
 		ret = append(ret, results[offset:offset+int(length)])
 		offset += int(length)
 	}

 	return ret, nil
 }

 // Config returns a JSON blob that describes the supported primitives. The
 // format of the blob is defined by ACVP. See
 // http://usnistgov.github.io/ACVP/artifacts/draft-fussell-acvp-spec-00.html#rfc.section.11.15.2.1
 func (m *Subprocess) Config() ([]byte, error) {
 	results, err := m.Transact("getConfig", 1)
 	if err != nil {
 		return nil, err
 	}
 	var config []struct {
 		Algorithm string   `json:"algorithm"`
 		Features  []string `json:"features"`
 	}
 	if err := json.Unmarshal(results[0], &config); err != nil {
 		return nil, errors.New("failed to parse config response from wrapper: " + err.Error())
 	}
 	for _, algo := range config {
 		if algo.Algorithm == "acvptool" {
 			for _, feature := range algo.Features {
 				switch feature {
 				case "batch":
 					m.supportsFlush = true
 				}
 			}
 		} else if _, ok := m.primitives[algo.Algorithm]; !ok {
 			return nil, fmt.Errorf("wrapper config advertises support for unknown algorithm %q", algo.Algorithm)
 		}
 	}

 	return results[0], nil
 }

 // Process runs a set of test vectors and returns the result.
 func (m *Subprocess) Process(algorithm string, vectorSet []byte) (any, error) {
 	prim, ok := m.primitives[algorithm]
 	if !ok {
 		return nil, fmt.Errorf("unknown algorithm %q", algorithm)
 	}
 	ret, err := prim.Process(vectorSet, m)
 	if err != nil {
 		return nil, err
 	}
 	return ret, nil
 }

 type primitive interface {
 	Process(vectorSet []byte, t Transactable) (any, error)
 }

 func uint32le(n uint32) []byte {
 	var ret [4]byte
 	binary.LittleEndian.PutUint32(ret[:], n)
 	return ret[:]
 }
	// Copyright (c) 2019, Google Inc.
	//
	// Permission to use, copy, modify, and/or distribute this software for any
	// purpose with or without fee is hereby granted, provided that the above
	// copyright notice and this permission notice appear in all copies.
	//
	// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
	// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
	// OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
	// CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

	// Package subprocess contains functionality to talk to a modulewrapper for
	// testing of various algorithm implementations.
	package subprocess

	import (
	"encoding/binary"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"os"
	"os/exec"
	)

	// Transactable provides an interface to allow test injection of transactions
	// that don't call a server.
	type Transactable interface {
	Transact(cmd string, expectedResults int, args ...[]byte) ([][]byte, error)
	TransactAsync(cmd string, expectedResults int, args [][]byte, callback func([][]byte) error)
	Barrier(callback func()) error
	Flush() error
	}

	// Subprocess is a "middle" layer that interacts with a FIPS module via running
	// a command and speaking a simple protocol over stdin/stdout.
	type Subprocess struct {
	cmd *exec.Cmd
	stdin io.WriteCloser
	stdout io.ReadCloser
	primitives map[string]primitive
	// supportsFlush is true if the modulewrapper indicated that it wants to receive flush commands.
	supportsFlush bool
	// pendingReads is a queue of expected responses. `readerRoutine` reads each response and calls the callback in the matching pendingRead.
	pendingReads chan pendingRead
	// readerFinished is a channel that is closed if `readerRoutine` has finished (e.g. because of a read error).
	readerFinished chan struct{}
	}

	// pendingRead represents an expected response from the modulewrapper.
	type pendingRead struct {
	// barrierCallback is called as soon as this pendingRead is the next in the queue, before any read from the modulewrapper.
	barrierCallback func()

	// callback is called with the result from the modulewrapper. If this is nil then no read is performed.
	callback func(result [][]byte) error
	// cmd is the command that requested this read for logging purposes.
	cmd string
	expectedNumResults int
	}

	// New returns a new Subprocess middle layer that runs the given binary.
	func New(path string) (*Subprocess, error) {
	cmd := exec.Command(path)
	cmd.Stderr = os.Stderr
	stdin, err := cmd.StdinPipe()
	if err != nil {
	return nil, err
	}
	stdout, err := cmd.StdoutPipe()
	if err != nil {
	return nil, err
	}

	if err := cmd.Start(); err != nil {
	return nil, err
	}

	return NewWithIO(cmd, stdin, stdout), nil
	}

	// maxPending is the maximum number of requests that can be in the pipeline.
	const maxPending = 4096

	// NewWithIO returns a new Subprocess middle layer with the given ReadCloser and
	// WriteCloser. The returned Subprocess will call Wait on the Cmd when closed.
	func NewWithIO(cmd exec.Cmd, in io.WriteCloser, out io.ReadCloser) Subprocess {
	m := &Subprocess{
	cmd: cmd,
	stdin: in,
	stdout: out,
	pendingReads: make(chan pendingRead, maxPending),
	readerFinished: make(chan struct{}),
	}

	m.primitives = map[string]primitive{
	"SHA-1": &hashPrimitive{"SHA-1", 20},
	"SHA2-224": &hashPrimitive{"SHA2-224", 28},
	"SHA2-256": &hashPrimitive{"SHA2-256", 32},
	"SHA2-384": &hashPrimitive{"SHA2-384", 48},
	"SHA2-512": &hashPrimitive{"SHA2-512", 64},
	"SHA2-512/256": &hashPrimitive{"SHA2-512/256", 32},
	"SHA3-224": &hashPrimitive{"SHA3-224", 28},
	"SHA3-256": &hashPrimitive{"SHA3-256", 32},
	"SHA3-384": &hashPrimitive{"SHA3-384", 48},
	"SHA3-512": &hashPrimitive{"SHA3-512", 64},
	"ACVP-AES-ECB": &blockCipher{"AES", 16, 2, true, false, iterateAES},
	"ACVP-AES-CBC": &blockCipher{"AES-CBC", 16, 2, true, true, iterateAESCBC},
	"ACVP-AES-CBC-CS3": &blockCipher{"AES-CBC-CS3", 16, 1, false, true, iterateAESCBC},
	"ACVP-AES-CTR": &blockCipher{"AES-CTR", 16, 1, false, true, nil},
	"ACVP-TDES-ECB": &blockCipher{"3DES-ECB", 8, 3, true, false, iterate3DES},
	"ACVP-TDES-CBC": &blockCipher{"3DES-CBC", 8, 3, true, true, iterate3DESCBC},
	"ACVP-AES-XTS": &xts{},
	"ACVP-AES-GCM": &aead{"AES-GCM", false},
	"ACVP-AES-GMAC": &aead{"AES-GCM", false},
	"ACVP-AES-CCM": &aead{"AES-CCM", true},
	"ACVP-AES-KW": &aead{"AES-KW", false},
	"ACVP-AES-KWP": &aead{"AES-KWP", false},
	"HMAC-SHA-1": &hmacPrimitive{"HMAC-SHA-1", 20},
	"HMAC-SHA2-224": &hmacPrimitive{"HMAC-SHA2-224", 28},
	"HMAC-SHA2-256": &hmacPrimitive{"HMAC-SHA2-256", 32},
	"HMAC-SHA2-384": &hmacPrimitive{"HMAC-SHA2-384", 48},
	"HMAC-SHA2-512": &hmacPrimitive{"HMAC-SHA2-512", 64},
	"HMAC-SHA2-512/256": &hmacPrimitive{"HMAC-SHA2-512/256", 32},
	"HMAC-SHA3-224": &hmacPrimitive{"HMAC-SHA3-224", 28},
	"HMAC-SHA3-256": &hmacPrimitive{"HMAC-SHA3-256", 32},
	"HMAC-SHA3-384": &hmacPrimitive{"HMAC-SHA3-384", 48},
	"HMAC-SHA3-512": &hmacPrimitive{"HMAC-SHA3-512", 64},
	"ctrDRBG": &drbg{"ctrDRBG", map[string]bool{"AES-128": true, "AES-192": true, "AES-256": true}},
	"hmacDRBG": &drbg{"hmacDRBG", map[string]bool{"SHA-1": true, "SHA2-224": true, "SHA2-256": true, "SHA2-384": true, "SHA2-512": true}},
	"KDF": &kdfPrimitive{},
	"KDA": &hkdf{},
	"TLS-v1.2": &tlsKDF{},
	"TLS-v1.3": &tls13{},
	"CMAC-AES": &keyedMACPrimitive{"CMAC-AES"},
	"RSA": &rsa{},
	"KAS-ECC-SSC": &kas{},
	"KAS-FFC-SSC": &kasDH{},
	}
	m.primitives["ECDSA"] = &ecdsa{"ECDSA", map[string]bool{"P-224": true, "P-256": true, "P-384": true, "P-521": true}, m.primitives}

	go m.readerRoutine()
	return m
	}

	// Close signals the child process to exit and waits for it to complete.
	func (m *Subprocess) Close() {
	m.stdout.Close()
	m.stdin.Close()
	m.cmd.Wait()
	close(m.pendingReads)
	<-m.readerFinished
	}

	func (m *Subprocess) flush() error {
	if !m.supportsFlush {
	return nil
	}

	const cmd = "flush"
	buf := make([]byte, 8, 8+len(cmd))
	binary.LittleEndian.PutUint32(buf, 1)
	binary.LittleEndian.PutUint32(buf[4:], uint32(len(cmd)))
	buf = append(buf, []byte(cmd)...)

	if _, err := m.stdin.Write(buf); err != nil {
	return err
	}
	return nil
	}

	func (m *Subprocess) enqueueRead(pending pendingRead) error {
	select {
	case <-m.readerFinished:
	panic("attempted to enqueue request after the reader failed")
	default:
	}

	select {
	case m.pendingReads <- pending:
	break
	default:
	// `pendingReads` is full. Ensure that the modulewrapper will process
	// some outstanding requests to free up space in the queue.
	if err := m.flush(); err != nil {
	return err
	}
	m.pendingReads <- pending
	}

	return nil
	}

	// TransactAsync performs a single request--response pair with the subprocess.
	// The callback will run at some future point, in a separate goroutine. All
	// callbacks will, however, be run in the order that TransactAsync was called.
	// Use Flush to wait for all outstanding callbacks.
	func (m *Subprocess) TransactAsync(cmd string, expectedNumResults int, args [][]byte, callback func(result [][]byte) error) {
	if err := m.enqueueRead(pendingRead{nil, callback, cmd, expectedNumResults}); err != nil {
	panic(err)
	}

	argLength := len(cmd)
	for _, arg := range args {
	argLength += len(arg)
	}

	buf := make([]byte, 4(2+len(args)), 4(2+len(args))+argLength)
	binary.LittleEndian.PutUint32(buf, uint32(1+len(args)))
	binary.LittleEndian.PutUint32(buf[4:], uint32(len(cmd)))
	for i, arg := range args {
	binary.LittleEndian.PutUint32(buf[4*(i+2):], uint32(len(arg)))
	}
	buf = append(buf, []byte(cmd)...)
	for _, arg := range args {
	buf = append(buf, arg...)
	}

	if _, err := m.stdin.Write(buf); err != nil {
	panic(err)
	}
	}

	// Flush tells the subprocess to complete all outstanding requests and waits
	// for all outstanding TransactAsync callbacks to complete.
	func (m *Subprocess) Flush() error {
	if m.supportsFlush {
	m.flush()
	}

	done := make(chan struct{})
	if err := m.enqueueRead(pendingRead{barrierCallback: func() {
	close(done)
	}}); err != nil {
	return err
	}

	<-done
	return nil
	}

	// Barrier runs callback after all outstanding TransactAsync callbacks have
	// been run.
	func (m *Subprocess) Barrier(callback func()) error {
	return m.enqueueRead(pendingRead{barrierCallback: callback})
	}

	func (m *Subprocess) Transact(cmd string, expectedNumResults int, args ...[]byte) ([][]byte, error) {
	done := make(chan struct{})
	var result [][]byte
	m.TransactAsync(cmd, expectedNumResults, args, func(r [][]byte) error {
	result = r
	close(done)
	return nil
	})

	if err := m.flush(); err != nil {
	return nil, err
	}

	select {
	case <-done:
	return result, nil
	case <-m.readerFinished:
	panic("was still waiting for a result when the reader finished")
	}
	}

	func (m *Subprocess) readerRoutine() {
	defer close(m.readerFinished)

	for pendingRead := range m.pendingReads {
	if pendingRead.barrierCallback != nil {
	pendingRead.barrierCallback()
	}

	if pendingRead.callback == nil {
	continue
	}

	result, err := m.readResult(pendingRead.cmd, pendingRead.expectedNumResults)
	if err != nil {
	panic(fmt.Errorf("failed to read from subprocess: %w", err))
	}

	if err := pendingRead.callback(result); err != nil {
	panic(fmt.Errorf("result from subprocess was rejected: %w", err))
	}
	}
	}

	func (m *Subprocess) readResult(cmd string, expectedNumResults int) ([][]byte, error) {
	buf := make([]byte, 4)

	if _, err := io.ReadFull(m.stdout, buf); err != nil {
	return nil, err
	}

	numResults := binary.LittleEndian.Uint32(buf)
	if int(numResults) != expectedNumResults {
	return nil, fmt.Errorf("expected %d results from %q but got %d", expectedNumResults, cmd, numResults)
	}

	buf = make([]byte, 4*numResults)
	if _, err := io.ReadFull(m.stdout, buf); err != nil {
	return nil, err
	}

	var resultsLength uint64
	for i := uint32(0); i < numResults; i++ {
	resultsLength += uint64(binary.LittleEndian.Uint32(buf[4*i:]))
	}

	if resultsLength > (1 << 30) {
	return nil, fmt.Errorf("results too large (%d bytes)", resultsLength)
	}

	results := make([]byte, resultsLength)
	if _, err := io.ReadFull(m.stdout, results); err != nil {
	return nil, err
	}

	ret := make([][]byte, 0, numResults)
	var offset int
	for i := uint32(0); i < numResults; i++ {
	length := binary.LittleEndian.Uint32(buf[4*i:])
	ret = append(ret, results[offset:offset+int(length)])
	offset += int(length)
	}

	return ret, nil
	}

	// Config returns a JSON blob that describes the supported primitives. The
	// format of the blob is defined by ACVP. See
	// http://usnistgov.github.io/ACVP/artifacts/draft-fussell-acvp-spec-00.html#rfc.section.11.15.2.1
	func (m *Subprocess) Config() ([]byte, error) {
	results, err := m.Transact("getConfig", 1)
	if err != nil {
	return nil, err
	}
	var config []struct {
	Algorithm string `json:"algorithm"`
	Features []string `json:"features"`
	}
	if err := json.Unmarshal(results[0], &config); err != nil {
	return nil, errors.New("failed to parse config response from wrapper: " + err.Error())
	}
	for _, algo := range config {
	if algo.Algorithm == "acvptool" {
	for _, feature := range algo.Features {
	switch feature {
	case "batch":
	m.supportsFlush = true
	}
	}
	} else if _, ok := m.primitives[algo.Algorithm]; !ok {
	return nil, fmt.Errorf("wrapper config advertises support for unknown algorithm %q", algo.Algorithm)
	}
	}

	return results[0], nil
	}

	// Process runs a set of test vectors and returns the result.
	func (m *Subprocess) Process(algorithm string, vectorSet []byte) (any, error) {
	prim, ok := m.primitives[algorithm]
	if !ok {
	return nil, fmt.Errorf("unknown algorithm %q", algorithm)
	}
	ret, err := prim.Process(vectorSet, m)
	if err != nil {
	return nil, err
	}
	return ret, nil
	}

	type primitive interface {
	Process(vectorSet []byte, t Transactable) (any, error)
	}

	func uint32le(n uint32) []byte {
	var ret [4]byte
	binary.LittleEndian.PutUint32(ret[:], n)
	return ret[:]
	}