Struct Template 

pub struct Template(/* private fields */);

A TPM public-area key template.

Implementations

impl Template

pub fn srk(alg: KeyAlg) -> Result<Self>

Storage root key template (restricted decryption parent).

pub fn attestation(alg: KeyAlg) -> Result<Self>

Attestation identity key (AIK) template — a restricted signing key used to certify other objects / quote PCRs.

Examples found in repository

examples/full_flow.rs (line 82)

fn main() -> Result<(), wolftpm::TpmError> {
    let dev = Device::open()?;
    println!("device            connected to TPM");

    let mut nonce = [0u8; 16];
    dev.get_random(&mut nonce)?;
    println!("get_random        {}", hex(&nonce));

    let srk = dev.create_primary(Hierarchy::Owner, KeyAlg::EccP256, None)?;
    println!("create_primary    ECC SRK handle 0x{:08x}", srk.handle());

    let signer = dev.create_and_load(&srk, &Template::signing(KeyAlg::EccP256)?, None)?;
    println!(
        "create_and_load   signing key handle 0x{:08x}",
        signer.handle()
    );

    let digest = [0x11u8; 32];
    let sig = signer.sign_hash(&digest)?;
    signer.verify_hash(&digest, &sig)?;
    println!("sign/verify       {} byte signature, verified", sig.len());

    let sealed = dev.seal(&srk, b"my secret", None)?;
    let secret = dev.unseal(sealed, &srk, None)?;
    println!(
        "seal/unseal       recovered \"{}\"",
        core::str::from_utf8(&secret).unwrap_or("<bytes>")
    );

    // Scope the reloaded key so its handle is freed before the attestation
    // step below. A TPM only holds a few transient objects at once (often 3),
    // so keep the number of simultaneously-loaded keys small.
    {
        let blob = dev.create_key(&srk, &Template::signing(KeyAlg::EccP256)?, None)?;
        let bytes = blob.to_bytes()?;
        let restored = KeyBlob::from_bytes(&dev, &bytes)?;
        let loaded = restored.load(&srk, None)?;
        println!(
            "key blob          {} bytes, reloaded as handle 0x{:08x}",
            bytes.len(),
            loaded.handle()
        );
    }

    let before = dev.pcr_read(16, HashAlg::Sha256)?;
    dev.pcr_extend(16, HashAlg::Sha256, &[0xAB; 32])?;
    let after = dev.pcr_read(16, HashAlg::Sha256)?;
    println!(
        "pcr read/extend   PCR16 {}.. -> {}..",
        hex(&before[..6]),
        hex(&after[..6])
    );

    let index = 0x0150_0100;
    let _ = dev.nv_delete(index);
    let mut slot = dev.nv_create(index, 32, None)?;
    dev.nv_write(&mut slot, b"metadata", 0)?;
    let mut buf = [0u8; 32];
    let n = dev.nv_read(&mut slot, &mut buf, 0)?;
    dev.nv_delete(index)?;
    println!("nv define/rw      {} bytes at index 0x{:08x}", n, index);

    let aik = dev.create_and_load(&srk, &Template::attestation(KeyAlg::EccP256)?, None)?;
    let att = dev.certify(&signer, &aik, &nonce)?;
    println!("certify           {} byte attestation", att.attest.len());

    println!("done              all operations succeeded");
    Ok(())
}

pub fn ek(alg: KeyAlg) -> Result<Self>

Endorsement key (EK) template, created under the endorsement hierarchy.

pub fn rsa_decrypt() -> Result<Self>

RSA decryption-key template (non-restricted), for RSA-OAEP encrypt and decrypt.

pub fn signing(alg: KeyAlg) -> Result<Self>

General signing-key template (non-restricted, ECDSA/RSASSA).

Examples found in repository

examples/full_flow.rs (line 31)

fn main() -> Result<(), wolftpm::TpmError> {
    let dev = Device::open()?;
    println!("device            connected to TPM");

    let mut nonce = [0u8; 16];
    dev.get_random(&mut nonce)?;
    println!("get_random        {}", hex(&nonce));

    let srk = dev.create_primary(Hierarchy::Owner, KeyAlg::EccP256, None)?;
    println!("create_primary    ECC SRK handle 0x{:08x}", srk.handle());

    let signer = dev.create_and_load(&srk, &Template::signing(KeyAlg::EccP256)?, None)?;
    println!(
        "create_and_load   signing key handle 0x{:08x}",
        signer.handle()
    );

    let digest = [0x11u8; 32];
    let sig = signer.sign_hash(&digest)?;
    signer.verify_hash(&digest, &sig)?;
    println!("sign/verify       {} byte signature, verified", sig.len());

    let sealed = dev.seal(&srk, b"my secret", None)?;
    let secret = dev.unseal(sealed, &srk, None)?;
    println!(
        "seal/unseal       recovered \"{}\"",
        core::str::from_utf8(&secret).unwrap_or("<bytes>")
    );

    // Scope the reloaded key so its handle is freed before the attestation
    // step below. A TPM only holds a few transient objects at once (often 3),
    // so keep the number of simultaneously-loaded keys small.
    {
        let blob = dev.create_key(&srk, &Template::signing(KeyAlg::EccP256)?, None)?;
        let bytes = blob.to_bytes()?;
        let restored = KeyBlob::from_bytes(&dev, &bytes)?;
        let loaded = restored.load(&srk, None)?;
        println!(
            "key blob          {} bytes, reloaded as handle 0x{:08x}",
            bytes.len(),
            loaded.handle()
        );
    }

    let before = dev.pcr_read(16, HashAlg::Sha256)?;
    dev.pcr_extend(16, HashAlg::Sha256, &[0xAB; 32])?;
    let after = dev.pcr_read(16, HashAlg::Sha256)?;
    println!(
        "pcr read/extend   PCR16 {}.. -> {}..",
        hex(&before[..6]),
        hex(&after[..6])
    );

    let index = 0x0150_0100;
    let _ = dev.nv_delete(index);
    let mut slot = dev.nv_create(index, 32, None)?;
    dev.nv_write(&mut slot, b"metadata", 0)?;
    let mut buf = [0u8; 32];
    let n = dev.nv_read(&mut slot, &mut buf, 0)?;
    dev.nv_delete(index)?;
    println!("nv define/rw      {} bytes at index 0x{:08x}", n, index);

    let aik = dev.create_and_load(&srk, &Template::attestation(KeyAlg::EccP256)?, None)?;
    let att = dev.certify(&signer, &aik, &nonce)?;
    println!("certify           {} byte attestation", att.attest.len());

    println!("done              all operations succeeded");
    Ok(())
}

pub fn hmac(hash: HashAlg) -> Result<Self>

TPM-generated keyed-hash HMAC key template, bound to this TPM.

The key material originates in the TPM (sensitiveDataOrigin) and is non-duplicable (fixedTPM/fixedParent), so the HMAC secret never leaves the TPM: create it once, keep only the wrapped blob, reload it, and compute with Key::hmac.

pub fn symmetric(bits: u16) -> Result<Self>

AES symmetric-cipher key template (CFB mode) for TPM-backed bulk encrypt/decrypt via Key::aes_encrypt / Key::aes_decrypt. bits is 128 or 256.

pub fn ecdh() -> Result<Self>

ECDH key-agreement key template (NIST P-256, restricted-decrypt with the ECDH scheme). Use with Key::ecdh_gen.