google · alexmwu · Dec 10, 2021 · Dec 8, 2021 · Dec 8, 2021 · Dec 9, 2021
diff --git a/cel/canonical_eventlog.go b/cel/canonical_eventlog.go
@@ -9,7 +9,9 @@ import (
 	"fmt"
 	"io"
 
+	pb "github.com/google/go-tpm-tools/proto/tpm"
 	"github.com/google/go-tpm/tpm2"
+	"github.com/google/go-tpm/tpmutil"
 )
 
 const (
@@ -129,7 +131,13 @@ func (c *CEL) AppendEvent(tpm io.ReadWriteCloser, pcr int, hashAlgos []crypto.Ha
 		}
 		digestsMap[hashAlgo] = digest
 
-		// TODO: extend the digest to TPM PCR
+		tpm2Alg, err := tpm2.HashToAlgorithm(hashAlgo)
+		if err != nil {
+			return err
+		}
+		if err := tpm2.PCRExtend(tpm, tpmutil.Handle(pcr), tpm2Alg, digest, ""); err != nil {
+			return fmt.Errorf("failed to extend event to PCR%d: %v", pcr, err)
+		}
 	}
 
 	celr := Record{
@@ -340,3 +348,46 @@ func DecodeToCELR(buf *bytes.Buffer) (r Record, err error) {
 	}
 	return r, nil
 }
+
+// replay takes the digests from a Canonical Event Log and carries out the
+// extend sequence for each PCR in the log. It then compares the final digests
+// against a bank of PCR values to see if they match.
+func (c *CEL) replay(bank *pb.PCRs) error {
+	tpm2Alg := tpm2.Algorithm(bank.GetHash())
+	cryptoHash, err := tpm2Alg.Hash()
+	if err != nil {
+		return err
+	}
+	replayed := make(map[uint8][]byte)
+	for _, record := range c.Records {
+		if _, ok := replayed[record.PCR]; !ok {
+			replayed[record.PCR] = make([]byte, cryptoHash.Size())
+		}
+		hasher := cryptoHash.New()
+		digestsMap := record.Digests
+		digest, ok := digestsMap[cryptoHash]
+		if !ok {
+			return fmt.Errorf("the CEL record did not contain a %v digest", tpm2Alg)
+		}
+		hasher.Write(replayed[record.PCR])
+		hasher.Write(digest)
+		replayed[record.PCR] = hasher.Sum(nil)
+	}
+
+	var failedReplayPcrs []uint8
+	for replayPcr, replayDigest := range replayed {
+		bankDigest, ok := bank.Pcrs[uint32(replayPcr)]
+		if !ok {
+			return fmt.Errorf("the CEL contained record(s) for PCR%d without a matching PCR in the bank to verify", replayPcr)
+		}
+		if !bytes.Equal(bankDigest, replayDigest) {
+			failedReplayPcrs = append(failedReplayPcrs, replayPcr)
+		}
+	}
+
+	if len(failedReplayPcrs) == 0 {
+		return nil
+	}
+
+	return fmt.Errorf("CEL replay failed for these PCRs in bank %v: %v", tpm2Alg, failedReplayPcrs)
+}
diff --git a/cel/canonical_eventlog_test.go b/cel/canonical_eventlog_test.go
@@ -3,35 +3,38 @@ package cel
 import (
 	"bytes"
 	"crypto"
+	"crypto/rand"
+	"io"
 	"reflect"
 	"testing"
+
+	"github.com/google/go-tpm-tools/client"
+	"github.com/google/go-tpm-tools/internal/test"
+	pb "github.com/google/go-tpm-tools/proto/tpm"
+	"github.com/google/go-tpm/tpm2"
 )
 
 func TestCELEncodingDecoding(t *testing.T) {
+	tpm := test.GetTPM(t)
+	defer client.CheckedClose(t, tpm)
+
 	hashAlgoList := []crypto.Hash{crypto.SHA256, crypto.SHA1, crypto.SHA512}
 	cel := &CEL{}
 
 	someEvent := make([]byte, 10)
 	cosEvent := CosTlv{someEvent}
-	err := cel.AppendEvent(nil, 13, hashAlgoList, cosEvent)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
+	appendOrFatal(t, cel, tpm, test.DebugPCR, hashAlgoList, cosEvent)
 
 	cosEvent2 := CosTlv{someEvent}
-	err = cel.AppendEvent(nil, 14, hashAlgoList, cosEvent2)
-	if err != nil {
-		t.Fatal(err.Error())
-	}
+	appendOrFatal(t, cel, tpm, test.ApplicationPCR, hashAlgoList, cosEvent2)
 
 	var buf bytes.Buffer
-	err = cel.EncodeCEL(&buf)
-	if err != nil {
-		t.Fatalf(err.Error())
+	if err := cel.EncodeCEL(&buf); err != nil {
+		t.Fatal(err)
 	}
 	decodedcel, err := DecodeToCEL(&buf)
 	if err != nil {
-		t.Fatalf(err.Error())
+		t.Fatal(err)
 	}
 	if len(decodedcel.Records) != 2 {
 		t.Errorf("should have two records")
@@ -42,10 +45,10 @@ func TestCELEncodingDecoding(t *testing.T) {
 	if decodedcel.Records[1].RecNum != 1 {
 		t.Errorf("recnum mismatch")
 	}
-	if decodedcel.Records[0].PCR != 13 {
+	if decodedcel.Records[0].PCR != uint8(test.DebugPCR) {
 		t.Errorf("pcr value mismatch")
 	}
-	if decodedcel.Records[1].PCR != 14 {
+	if decodedcel.Records[1].PCR != uint8(test.ApplicationPCR) {
 		t.Errorf("pcr value mismatch")
 	}
 
@@ -56,7 +59,126 @@ func TestCELEncodingDecoding(t *testing.T) {
 	if len(digestsMap[crypto.SHA1]) != 20 {
 		t.Errorf("SHA1 digest length doesn't match")
 	}
-	if reflect.DeepEqual(decodedcel.Records, (*cel).Records) == false {
+	if !reflect.DeepEqual(decodedcel.Records, cel.Records) {
 		t.Errorf("decoded CEL doesn't equal to the original one")
 	}
 }
+
+func TestCELMeasureAndReplay(t *testing.T) {
+	tpm := test.GetTPM(t)
+	defer client.CheckedClose(t, tpm)
+
+	cel := &CEL{}
+	measuredHashes := []crypto.Hash{crypto.SHA256, crypto.SHA1, crypto.SHA512}
+
+	someEvent := make([]byte, 10)
+	cosEvent := CosTlv{someEvent}
+	someEvent2 := make([]byte, 10)
+
+	rand.Read(someEvent2)
+	cosEvent2 := CosTlv{someEvent2}
+	appendOrFatal(t, cel, tpm, test.DebugPCR, measuredHashes, cosEvent)
+	appendOrFatal(t, cel, tpm, test.DebugPCR, measuredHashes, cosEvent2)
+
+	appendOrFatal(t, cel, tpm, test.ApplicationPCR, measuredHashes, cosEvent2)
+	appendOrFatal(t, cel, tpm, test.ApplicationPCR, measuredHashes, cosEvent)
+	appendOrFatal(t, cel, tpm, test.ApplicationPCR, measuredHashes, cosEvent)
+
+	replay(t, cel, tpm, measuredHashes,
+		[]int{test.DebugPCR, test.ApplicationPCR},
+		/*shouldSucceed=*/ true)
+	// Supersets should pass.
+	replay(t, cel, tpm, measuredHashes,
+		[]int{0, 13, 14, test.DebugPCR, 22, test.ApplicationPCR},
+		/*shouldSucceed=*/ true)
+}
+
+func TestCELReplayFailTampered(t *testing.T) {
+	tpm := test.GetTPM(t)
+	defer client.CheckedClose(t, tpm)
+
+	cel := &CEL{}
+	measuredHashes := []crypto.Hash{crypto.SHA256, crypto.SHA1, crypto.SHA512}
+
+	someEvent := make([]byte, 10)
+	cosEvent := CosTlv{someEvent}
+	someEvent2 := make([]byte, 10)
+
+	rand.Read(someEvent2)
+	cosEvent2 := CosTlv{someEvent2}
+	appendOrFatal(t, cel, tpm, test.DebugPCR, measuredHashes, cosEvent)
+	appendOrFatal(t, cel, tpm, test.DebugPCR, measuredHashes, cosEvent2)
+
+	appendOrFatal(t, cel, tpm, test.ApplicationPCR, measuredHashes, cosEvent2)
+	appendOrFatal(t, cel, tpm, test.ApplicationPCR, measuredHashes, cosEvent)
+	appendOrFatal(t, cel, tpm, test.ApplicationPCR, measuredHashes, cosEvent)
+
+	modifiedRecord := cel.Records[3]
+	for hash := range modifiedRecord.Digests {
+		newDigest := make([]byte, hash.Size())
+		rand.Read(newDigest)
+		modifiedRecord.Digests[hash] = newDigest
+	}
+	replay(t, cel, tpm, measuredHashes,
+		[]int{test.DebugPCR, test.ApplicationPCR},
+		/*shouldSucceed=*/ false)
+}
+
+func TestCELReplayEmpty(t *testing.T) {
+	tpm := test.GetTPM(t)
+	defer client.CheckedClose(t, tpm)
+
+	cel := &CEL{}
+	replay(t, cel, tpm, []crypto.Hash{crypto.SHA256, crypto.SHA1, crypto.SHA512},
+		[]int{test.DebugPCR, test.ApplicationPCR},
+		/*shouldSucceed=*/ true)
+}
+
+func TestCELReplayFailMissingPCRsInBank(t *testing.T) {
+	tpm := test.GetTPM(t)
+	defer client.CheckedClose(t, tpm)
+
+	cel := &CEL{}
+	measuredHashes := []crypto.Hash{crypto.SHA256, crypto.SHA1, crypto.SHA512}
+
+	someEvent := make([]byte, 10)
+	someEvent2 := make([]byte, 10)
+	rand.Read(someEvent2)
+	appendOrFatal(t, cel, tpm, test.DebugPCR, measuredHashes, CosTlv{someEvent})
+	appendOrFatal(t, cel, tpm, test.ApplicationPCR, measuredHashes, CosTlv{someEvent2})
+	replay(t, cel, tpm, measuredHashes,
+		[]int{test.DebugPCR},
+		/*shouldSucceed=*/ false)
+	replay(t, cel, tpm, measuredHashes,
+		[]int{test.ApplicationPCR},
+		/*shouldSucceed=*/ false)
+}
+
+func replay(t *testing.T, cel *CEL, tpm io.ReadWriteCloser, measuredHashes []crypto.Hash, pcrs []int, shouldSucceed bool) {
+	for _, hash := range measuredHashes {
+		tpm2Hash, err := tpm2.HashToAlgorithm(hash)
+		if err != nil {
+			t.Fatal(err)
+		}
+		pcrMap, err := tpm2.ReadPCRs(tpm, tpm2.PCRSelection{Hash: tpm2Hash, PCRs: pcrs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		pbPcr := &pb.PCRs{Hash: pb.HashAlgo(tpm2Hash),
+			Pcrs: map[uint32][]byte{},
+		}
+		for index, val := range pcrMap {
+			pbPcr.Pcrs[uint32(index)] = val
+		}
+		if err := cel.replay(pbPcr); shouldSucceed && err != nil {
+			t.Errorf("failed to replay CEL on %v bank: %v",
+				pb.HashAlgo_name[int32(pbPcr.Hash)], err)
+		}
+	}
+}
+
+func appendOrFatal(t *testing.T, cel *CEL, tpm io.ReadWriteCloser, pcr int, hashAlgos []crypto.Hash, event Content) {
+	if err := cel.AppendEvent(tpm, pcr, hashAlgos, event); err != nil {
+		t.Fatalf("failed to append event: %v", err)
+	}
+}
diff --git a/client/attest.go b/client/attest.go
@@ -19,6 +19,11 @@ type AttestOpts struct {
 	// attestation protocols:
 	// https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.70.4562&rep=rep1&type=pdf
 	Nonce []byte
+	// TCG Canonical Event Log to add to the attestation.
+	// Currently, we only support PCR replay for PCRs orthogonal to those in the
+	// firmware event log, where PCRs 0-9 and 14 are often measured. If the two
+	// logs overlap, server-side verification using this library may fail.
+	CanonicalEventLog []byte
 }
 
 // Attest generates an Attestation containing the TCG Event Log and a Quote over
@@ -53,5 +58,8 @@ func (k *Key) Attest(opts AttestOpts) (*pb.Attestation, error) {
 	if attestation.EventLog, err = GetEventLog(k.rw); err != nil {
 		return nil, fmt.Errorf("failed to retrieve TCG Event Log: %w", err)
 	}
+	if len(opts.CanonicalEventLog) != 0 {
+		attestation.CanonicalEventLog = opts.CanonicalEventLog
+	}
 	return &attestation, nil
 }
diff --git a/client/example_test.go b/client/example_test.go
@@ -118,7 +118,7 @@ func ExampleKey_Attest() {
 	}
 	defer ak.Close()
 
-	attestation, err := ak.Attest(client.AttestOpts{nonce})
+	attestation, err := ak.Attest(client.AttestOpts{Nonce: nonce})
 	if err != nil {
 		log.Fatalf("failed to attest: %v", err)
 	}

diff --git a/client/quote_test.go b/client/quote_test.go
@@ -127,7 +127,7 @@ func TestAttest(t *testing.T) {
 			}
 			defer ak.Close()
 
-			attestation, err := ak.Attest(client.AttestOpts{[]byte("some nonce")})
+			attestation, err := ak.Attest(client.AttestOpts{Nonce: []byte("some nonce")})
 			if !key.shouldSucceed {
 				if err == nil {
 					t.Error("expected failure when calling Attest")

diff --git a/proto/attest.proto b/proto/attest.proto
@@ -21,10 +21,13 @@ message Attestation {
   bytes ak_pub = 1;
   // Quotes over all supported PCR banks
   repeated tpm.Quote quotes = 2;
-  // TCG Event Log, encoded in the raw binary format
+  // TCG Event Log, encoded in the raw binary format.
+  // Can be SHA-1 or crypto-agile.
   bytes event_log = 3;
   // Optional information about a GCE instance, unused outside of GCE
   GCEInstanceInfo instance_info = 4;
+  // A TCG Canonical Event Log.
+  bytes canonical_event_log = 5;
 }
 
 // Type of hardware technology used to protect this instance

diff --git a/proto/attest/attest.pb.go b/proto/attest/attest.pb.go
diff --git a/server/eventlog_test.go b/server/eventlog_test.go
@@ -274,7 +274,7 @@ func TestParseEventLogs(t *testing.T) {
 					if !ok {
 						t.Errorf("ParseMachineState should return a GroupedError")
 					}
-					if log.errorSubstr != "" && !gErr.containsOnlySubstring(log.errorSubstr) {
+					if log.errorSubstr == "" || !gErr.containsOnlySubstring(log.errorSubstr) {
 						t.Errorf("failed to parse and replay log: %v", err)
 					}
 				}