From e67fb0167bf57644c784c5f3eb95c0f5cb6c1922 Mon Sep 17 00:00:00 2001 From: "khalifa.toumi" Date: Tue, 10 Mar 2026 13:11:46 +0100 Subject: [PATCH 1/5] delete hardocoded IP address --- scripts/integration/local_tee_workflow.go | 20 ++++++++++++++------ scripts/tee-mgmt-cli/.env.example | 2 +- 2 files changed, 15 insertions(+), 7 deletions(-) diff --git a/scripts/integration/local_tee_workflow.go b/scripts/integration/local_tee_workflow.go index c8d01157..b26bb3fa 100755 --- a/scripts/integration/local_tee_workflow.go +++ b/scripts/integration/local_tee_workflow.go @@ -29,20 +29,21 @@ import ( "github.com/fxamacker/cbor/v2" ) -const ( +var ( RPC_URL = "http://127.0.0.1:8545" + ENCLAVE_HOST = getEnvOrDefault("TEE_ENCLAVE_HOST", "127.0.0.1") + ENCLAVE_PORT = getEnvOrDefault("TEE_ENCLAVE_PORT", "443") + MEASUREMENTS_PATH = getEnvOrDefault("TEE_MEASUREMENTS_PATH", "measurements.txt") VERIFIER_ADDRESS = "0x0000000000000000000000000000000000000900" - ENCLAVE_HOST = "3.15.214.21" - ENCLAVE_PORT = "443" - MEASUREMENTS_PATH = "measurements.txt" + TEE_REGISTRY_ADDRESS + ) -var TEE_REGISTRY_ADDRESS string // ============================================================================ // PASTE YOUR NEW COMPILED BYTECODE HERE // ============================================================================ -const TEE_REGISTRY_BYTECODE = "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" +const TEE_REGISTRY_BYTECODE = "" // ============================================================================ // AccessControl Role Constants @@ -1473,3 +1474,10 @@ func extractPCRsFromAttestation(attestationBytes []byte) (map[int][]byte, error) return doc.PCRs, nil } + +func getEnvOrDefault(key, defaultValue string) string { + if value := os.Getenv(key); value != "" { + return value + } + return defaultValue +} \ No newline at end of file diff --git a/scripts/tee-mgmt-cli/.env.example b/scripts/tee-mgmt-cli/.env.example index 6a1a2a2d..390c11e1 100644 --- a/scripts/tee-mgmt-cli/.env.example +++ b/scripts/tee-mgmt-cli/.env.example @@ -6,7 +6,7 @@ # ============================================================================= # RPC endpoint for the OpenGradient network -RPC_URL=http://13.59.43.94:8545 +RPC_URL=http://127.0.0.1:8545 # TEE Registry contract address TEE_REGISTRY_ADDRESS=0x3d641a2791533b4a0000345ea8d509d01e1ec301 From e3526eecb5bb82eab95cf48df03ccc776e024cf5 Mon Sep 17 00:00:00 2001 From: "khalifa.toumi" Date: Tue, 10 Mar 2026 18:32:20 +0100 Subject: [PATCH 2/5] reslove precompile contract issue --- contracts/hardhat.config.js | 1 + contracts/package.json | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/contracts/hardhat.config.js b/contracts/hardhat.config.js index 7be09191..88d5e90a 100644 --- a/contracts/hardhat.config.js +++ b/contracts/hardhat.config.js @@ -20,5 +20,6 @@ export default { }, paths: { sources: "./solidity", + exclude: ["**/lib/**"] }, }; diff --git a/contracts/package.json b/contracts/package.json index 7b9c584c..d49eca81 100644 --- a/contracts/package.json +++ b/contracts/package.json @@ -3,7 +3,7 @@ "version": "2.0.0", "description": "A collection of smart contracts used in the development of the Cosmos EVM blockchain.", "devDependencies": { - "@openzeppelin/contracts": "^5.4.0", + "@openzeppelin/contracts": "4.9.6", "hardhat": "^3.0.15" }, "scripts": { From b971ec396759c9b7032d4422c637c648e8dd047d Mon Sep 17 00:00:00 2001 From: "khalifa.toumi" Date: Wed, 11 Mar 2026 13:45:06 +0100 Subject: [PATCH 3/5] provide registration steps --- scripts/tee-mgmt-cli/Registration.md | 205 +++++++++++++++++++++++++++ 1 file changed, 205 insertions(+) create mode 100644 scripts/tee-mgmt-cli/Registration.md diff --git a/scripts/tee-mgmt-cli/Registration.md b/scripts/tee-mgmt-cli/Registration.md new file mode 100644 index 00000000..c919880f --- /dev/null +++ b/scripts/tee-mgmt-cli/Registration.md @@ -0,0 +1,205 @@ +# How to Register a New TEE + +This guide walks through the complete process of registering a Trusted Execution Environment (TEE) on the OpenGradient network. + +## Overview + +TEE registration establishes a hardware-rooted chain of trust: +1. **AWS Nitro Hardware** signs an attestation document +2. **Precompile verifies** attestation against AWS root certificate +3. **Contract validates** PCR measurements match approved enclave code +4. **Keys are bound** — signing key & TLS cert cryptographically tied to verified enclave +5. **TEE registered** — now ready to serve verified AI inference requests + +## Prerequisites + +### 1. Access & Permissions + +- **RPC endpoint** to OpenGradient network +- **Funded account** with gas for transactions +- **TEE_OPERATOR role** (granted by admin) to register TEEs +- **Registry address** of the deployed TEERegistry contract + +### 2. Running Enclave + +- **AWS Nitro Enclave** running approved code +- Accessible at `:443` with HTTPS endpoints: + - `GET /enclave/attestation?nonce=<40-char-hex>` — returns base64 attestation document + - `GET /signing-key` — returns JSON with signing public key PEM + - TLS endpoint exposing certificate at `:443` + +### 3. PCR Measurements + +- **measurements.txt** file with PCR0, PCR1, PCR2 values from your enclave build +- Format: +```json + { + "Measurements": { + "PCR0": "8c7b728e1a8e034aa1cc6c82521adeacec05118b766d5203c80aaf84322b73d095e05672d98fba613ba2b3aaa0e6a482", + "PCR1": "4b4d5b3661b3efc12920900c80e126e4ce783c522de6c02a2a5bf7af3a2b9327b86776f188e4be1c1c404a129dbda493", + "PCR2": "74787f27d0c4bbead44d7a61a02df3b8297b0ab1faffb8ebd113a34b434147acb7cd21504b82eeea34100034ccaaed94" + } + } +``` + +## Step-by-Step Registration + +### Step 1: Configure CLI +```bash +# Option A: Use .env file +cp .env.example .env +``` + +Edit `.env`: +```bash +RPC_URL=https://ogevmdevnet.opengradient.ai +TEE_REGISTRY_ADDRESS=0x4e72238852f3c918f4E4e57AeC9280dDB0c80248 +TEE_PRIVATE_KEY=your_private_key_here # Account with TEE_OPERATOR role +``` +```bash +### Step 2: One-Time Admin Setup (Skip if you are using our mainnet) + +These steps only need to be performed once by an admin: +```bash +# Add TEE type (type 0 = LLMProxy) +./tee-cli type add 0 LLMProxy + +# Set AWS Nitro root certificate (validates attestation documents) +./tee-cli cert set-aws aws_nitro_root.pem + +# Approve your enclave's PCR measurements +./tee-cli pcr approve \ + -m measurements.txt \ + -v "v1.0.0" \ + --tee-type 0 +``` + +Verify PCR is approved: +```bash +# Compute the PCR hash first +./tee-cli pcr compute -m measurements.txt +# Output: PCR Hash: 0x77786f3515030fe50a260c26d229eff15d2db0e211008f1581dc3e91bfd25703 + +# Check approval status +./tee-cli pcr check 0x77786f3515030fe50a260c26d229eff15d2db0e211008f1581dc3e91bfd25703 +``` + +### Step 3: Register Your TEE +```bash +./tee-cli tee register +``` + +**What happens during registration:** + +1. ✅ CLI generates a random 20-byte nonce +2. ✅ Fetches attestation document from `https://enclave_host/enclave/attestation?nonce=` +3. ✅ Fetches signing public key from `https://enclave_host/signing-key` +4. ✅ Fetches TLS certificate via TLS handshake to `enclave_host:443` +5. ✅ Computes expected TEE ID: `keccak256(signing_public_key)` +6. ✅ Submits transaction: `registerTEEWithAttestation(attestation, signingKey, tlsCert, paymentAddr, endpoint, teeType)` +7. ✅ Contract verifies attestation via precompile (checks AWS signature, PCR approval) +8. ✅ TEE is registered and **enabled** by default + +### Step 4: Verify Registration +```bash +# List all enabled TEEs +./tee-cli tee list + +# Show your TEE details +./tee-cli tee show 0xe10366dfcd1a40e97042fbd7b422cd9033921291d0d1b7f40a2a15fc748ae711 +``` + +Expected output: +``` +=== TEE Details: 0xe10366dfcd1a40e97042fbd7b422cd9033921291d0d1b7f40a2a15fc748ae711 === + Owner: 0x24E4BEa7164BCFb52CCAe10EdE4f5a0cB9F09C4b + Payment Addr: 0x24E4BEa7164BCFb52CCAe10EdE4f5a0cB9F09C4b + Endpoint: https://3.15.214.21 + PCR Hash: 0x77786f3515030fe50a260c26d229eff15d2db0e211008f1581dc3e91bfd25703 + TEE Type: 0 (LLMProxy) + Enabled: true + Registered: 2026-03-11 10:36:37 UTC + Last Heartbeat: 2026-03-11 10:36:37 UTC +``` + +## Lifecycle Management +```bash +# Temporarily disable a TEE (can be re-enabled) +./tee-cli tee deactivate 0xe10366dfcd1a40e97042fbd7b422cd9033921291d0d1b7f40a2a15fc748ae711 + +# Re-enable a disabled TEE (validates PCR is still approved) +./tee-cli tee activate 0xe10366dfcd1a40e97042fbd7b422cd9033921291d0d1b7f40a2a15fc748ae711 +``` + +## Common Issues + +### "PCR not approved" +**Cause:** Your enclave's PCR measurements haven't been approved by an admin. + +**Solution:** +```bash +# Check which PCRs are approved +./tee-cli pcr list + +# Admin must approve your PCR +./tee-cli pcr approve -m measurements.txt -v "v1.0.0" --tee-type 0 +``` + +### "Attestation verification failed" +**Causes:** +- AWS root certificate not set in contract +- Attestation document expired or invalid +- Enclave not running approved code + +**Solutions:** +```bash +# Verify AWS cert is set +./tee-cli cert set-aws aws_nitro_root.pem + +# Check enclave is accessible +curl -k https://enclave_host/enclave/attestation?nonce=abc123... + +# Verify PCR values match approved measurements +./tee-cli pcr compute -m measurements.txt +``` + +### "Key not found" or "insufficient funds" +**Cause:** Account doesn't have TEE_OPERATOR role or gas funds. + +**Solution:** +```bash +# Check role +./tee-cli role check operator account_address + +# Admin grants role +./tee-cli role grant-operator account_address + +# Fund account (transfer from funded account) +``` + +### "TEE already exists" +**Cause:** A TEE with the same signing public key is already registered. + +**Solution:** +- Each enclave instance has a unique signing key bound at boot +- If you restarted the enclave, it will have a new key → new TEE ID +- If the old TEE ID exists, disable it first: +```bash + ./tee-cli tee deactivate +``` + +## Quick Reference +```bash +# Complete registration flow (assuming admin setup done) +./tee-cli tee register --enclave-host 3.15.214.21 --tee-type 0 +./tee-cli tee list +./tee-cli tee show + +# Disable/re-enable +./tee-cli tee deactivate +./tee-cli tee activate + +# Check PCR approval +./tee-cli pcr compute -m measurements.txt +./tee-cli pcr check +``` From a6deb21f4773894b44c89211a97e3c9d052c8ee5 Mon Sep 17 00:00:00 2001 From: "khalifa.toumi" Date: Thu, 12 Mar 2026 16:46:53 +0100 Subject: [PATCH 4/5] remove hardcoded Ip addresses --- scripts/integration/tee_list.sh | 2 +- scripts/tee-mgmt-cli/Registration.md | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/scripts/integration/tee_list.sh b/scripts/integration/tee_list.sh index 70d62489..8d5e55a1 100755 --- a/scripts/integration/tee_list.sh +++ b/scripts/integration/tee_list.sh @@ -1,7 +1,7 @@ #!/bin/bash REGISTRY="0x3d641a2791533b4a0000345ea8d509d01e1ec301" -RPC="http://13.59.43.94:8545" +RPC="http://127.0.0.1:8545" echo "=== Fetching Active TEEs ===" RESPONSE=$(curl -s -X POST $RPC \ diff --git a/scripts/tee-mgmt-cli/Registration.md b/scripts/tee-mgmt-cli/Registration.md index c919880f..6a2817b4 100644 --- a/scripts/tee-mgmt-cli/Registration.md +++ b/scripts/tee-mgmt-cli/Registration.md @@ -114,7 +114,7 @@ Expected output: === TEE Details: 0xe10366dfcd1a40e97042fbd7b422cd9033921291d0d1b7f40a2a15fc748ae711 === Owner: 0x24E4BEa7164BCFb52CCAe10EdE4f5a0cB9F09C4b Payment Addr: 0x24E4BEa7164BCFb52CCAe10EdE4f5a0cB9F09C4b - Endpoint: https://3.15.214.21 + Endpoint: https://127.0.0.1 PCR Hash: 0x77786f3515030fe50a260c26d229eff15d2db0e211008f1581dc3e91bfd25703 TEE Type: 0 (LLMProxy) Enabled: true @@ -191,7 +191,7 @@ curl -k https://enclave_host/enclave/attestation?nonce=abc123... ## Quick Reference ```bash # Complete registration flow (assuming admin setup done) -./tee-cli tee register --enclave-host 3.15.214.21 --tee-type 0 +./tee-cli tee register --enclave-host 127.0.0.1 --tee-type 0 ./tee-cli tee list ./tee-cli tee show From 910ac9b0eae0dd2d24669db5612219c5bff7e8b6 Mon Sep 17 00:00:00 2001 From: "khalifa.toumi" Date: Fri, 13 Mar 2026 00:16:35 +0100 Subject: [PATCH 5/5] update integration test and cli --- precompiles/tee/README.md | 10 - scripts/integration/local_tee_workflow.go | 804 ++++++++---------- scripts/integration/tee_list.sh | 104 --- .../.env.example | 0 .../tee-mgmt-cli => tee-mgmt-cli}/.gitignore | 0 .../tee-mgmt-cli => tee-mgmt-cli}/Readme.md | 0 .../Registration.md | 0 .../tee-mgmt-cli => tee-mgmt-cli}/cmd/cert.go | 0 .../cmd/heartbeat.go | 0 .../tee-mgmt-cli => tee-mgmt-cli}/cmd/pcr.go | 0 .../tee-mgmt-cli => tee-mgmt-cli}/cmd/role.go | 0 .../tee-mgmt-cli => tee-mgmt-cli}/cmd/root.go | 0 .../tee-mgmt-cli => tee-mgmt-cli}/cmd/tee.go | 0 .../cmd/types.go | 0 {scripts/tee-mgmt-cli => tee-mgmt-cli}/go.mod | 0 {scripts/tee-mgmt-cli => tee-mgmt-cli}/go.sum | 0 .../tee-mgmt-cli => tee-mgmt-cli}/main.go | 0 .../registry/client.go | 0 18 files changed, 363 insertions(+), 555 deletions(-) delete mode 100755 scripts/integration/tee_list.sh rename {scripts/tee-mgmt-cli => tee-mgmt-cli}/.env.example (100%) rename {scripts/tee-mgmt-cli => tee-mgmt-cli}/.gitignore (100%) rename {scripts/tee-mgmt-cli => tee-mgmt-cli}/Readme.md (100%) rename {scripts/tee-mgmt-cli => tee-mgmt-cli}/Registration.md (100%) rename {scripts/tee-mgmt-cli => tee-mgmt-cli}/cmd/cert.go (100%) rename {scripts/tee-mgmt-cli => tee-mgmt-cli}/cmd/heartbeat.go (100%) rename {scripts/tee-mgmt-cli => tee-mgmt-cli}/cmd/pcr.go (100%) rename {scripts/tee-mgmt-cli => tee-mgmt-cli}/cmd/role.go (100%) rename {scripts/tee-mgmt-cli => tee-mgmt-cli}/cmd/root.go (100%) rename {scripts/tee-mgmt-cli => tee-mgmt-cli}/cmd/tee.go (100%) rename {scripts/tee-mgmt-cli => tee-mgmt-cli}/cmd/types.go (100%) rename {scripts/tee-mgmt-cli => tee-mgmt-cli}/go.mod (100%) rename {scripts/tee-mgmt-cli => tee-mgmt-cli}/go.sum (100%) rename {scripts/tee-mgmt-cli => tee-mgmt-cli}/main.go (100%) rename {scripts/tee-mgmt-cli => tee-mgmt-cli}/registry/client.go (100%) diff --git a/precompiles/tee/README.md b/precompiles/tee/README.md index 58a904c9..bb442493 100644 --- a/precompiles/tee/README.md +++ b/precompiles/tee/README.md @@ -174,13 +174,3 @@ TEE_REGISTRY_ADDRESS=0x... TEE_ENCLAVE_HOST=127.0.0.1 go run local_tee_workflow. > Integration tests are excluded from CI via `//go:build integration` tag and skip automatically if `TEE_ENCLAVE_HOST` is not set. -## TODO - -### Planned Features -- [ ] TEE health monitoring hooks -- [ ] Batch TEE registration - -### Integration Tasks -- [ ] Facilitator (x402): Call `verifySignature()` via FacilitatorSettlementRelay before payment -- [ ] Frontend/dashboard: Download and pin TLS certificates -- [ ] Monitoring: Track TEE active status diff --git a/scripts/integration/local_tee_workflow.go b/scripts/integration/local_tee_workflow.go index b26bb3fa..420a49cc 100755 --- a/scripts/integration/local_tee_workflow.go +++ b/scripts/integration/local_tee_workflow.go @@ -4,6 +4,8 @@ package main import ( "bytes" + "context" + "crypto/ecdsa" "crypto/rand" "crypto/rsa" "crypto/sha256" @@ -23,27 +25,33 @@ import ( gcrypto "crypto" + "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethclient" "github.com/fxamacker/cbor/v2" ) var ( - RPC_URL = "http://127.0.0.1:8545" + RPC_URL = getEnvOrDefault("RPC_URL", "http://127.0.0.1:8545") ENCLAVE_HOST = getEnvOrDefault("TEE_ENCLAVE_HOST", "127.0.0.1") ENCLAVE_PORT = getEnvOrDefault("TEE_ENCLAVE_PORT", "443") MEASUREMENTS_PATH = getEnvOrDefault("TEE_MEASUREMENTS_PATH", "measurements.txt") + PRIVATE_KEY = os.Getenv("PRIVATE_KEY") VERIFIER_ADDRESS = "0x0000000000000000000000000000000000000900" - TEE_REGISTRY_ADDRESS + TEE_REGISTRY_ADDRESS string + ethClient *ethclient.Client + privateKey *ecdsa.PrivateKey + chainID *big.Int ) - // ============================================================================ // PASTE YOUR NEW COMPILED BYTECODE HERE // ============================================================================ -const TEE_REGISTRY_BYTECODE = "" +const TEE_REGISTRY_BYTECODE = "0x6080604052610708600255348015610015575f5ffd5b506100285f5f1b3361009160201b60201c565b506100597fae5084c516dacf3f1a818c437d702c28b8d2088455f592a7ea799413e3b6f1bf3361009160201b60201c565b5061008c7fae5084c516dacf3f1a818c437d702c28b8d2088455f592a7ea799413e3b6f1bf5f5f1b61018660201b60201c565b61026a565b5f6100a283836101e460201b60201c565b61017c5760015f5f8581526020019081526020015f205f015f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f6101000a81548160ff02191690831515021790555061011961024760201b60201c565b73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16847f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a460019050610180565b5f90505b92915050565b5f6101968361024e60201b60201c565b9050815f5f8581526020019081526020015f20600101819055508181847fbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff60405160405180910390a4505050565b5f5f5f8481526020019081526020015f205f015f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f9054906101000a900460ff16905092915050565b5f33905090565b5f5f5f8381526020019081526020015f20600101549050919050565b61503e806102775f395ff3fe608060405234801561000f575f5ffd5b5060043610610224575f3560e01c80635c1090b21161012e578063a3bf31f1116100b6578063d6741a421161007a578063d6741a42146106ed578063e10a2ea41461071e578063e44cc4821461074e578063f33d2c001461077e578063f44a0780146107ae57610224565b8063a3bf31f11461061c578063b82644b71461064c578063cbdfc4e01461067c578063ccdf049314610698578063d547741f146106d157610224565b8063927d3c95116100fd578063927d3c9514610563578063971cfbf1146105935780639831ced5146105b2578063a041ff51146105e2578063a217fddf146105fe57610224565b80635c1090b2146104c957806363b86b89146104e557806387267aca1461051557806391d148541461053357610224565b806336568abe116101b157806343ed32741161018057806343ed327414610413578063476cb0301461042f5780634b6014da1461045f5780634c4c8e8b1461048f5780635766275a146104ab57610224565b806336568abe1461038d5780633c1a88b0146103a9578063418b207d146103c757806342830ad8146103f757610224565b806317883717116101f857806317883717146102c25780632068b3db146102de578063248a9ca3146103115780632cbe7552146103415780632f2ff15d1461037157610224565b80625ae7cf1461022857806301ffc9a71461024457806308c84e701461027457806315c9bdb414610292575b5f5ffd5b610242600480360381019061023d91906134b0565b6107cc565b005b61025e60048036038101906102599190613530565b6109bd565b60405161026b9190613575565b60405180910390f35b61027c610a36565b6040516102899190613608565b60405180910390f35b6102ac60048036038101906102a79190613748565b610a3c565b6040516102b99190613861565b60405180910390f35b6102dc60048036038101906102d791906134b0565b610fe0565b005b6102f860048036038101906102f3919061387a565b6111dc565b604051610308949392919061394f565b60405180910390f35b61032b600480360381019061032691906134b0565b6112b1565b6040516103389190613861565b60405180910390f35b61035b600480360381019061035691906134b0565b6112cd565b60405161036891906139eb565b60405180910390f35b61038b60048036038101906103869190613a0b565b611371565b005b6103a760048036038101906103a29190613a0b565b611393565b005b6103b161140e565b6040516103be9190613861565b60405180910390f35b6103e160048036038101906103dc91906134b0565b611432565b6040516103ee9190613c09565b60405180910390f35b610411600480360381019061040c9190613c53565b611759565b005b61042d60048036038101906104289190613cc4565b6119a6565b005b61044960048036038101906104449190613d31565b611a0d565b6040516104569190613861565b60405180910390f35b61047960048036038101906104749190613d78565b611a6f565b6040516104869190613f43565b60405180910390f35b6104a960048036038101906104a49190613f63565b611ec6565b005b6104b36120f4565b6040516104c091906140c5565b60405180910390f35b6104e360048036038101906104de91906140e5565b6122e8565b005b6104ff60048036038101906104fa9190613d78565b6122ff565b60405161050c91906141b8565b60405180910390f35b61051d61236c565b60405161052a91906141d8565b60405180910390f35b61054d60048036038101906105489190613a0b565b612372565b60405161055a9190613575565b60405180910390f35b61057d600480360381019061057891906134b0565b6123d5565b60405161058a9190613575565b60405180910390f35b61059b6123ff565b6040516105a992919061438e565b60405180910390f35b6105cc60048036038101906105c7919061387a565b612600565b6040516105d99190613575565b60405180910390f35b6105fc60048036038101906105f791906143c3565b61263e565b005b6106066127ea565b6040516106139190613861565b60405180910390f35b610636600480360381019061063191906134b0565b6127f0565b6040516106439190613575565b60405180910390f35b61066660048036038101906106619190613d78565b612811565b60405161067391906141b8565b60405180910390f35b61069660048036038101906106919190614401565b61287e565b005b6106b260048036038101906106ad91906134b0565b6129f3565b6040516106c89a9998979695949392919061446d565b60405180910390f35b6106eb60048036038101906106e69190613a0b565b612c2c565b005b61070760048036038101906107029190613d78565b612c4e565b60405161071592919061451c565b60405180910390f35b61073860048036038101906107339190613d78565b612cf4565b6040516107459190613575565b60405180910390f35b6107686004803603810190610763919061454a565b612d1a565b60405161077591906141b8565b60405180910390f35b61079860048036038101906107939190613cc4565b612dad565b6040516107a59190613861565b60405180910390f35b6107b6612dce565b6040516107c391906139eb565b60405180910390f35b805f60075f8381526020019081526020015f20600701540361081a576040517ff6523b6500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f6108275f5f1b33612372565b90505f3373ffffffffffffffffffffffffffffffffffffffff1660075f8581526020019081526020015f205f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff161480156108bd57506108bc7fae5084c516dacf3f1a818c437d702c28b8d2088455f592a7ea799413e3b6f1bf33612372565b5b9050811580156108cb575080155b15610902576040517f98b31e6f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f60075f8681526020019081526020015f2090508060060160019054906101000a900460ff161561093357506109b7565b6109518160050154826006015f9054906101000a900460ff16612e5a565b60018160060160016101000a81548160ff02191690831515021790555061098885826006015f9054906101000a900460ff16612ec9565b847fcfe7e61b35fbf35c6b0d5c7ebe6feb619ab832dc476c4a02dbdc041fb92b5ca660405160405180910390a2505b50505050565b5f7f7965db0b000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19161480610a2f5750610a2e82612f4d565b5b9050919050565b61090081565b5f7fae5084c516dacf3f1a818c437d702c28b8d2088455f592a7ea799413e3b6f1bf610a6781612fb6565b610a7083612cf4565b610aa6576040517f5d672da700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8989604051610ab69291906145b1565b604051809103902091505f60075f8481526020019081526020015f206007015414610b0d576040517f1346e43900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f5f61090073ffffffffffffffffffffffffffffffffffffffff1663f7cf40d38f8f8f8f8f8f60016040518863ffffffff1660e01b8152600401610b5797969594939291906146e5565b6040805180830381865afa158015610b71573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610b959190614788565b9150915081610bd9576040517f06d1f25a000000000000000000000000000000000000000000000000000000008152600401610bd090614836565b60405180910390fd5b610be38186612e5a565b6040518061014001604052803373ffffffffffffffffffffffffffffffffffffffff1681526020018973ffffffffffffffffffffffffffffffffffffffff16815260200188888080601f0160208091040260200160405190810160405280939291908181526020018383808284375f81840152601f19601f8201169050808301925050505050505081526020018d8d8080601f0160208091040260200160405190810160405280939291908181526020018383808284375f81840152601f19601f8201169050808301925050505050505081526020018b8b8080601f0160208091040260200160405190810160405280939291908181526020018383808284375f81840152601f19601f8201169050808301925050505050505081526020018281526020018660ff1681526020016001151581526020014281526020014281525060075f8681526020019081526020015f205f820151815f015f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506020820151816001015f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506040820151816002019081610dd49190614a18565b506060820151816003019081610dea9190614b2d565b506080820151816004019081610e009190614b2d565b5060a0820151816005015560c0820151816006015f6101000a81548160ff021916908360ff16021790555060e08201518160060160016101000a81548160ff0219169083151502179055506101008201518160070155610120820151816008015590505060085f8660ff1660ff1681526020019081526020015f208054905060095f8760ff1660ff1681526020019081526020015f205f8681526020019081526020015f208190555060085f8660ff1660ff1681526020019081526020015f2084908060018154018082558091505060019003905f5260205f20015f9091909190915055600a5f8660ff1660ff1681526020019081526020015f2084908060018154018082558091505060019003905f5260205f20015f9091909190915055600b5f3373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2084908060018154018082558091505060019003905f5260205f20015f90919091909150553373ffffffffffffffffffffffffffffffffffffffff16847f97d0af70a4d2c616e9c1093d5f57c8b31b3a7d824f1d335e5d5416402ec1493187604051610fc79190614bfc565b60405180910390a35050509a9950505050505050505050565b805f60075f8381526020019081526020015f20600701540361102e576040517ff6523b6500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f61103b5f5f1b33612372565b90505f3373ffffffffffffffffffffffffffffffffffffffff1660075f8581526020019081526020015f205f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff161480156110d157506110d07fae5084c516dacf3f1a818c437d702c28b8d2088455f592a7ea799413e3b6f1bf33612372565b5b9050811580156110df575080155b15611116576040517f98b31e6f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f60075f8681526020019081526020015f2090508060060160019054906101000a900460ff16611172576040517fa2e3924000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f8160060160016101000a81548160ff0219169083151502179055506111a885826006015f9054906101000a900460ff16612fca565b847f01c235337ed5406ee8cebb3f299d60f237a2837430f8a14fbc81f94ce50236b660405160405180910390a25050505050565b6005602052815f5260405f20602052805f5260405f205f9150915050805f015f9054906101000a900460ff1690805f0160019054906101000a900460ff169080600101549080600201805461123090614622565b80601f016020809104026020016040519081016040528092919081815260200182805461125c90614622565b80156112a75780601f1061127e576101008083540402835291602001916112a7565b820191905f5260205f20905b81548152906001019060200180831161128a57829003601f168201915b5050505050905084565b5f5f5f8381526020019081526020015f20600101549050919050565b606060075f8381526020019081526020015f2060030180546112ee90614622565b80601f016020809104026020016040519081016040528092919081815260200182805461131a90614622565b80156113655780601f1061133c57610100808354040283529160200191611365565b820191905f5260205f20905b81548152906001019060200180831161134857829003601f168201915b50505050509050919050565b61137a826112b1565b61138381612fb6565b61138d8383613126565b50505050565b61139b61320f565b73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16146113ff576040517f6697b23200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6114098282613216565b505050565b7fae5084c516dacf3f1a818c437d702c28b8d2088455f592a7ea799413e3b6f1bf81565b61143a6133c4565b5f60075f8481526020019081526020015f206007015403611487576040517ff6523b6500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60075f8381526020019081526020015f20604051806101400160405290815f82015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001600182015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200160028201805461155d90614622565b80601f016020809104026020016040519081016040528092919081815260200182805461158990614622565b80156115d45780601f106115ab576101008083540402835291602001916115d4565b820191905f5260205f20905b8154815290600101906020018083116115b757829003601f168201915b505050505081526020016003820180546115ed90614622565b80601f016020809104026020016040519081016040528092919081815260200182805461161990614622565b80156116645780601f1061163b57610100808354040283529160200191611664565b820191905f5260205f20905b81548152906001019060200180831161164757829003601f168201915b5050505050815260200160048201805461167d90614622565b80601f01602080910402602001604051908101604052809291908181526020018280546116a990614622565b80156116f45780601f106116cb576101008083540402835291602001916116f4565b820191905f5260205f20905b8154815290600101906020018083116116d757829003601f168201915b5050505050815260200160058201548152602001600682015f9054906101000a900460ff1660ff1660ff1681526020016006820160019054906101000a900460ff16151515158152602001600782015481526020016008820154815250509050919050565b5f60075f8681526020019081526020015f2090505f8160070154036117aa576040517ff6523b6500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8060060160019054906101000a900460ff166117f2576040517fa2e3924000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b4284111561182c576040517f0c57bc2c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600254844261183b9190614c42565b1115611873576040517f39f8a70600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f8585604051602001611887929190614cb5565b6040516020818303038152906040528051906020012090505f61090073ffffffffffffffffffffffffffffffffffffffff16637e26679a846003018488886040518563ffffffff1660e01b81526004016118e49493929190614ce0565b602060405180830381865afa1580156118ff573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906119239190614d25565b90508061195c576040517f45576abb00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b428360080181905550867f3cf0bf7708060bf073b6ddb921eef0485b3eb9da828e0ed751fa6582ef337f578760405161199591906141d8565b60405180910390a250505050505050565b5f5f1b6119b281612fb6565b8282600191826119c3929190614d5a565b5082826040516119d49291906145b1565b60405180910390207f378c4547bd8b346276ae1db9e298d984a43bd8788ad795e7a141ba069045f4cb60405160405180910390a2505050565b5f81805f0190611a1d9190614e33565b838060200190611a2d9190614e33565b858060400190611a3d9190614e33565b604051602001611a5296959493929190614e95565b604051602081830303815290604052805190602001209050919050565b60605f60085f8460ff1660ff1681526020019081526020015f2090505f5f90505f5f90505b8280549050811015611af557611ad460075f858481548110611ab957611ab8614ecb565b5b905f5260205f20015481526020019081526020015f206132ff565b15611ae8578180611ae490614ef8565b9250505b8080600101915050611a94565b505f8167ffffffffffffffff811115611b1157611b10614854565b5b604051908082528060200260200182016040528015611b4a57816020015b611b376133c4565b815260200190600190039081611b2f5790505b5090505f5f90505f5f90505b8480549050811015611eb957611b9660075f878481548110611b7b57611b7a614ecb565b5b905f5260205f20015481526020019081526020015f206132ff565b15611eac5760075f868381548110611bb157611bb0614ecb565b5b905f5260205f20015481526020019081526020015f20604051806101400160405290815f82015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001600182015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001600282018054611c8c90614622565b80601f0160208091040260200160405190810160405280929190818152602001828054611cb890614622565b8015611d035780601f10611cda57610100808354040283529160200191611d03565b820191905f5260205f20905b815481529060010190602001808311611ce657829003601f168201915b50505050508152602001600382018054611d1c90614622565b80601f0160208091040260200160405190810160405280929190818152602001828054611d4890614622565b8015611d935780601f10611d6a57610100808354040283529160200191611d93565b820191905f5260205f20905b815481529060010190602001808311611d7657829003601f168201915b50505050508152602001600482018054611dac90614622565b80601f0160208091040260200160405190810160405280929190818152602001828054611dd890614622565b8015611e235780601f10611dfa57610100808354040283529160200191611e23565b820191905f5260205f20905b815481529060010190602001808311611e0657829003601f168201915b5050505050815260200160058201548152602001600682015f9054906101000a900460ff1660ff1660ff1681526020016006820160019054906101000a900460ff1615151515815260200160078201548152602001600882015481525050838380611e8d90614ef8565b945081518110611ea057611e9f614ecb565b5b60200260200101819052505b8080600101915050611b56565b5081945050505050919050565b5f5f1b611ed281612fb6565b611edb82612cf4565b611f11576040517f5d672da700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f611f1b86611a0d565b90505f5f60055f8660ff1660ff1681526020019081526020015f205f8481526020019081526020015f206001015414905060405180608001604052806001151581526020018560ff16815260200142815260200187878080601f0160208091040260200160405190810160405280939291908181526020018383808284375f81840152601f19601f8201169050808301925050505050505081525060055f8660ff1660ff1681526020019081526020015f205f8481526020019081526020015f205f820151815f015f6101000a81548160ff0219169083151502179055506020820151815f0160016101000a81548160ff021916908360ff1602179055506040820151816001015560608201518160020190816120389190614a18565b5090505080156120ad57600660405180604001604052808481526020018660ff16815250908060018154018082558091505060019003905f5260205f2090600202015f909190919091505f820151815f01556020820151816001015f6101000a81548160ff021916908360ff16021790555050505b8360ff16827f98c6d69cba0181c4e436357d22ac56e02ec472c03f04df0fbf89d1bb614af2fe88886040516120e3929190614f6b565b60405180910390a350505050505050565b60605f5f90505f5f90505b600680549050811015612188576121676006828154811061212357612122614ecb565b5b905f5260205f2090600202016001015f9054906101000a900460ff166006838154811061215357612152614ecb565b5b905f5260205f2090600202015f0154612600565b1561217b57818061217790614ef8565b9250505b80806001019150506120ff565b505f8167ffffffffffffffff8111156121a4576121a3614854565b5b6040519080825280602002602001820160405280156121dd57816020015b6121ca613441565b8152602001906001900390816121c25790505b5090505f5f90505f5f90505b6006805490508110156122de576122516006828154811061220d5761220c614ecb565b5b905f5260205f2090600202016001015f9054906101000a900460ff166006838154811061223d5761223c614ecb565b5b905f5260205f2090600202015f0154612600565b156122d1576006818154811061226a57612269614ecb565b5b905f5260205f2090600202016040518060400160405290815f8201548152602001600182015f9054906101000a900460ff1660ff1660ff16815250508383806122b290614ef8565b9450815181106122c5576122c4614ecb565b5b60200260200101819052505b80806001019150506121e9565b5081935050505090565b5f5f1b6122f481612fb6565b816002819055505050565b606060085f8360ff1660ff1681526020019081526020015f2080548060200260200160405190810160405280929190818152602001828054801561236057602002820191905f5260205f20905b81548152602001906001019080831161234c575b50505050509050919050565b60025481565b5f5f5f8481526020019081526020015f205f015f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f9054906101000a900460ff16905092915050565b5f60075f8381526020019081526020015f2060060160019054906101000a900460ff169050919050565b606080600480548060200260200160405190810160405280929190818152602001828054801561247057602002820191905f5260205f20905f905b82829054906101000a900460ff1660ff16815260200190600101906020825f0104928301926001038202915080841161243a5790505b5050505050915060048054905067ffffffffffffffff81111561249657612495614854565b5b6040519080825280602002602001820160405280156124cf57816020015b6124bc61345c565b8152602001906001900390816124b45790505b5090505f5f90505b6004805490508110156125fb5760035f600483815481106124fb576124fa614ecb565b5b905f5260205f2090602091828204019190069054906101000a900460ff1660ff1660ff1681526020019081526020015f206040518060400160405290815f8201805461254690614622565b80601f016020809104026020016040519081016040528092919081815260200182805461257290614622565b80156125bd5780601f10612594576101008083540402835291602001916125bd565b820191905f5260205f20905b8154815290600101906020018083116125a057829003601f168201915b505050505081526020016001820154815250508282815181106125e3576125e2614ecb565b5b602002602001018190525080806001019150506124d7565b509091565b5f60055f8460ff1660ff1681526020019081526020015f205f8381526020019081526020015f205f015f9054906101000a900460ff16905092915050565b5f5f1b61264a81612fb6565b6126548284612600565b61268a576040517f6c2ebf8000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f60055f8460ff1660ff1681526020019081526020015f205f8581526020019081526020015f205f015f6101000a81548160ff0219169083151502179055505f60085f8460ff1660ff1681526020019081526020015f2090505f818054905090505b5f8111156127b2575f826001836127039190614c42565b8154811061271457612713614ecb565b5b905f5260205f20015490508560075f8381526020019081526020015f20600501540361279e575f60075f8381526020019081526020015f2060060160016101000a81548160ff0219169083151502179055506127708186612fca565b807f01c235337ed5406ee8cebb3f299d60f237a2837430f8a14fbc81f94ce50236b660405160405180910390a25b5080806127aa90614f8d565b9150506126ec565b508260ff16847fd5a6741f8bbaee4cc3ea05953ea04c6a1863ce4c66a52da653dd0a315f84c2fb60405160405180910390a350505050565b5f5f1b81565b5f61280a60075f8481526020019081526020015f206132ff565b9050919050565b6060600a5f8360ff1660ff1681526020019081526020015f2080548060200260200160405190810160405280929190818152602001828054801561287257602002820191905f5260205f20905b81548152602001906001019080831161285e575b50505050509050919050565b5f5f1b61288a81612fb6565b5f60035f8660ff1660ff1681526020019081526020015f2060010154146128dd576040517f095faf7300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b604051806040016040528084848080601f0160208091040260200160405190810160405280939291908181526020018383808284375f81840152601f19601f8201169050808301925050505050505081526020014281525060035f8660ff1660ff1681526020019081526020015f205f820151815f01908161295f9190614a18565b5060208201518160010155905050600484908060018154018082558091505060019003905f5260205f2090602091828204019190069091909190916101000a81548160ff021916908360ff1602179055508360ff167fed0161664cf318441e585cccad9fa9fc770298b648a49635dda84ac6f0adc90884846040516129e5929190614f6b565b60405180910390a250505050565b6007602052805f5260405f205f91509050805f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690806001015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690806002018054612a5c90614622565b80601f0160208091040260200160405190810160405280929190818152602001828054612a8890614622565b8015612ad35780601f10612aaa57610100808354040283529160200191612ad3565b820191905f5260205f20905b815481529060010190602001808311612ab657829003601f168201915b505050505090806003018054612ae890614622565b80601f0160208091040260200160405190810160405280929190818152602001828054612b1490614622565b8015612b5f5780601f10612b3657610100808354040283529160200191612b5f565b820191905f5260205f20905b815481529060010190602001808311612b4257829003601f168201915b505050505090806004018054612b7490614622565b80601f0160208091040260200160405190810160405280929190818152602001828054612ba090614622565b8015612beb5780601f10612bc257610100808354040283529160200191612beb565b820191905f5260205f20905b815481529060010190602001808311612bce57829003601f168201915b505050505090806005015490806006015f9054906101000a900460ff16908060060160019054906101000a900460ff1690806007015490806008015490508a565b612c35826112b1565b612c3e81612fb6565b612c488383613216565b50505050565b6003602052805f5260405f205f91509050805f018054612c6d90614622565b80601f0160208091040260200160405190810160405280929190818152602001828054612c9990614622565b8015612ce45780601f10612cbb57610100808354040283529160200191612ce4565b820191905f5260205f20905b815481529060010190602001808311612cc757829003601f168201915b5050505050908060010154905082565b5f5f60035f8460ff1660ff1681526020019081526020015f206001015414159050919050565b6060600b5f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20805480602002602001604051908101604052809291908181526020018280548015612da157602002820191905f5260205f20905b815481526020019060010190808311612d8d575b50505050509050919050565b5f8282604051612dbe9291906145b1565b6040518091039020905092915050565b60018054612ddb90614622565b80601f0160208091040260200160405190810160405280929190818152602001828054612e0790614622565b8015612e525780601f10612e2957610100808354040283529160200191612e52565b820191905f5260205f20905b815481529060010190602001808311612e3557829003601f168201915b505050505081565b60055f8260ff1660ff1681526020019081526020015f205f8381526020019081526020015f205f015f9054906101000a900460ff16612ec5576040517f6c2ebf8000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5050565b60085f8260ff1660ff1681526020019081526020015f208054905060095f8360ff1660ff1681526020019081526020015f205f8481526020019081526020015f208190555060085f8260ff1660ff1681526020019081526020015f2082908060018154018082558091505060019003905f5260205f20015f90919091909150555050565b5f7f01ffc9a7000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916149050919050565b612fc781612fc261320f565b613373565b50565b5f60095f8360ff1660ff1681526020019081526020015f205f8481526020019081526020015f205490505f600160085f8560ff1660ff1681526020019081526020015f208054905061301c9190614c42565b90508082146130bd575f60085f8560ff1660ff1681526020019081526020015f20828154811061304f5761304e614ecb565b5b905f5260205f20015490508060085f8660ff1660ff1681526020019081526020015f20848154811061308457613083614ecb565b5b905f5260205f2001819055508260095f8660ff1660ff1681526020019081526020015f205f8381526020019081526020015f2081905550505b60085f8460ff1660ff1681526020019081526020015f208054806130e4576130e3614fb4565b5b600190038181905f5260205f20015f9055905560095f8460ff1660ff1681526020019081526020015f205f8581526020019081526020015f205f905550505050565b5f6131318383612372565b6132055760015f5f8581526020019081526020015f205f015f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f6101000a81548160ff0219169083151502179055506131a261320f565b73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16847f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a460019050613209565b5f90505b92915050565b5f33905090565b5f6132218383612372565b156132f5575f5f5f8581526020019081526020015f205f015f8473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f6101000a81548160ff02191690831515021790555061329261320f565b73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16847ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b60405160405180910390a4600190506132f9565b5f90505b92915050565b5f8160060160019054906101000a900460ff1661331e575f905061336e565b6002548260080154426133319190614c42565b111561333f575f905061336e565b61335d826006015f9054906101000a900460ff168360050154612600565b613369575f905061336e565b600190505b919050565b61337d8282612372565b6133c05780826040517fe2517d3f0000000000000000000000000000000000000000000000000000000081526004016133b7929190614fe1565b60405180910390fd5b5050565b6040518061014001604052805f73ffffffffffffffffffffffffffffffffffffffff1681526020015f73ffffffffffffffffffffffffffffffffffffffff1681526020016060815260200160608152602001606081526020015f81526020015f60ff1681526020015f151581526020015f81526020015f81525090565b60405180604001604052805f81526020015f60ff1681525090565b6040518060400160405280606081526020015f81525090565b5f5ffd5b5f5ffd5b5f819050919050565b61348f8161347d565b8114613499575f5ffd5b50565b5f813590506134aa81613486565b92915050565b5f602082840312156134c5576134c4613475565b5b5f6134d28482850161349c565b91505092915050565b5f7fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b61350f816134db565b8114613519575f5ffd5b50565b5f8135905061352a81613506565b92915050565b5f6020828403121561354557613544613475565b5b5f6135528482850161351c565b91505092915050565b5f8115159050919050565b61356f8161355b565b82525050565b5f6020820190506135885f830184613566565b92915050565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f819050919050565b5f6135d06135cb6135c68461358e565b6135ad565b61358e565b9050919050565b5f6135e1826135b6565b9050919050565b5f6135f2826135d7565b9050919050565b613602816135e8565b82525050565b5f60208201905061361b5f8301846135f9565b92915050565b5f5ffd5b5f5ffd5b5f5ffd5b5f5f83601f84011261364257613641613621565b5b8235905067ffffffffffffffff81111561365f5761365e613625565b5b60208301915083600182028301111561367b5761367a613629565b5b9250929050565b5f61368c8261358e565b9050919050565b61369c81613682565b81146136a6575f5ffd5b50565b5f813590506136b781613693565b92915050565b5f5f83601f8401126136d2576136d1613621565b5b8235905067ffffffffffffffff8111156136ef576136ee613625565b5b60208301915083600182028301111561370b5761370a613629565b5b9250929050565b5f60ff82169050919050565b61372781613712565b8114613731575f5ffd5b50565b5f813590506137428161371e565b92915050565b5f5f5f5f5f5f5f5f5f5f60c08b8d03121561376657613765613475565b5b5f8b013567ffffffffffffffff81111561378357613782613479565b5b61378f8d828e0161362d565b9a509a505060208b013567ffffffffffffffff8111156137b2576137b1613479565b5b6137be8d828e0161362d565b985098505060408b013567ffffffffffffffff8111156137e1576137e0613479565b5b6137ed8d828e0161362d565b965096505060606138008d828e016136a9565b94505060808b013567ffffffffffffffff81111561382157613820613479565b5b61382d8d828e016136bd565b935093505060a06138408d828e01613734565b9150509295989b9194979a5092959850565b61385b8161347d565b82525050565b5f6020820190506138745f830184613852565b92915050565b5f5f604083850312156138905761388f613475565b5b5f61389d85828601613734565b92505060206138ae8582860161349c565b9150509250929050565b6138c181613712565b82525050565b5f819050919050565b6138d9816138c7565b82525050565b5f81519050919050565b5f82825260208201905092915050565b8281835e5f83830152505050565b5f601f19601f8301169050919050565b5f613921826138df565b61392b81856138e9565b935061393b8185602086016138f9565b61394481613907565b840191505092915050565b5f6080820190506139625f830187613566565b61396f60208301866138b8565b61397c60408301856138d0565b818103606083015261398e8184613917565b905095945050505050565b5f81519050919050565b5f82825260208201905092915050565b5f6139bd82613999565b6139c781856139a3565b93506139d78185602086016138f9565b6139e081613907565b840191505092915050565b5f6020820190508181035f830152613a0381846139b3565b905092915050565b5f5f60408385031215613a2157613a20613475565b5b5f613a2e8582860161349c565b9250506020613a3f858286016136a9565b9150509250929050565b613a5281613682565b82525050565b5f82825260208201905092915050565b5f613a72826138df565b613a7c8185613a58565b9350613a8c8185602086016138f9565b613a9581613907565b840191505092915050565b5f82825260208201905092915050565b5f613aba82613999565b613ac48185613aa0565b9350613ad48185602086016138f9565b613add81613907565b840191505092915050565b613af18161347d565b82525050565b613b0081613712565b82525050565b613b0f8161355b565b82525050565b613b1e816138c7565b82525050565b5f61014083015f830151613b3a5f860182613a49565b506020830151613b4d6020860182613a49565b5060408301518482036040860152613b658282613a68565b91505060608301518482036060860152613b7f8282613ab0565b91505060808301518482036080860152613b998282613ab0565b91505060a0830151613bae60a0860182613ae8565b5060c0830151613bc160c0860182613af7565b5060e0830151613bd460e0860182613b06565b50610100830151613be9610100860182613b15565b50610120830151613bfe610120860182613b15565b508091505092915050565b5f6020820190508181035f830152613c218184613b24565b905092915050565b613c32816138c7565b8114613c3c575f5ffd5b50565b5f81359050613c4d81613c29565b92915050565b5f5f5f5f60608587031215613c6b57613c6a613475565b5b5f613c788782880161349c565b9450506020613c8987828801613c3f565b935050604085013567ffffffffffffffff811115613caa57613ca9613479565b5b613cb68782880161362d565b925092505092959194509250565b5f5f60208385031215613cda57613cd9613475565b5b5f83013567ffffffffffffffff811115613cf757613cf6613479565b5b613d038582860161362d565b92509250509250929050565b5f5ffd5b5f60608284031215613d2857613d27613d0f565b5b81905092915050565b5f60208284031215613d4657613d45613475565b5b5f82013567ffffffffffffffff811115613d6357613d62613479565b5b613d6f84828501613d13565b91505092915050565b5f60208284031215613d8d57613d8c613475565b5b5f613d9a84828501613734565b91505092915050565b5f81519050919050565b5f82825260208201905092915050565b5f819050602082019050919050565b5f61014083015f830151613de25f860182613a49565b506020830151613df56020860182613a49565b5060408301518482036040860152613e0d8282613a68565b91505060608301518482036060860152613e278282613ab0565b91505060808301518482036080860152613e418282613ab0565b91505060a0830151613e5660a0860182613ae8565b5060c0830151613e6960c0860182613af7565b5060e0830151613e7c60e0860182613b06565b50610100830151613e91610100860182613b15565b50610120830151613ea6610120860182613b15565b508091505092915050565b5f613ebc8383613dcc565b905092915050565b5f602082019050919050565b5f613eda82613da3565b613ee48185613dad565b935083602082028501613ef685613dbd565b805f5b85811015613f315784840389528151613f128582613eb1565b9450613f1d83613ec4565b925060208a01995050600181019050613ef9565b50829750879550505050505092915050565b5f6020820190508181035f830152613f5b8184613ed0565b905092915050565b5f5f5f5f60608587031215613f7b57613f7a613475565b5b5f85013567ffffffffffffffff811115613f9857613f97613479565b5b613fa487828801613d13565b945050602085013567ffffffffffffffff811115613fc557613fc4613479565b5b613fd1878288016136bd565b93509350506040613fe487828801613734565b91505092959194509250565b5f81519050919050565b5f82825260208201905092915050565b5f819050602082019050919050565b604082015f82015161402d5f850182613ae8565b5060208201516140406020850182613af7565b50505050565b5f6140518383614019565b60408301905092915050565b5f602082019050919050565b5f61407382613ff0565b61407d8185613ffa565b93506140888361400a565b805f5b838110156140b857815161409f8882614046565b97506140aa8361405d565b92505060018101905061408b565b5085935050505092915050565b5f6020820190508181035f8301526140dd8184614069565b905092915050565b5f602082840312156140fa576140f9613475565b5b5f61410784828501613c3f565b91505092915050565b5f81519050919050565b5f82825260208201905092915050565b5f819050602082019050919050565b5f6141448383613ae8565b60208301905092915050565b5f602082019050919050565b5f61416682614110565b614170818561411a565b935061417b8361412a565b805f5b838110156141ab5781516141928882614139565b975061419d83614150565b92505060018101905061417e565b5085935050505092915050565b5f6020820190508181035f8301526141d0818461415c565b905092915050565b5f6020820190506141eb5f8301846138d0565b92915050565b5f81519050919050565b5f82825260208201905092915050565b5f819050602082019050919050565b5f6142258383613af7565b60208301905092915050565b5f602082019050919050565b5f614247826141f1565b61425181856141fb565b935061425c8361420b565b805f5b8381101561428c578151614273888261421a565b975061427e83614231565b92505060018101905061425f565b5085935050505092915050565b5f81519050919050565b5f82825260208201905092915050565b5f819050602082019050919050565b5f604083015f8301518482035f8601526142dc8282613a68565b91505060208301516142f16020860182613b15565b508091505092915050565b5f61430783836142c2565b905092915050565b5f602082019050919050565b5f61432582614299565b61432f81856142a3565b935083602082028501614341856142b3565b805f5b8581101561437c578484038952815161435d85826142fc565b94506143688361430f565b925060208a01995050600181019050614344565b50829750879550505050505092915050565b5f6040820190508181035f8301526143a6818561423d565b905081810360208301526143ba818461431b565b90509392505050565b5f5f604083850312156143d9576143d8613475565b5b5f6143e68582860161349c565b92505060206143f785828601613734565b9150509250929050565b5f5f5f6040848603121561441857614417613475565b5b5f61442586828701613734565b935050602084013567ffffffffffffffff81111561444657614445613479565b5b614452868287016136bd565b92509250509250925092565b61446781613682565b82525050565b5f610140820190506144815f83018d61445e565b61448e602083018c61445e565b81810360408301526144a0818b613917565b905081810360608301526144b4818a6139b3565b905081810360808301526144c881896139b3565b90506144d760a0830188613852565b6144e460c08301876138b8565b6144f160e0830186613566565b6144ff6101008301856138d0565b61450d6101208301846138d0565b9b9a5050505050505050505050565b5f6040820190508181035f8301526145348185613917565b905061454360208301846138d0565b9392505050565b5f6020828403121561455f5761455e613475565b5b5f61456c848285016136a9565b91505092915050565b5f81905092915050565b828183375f83830152505050565b5f6145988385614575565b93506145a583858461457f565b82840190509392505050565b5f6145bd82848661458d565b91508190509392505050565b5f6145d483856139a3565b93506145e183858461457f565b6145ea83613907565b840190509392505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b5f600282049050600182168061463957607f821691505b60208210810361464c5761464b6145f5565b5b50919050565b5f819050815f5260205f209050919050565b5f815461467081614622565b61467a81866139a3565b9450600182165f811461469457600181146146aa576146dc565b60ff1983168652811515602002860193506146dc565b6146b385614652565b5f5b838110156146d4578154818901526001820191506020810190506146b5565b808801955050505b50505092915050565b5f6080820190508181035f8301526146fe81898b6145c9565b905081810360208301526147138187896145c9565b905081810360408301526147288185876145c9565b9050818103606083015261473c8184614664565b905098975050505050505050565b6147538161355b565b811461475d575f5ffd5b50565b5f8151905061476e8161474a565b92915050565b5f8151905061478281613486565b92915050565b5f5f6040838503121561479e5761479d613475565b5b5f6147ab85828601614760565b92505060206147bc85828601614774565b9150509250929050565b7f4174746573746174696f6e20646f63756d656e7420766572696669636174696f5f8201527f6e206661696c6564000000000000000000000000000000000000000000000000602082015250565b5f6148206028836138e9565b915061482b826147c6565b604082019050919050565b5f6020820190508181035f83015261484d81614814565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b5f819050815f5260205f209050919050565b5f6020601f8301049050919050565b5f82821b905092915050565b5f600883026148dd7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff826148a2565b6148e786836148a2565b95508019841693508086168417925050509392505050565b5f61491961491461490f846138c7565b6135ad565b6138c7565b9050919050565b5f819050919050565b614932836148ff565b61494661493e82614920565b8484546148ae565b825550505050565b5f5f905090565b61495d61494e565b614968818484614929565b505050565b5b8181101561498b576149805f82614955565b60018101905061496e565b5050565b601f8211156149d0576149a181614881565b6149aa84614893565b810160208510156149b9578190505b6149cd6149c585614893565b83018261496d565b50505b505050565b5f82821c905092915050565b5f6149f05f19846008026149d5565b1980831691505092915050565b5f614a0883836149e1565b9150826002028217905092915050565b614a21826138df565b67ffffffffffffffff811115614a3a57614a39614854565b5b614a448254614622565b614a4f82828561498f565b5f60209050601f831160018114614a80575f8415614a6e578287015190505b614a7885826149fd565b865550614adf565b601f198416614a8e86614881565b5f5b82811015614ab557848901518255600182019150602085019450602081019050614a90565b86831015614ad25784890151614ace601f8916826149e1565b8355505b6001600288020188555050505b505050505050565b601f821115614b2857614af981614652565b614b0284614893565b81016020851015614b11578190505b614b25614b1d85614893565b83018261496d565b50505b505050565b614b3682613999565b67ffffffffffffffff811115614b4f57614b4e614854565b5b614b598254614622565b614b64828285614ae7565b5f60209050601f831160018114614b95575f8415614b83578287015190505b614b8d85826149fd565b865550614bf4565b601f198416614ba386614652565b5f5b82811015614bca57848901518255600182019150602085019450602081019050614ba5565b86831015614be75784890151614be3601f8916826149e1565b8355505b6001600288020188555050505b505050505050565b5f602082019050614c0f5f8301846138b8565b92915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f614c4c826138c7565b9150614c57836138c7565b9250828203905081811115614c6f57614c6e614c15565b5b92915050565b5f819050919050565b614c8f614c8a8261347d565b614c75565b82525050565b5f819050919050565b614caf614caa826138c7565b614c95565b82525050565b5f614cc08285614c7e565b602082019150614cd08284614c9e565b6020820191508190509392505050565b5f6060820190508181035f830152614cf88187614664565b9050614d076020830186613852565b8181036040830152614d1a8184866145c9565b905095945050505050565b5f60208284031215614d3a57614d39613475565b5b5f614d4784828501614760565b91505092915050565b5f82905092915050565b614d648383614d50565b67ffffffffffffffff811115614d7d57614d7c614854565b5b614d878254614622565b614d92828285614ae7565b5f601f831160018114614dbf575f8415614dad578287013590505b614db785826149fd565b865550614e1e565b601f198416614dcd86614652565b5f5b82811015614df457848901358255600182019150602085019450602081019050614dcf565b86831015614e115784890135614e0d601f8916826149e1565b8355505b6001600288020188555050505b50505050505050565b5f5ffd5b5f5ffd5b5f5ffd5b5f5f83356001602003843603038112614e4f57614e4e614e27565b5b80840192508235915067ffffffffffffffff821115614e7157614e70614e2b565b5b602083019250600182023603831315614e8d57614e8c614e2f565b5b509250929050565b5f614ea182888a61458d565b9150614eae82868861458d565b9150614ebb82848661458d565b9150819050979650505050505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b5f614f02826138c7565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8203614f3457614f33614c15565b5b600182019050919050565b5f614f4a83856138e9565b9350614f5783858461457f565b614f6083613907565b840190509392505050565b5f6020820190508181035f830152614f84818486614f3f565b90509392505050565b5f614f97826138c7565b91505f8203614fa957614fa8614c15565b5b600182039050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603160045260245ffd5b5f604082019050614ff45f83018561445e565b6150016020830184613852565b939250505056fea264697066735822122085bdc58005015270939462c6d1f90fe5429356008ecc18381cd5dbce49a9c09664736f6c634300081c0033" // ============================================================================ // AccessControl Role Constants @@ -57,35 +65,48 @@ var ( // Method Selectors // ============================================================================ var ( + // AccessControl SEL_GRANT_ROLE = crypto.Keccak256([]byte("grantRole(bytes32,address)"))[:4] SEL_REVOKE_ROLE = crypto.Keccak256([]byte("revokeRole(bytes32,address)"))[:4] SEL_HAS_ROLE = crypto.Keccak256([]byte("hasRole(bytes32,address)"))[:4] SEL_GET_ROLE_ADMIN = crypto.Keccak256([]byte("getRoleAdmin(bytes32)"))[:4] + // TEE Types SEL_ADD_TEE_TYPE = crypto.Keccak256([]byte("addTEEType(uint8,string)"))[:4] SEL_IS_VALID_TYPE = crypto.Keccak256([]byte("isValidTEEType(uint8)"))[:4] SEL_GET_TEE_TYPES = crypto.Keccak256([]byte("getTEETypes()"))[:4] - SEL_APPROVE_PCR = crypto.Keccak256([]byte("approvePCR((bytes,bytes,bytes),string,uint8)"))[:4] - SEL_REVOKE_PCR = crypto.Keccak256([]byte("revokePCR(bytes32,uint8)"))[:4] - SEL_IS_PCR_APPROVED = crypto.Keccak256([]byte("isPCRApproved(uint8,bytes32)"))[:4] - SEL_COMPUTE_PCR_HASH = crypto.Keccak256([]byte("computePCRHash((bytes,bytes,bytes))"))[:4] - SEL_GET_APPROVED_PCRS = crypto.Keccak256([]byte("getApprovedPCRs()"))[:4] + // PCR Management - FIXED + SEL_APPROVE_PCR = crypto.Keccak256([]byte("approvePCR((bytes,bytes,bytes),string,uint8)"))[:4] + SEL_REVOKE_PCR = crypto.Keccak256([]byte("revokePCR(bytes32,uint8)"))[:4] // FIXED: removed gracePeriod + SEL_IS_PCR_APPROVED = crypto.Keccak256([]byte("isPCRApproved(uint8,bytes32)"))[:4] + SEL_COMPUTE_PCR_HASH = crypto.Keccak256([]byte("computePCRHash((bytes,bytes,bytes))"))[:4] + SEL_GET_APPROVED_PCRS = crypto.Keccak256([]byte("getApprovedPCRs()"))[:4] // FIXED: getApproved not getActive + // AWS Certificate SEL_SET_AWS_ROOT_CERT = crypto.Keccak256([]byte("setAWSRootCertificate(bytes)"))[:4] - SEL_REGISTER_TEE = crypto.Keccak256([]byte("registerTEEWithAttestation(bytes,bytes,bytes,address,string,uint8)"))[:4] - SEL_DISABLE_TEE = crypto.Keccak256([]byte("disableTEE(bytes32)"))[:4] - SEL_ENABLE_TEE = crypto.Keccak256([]byte("enableTEE(bytes32)"))[:4] + // TEE Registration & Lifecycle - FIXED + SEL_REGISTER_TEE = crypto.Keccak256([]byte("registerTEEWithAttestation(bytes,bytes,bytes,address,string,uint8)"))[:4] + SEL_DISABLE_TEE = crypto.Keccak256([]byte("disableTEE(bytes32)"))[:4] // FIXED: disable not deactivate + SEL_ENABLE_TEE = crypto.Keccak256([]byte("enableTEE(bytes32)"))[:4] // FIXED: enable not activate + // TEE Queries - FIXED SEL_GET_TEE = crypto.Keccak256([]byte("getTEE(bytes32)"))[:4] - SEL_GET_ENABLED_TEES = crypto.Keccak256([]byte("getEnabledTEEs(uint8)"))[:4] + SEL_GET_ENABLED_TEES = crypto.Keccak256([]byte("getEnabledTEEs(uint8)"))[:4] // FIXED + SEL_GET_ACTIVE_TEES = crypto.Keccak256([]byte("getActiveTEEs(uint8)"))[:4] // FIXED SEL_GET_TEES_BY_TYPE = crypto.Keccak256([]byte("getTEEsByType(uint8)"))[:4] SEL_GET_TEES_BY_OWNER = crypto.Keccak256([]byte("getTEEsByOwner(address)"))[:4] - SEL_GET_TEE_PUBLIC_KEY = crypto.Keccak256([]byte("getTEEPublicKey(bytes32)"))[:4] - SEL_IS_TEE_ENABLED = crypto.Keccak256([]byte("isTEEEnabled(bytes32)"))[:4] + SEL_GET_PUBLIC_KEY = crypto.Keccak256([]byte("getTEEPublicKey(bytes32)"))[:4] // FIXED + SEL_IS_TEE_ENABLED = crypto.Keccak256([]byte("isTEEEnabled(bytes32)"))[:4] + SEL_IS_TEE_ACTIVE = crypto.Keccak256([]byte("isTEEActive(bytes32)"))[:4] // FIXED + + // Heartbeat + SEL_HEARTBEAT = crypto.Keccak256([]byte("heartbeat(bytes32,uint256,bytes)"))[:4] + SEL_SET_HEARTBEAT_MAX_AGE = crypto.Keccak256([]byte("setHeartbeatMaxAge(uint256)"))[:4] - SEL_COMPUTE_TEE_ID = crypto.Keccak256([]byte("computeTEEId(bytes)"))[:4] + // Utility + SEL_COMPUTE_TEE_ID = crypto.Keccak256([]byte("computeTEEId(bytes)"))[:4] ) // ============================================================================ @@ -102,15 +123,16 @@ type MeasurementsFile struct { Measurements PCRMeasurements `json:"Measurements"` } -type ApprovedPCRKey struct { - PCRHash [32]byte - TEEType uint8 -} - type AttestationResponse struct { PublicKey string `json:"public_key"` } +// PCRKey mirrors the contract struct +type PCRKey struct { + PCRHash [32]byte + TEEType uint8 +} + type TestResults struct { Passed int Failed int @@ -126,12 +148,14 @@ type TestResult struct { func (tr *TestResults) Add(name string, passed bool, msg string) { tr.Tests = append(tr.Tests, TestResult{name, passed, msg}) if passed { - tr.Passed++ fmt.Printf(" ✅ %s\n", name) } else { tr.Failed++ fmt.Printf(" ❌ %s: %s\n", name, msg) } + if passed { + tr.Passed++ + } } // ============================================================================ @@ -141,18 +165,19 @@ func (tr *TestResults) Add(name string, passed bool, msg string) { func main() { fmt.Println("==========================================") fmt.Println(" TEE Registry Integration Test") - fmt.Println(" (AccessControl + Dual-Key Architecture)") fmt.Println("==========================================") fmt.Println() results := &TestResults{} - account, err := getFirstAccount() - if err != nil { - fmt.Printf("❌ Failed to get account: %v\n", err) + // Initialize Ethereum client and private key + if err := initEthClient(); err != nil { + fmt.Printf("❌ Failed to initialize Ethereum client: %v\n", err) os.Exit(1) } - fmt.Printf("📍 Primary account: %s\n\n", account) + + account := crypto.PubkeyToAddress(privateKey.PublicKey).Hex() + fmt.Printf("📍 Account (from private key): %s\n\n", account) // SECTION 0: Deploy or Find TEERegistry fmt.Println("------------------------------------------") @@ -178,7 +203,6 @@ func main() { rand.Read(pcr1) rand.Read(pcr2) } else { - // [LOG] Show PCRs loaded from file so we can cross-check against enclave fmt.Printf(" 📂 Loaded PCRs from %s:\n", MEASUREMENTS_PATH) fmt.Printf(" PCR0: %s\n", hex.EncodeToString(pcr0)) fmt.Printf(" PCR1: %s\n", hex.EncodeToString(pcr1)) @@ -206,7 +230,7 @@ func main() { isValid, _ := callIsValidTEEType(0) if !isValid { - txHash, err := callAddTEEType(account, 0, "LLMProxy") + txHash, err := callAddTEEType(0, "LLMProxy") if err == nil { waitForTx(txHash) } @@ -216,7 +240,7 @@ func main() { isValid, _ = callIsValidTEEType(1) if !isValid { - txHash, err := callAddTEEType(account, 1, "Validator") + txHash, err := callAddTEEType(1, "Validator") if err == nil { waitForTx(txHash) } @@ -235,42 +259,45 @@ func main() { pcrHash, _ := callComputePCRHash(pcr0, pcr1, pcr2) fmt.Printf(" 📊 PCR Hash (file measurements): 0x%s\n", hex.EncodeToString(pcrHash[:])) - // [LOG] Show existing approved PCRs before making any changes + // Fetch existing approved PCRs fmt.Println(" 🔍 Fetching currently approved PCRs from contract...") - existingApprovedPCRs, err := callGetApprovedPCRs() + existingActivePCRs, err := callGetActivePCRs() if err != nil { - fmt.Printf(" ⚠️ Could not fetch approved PCRs: %v\n", err) + fmt.Printf(" ⚠️ Could not fetch active PCRs: %v\n", err) } else { - fmt.Printf(" 📋 Currently approved PCRs (%d):\n", len(existingApprovedPCRs)) - for i, p := range existingApprovedPCRs { - fmt.Printf(" [%d] pcrHash=0x%s teeType=%d\n", i, hex.EncodeToString(p.PCRHash[:]), p.TEEType) + fmt.Printf(" 📋 Currently approved PCRs (%d):\n", len(existingActivePCRs)) + for i, p := range existingActivePCRs { + fmt.Printf(" [%d] hash=%s teeType=%d\n", i, hex.EncodeToString(p.PCRHash[:]), p.TEEType) } } - if len(existingApprovedPCRs) == 0 { - txHash, err := callApprovePCR(account, pcr0, pcr1, pcr2, "v1.0.0", 0) + + // Check if PCR is already approved for teeType=0 + approved, _ := callIsPCRApproved(0, pcrHash) // FIXED: pass teeType + if !approved { + txHash, err := callApprovePCR(pcr0, pcr1, pcr2, "v1.0.0", 0) if err == nil { waitForTx(txHash) } + approved, _ = callIsPCRApproved(0, pcrHash) } - approved, _ := callIsPCRApproved(0, pcrHash) - // [LOG] Clearly show the approval status of the PCR we are about to use - fmt.Printf(" 🔍 isPCRApproved(filePCRHash=%s) = %v\n", hex.EncodeToString(pcrHash[:]), approved) + fmt.Printf(" 🔍 isPCRApproved(teeType=0, filePCRHash=%s) = %v\n", hex.EncodeToString(pcrHash[:]), approved) if !approved { - fmt.Print("PCRs do not match") + fmt.Println("PCRs do not match") os.Exit(1) } - results.Add("PCR v1.0.0 approved", approved, "") + results.Add("PCR v1.0.0 approved for teeType=0", approved, "") + // Test with fake PCR fakePCR := make([]byte, 48) rand.Read(fakePCR) fakeHash, _ := callComputePCRHash(fakePCR, pcr1, pcr2) - fmt.Printf(" 🔍 isPCRApproved(fakePCRHash=%s) = expected false\n", hex.EncodeToString(fakeHash[:])) + fmt.Printf(" 🔍 isPCRApproved(teeType=0, fakePCRHash=%s) = expected false\n", hex.EncodeToString(fakeHash[:])) approved, _ = callIsPCRApproved(0, fakeHash) results.Add("isPCRApproved returns false for unknown PCR", !approved, "") - approvedPCRs, err := callGetApprovedPCRs() - results.Add("getApprovedPCRs returns list", err == nil && len(approvedPCRs) > 0, fmt.Sprintf("count=%d", len(approvedPCRs))) + activePCRs, err := callGetActivePCRs() + results.Add("getActivePCRs returns list", err == nil && len(activePCRs) > 0, fmt.Sprintf("count=%d", len(activePCRs))) // SECTION 4: TEE Registration fmt.Println("\n------------------------------------------") @@ -283,7 +310,7 @@ func main() { if err != nil { fmt.Printf(" ❌ Failed to get AWS root cert: %v\n", err) } else { - txHash, err := callSetAWSRootCert(account, awsRootCert) + txHash, err := callSetAWSRootCert(awsRootCert) if err != nil { fmt.Printf(" ⚠️ Set AWS root cert failed (may already be set): %v\n", err) } else { @@ -312,7 +339,6 @@ func main() { if err != nil { fmt.Printf(" ❌ Failed to extract PCRs: %v\n", err) } else { - // [LOG] Print all PCRs extracted from the attestation, not just 0-1-2 fmt.Printf(" 📊 PCRs extracted from attestation (%d total):\n", len(realPCRs)) for idx, val := range realPCRs { fmt.Printf(" PCR%d: %s\n", idx, hex.EncodeToString(val)) @@ -322,7 +348,7 @@ func main() { realPCR1 := realPCRs[1] realPCR2 := realPCRs[2] - // [LOG] Explicit comparison between file PCRs and attestation PCRs + // Compare file PCRs vs attestation PCRs fmt.Println(" 🔍 Comparing file PCRs vs attestation PCRs:") fmt.Printf(" PCR0 match: %v (file=%s | attest=%s)\n", hex.EncodeToString(pcr0) == hex.EncodeToString(realPCR0), @@ -338,15 +364,14 @@ func main() { realPCRHash, _ := callComputePCRHash(realPCR0, realPCR1, realPCR2) fmt.Printf(" 📊 Real enclave PCR hash: 0x%s\n", hex.EncodeToString(realPCRHash[:])) - realApproved, _ := callIsPCRApproved(0, realPCRHash) - fmt.Printf(" 🔍 isPCRApproved(realPCRHash) = %v\n", realApproved) + realApproved, _ := callIsPCRApproved(0, realPCRHash) // teeType=0 + fmt.Printf(" 🔍 isPCRApproved(teeType=0, realPCRHash) = %v\n", realApproved) if !realApproved { fmt.Println(" 📝 Approving real enclave PCRs...") - txHash, err := callApprovePCR(account, realPCR0, realPCR1, realPCR2, "enclave-v1", 0) + txHash, err := callApprovePCR(realPCR0, realPCR1, realPCR2, "enclave-v1", 0) if err == nil { waitForTx(txHash) - // [LOG] Verify the approval actually stuck postApproval, _ := callIsPCRApproved(0, realPCRHash) fmt.Printf(" ✅ Real PCRs approved — post-approval isPCRApproved=%v\n", postApproval) } else { @@ -356,14 +381,14 @@ func main() { fmt.Println(" ✅ Real PCRs already approved") } - // [LOG] Dump final state of approved PCRs right before registration attempt - fmt.Println(" 🔍 Approved PCRs in contract (pre-registration):") - preRegPCRs, err := callGetApprovedPCRs() + // Dump final state of active PCRs right before registration attempt + fmt.Println(" 🔍 Active PCRs in contract (pre-registration):") + preRegPCRs, err := callGetActivePCRs() if err != nil { fmt.Printf(" ⚠️ Could not fetch: %v\n", err) } else { for i, p := range preRegPCRs { - fmt.Printf(" [%d] pcrHash=0x%s teeType=%d\n", i, hex.EncodeToString(p.PCRHash[:]), p.TEEType) + fmt.Printf(" [%d] hash=%s teeType=%d\n", i, hex.EncodeToString(p.PCRHash[:]), p.TEEType) } } } @@ -376,7 +401,6 @@ func main() { } else { results.Add("Fetch signing public key", true, fmt.Sprintf("%d bytes", len(signingPubKeyDER))) - // [LOG] Show the TEE ID that will be derived from the signing key expectedTeeId := crypto.Keccak256Hash(signingPubKeyDER) fmt.Printf(" 🔑 Signing key SHA256: %x\n", sha256.Sum256(signingPubKeyDER)) fmt.Printf(" 🆔 Expected TEE ID (keccak256(signingKey)): 0x%s\n", hex.EncodeToString(expectedTeeId[:])) @@ -387,13 +411,12 @@ func main() { } else { results.Add("Fetch TLS certificate", true, fmt.Sprintf("%d bytes", len(tlsCertDER))) - // [LOG] Show TLS cert fingerprint for cross-check fmt.Printf(" 🔏 TLS cert SHA256: %x\n", sha256.Sum256(tlsCertDER)) - isEnabled, _ := callIsTEEEnabled(expectedTeeId) - fmt.Printf(" 🔍 isTEEEnabled(expectedTeeId) = %v\n", isEnabled) + isActive, _ := callIsActive(expectedTeeId) + fmt.Printf(" 🔍 isActive(expectedTeeId) = %v\n", isActive) - if isEnabled { + if isActive { fmt.Println(" ℹ️ TEE already registered") registrationSuccess = true registeredTEEId = expectedTeeId @@ -401,7 +424,6 @@ func main() { } else { endpoint := fmt.Sprintf("https://%s", ENCLAVE_HOST) - // [LOG] Summarize all registration inputs before the call fmt.Println(" 📦 Registration inputs:") fmt.Printf(" attestation: %d bytes\n", len(attestationBytes)) fmt.Printf(" signingKey: %d bytes (SHA256=%x)\n", len(signingPubKeyDER), sha256.Sum256(signingPubKeyDER)) @@ -410,7 +432,7 @@ func main() { fmt.Printf(" endpoint: %s\n", endpoint) fmt.Printf(" teeType: 0\n") - txHash, err := callRegisterTEE(account, attestationBytes, signingPubKeyDER, tlsCertDER, account, endpoint, 0) + txHash, err := callRegisterTEE(attestationBytes, signingPubKeyDER, tlsCertDER, account, endpoint, 0) if err != nil { fmt.Printf(" ❌ Registration error: %v\n", err) results.Add("Register TEE with attestation", false, err.Error()) @@ -422,17 +444,15 @@ func main() { registrationSuccess = true registeredTEEId = expectedTeeId - // [LOG] Verify post-registration state fmt.Printf(" ✅ Registration succeeded — verifying on-chain state...\n") - postEnabled, _ := callIsTEEEnabled(registeredTEEId) - fmt.Printf(" isTEEEnabled(teeId)=%v\n", postEnabled) + postActive, _ := callIsActive(registeredTEEId) + fmt.Printf(" isActive(teeId)=%v\n", postActive) } else { - // [LOG] On failure, dump current PCR state to diagnose mismatch fmt.Println(" ❌ Registration failed — dumping PCR state for diagnosis:") - failPCRs, _ := callGetApprovedPCRs() - fmt.Printf(" Approved PCRs in contract (%d):\n", len(failPCRs)) + failPCRs, _ := callGetActivePCRs() + fmt.Printf(" Active PCRs in contract (%d):\n", len(failPCRs)) for i, p := range failPCRs { - fmt.Printf(" [%d] pcrHash=0x%s teeType=%d\n", i, hex.EncodeToString(p.PCRHash[:]), p.TEEType) + fmt.Printf(" [%d] hash=%s teeType=%d\n", i, hex.EncodeToString(p.PCRHash[:]), p.TEEType) } } } @@ -447,12 +467,11 @@ func main() { fmt.Println("------------------------------------------") if registrationSuccess { - isEnabled, err := callIsTEEEnabled(registeredTEEId) - results.Add("isTEEEnabled returns true for registered TEE", isEnabled && err == nil, "") + isActive, err := callIsActive(registeredTEEId) + results.Add("isActive returns true for registered TEE", isActive && err == nil, "") - storedKey, err := callGetTEEPublicKey(registeredTEEId) + storedKey, err := callGetPublicKey(registeredTEEId) keyMatches := err == nil && bytes.Equal(storedKey, signingPubKeyDER) - // [LOG] Show key comparison detail when it fails if !keyMatches { fmt.Printf(" ⚠️ Key mismatch — stored=%d bytes, expected=%d bytes\n", len(storedKey), len(signingPubKeyDER)) if len(storedKey) > 0 { @@ -460,10 +479,15 @@ func main() { } fmt.Printf(" expected SHA256: %x\n", sha256.Sum256(signingPubKeyDER)) } - results.Add("getTEEPublicKey returns correct key", keyMatches, "") + results.Add("getPublicKey returns correct key", keyMatches, "") - enabledTEEs, err := callGetEnabledTEEs(0) - results.Add("getEnabledTEEs includes registered TEE", err == nil && len(enabledTEEs) > 0, fmt.Sprintf("count=%d", len(enabledTEEs))) + // Use getTEE to get TLS certificate (no dedicated getter in new contract) + teeInfo, err := callGetTEE(registeredTEEId) + results.Add("getTEE returns TEE info", err == nil && len(teeInfo.TLSCertificate) > 0, fmt.Sprintf("%d bytes tlsCert", len(teeInfo.TLSCertificate))) + + // getActivatedTEEs now takes teeType parameter + activeTEEs, err := callGetActivatedTEEs(0) + results.Add("getActivatedTEEs(0) includes registered TEE", err == nil && len(activeTEEs) > 0, fmt.Sprintf("count=%d", len(activeTEEs))) teesByType, err := callGetTEEsByType(0) results.Add("getTEEsByType(0) includes registered TEE", err == nil && len(teesByType) > 0, fmt.Sprintf("count=%d", len(teesByType))) @@ -480,19 +504,19 @@ func main() { fmt.Println("------------------------------------------") if registrationSuccess { - txHash, err := callDisableTEE(account, registeredTEEId) + txHash, err := callDeactivateTEE(registeredTEEId) if err == nil { waitForTx(txHash) } - isEnabled, _ := callIsTEEEnabled(registeredTEEId) - results.Add("Disable TEE", !isEnabled, "") + isActive, _ := callIsActive(registeredTEEId) + results.Add("Deactivate TEE", !isActive, "") - txHash, err = callEnableTEE(account, registeredTEEId) + txHash, err = callActivateTEE(registeredTEEId) if err == nil { waitForTx(txHash) } - isEnabled, _ = callIsTEEEnabled(registeredTEEId) - results.Add("Re-enable TEE", isEnabled, "") + isActive, _ = callIsActive(registeredTEEId) + results.Add("Reactivate TEE", isActive, "") } else { fmt.Println(" ⚠️ Skipping lifecycle tests (registration failed)") } @@ -502,12 +526,14 @@ func main() { fmt.Println("SECTION 7: Signature Verification (Local)") fmt.Println("------------------------------------------") - privateKey, testPubKeyDER := generateKeyPair() - inputHash := sha256.Sum256([]byte(`{"prompt": "Hello"}`)) - outputHash := sha256.Sum256([]byte(`{"response": "Hi"}`)) + rsaPrivateKey, testPubKeyDER := generateRSAKeyPair() timestamp := big.NewInt(time.Now().Unix()) - messageHash := computeMessageHash(inputHash, outputHash, timestamp) - signature := signMessage(privateKey, messageHash[:]) + + // For local test, create a message hash similar to heartbeat + // The heartbeat uses keccak256(abi.encodePacked(teeId, timestamp)) + testTeeId := crypto.Keccak256Hash(testPubKeyDER) + messageHash := crypto.Keccak256Hash(append(testTeeId[:], common.LeftPadBytes(timestamp.Bytes(), 32)...)) + signature := signMessageRSA(rsaPrivateKey, messageHash[:]) err = verifySignatureLocal(testPubKeyDER, messageHash[:], signature) results.Add("Local RSA-PSS signature verification", err == nil, fmt.Sprintf("%v", err)) @@ -517,9 +543,10 @@ func main() { badSig[0] ^= 0xFF err = verifySignatureLocal(testPubKeyDER, messageHash[:], badSig) results.Add("Reject invalid signature", err != nil, "") - // SECTION 8: PCR Revocation & TEE Disable Security + + // SECTION 8: PCR Revocation & TEE Deactivation Security fmt.Println("\n------------------------------------------") - fmt.Println("SECTION 8: PCR Revocation & TEE Disable") + fmt.Println("SECTION 8: PCR Revocation & TEE Deactivation") fmt.Println("------------------------------------------") if registrationSuccess { @@ -537,8 +564,8 @@ func main() { testPCRHash, _ := callComputePCRHash(testPCR0, testPCR1, testPCR2) fmt.Printf(" 📊 Test PCR Hash: 0x%s\n", hex.EncodeToString(testPCRHash[:])) - // Approve the test PCR - txHash, err := callApprovePCR(account, testPCR0, testPCR1, testPCR2, "test-revoke", 0) + // Approve the test PCR for teeType=0 + txHash, err := callApprovePCR(testPCR0, testPCR1, testPCR2, "test-revoke", 0) if err == nil { waitForTx(txHash) approved, _ := callIsPCRApproved(0, testPCRHash) @@ -549,7 +576,7 @@ func main() { // Step 2: Revoke the test PCR fmt.Println("\n Step 2: Revoke test PCR") - txHash, err = callRevokePCR(account, testPCRHash, 0) // teeType=0 + txHash, err = callRevokePCR(testPCRHash, 0, 0) // pcrHash, teeType=0, gracePeriod=0 if err != nil { results.Add("Revoke test PCR", false, err.Error()) } else { @@ -559,114 +586,30 @@ func main() { fmt.Println(" ✅ Test PCR successfully revoked") } - // Step 3: Test enable/disable cycle with valid PCR - fmt.Println("\n Step 3: Test enable/disable cycle") + // Step 3: Test activate/deactivate cycle with valid PCR + fmt.Println("\n Step 3: Test activate/deactivate cycle") - // Disable our real TEE - txHash, err = callDisableTEE(account, registeredTEEId) + txHash, err = callDeactivateTEE(registeredTEEId) if err == nil { waitForTx(txHash) - isEnabled, _ := callIsTEEEnabled(registeredTEEId) - results.Add("TEE disabled", !isEnabled, "") + isActive, _ := callIsActive(registeredTEEId) + results.Add("TEE deactivated", !isActive, "") } - // Re-enable - should succeed since TEE's PCR is still valid - txHash, err = callEnableTEE(account, registeredTEEId) + txHash, err = callActivateTEE(registeredTEEId) if err == nil { waitForTx(txHash) - isEnabled, _ := callIsTEEEnabled(registeredTEEId) - results.Add("TEE re-enabled with valid PCR", isEnabled, "") - fmt.Println(" ✅ Re-enable successful (PCR valid)") + isActive, _ := callIsActive(registeredTEEId) + results.Add("TEE reactivated with valid PCR", isActive, "") + fmt.Println(" ✅ Reactivation successful (PCR valid)") } else { - results.Add("Re-enable TEE", false, err.Error()) + results.Add("Reactivate TEE", false, err.Error()) } - // Step 4: Test PCR revocation disables TEEs - fmt.Println("\n Step 4: Test PCR revocation disables TEEs") - - pcrV1_0 := make([]byte, 48) - pcrV1_1 := make([]byte, 48) - pcrV1_2 := make([]byte, 48) - rand.Read(pcrV1_0) - rand.Read(pcrV1_1) - rand.Read(pcrV1_2) - - pcrV2_0 := make([]byte, 48) - pcrV2_1 := make([]byte, 48) - pcrV2_2 := make([]byte, 48) - rand.Read(pcrV2_0) - rand.Read(pcrV2_1) - rand.Read(pcrV2_2) - - pcrV1Hash, _ := callComputePCRHash(pcrV1_0, pcrV1_1, pcrV1_2) - pcrV2Hash, _ := callComputePCRHash(pcrV2_0, pcrV2_1, pcrV2_2) - - fmt.Printf(" 📊 PCR v1 Hash: 0x%s\n", hex.EncodeToString(pcrV1Hash[:])) - fmt.Printf(" 📊 PCR v2 Hash: 0x%s\n", hex.EncodeToString(pcrV2Hash[:])) - - // Approve v1 and v2 - txHash, _ = callApprovePCR(account, pcrV1_0, pcrV1_1, pcrV1_2, "v1-revoke-test", 0) - waitForTx(txHash) - txHash, _ = callApprovePCR(account, pcrV2_0, pcrV2_1, pcrV2_2, "v2-revoke-test", 0) - waitForTx(txHash) - - // Revoke v1 - should be immediate - txHash, err = callRevokePCR(account, pcrV1Hash, 0) // teeType=0 - if err == nil { - waitForTx(txHash) - - // v1 should be revoked, v2 should still be valid - v1Valid, _ := callIsPCRApproved(0, pcrV1Hash) - v2Valid, _ := callIsPCRApproved(0, pcrV2Hash) - - results.Add("Revoked PCR v1 is invalid", !v1Valid, - fmt.Sprintf("v1=%v (expected false)", v1Valid)) - results.Add("PCR v2 still valid after v1 revocation", v2Valid, - fmt.Sprintf("v2=%v", v2Valid)) - - if !v1Valid && v2Valid { - fmt.Println(" ✅ PCR revocation working: v1 revoked, v2 still valid") - } else { - fmt.Printf(" ⚠️ Revocation issue: v1=%v, v2=%v\n", v1Valid, v2Valid) - } - } else { - results.Add("Revoke PCR", false, err.Error()) - } - - // Step 5: Test duplicate PCR prevention - fmt.Println("\n Step 5: Test duplicate PCR prevention") - - dupPCR0 := make([]byte, 48) - dupPCR1 := make([]byte, 48) - dupPCR2 := make([]byte, 48) - rand.Read(dupPCR0) - rand.Read(dupPCR1) - rand.Read(dupPCR2) - - // Approve once - txHash, err = callApprovePCR(account, dupPCR0, dupPCR1, dupPCR2, "dup-test-1", 0) - if err == nil { - waitForTx(txHash) - } - - // Try to approve same PCRs again - should fail - txHash, err = callApprovePCR(account, dupPCR0, dupPCR1, dupPCR2, "dup-test-2", 0) - if err != nil { - results.Add("Duplicate PCR registration prevented", true, "") - fmt.Println(" ✅ Duplicate PCR rejected as expected") - } else { - // If tx was sent, wait for it - it should revert - success := waitForTx(txHash) - results.Add("Duplicate PCR registration prevented", !success, "") - if !success { - fmt.Println(" ✅ Duplicate PCR transaction reverted") - } else { - fmt.Println(" ⚠️ Duplicate PCR was accepted (should have failed)") - } - } } else { fmt.Println(" ⚠️ Skipping PCR revocation tests (no registered TEE)") } + // SECTION 9: Utility Functions fmt.Println("\n------------------------------------------") fmt.Println("SECTION 9: Utility Functions") @@ -696,6 +639,36 @@ func main() { } } +// ============================================================================ +// ETHEREUM CLIENT INITIALIZATION (Private Key) +// ============================================================================ + +func initEthClient() error { + var err error + ethClient, err = ethclient.Dial(RPC_URL) + if err != nil { + return fmt.Errorf("failed to connect to Ethereum client: %v", err) + } + + chainID, err = ethClient.ChainID(context.Background()) + if err != nil { + return fmt.Errorf("failed to get chain ID: %v", err) + } + fmt.Printf("📍 Connected to chain ID: %s\n", chainID.String()) + + if PRIVATE_KEY == "" { + return fmt.Errorf("PRIVATE_KEY environment variable is required") + } + + // Remove 0x prefix if present + keyHex := strings.TrimPrefix(PRIVATE_KEY, "0x") + privateKey, err = crypto.HexToECDSA(keyHex) + if err != nil { + return fmt.Errorf("failed to parse private key: %v", err) + } + return nil +} + // ============================================================================ // CONTRACT DEPLOYMENT // ============================================================================ @@ -721,7 +694,7 @@ func deployOrFindRegistry(account string) (string, error) { return "", fmt.Errorf("invalid bytecode: %v", err) } - txHash, err := deployContract(account, bytecode) + txHash, err := deployContract(bytecode) if err != nil { return "", fmt.Errorf("deploy failed: %v", err) } @@ -740,63 +713,130 @@ func deployOrFindRegistry(account string) (string, error) { } func getCode(address string) ([]byte, error) { - params := []interface{}{address, "latest"} - resp, err := rpcCall("eth_getCode", params) + code, err := ethClient.CodeAt(context.Background(), common.HexToAddress(address), nil) if err != nil { return nil, err } - var result struct{ Result string } - json.Unmarshal(resp, &result) - if len(result.Result) <= 2 { - return nil, nil - } - return hex.DecodeString(result.Result[2:]) + return code, nil } -func deployContract(from string, bytecode []byte) (string, error) { - params := []interface{}{ - map[string]string{ - "from": from, - "gas": "0x980000", - "data": "0x" + hex.EncodeToString(bytecode), - }, +func deployContract(bytecode []byte) (string, error) { + nonce, err := ethClient.PendingNonceAt(context.Background(), crypto.PubkeyToAddress(privateKey.PublicKey)) + if err != nil { + return "", fmt.Errorf("failed to get nonce: %v", err) } - resp, err := rpcCall("eth_sendTransaction", params) + + gasPrice, err := ethClient.SuggestGasPrice(context.Background()) if err != nil { - return "", err + return "", fmt.Errorf("failed to get gas price: %v", err) } - var result struct { - Result string - Error *struct{ Message string } + + tx := types.NewContractCreation(nonce, big.NewInt(0), 10000000, gasPrice, bytecode) + + signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), privateKey) + if err != nil { + return "", fmt.Errorf("failed to sign tx: %v", err) } - json.Unmarshal(resp, &result) - if result.Error != nil { - return "", fmt.Errorf("%s", result.Error.Message) + + err = ethClient.SendTransaction(context.Background(), signedTx) + if err != nil { + return "", fmt.Errorf("failed to send tx: %v", err) } - return result.Result, nil + + return signedTx.Hash().Hex(), nil } func waitForContractAddress(txHash string) (string, error) { + hash := common.HexToHash(txHash) for i := 0; i < 30; i++ { - resp, _ := rpcCall("eth_getTransactionReceipt", []string{txHash}) - var result struct { - Result *struct { - Status string - ContractAddress string - } - } - json.Unmarshal(resp, &result) - if result.Result != nil { - if result.Result.Status != "0x1" { + receipt, err := ethClient.TransactionReceipt(context.Background(), hash) + if err == nil { + if receipt.Status != 1 { return "", fmt.Errorf("deployment failed") } - return result.Result.ContractAddress, nil + return receipt.ContractAddress.Hex(), nil } time.Sleep(time.Second) } return "", fmt.Errorf("timeout waiting for receipt") } +// ============================================================================ +// TRANSACTION HELPERS (Private Key Signing) +// ============================================================================ + +func sendTx(data []byte) (string, error) { + from := crypto.PubkeyToAddress(privateKey.PublicKey) + to := common.HexToAddress(TEE_REGISTRY_ADDRESS) + + nonce, err := ethClient.PendingNonceAt(context.Background(), from) + if err != nil { + return "", fmt.Errorf("failed to get nonce: %v", err) + } + + gasPrice, err := ethClient.SuggestGasPrice(context.Background()) + if err != nil { + return "", fmt.Errorf("failed to get gas price: %v", err) + } + + // Estimate gas + msg := ethereum.CallMsg{ + From: from, + To: &to, + Data: data, + } + gasLimit, err := ethClient.EstimateGas(context.Background(), msg) + if err != nil { + // Fallback to fixed gas limit + gasLimit = 5000000 + fmt.Printf(" ⚠️ Gas estimation failed, using fallback: %v\n", err) + } + + tx := types.NewTransaction(nonce, to, big.NewInt(0), gasLimit, gasPrice, data) + + signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), privateKey) + if err != nil { + return "", fmt.Errorf("failed to sign tx: %v", err) + } + + err = ethClient.SendTransaction(context.Background(), signedTx) + if err != nil { + return "", fmt.Errorf("failed to send tx: %v", err) + } + + return signedTx.Hash().Hex(), nil +} + +func ethCall(data []byte) ([]byte, error) { + to := common.HexToAddress(TEE_REGISTRY_ADDRESS) + msg := ethereum.CallMsg{ + To: &to, + Data: data, + } + result, err := ethClient.CallContract(context.Background(), msg, nil) + if err != nil { + return nil, err + } + return result, nil +} + +func waitForTx(txHash string) bool { + hash := common.HexToHash(txHash) + for i := 0; i < 15; i++ { + receipt, err := ethClient.TransactionReceipt(context.Background(), hash) + if err == nil { + if receipt.Status != 1 { + fmt.Printf(" ⚠️ Tx reverted. GasUsed: %d\n", receipt.GasUsed) + return false + } + return true + } + time.Sleep(time.Second) + } + fmt.Println(" ⚠️ Timeout waiting for tx receipt") + return false +} + // ============================================================================ // NETWORK HELPERS // ============================================================================ @@ -883,7 +923,7 @@ func fetchTLSCertificate(host, port string) ([]byte, error) { fmt.Printf(" 🔌 Connecting to %s via TLS...\n", addr) conn, err := tls.Dial("tcp", addr, &tls.Config{ - InsecureSkipVerify: true, // enclave uses self-signed cert + InsecureSkipVerify: true, }) if err != nil { fmt.Printf(" ❌ TLS Dial failed: %v\n", err) @@ -909,7 +949,6 @@ func fetchTLSCertificate(host, port string) ([]byte, error) { fmt.Printf(" 📄 Raw size: %d bytes\n", len(cert.Raw)) fmt.Printf(" 📄 SHA256: %x\n", sha256.Sum256(cert.Raw)) - // Sanity check — parse back to confirm valid DER if _, err := x509.ParseCertificate(cert.Raw); err != nil { fmt.Printf(" ❌ Failed to parse cert back: %v\n", err) return nil, fmt.Errorf("invalid certificate: %v", err) @@ -936,14 +975,6 @@ func loadPCRMeasurements() ([]byte, []byte, []byte, error) { return pcr0, pcr1, pcr2, nil } -func callRevokePCR(from string, pcrHash [32]byte, teeType uint8) (string, error) { - bytes32Type, _ := abi.NewType("bytes32", "", nil) - u8Type, _ := abi.NewType("uint8", "", nil) - args := abi.Arguments{{Type: bytes32Type}, {Type: u8Type}} - encoded, _ := args.Pack(pcrHash, teeType) - return sendTx(from, append(SEL_REVOKE_PCR, encoded...)) -} - // ============================================================================ // AWS NITRO ROOT CERTIFICATE // ============================================================================ @@ -981,13 +1012,13 @@ IwLz3/Y= // CRYPTO HELPERS // ============================================================================ -func generateKeyPair() (*rsa.PrivateKey, []byte) { +func generateRSAKeyPair() (*rsa.PrivateKey, []byte) { privateKey, _ := rsa.GenerateKey(rand.Reader, 2048) publicKeyDER, _ := x509.MarshalPKIXPublicKey(&privateKey.PublicKey) return privateKey, publicKeyDER } -func signMessage(privateKey *rsa.PrivateKey, messageHash []byte) []byte { +func signMessageRSA(privateKey *rsa.PrivateKey, messageHash []byte) []byte { hash := sha256.Sum256(messageHash) signature, _ := rsa.SignPSS(rand.Reader, privateKey, gcrypto.SHA256, hash[:], &rsa.PSSOptions{ SaltLength: rsa.PSSSaltLengthEqualsHash, @@ -1009,15 +1040,6 @@ func verifySignatureLocal(publicKeyDER, messageHash, signature []byte) error { }) } -func computeMessageHash(inputHash, outputHash [32]byte, timestamp *big.Int) [32]byte { - data := make([]byte, 96) - copy(data[0:32], inputHash[:]) - copy(data[32:64], outputHash[:]) - timestampBytes := timestamp.Bytes() - copy(data[96-len(timestampBytes):96], timestampBytes) - return crypto.Keccak256Hash(data) -} - // ============================================================================ // CONTRACT CALLS - AccessControl // ============================================================================ @@ -1034,32 +1056,32 @@ func callHasRole(role [32]byte, account string) (bool, error) { return result[31] == 1, nil } -func callGrantRole(from string, role [32]byte, account string) (string, error) { +func callGrantRole(role [32]byte, account string) (string, error) { bytes32Type, _ := abi.NewType("bytes32", "", nil) addrType, _ := abi.NewType("address", "", nil) args := abi.Arguments{{Type: bytes32Type}, {Type: addrType}} encoded, _ := args.Pack(role, common.HexToAddress(account)) - return sendTx(from, append(SEL_GRANT_ROLE, encoded...)) + return sendTx(append(SEL_GRANT_ROLE, encoded...)) } -func callRevokeRole(from string, role [32]byte, account string) (string, error) { +func callRevokeRole(role [32]byte, account string) (string, error) { bytes32Type, _ := abi.NewType("bytes32", "", nil) addrType, _ := abi.NewType("address", "", nil) args := abi.Arguments{{Type: bytes32Type}, {Type: addrType}} encoded, _ := args.Pack(role, common.HexToAddress(account)) - return sendTx(from, append(SEL_REVOKE_ROLE, encoded...)) + return sendTx(append(SEL_REVOKE_ROLE, encoded...)) } // ============================================================================ // CONTRACT CALLS - TEE Types // ============================================================================ -func callAddTEEType(from string, typeId uint8, name string) (string, error) { +func callAddTEEType(typeId uint8, name string) (string, error) { uint8Type, _ := abi.NewType("uint8", "", nil) stringType, _ := abi.NewType("string", "", nil) args := abi.Arguments{{Type: uint8Type}, {Type: stringType}} encoded, _ := args.Pack(typeId, name) - return sendTx(from, append(SEL_ADD_TEE_TYPE, encoded...)) + return sendTx(append(SEL_ADD_TEE_TYPE, encoded...)) } func callIsValidTEEType(typeId uint8) (bool, error) { @@ -1077,7 +1099,7 @@ func callIsValidTEEType(typeId uint8) (bool, error) { // CONTRACT CALLS - PCR Management // ============================================================================ -func callApprovePCR(from string, pcr0, pcr1, pcr2 []byte, version string, teeType uint8) (string, error) { +func callApprovePCR(pcr0, pcr1, pcr2 []byte, version string, teeType uint8) (string, error) { tupleType, _ := abi.NewType("tuple", "", []abi.ArgumentMarshaling{ {Name: "pcr0", Type: "bytes"}, {Name: "pcr1", Type: "bytes"}, @@ -1089,7 +1111,7 @@ func callApprovePCR(from string, pcr0, pcr1, pcr2 []byte, version string, teeTyp args := abi.Arguments{{Type: tupleType}, {Type: stringType}, {Type: uint8Type}} pcrs := struct{ Pcr0, Pcr1, Pcr2 []byte }{pcr0, pcr1, pcr2} encoded, _ := args.Pack(pcrs, version, teeType) - return sendTx(from, append(SEL_APPROVE_PCR, encoded...)) + return sendTx(append(SEL_APPROVE_PCR, encoded...)) } func callIsPCRApproved(teeType uint8, pcrHash [32]byte) (bool, error) { @@ -1104,6 +1126,15 @@ func callIsPCRApproved(teeType uint8, pcrHash [32]byte) (bool, error) { return result[31] == 1, nil } +func callRevokePCR(pcrHash [32]byte, teeType uint8, gracePeriod uint64) (string, error) { + bytes32Type, _ := abi.NewType("bytes32", "", nil) + uint8Type, _ := abi.NewType("uint8", "", nil) + uint256Type, _ := abi.NewType("uint256", "", nil) + args := abi.Arguments{{Type: bytes32Type}, {Type: uint8Type}, {Type: uint256Type}} + encoded, _ := args.Pack(pcrHash, teeType, new(big.Int).SetUint64(gracePeriod)) + return sendTx(append(SEL_REVOKE_PCR, encoded...)) +} + func callComputePCRHash(pcr0, pcr1, pcr2 []byte) ([32]byte, error) { tupleType, _ := abi.NewType("tuple", "", []abi.ArgumentMarshaling{ {Name: "pcr0", Type: "bytes"}, @@ -1122,25 +1153,31 @@ func callComputePCRHash(pcr0, pcr1, pcr2 []byte) ([32]byte, error) { return hash, nil } -func callGetApprovedPCRs() ([]ApprovedPCRKey, error) { +func callGetActivePCRs() ([]PCRKey, error) { result, err := ethCall(SEL_GET_APPROVED_PCRS) - if err != nil || len(result) < 64 { + if err != nil { return nil, err } - // ABI: offset (32 bytes) | length (32 bytes) | then length * (bytes32 pcrHash, uint8 teeType padded to 32 bytes) - offset := new(big.Int).SetBytes(result[0:32]).Uint64() - length := new(big.Int).SetBytes(result[offset : offset+32]).Uint64() - pcrs := make([]ApprovedPCRKey, length) - dataStart := offset + 32 + + // ABI decode array of tuples + // The return format is: offset(32) | length(32) | tuple data... + // Each tuple is (bytes32 pcrHash, uint8 teeType) = 64 bytes (32 + 32 padded) + if len(result) < 64 { + return nil, fmt.Errorf("result too short: %d bytes", len(result)) + } + + length := new(big.Int).SetBytes(result[32:64]).Uint64() + pcrs := make([]PCRKey, length) + for i := uint64(0); i < length; i++ { - entryStart := dataStart + i*64 // each tuple is 2 slots: bytes32 + uint8 - if entryStart+64 > uint64(len(result)) { - break + // Each element is 64 bytes: 32 bytes pcrHash + 32 bytes (padded uint8 teeType) + start := 64 + i*64 + if start+64 <= uint64(len(result)) { + var pcrHash [32]byte + copy(pcrHash[:], result[start:start+32]) + teeType := uint8(result[start+63]) // Last byte of the 32-byte slot + pcrs[i] = PCRKey{PCRHash: pcrHash, TEEType: teeType} } - var key ApprovedPCRKey - copy(key.PCRHash[:], result[entryStart:entryStart+32]) - key.TEEType = result[entryStart+63] // uint8 is right-padded in the last byte of the 32-byte slot - pcrs[i] = key } return pcrs, nil } @@ -1149,18 +1186,18 @@ func callGetApprovedPCRs() ([]ApprovedPCRKey, error) { // CONTRACT CALLS - AWS Root Certificate // ============================================================================ -func callSetAWSRootCert(from string, certDER []byte) (string, error) { +func callSetAWSRootCert(certDER []byte) (string, error) { bytesType, _ := abi.NewType("bytes", "", nil) args := abi.Arguments{{Type: bytesType}} encoded, _ := args.Pack(certDER) - return sendTx(from, append(SEL_SET_AWS_ROOT_CERT, encoded...)) + return sendTx(append(SEL_SET_AWS_ROOT_CERT, encoded...)) } // ============================================================================ // CONTRACT CALLS - TEE Registration // ============================================================================ -func callRegisterTEE(from string, attestation, signingKey, tlsCert []byte, paymentAddr, endpoint string, teeType uint8) (string, error) { +func callRegisterTEE(attestation, signingKey, tlsCert []byte, paymentAddr, endpoint string, teeType uint8) (string, error) { bytesType, _ := abi.NewType("bytes", "", nil) addrType, _ := abi.NewType("address", "", nil) stringType, _ := abi.NewType("string", "", nil) @@ -1175,43 +1212,43 @@ func callRegisterTEE(from string, attestation, signingKey, tlsCert []byte, payme return "", fmt.Errorf("abi pack failed: %v", err) } - return sendTx(from, append(SEL_REGISTER_TEE, encoded...)) + return sendTx(append(SEL_REGISTER_TEE, encoded...)) } -func callDisableTEE(from string, teeId [32]byte) (string, error) { +func callDeactivateTEE(teeId [32]byte) (string, error) { bytes32Type, _ := abi.NewType("bytes32", "", nil) args := abi.Arguments{{Type: bytes32Type}} encoded, _ := args.Pack(teeId) - return sendTx(from, append(SEL_DISABLE_TEE, encoded...)) + return sendTx(append(SEL_DISABLE_TEE, encoded...)) } -func callEnableTEE(from string, teeId [32]byte) (string, error) { +func callActivateTEE(teeId [32]byte) (string, error) { bytes32Type, _ := abi.NewType("bytes32", "", nil) args := abi.Arguments{{Type: bytes32Type}} encoded, _ := args.Pack(teeId) - return sendTx(from, append(SEL_ENABLE_TEE, encoded...)) + return sendTx(append(SEL_ENABLE_TEE, encoded...)) } // ============================================================================ // CONTRACT CALLS - Queries // ============================================================================ -func callIsTEEEnabled(teeId [32]byte) (bool, error) { +func callIsActive(teeId [32]byte) (bool, error) { bytes32Type, _ := abi.NewType("bytes32", "", nil) args := abi.Arguments{{Type: bytes32Type}} encoded, _ := args.Pack(teeId) - result, err := ethCall(append(SEL_IS_TEE_ENABLED, encoded...)) + result, err := ethCall(append(SEL_IS_TEE_ACTIVE, encoded...)) if err != nil || len(result) < 32 { return false, err } return result[31] == 1, nil } -func callGetTEEPublicKey(teeId [32]byte) ([]byte, error) { +func callGetPublicKey(teeId [32]byte) ([]byte, error) { bytes32Type, _ := abi.NewType("bytes32", "", nil) args := abi.Arguments{{Type: bytes32Type}} encoded, _ := args.Pack(teeId) - result, err := ethCall(append(SEL_GET_TEE_PUBLIC_KEY, encoded...)) + result, err := ethCall(append(SEL_GET_PUBLIC_KEY, encoded...)) if err != nil || len(result) < 64 { return nil, err } @@ -1222,11 +1259,50 @@ func callGetTEEPublicKey(teeId [32]byte) ([]byte, error) { return result[64 : 64+length], nil } -func callGetEnabledTEEs(teeType uint8) ([]string, error) { +// TEEInfo struct for getTEE response +type TEEInfoResponse struct { + Owner common.Address + PaymentAddress common.Address + Endpoint string + PublicKey []byte + TLSCertificate []byte + PCRHash [32]byte + TEEType uint8 + Active bool + RegisteredAt *big.Int + LastUpdatedAt *big.Int +} + +func callGetTEE(teeId [32]byte) (*TEEInfoResponse, error) { + bytes32Type, _ := abi.NewType("bytes32", "", nil) + args := abi.Arguments{{Type: bytes32Type}} + encoded, _ := args.Pack(teeId) + result, err := ethCall(append(SEL_GET_TEE, encoded...)) + if err != nil { + return nil, err + } + + info := &TEEInfoResponse{} + + // This requires proper ABI tuple decoding - simplified version + if len(result) > 0 { + // Extract owner (first 32 bytes, address in last 20) + if len(result) >= 32 { + info.Owner = common.BytesToAddress(result[12:32]) + } + // For TLS certificate, we need to parse the dynamic data properly + // This is a simplified extraction + info.TLSCertificate = result // Placeholder - need proper ABI decoding + } + + return info, nil +} + +func callGetActivatedTEEs(teeType uint8) ([]string, error) { uint8Type, _ := abi.NewType("uint8", "", nil) args := abi.Arguments{{Type: uint8Type}} encoded, _ := args.Pack(teeType) - result, err := ethCall(append(SEL_GET_ENABLED_TEES, encoded...)) + result, err := ethCall(append(SEL_GET_ACTIVE_TEES, encoded...)) if err != nil || len(result) < 64 { return nil, err } @@ -1296,160 +1372,6 @@ func callComputeTEEId(publicKey []byte) ([32]byte, error) { return id, nil } -// ============================================================================ -// RPC HELPERS -// ============================================================================ - -func getFirstAccount() (string, error) { - resp, err := rpcCall("eth_accounts", []interface{}{}) - if err != nil { - return "", err - } - var result struct{ Result []string } - json.Unmarshal(resp, &result) - if len(result.Result) == 0 { - return "", fmt.Errorf("no accounts") - } - return result.Result[0], nil -} - -func ethCall(data []byte) ([]byte, error) { - params := []interface{}{ - map[string]string{"to": TEE_REGISTRY_ADDRESS, "data": "0x" + hex.EncodeToString(data)}, - "latest", - } - resp, err := rpcCall("eth_call", params) - if err != nil { - return nil, err - } - var result struct { - Result string - Error *struct{ Message string } - } - json.Unmarshal(resp, &result) - if result.Error != nil { - return nil, fmt.Errorf("%s", result.Error.Message) - } - if len(result.Result) > 2 { - return hex.DecodeString(result.Result[2:]) - } - return nil, nil -} - -func sendTx(from string, data []byte) (string, error) { - fmt.Printf(" 🔍 sendTx: from=%s, to=%s, data=%d bytes\n", from, TEE_REGISTRY_ADDRESS, len(data)) - - // First simulate with eth_call - callParams := []interface{}{ - map[string]string{ - "from": from, - "to": TEE_REGISTRY_ADDRESS, - "gas": "0x500000", - "data": "0x" + hex.EncodeToString(data), - }, - "latest", - } - callResp, err := rpcCall("eth_call", callParams) - if err != nil { - return "", fmt.Errorf("eth_call RPC error: %v", err) - } - - var callResult struct { - Result string - Error *struct { - Message string - Data string - } - } - json.Unmarshal(callResp, &callResult) - if callResult.Error != nil { - return "", fmt.Errorf("simulation failed: %s (data: %s)", callResult.Error.Message, callResult.Error.Data) - } - - // Check for revert - if len(callResult.Result) > 10 { - selector := callResult.Result[2:10] - if selector == "08c379a0" { - revertData, _ := hex.DecodeString(callResult.Result[10:]) - if len(revertData) >= 64 { - length := new(big.Int).SetBytes(revertData[32:64]).Uint64() - if uint64(len(revertData)) >= 64+length { - errorMsg := string(revertData[64 : 64+length]) - return "", fmt.Errorf("revert: %s", errorMsg) - } - } - } - } - - // Send actual transaction - params := []interface{}{ - map[string]string{ - "from": from, - "to": TEE_REGISTRY_ADDRESS, - "gas": "0x500000", - "data": "0x" + hex.EncodeToString(data), - }, - } - resp, err := rpcCall("eth_sendTransaction", params) - if err != nil { - return "", fmt.Errorf("eth_sendTransaction RPC error: %v", err) - } - - var result struct { - Result string - Error *struct{ Message string } - } - json.Unmarshal(resp, &result) - if result.Error != nil { - return "", fmt.Errorf("tx error: %s", result.Error.Message) - } - if result.Result == "" { - return "", fmt.Errorf("empty tx hash in response: %s", string(resp)) - } - return result.Result, nil -} - -func waitForTx(txHash string) bool { - for i := 0; i < 15; i++ { - resp, _ := rpcCall("eth_getTransactionReceipt", []string{txHash}) - var result struct { - Result *struct { - Status string - GasUsed string - } - } - json.Unmarshal(resp, &result) - if result.Result != nil { - if result.Result.Status != "0x1" { - fmt.Printf(" ⚠️ Tx reverted. GasUsed: %s\n", result.Result.GasUsed) - return false - } - return true - } - time.Sleep(time.Second) - } - fmt.Println(" ⚠️ Timeout waiting for tx receipt") - return false -} - -func rpcCall(method string, params interface{}) ([]byte, error) { - body := map[string]interface{}{"jsonrpc": "2.0", "method": method, "params": params, "id": 1} - jsonBody, _ := json.Marshal(body) - resp, err := http.Post(RPC_URL, "application/json", bytes.NewReader(jsonBody)) - if err != nil { - return nil, err - } - defer resp.Body.Close() - return io.ReadAll(resp.Body) -} - -func min(a, b int) int { - if a < b { - return a - } - return b -} - func extractPCRsFromAttestation(attestationBytes []byte) (map[int][]byte, error) { // COSE Sign1 structure: [protected, unprotected, payload, signature] var cose []cbor.RawMessage @@ -1476,8 +1398,8 @@ func extractPCRsFromAttestation(attestationBytes []byte) (map[int][]byte, error) } func getEnvOrDefault(key, defaultValue string) string { - if value := os.Getenv(key); value != "" { - return value - } - return defaultValue -} \ No newline at end of file + if value := os.Getenv(key); value != "" { + return value + } + return defaultValue +} diff --git a/scripts/integration/tee_list.sh b/scripts/integration/tee_list.sh deleted file mode 100755 index 8d5e55a1..00000000 --- a/scripts/integration/tee_list.sh +++ /dev/null @@ -1,104 +0,0 @@ -#!/bin/bash - -REGISTRY="0x3d641a2791533b4a0000345ea8d509d01e1ec301" -RPC="http://127.0.0.1:8545" - -echo "=== Fetching Active TEEs ===" -RESPONSE=$(curl -s -X POST $RPC \ - -H "Content-Type: application/json" \ - -d "{\"jsonrpc\":\"2.0\",\"method\":\"eth_call\",\"params\":[{\"to\":\"$REGISTRY\",\"data\":\"0xd046a7fa\"},\"latest\"],\"id\":1}") - -TEE_IDS=$(echo $RESPONSE | python3 -c " -import sys, json -data = json.load(sys.stdin) -result = data['result'][2:] -count = int(result[64:128], 16) -print(f'Found {count} TEE(s)', file=sys.stderr) -for i in range(count): - print(result[128 + i*64 : 128 + (i+1)*64]) -") - -echo "" -echo "=== TEE Details ===" - -echo "$TEE_IDS" | while read ID; do - [ -z "$ID" ] && continue - echo "--- TEE: 0x$ID ---" - - # Get main TEE info - DETAIL=$(curl -s -X POST $RPC \ - -H "Content-Type: application/json" \ - -d "{\"jsonrpc\":\"2.0\",\"method\":\"eth_call\",\"params\":[{\"to\":\"$REGISTRY\",\"data\":\"0xccdf0493$ID\"},\"latest\"],\"id\":1}") - - echo $DETAIL | python3 -c " -import sys, json, datetime -data = json.load(sys.stdin) -if 'error' in data: - print(f' Error: {data[\"error\"]}') - sys.exit(0) -result = data['result'][2:] -def word(pos): - return int(result[pos*64:(pos+1)*64], 16) -def dyn(pos): - offset = word(pos) // 32 - length = word(offset) - return bytes.fromhex(result[(offset+1)*64:(offset+1)*64 + length*2]) -print(f' owner: 0x{result[24:64]}') -print(f' paymentAddr: 0x{result[88:128]}') -print(f' endpoint: {dyn(2).decode()}') -print(f' pcrHash: 0x{result[5*64:6*64]}') -print(f' teeType: {word(6)} (0=LLMProxy 1=Validator)') -print(f' active: {bool(word(7))}') -print(f' registeredAt: {datetime.datetime.fromtimestamp(word(8), tz=datetime.timezone.utc)} UTC') -print(f' lastUpdatedAt: {datetime.datetime.fromtimestamp(word(9), tz=datetime.timezone.utc)} UTC') -" - - # Get public key — getPublicKey(bytes32) selector: b1c551ca - echo " --- Public Key ---" - RAW=$(curl -s -X POST $RPC \ --H "Content-Type: application/json" \ --d "{\"jsonrpc\":\"2.0\",\"method\":\"eth_call\",\"params\":[{\"to\":\"$REGISTRY\",\"data\":\"0xb1c551ca$ID\"},\"latest\"],\"id\":1}") - - - -echo "$RAW" | python3 -c " -import sys, json, base64 -data = json.load(sys.stdin) -result = data['result'][2:] -length = int(result[64:128], 16) -key_hex = result[128:128 + length*2] -key_bytes = bytes.fromhex(key_hex) -print(f' size: {length} bytes') -print(f' hex: {key_hex[:32]}...') -print(f' base64: {base64.b64encode(key_bytes).decode()[:64]}...') -# print as PEM -import base64 as b64 -pem = '-----BEGIN PUBLIC KEY-----\n' -pem += b64.b64encode(key_bytes).decode() -pem += '\n-----END PUBLIC KEY-----' -print(f' PEM:\n{pem}') -" - - # Get TLS certificate — getTLSCertificate(bytes32) selector: b778f869 - echo " --- TLS Certificate ---" - curl -s -X POST $RPC \ - -H "Content-Type: application/json" \ - -d "{\"jsonrpc\":\"2.0\",\"method\":\"eth_call\",\"params\":[{\"to\":\"$REGISTRY\",\"data\":\"0xb778f869$ID\"},\"latest\"],\"id\":1}" \ - | python3 -c " -import sys, json, base64, hashlib -data = json.load(sys.stdin) -result = data['result'][2:] -length = int(result[64:128], 16) -cert_hex = result[128:128 + length*2] -cert_bytes = bytes.fromhex(cert_hex) -print(f' size: {length} bytes') -print(f' SHA256: {hashlib.sha256(cert_bytes).hexdigest()}') -# print as PEM -pem = '-----BEGIN CERTIFICATE-----\n' -pem += base64.b64encode(cert_bytes).decode() -pem += '\n-----END CERTIFICATE-----' -print(f' PEM:\n{pem}') -" - - echo "" -done \ No newline at end of file diff --git a/scripts/tee-mgmt-cli/.env.example b/tee-mgmt-cli/.env.example similarity index 100% rename from scripts/tee-mgmt-cli/.env.example rename to tee-mgmt-cli/.env.example diff --git a/scripts/tee-mgmt-cli/.gitignore b/tee-mgmt-cli/.gitignore similarity index 100% rename from scripts/tee-mgmt-cli/.gitignore rename to tee-mgmt-cli/.gitignore diff --git a/scripts/tee-mgmt-cli/Readme.md b/tee-mgmt-cli/Readme.md similarity index 100% rename from scripts/tee-mgmt-cli/Readme.md rename to tee-mgmt-cli/Readme.md diff --git a/scripts/tee-mgmt-cli/Registration.md b/tee-mgmt-cli/Registration.md similarity index 100% rename from scripts/tee-mgmt-cli/Registration.md rename to tee-mgmt-cli/Registration.md diff --git a/scripts/tee-mgmt-cli/cmd/cert.go b/tee-mgmt-cli/cmd/cert.go similarity index 100% rename from scripts/tee-mgmt-cli/cmd/cert.go rename to tee-mgmt-cli/cmd/cert.go diff --git a/scripts/tee-mgmt-cli/cmd/heartbeat.go b/tee-mgmt-cli/cmd/heartbeat.go similarity index 100% rename from scripts/tee-mgmt-cli/cmd/heartbeat.go rename to tee-mgmt-cli/cmd/heartbeat.go diff --git a/scripts/tee-mgmt-cli/cmd/pcr.go b/tee-mgmt-cli/cmd/pcr.go similarity index 100% rename from scripts/tee-mgmt-cli/cmd/pcr.go rename to tee-mgmt-cli/cmd/pcr.go diff --git a/scripts/tee-mgmt-cli/cmd/role.go b/tee-mgmt-cli/cmd/role.go similarity index 100% rename from scripts/tee-mgmt-cli/cmd/role.go rename to tee-mgmt-cli/cmd/role.go diff --git a/scripts/tee-mgmt-cli/cmd/root.go b/tee-mgmt-cli/cmd/root.go similarity index 100% rename from scripts/tee-mgmt-cli/cmd/root.go rename to tee-mgmt-cli/cmd/root.go diff --git a/scripts/tee-mgmt-cli/cmd/tee.go b/tee-mgmt-cli/cmd/tee.go similarity index 100% rename from scripts/tee-mgmt-cli/cmd/tee.go rename to tee-mgmt-cli/cmd/tee.go diff --git a/scripts/tee-mgmt-cli/cmd/types.go b/tee-mgmt-cli/cmd/types.go similarity index 100% rename from scripts/tee-mgmt-cli/cmd/types.go rename to tee-mgmt-cli/cmd/types.go diff --git a/scripts/tee-mgmt-cli/go.mod b/tee-mgmt-cli/go.mod similarity index 100% rename from scripts/tee-mgmt-cli/go.mod rename to tee-mgmt-cli/go.mod diff --git a/scripts/tee-mgmt-cli/go.sum b/tee-mgmt-cli/go.sum similarity index 100% rename from scripts/tee-mgmt-cli/go.sum rename to tee-mgmt-cli/go.sum diff --git a/scripts/tee-mgmt-cli/main.go b/tee-mgmt-cli/main.go similarity index 100% rename from scripts/tee-mgmt-cli/main.go rename to tee-mgmt-cli/main.go diff --git a/scripts/tee-mgmt-cli/registry/client.go b/tee-mgmt-cli/registry/client.go similarity index 100% rename from scripts/tee-mgmt-cli/registry/client.go rename to tee-mgmt-cli/registry/client.go