refactor(sdk): remove RTMR replay helpers from client SDKs

The SDKs are attester-side tools for obtaining attestation evidence from
inside a CVM; replaying RTMRs is a relying-party concern and does not
belong here. The helpers were also unsound as shipped: get_quote strips
runtime-event digests (see TdxEvent::stripped), so replaying RTMR3 from
the returned event_log could not reproduce the quoted value.

Removes replay_rtmrs / replayRtmrs / ReplayRTMRs and their private
replay_rtmr helpers from the Rust, Python, JS and Go SDKs, including the
legacy tappd clients, plus the associated tests, examples and docs.
Drops the now-unused sha2 dependency from dstack-sdk-types.

BREAKING CHANGE: consumers replaying RTMRs must do so against a verifier
that has the unstripped event log.

Author: kvinwang

sdk/go/README.md

@@ -123,13 +123,6 @@ func main() {
 
 	fmt.Println("TDX Quote:", quote.Quote)
 	fmt.Println("Event Log:", quote.EventLog)
-
-	// Verify measurement registers
-	rtmrs, err := quote.ReplayRTMRs()
-	if err != nil {
-		log.Fatal(err)
-	}
-	fmt.Println("RTMR0-3:", rtmrs)
 }
 ```
 
@@ -574,7 +567,6 @@ Generates a TDX attestation quote containing the provided report data.
 **Returns:** `GetQuoteResponse`
 - `Quote`: TDX quote as hex string
 - `EventLog`: JSON string of system events
-- `ReplayRTMRs()`: Function returning computed RTMR values
 
 **Use Cases:**
 - Remote attestation of application state

sdk/go/dstack/client.go

@@ -11,7 +11,6 @@ import (
 	"context"
 	"crypto/ecdsa"
 	"crypto/ed25519"
-	"crypto/sha512"
 	"crypto/x509"
 	"encoding/hex"
 	"encoding/json"
@@ -114,7 +113,6 @@ func (r *GetQuoteResponse) DecodeEventLog() ([]EventLog, error) {
 	return events, err
 }
 
-
 // Represents the response from an attestation request.
 type AttestResponse struct {
 	Attestation []byte
@@ -187,63 +185,6 @@ func (r *InfoResponse) DecodeTcbInfo() (*TcbInfo, error) {
 	return &tcbInfo, nil
 }
 
-const INIT_MR = "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
-
-// Replays the RTMR history to calculate final RTMR values
-func replayRTMR(history []string) (string, error) {
-	if len(history) == 0 {
-		return INIT_MR, nil
-	}
-
-	mr := make([]byte, 48)
-
-	for _, content := range history {
-		contentBytes, err := hex.DecodeString(content)
-		if err != nil {
-			return "", err
-		}
-
-		if len(contentBytes) < 48 {
-			padding := make([]byte, 48-len(contentBytes))
-			contentBytes = append(contentBytes, padding...)
-		}
-
-		h := sha512.New384()
-		h.Write(append(mr, contentBytes...))
-		mr = h.Sum(nil)
-	}
-
-	return hex.EncodeToString(mr), nil
-}
-
-// Replays the RTMR history to calculate final RTMR values
-func (r *GetQuoteResponse) ReplayRTMRs() (map[int]string, error) {
-	var eventLog []struct {
-		IMR    int    `json:"imr"`
-		Digest string `json:"digest"`
-	}
-	json.Unmarshal([]byte(r.EventLog), &eventLog)
-
-	rtmrs := make(map[int]string, 4)
-	for idx := 0; idx < 4; idx++ {
-		history := make([]string, 0)
-		for _, event := range eventLog {
-			if event.IMR == idx {
-				history = append(history, event.Digest)
-			}
-		}
-
-		rtmr, err := replayRTMR(history)
-		if err != nil {
-			return nil, err
-		}
-
-		rtmrs[idx] = rtmr
-	}
-
-	return rtmrs, nil
-}
-
 // QuoteHashAlgorithm represents the hash algorithm used for quote generation
 type QuoteHashAlgorithm string
 

sdk/go/dstack/client_test.go

@@ -9,7 +9,6 @@ import (
 	"context"
 	"crypto/sha256"
 	"crypto/x509"
-	"encoding/hex"
 	"encoding/json"
 	"encoding/pem"
 	"fmt"
@@ -57,45 +56,6 @@ func TestGetQuote(t *testing.T) {
 	if err != nil {
 		t.Errorf("expected event log to be a valid JSON object: %v", err)
 	}
-
-	// Get quote RTMRs manually
-	quoteBytes, err := resp.DecodeQuote()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	quoteRtmrs := [4][48]byte{
-		[48]byte(quoteBytes[376:424]),
-		[48]byte(quoteBytes[424:472]),
-		[48]byte(quoteBytes[472:520]),
-		[48]byte(quoteBytes[520:568]),
-	}
-
-	// Test ReplayRTMRs
-	rtmrs, err := resp.ReplayRTMRs()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(rtmrs) != 4 {
-		t.Errorf("expected 4 RTMRs, got %d", len(rtmrs))
-	}
-
-	// Verify RTMRs
-	for i := 0; i < 4; i++ {
-		if rtmrs[i] == "" {
-			t.Errorf("expected RTMR %d to not be empty", i)
-		}
-
-		rtmrBytes, err := hex.DecodeString(rtmrs[i])
-		if err != nil {
-			t.Errorf("expected RTMR %d to be valid hex: %v", i, err)
-		}
-
-		if !bytes.Equal(rtmrBytes, quoteRtmrs[i][:]) {
-			t.Errorf("expected RTMR %d to be %s, got %s", i, hex.EncodeToString(quoteRtmrs[i][:]), rtmrs[i])
-		}
-	}
 }
 
 func TestAttest(t *testing.T) {

sdk/go/tappd/client.go

@@ -11,7 +11,6 @@ package tappd
 import (
 	"bytes"
 	"context"
-	"crypto/sha512"
 	"encoding/base64"
 	"encoding/hex"
 	"encoding/json"
@@ -100,63 +99,6 @@ type TappdInfoResponse struct {
 	AppName    string  `json:"app_name"`
 }
 
-const INIT_MR = "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
-
-// Replays the RTMR history to calculate final RTMR values
-func replayRTMR(history []string) (string, error) {
-	if len(history) == 0 {
-		return INIT_MR, nil
-	}
-
-	mr := make([]byte, 48)
-
-	for _, content := range history {
-		contentBytes, err := hex.DecodeString(content)
-		if err != nil {
-			return "", err
-		}
-
-		if len(contentBytes) < 48 {
-			padding := make([]byte, 48-len(contentBytes))
-			contentBytes = append(contentBytes, padding...)
-		}
-
-		h := sha512.New384()
-		h.Write(append(mr, contentBytes...))
-		mr = h.Sum(nil)
-	}
-
-	return hex.EncodeToString(mr), nil
-}
-
-// Replays the RTMR history to calculate final RTMR values
-func (r *TdxQuoteResponse) ReplayRTMRs() (map[int]string, error) {
-	var eventLog []struct {
-		IMR    int    `json:"imr"`
-		Digest string `json:"digest"`
-	}
-	json.Unmarshal([]byte(r.EventLog), &eventLog)
-
-	rtmrs := make(map[int]string, 4)
-	for idx := 0; idx < 4; idx++ {
-		history := make([]string, 0)
-		for _, event := range eventLog {
-			if event.IMR == idx {
-				history = append(history, event.Digest)
-			}
-		}
-
-		rtmr, err := replayRTMR(history)
-		if err != nil {
-			return nil, err
-		}
-
-		rtmrs[idx] = rtmr
-	}
-
-	return rtmrs, nil
-}
-
 // Handles communication with the Tappd service.
 type TappdClient struct {
 	endpoint   string

sdk/go/tappd/client_test.go

@@ -5,7 +5,6 @@
 package tappd_test
 
 import (
-	"bytes"
 	"context"
 	"encoding/hex"
 	"encoding/json"
@@ -70,44 +69,10 @@ func TestTdxQuote(t *testing.T) {
 		t.Errorf("expected event log to be a valid JSON object: %v", err)
 	}
 
-	quoteBytes, err := hex.DecodeString(resp.Quote)
+	_, err = hex.DecodeString(resp.Quote)
 	if err != nil {
 		t.Errorf("expected quote to be a valid hex string: %v", err)
 	}
-
-	// Get quote RTMRs manually
-	quoteRtmrs := [4][48]byte{
-		[48]byte(quoteBytes[376:424]),
-		[48]byte(quoteBytes[424:472]),
-		[48]byte(quoteBytes[472:520]),
-		[48]byte(quoteBytes[520:568]),
-	}
-
-	// Test ReplayRTMRs
-	rtmrs, err := resp.ReplayRTMRs()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(rtmrs) != 4 {
-		t.Errorf("expected 4 RTMRs, got %d", len(rtmrs))
-	}
-
-	// Verify RTMRs
-	for i := 0; i < 4; i++ {
-		if rtmrs[i] == "" {
-			t.Errorf("expected RTMR %d to not be empty", i)
-		}
-
-		rtmrBytes, err := hex.DecodeString(rtmrs[i])
-		if err != nil {
-			t.Errorf("expected RTMR %d to be valid hex: %v", i, err)
-		}
-
-		if !bytes.Equal(rtmrBytes, quoteRtmrs[i][:]) {
-			t.Errorf("expected RTMR %d to be %s, got %s", i, hex.EncodeToString(quoteRtmrs[i][:]), rtmrs[i])
-		}
-	}
 }
 
 func TestTdxQuoteRawHash(t *testing.T) {

sdk/js/README.md

@@ -33,7 +33,7 @@ console.log(Buffer.from(key.key).toString('hex'))
 
 const quote = await client.getQuote('app-state-snapshot')
 console.log(quote.quote)
-console.log(quote.replayRtmrs())
+console.log(quote.event_log)
 ```
 
 The constructor probes `/var/run/dstack.sock`, then `/run/dstack.sock`, then the `/var/run/dstack/` and `/run/dstack/` variants. Pass an explicit endpoint for HTTP or for a non-default socket:
@@ -86,7 +86,6 @@ Generate a raw TDX quote. `reportData` is up to 64 bytes (string, Buffer, or Uin
 const quote = await client.getQuote('user:alice:nonce123')
 quote.quote        // hex-encoded TDX quote
 quote.event_log    // JSON string of measured events
-quote.replayRtmrs() // recompute RTMR[0..3] from the event log
 ```
 
 ### `attest(reportData)`

sdk/js/src/__tests__/index.test.ts

@@ -46,7 +46,6 @@ describe('DstackClient', () => {
     expect(result).toHaveProperty('event_log')
     expect(result.event_log.substring(0, 1) === '{')
     expect(() => JSON.parse(result.event_log)).not.toThrowError()
-    expect(result.replayRtmrs().length).toBe(4)
   })
 
   it('should be able to attest', async () => {

sdk/js/src/index.ts

@@ -3,7 +3,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import fs from 'fs'
-import { sha384 } from '@noble/hashes/sha512'
 import { send_rpc_request } from './send-rpc-request'
 export { getComposeHash } from './get-compose-hash'
 export { verifyEnvEncryptPublicKey, verifyEnvEncryptPublicKeyLegacy } from './verify-env-encrypt-public-key'
@@ -101,8 +100,6 @@ export interface GetQuoteResponse {
   report_data?: Hex
   vm_config?: string
   attestation?: Hex
-
-  replayRtmrs: () => string[]
 }
 
 export interface AttestResponse {
@@ -149,36 +146,6 @@ function x509key_to_uint8array(pem: string, max_length?: number) {
   return result
 }
 
-function replay_rtmr(history: string[]): string {
-  const INIT_MR = "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
-  if (history.length === 0) {
-    return INIT_MR
-  }
-  let mr = Buffer.from(INIT_MR, 'hex')
-  for (const content of history) {
-    // Convert hex string to buffer
-    let contentBuffer = Buffer.from(content, 'hex')
-    // Pad content with zeros if shorter than 48 bytes
-    if (contentBuffer.length < 48) {
-      const padding = Buffer.alloc(48 - contentBuffer.length, 0)
-      contentBuffer = Buffer.concat([contentBuffer, padding])
-    }
-    mr = Buffer.from(sha384(Buffer.concat([mr, contentBuffer])))
-  }
-  return mr.toString('hex')
-}
-
-function reply_rtmrs(event_log: EventLog[]): Record<number, string> {
-  const rtmrs: Array<string> = []
-  for (let idx = 0; idx < 4; idx++) {
-    const history = event_log
-      .filter(event => event.imr === idx)
-      .map(event => event.digest)
-    rtmrs[idx] = replay_rtmr(history)
-  }
-  return rtmrs
-}
-
 export interface TlsKeyOptions {
   path?: string;
   subject?: string;
@@ -312,11 +279,6 @@ export class DstackClient<T extends TcbInfo = TcbInfoV05x> {
       const err = result['error'] as string
       throw new Error(err)
     }
-    Object.defineProperty(result, 'replayRtmrs', {
-      get: () => () => reply_rtmrs(JSON.parse(result.event_log) as EventLog[]),
-      enumerable: true,
-      configurable: false,
-    })
     return Object.freeze(result)
   }
 
@@ -531,11 +493,6 @@ export class TappdClient extends DstackClient<TcbInfoV03x> {
       const err = result['error'] as string
       throw new Error(err)
     }
-    Object.defineProperty(result, 'replayRtmrs', {
-      get: () => () => reply_rtmrs(JSON.parse(result.event_log) as EventLog[]),
-      enumerable: true,
-      configurable: false,
-    })
     return Object.freeze(result)
   }