diff --git a/osbase/build/mkverity/mkverity.go b/osbase/build/mkverity/mkverity.go
index 82db0da..f75845d 100644
--- a/osbase/build/mkverity/mkverity.go
+++ b/osbase/build/mkverity/mkverity.go
@@ -11,6 +11,7 @@
 package main
 
 import (
+	"crypto/sha256"
 	"flag"
 	"fmt"
 	"io"
@@ -55,20 +56,34 @@
 	}
 	defer outputImage.Close()
 
-	// Copy the input data into the output file, then rewind dataImage to be read
-	// again by the Verity encoder.
+	// Copy the input data into the output file, then rewind dataImage.
 	_, err = io.Copy(outputImage, dataImage)
 	if err != nil {
 		return nil, err
 	}
-	_, err = dataImage.Seek(0, os.SEEK_SET)
+	_, err = dataImage.Seek(0, io.SeekStart)
 	if err != nil {
 		return nil, err
 	}
 
+	// Hash the input data for use as the salt, then rewind dataImage. The purpose
+	// of the salt is to prevent reuse of collisions across different images. 16
+	// bytes is enough for this. We use a hash of the input instead of generating
+	// random bytes to make the build reproducible.
+	dataHash := sha256.New()
+	_, err = io.Copy(dataHash, dataImage)
+	if err != nil {
+		return nil, err
+	}
+	_, err = dataImage.Seek(0, io.SeekStart)
+	if err != nil {
+		return nil, err
+	}
+	salt := dataHash.Sum(nil)[:16]
+
 	// Write outputImage contents. Start with initializing a verity encoder,
-	// seting outputImage as its output.
-	v, err := verity.NewEncoder(outputImage, bs, bs, wsb)
+	// setting outputImage as its output.
+	v, err := verity.NewEncoder(outputImage, bs, bs, salt, wsb)
 	if err != nil {
 		return nil, fmt.Errorf("while initializing a verity encoder: %w", err)
 	}
diff --git a/osbase/verity/encoder.go b/osbase/verity/encoder.go
index 5a968cd..6ba8b97 100644
--- a/osbase/verity/encoder.go
+++ b/osbase/verity/encoder.go
@@ -28,7 +28,6 @@
 
 import (
 	"bytes"
-	"crypto/rand"
 	"crypto/sha256"
 	"encoding/binary"
 	"encoding/hex"
@@ -93,19 +92,10 @@
 		version:       1,
 		hashType:      1,
 		algorithm:     [32]byte{'s', 'h', 'a', '2', '5', '6'},
-		saltSize:      64,
 		dataBlockSize: 4096,
 		hashBlockSize: 4096,
 	}
 
-	// Fill in the superblock UUID and cryptographic salt.
-	if _, err := rand.Read(sb.uuid[:]); err != nil {
-		return nil, fmt.Errorf("when generating UUID: %w", err)
-	}
-	if _, err := rand.Read(sb.saltBuffer[:]); err != nil {
-		return nil, fmt.Errorf("when generating salt: %w", err)
-	}
-
 	return &sb, nil
 }
 
@@ -308,6 +298,10 @@
 // VerityParameterList returns a list of Verity target parameters, ordered
 // as they would appear in a parameter string.
 func (t *MappingTable) VerityParameterList() []string {
+	salt := hex.EncodeToString(t.superblock.salt())
+	if salt == "" {
+		salt = "-"
+	}
 	return []string{
 		"1",
 		t.DataDevicePath,
@@ -318,7 +312,7 @@
 		strconv.FormatInt(t.HashStart, 10),
 		t.superblock.algorithmName(),
 		hex.EncodeToString(t.rootHash),
-		hex.EncodeToString(t.superblock.salt()),
+		salt,
 	}
 }
 
@@ -433,13 +427,14 @@
 // encoder will write to the given io.Writer object.
 // A verity superblock will be written, preceding the hash tree, if
 // writeSb is true.
-func NewEncoder(out io.Writer, dataBlockSize, hashBlockSize uint32, writeSb bool) (*encoder, error) {
+func NewEncoder(out io.Writer, dataBlockSize, hashBlockSize uint32, salt []byte, writeSb bool) (*encoder, error) {
 	sb, err := newSuperblock()
 	if err != nil {
 		return nil, fmt.Errorf("while creating a superblock: %w", err)
 	}
 	sb.dataBlockSize = dataBlockSize
 	sb.hashBlockSize = hashBlockSize
+	sb.saltSize = uint16(copy(sb.saltBuffer[:], salt))
 
 	e := encoder{
 		out:     out,
diff --git a/osbase/verity/encoder_test.go b/osbase/verity/encoder_test.go
index 012cb27..2c9c35b 100644
--- a/osbase/verity/encoder_test.go
+++ b/osbase/verity/encoder_test.go
@@ -93,7 +93,8 @@
 	// Create a Verity encoder, backed with hfd. Configure it to write the
 	// Verity superblock. Use 4096-byte blocks.
 	bs := uint32(4096)
-	verityEnc, err := NewEncoder(hfd, bs, bs, true)
+	salt := []byte("testsalt")
+	verityEnc, err := NewEncoder(hfd, bs, bs, salt, true)
 	require.NoError(t, err, "while creating a Verity encoder")
 
 	// Write pseudorandom data both to the Verity-protected data device, and