DEV Community: tsuruko

Automatically Revert Temporary Value Changes in a with Block

tsuruko — Sat, 21 Mar 2026 14:20:40 +0000

The new rollback() API introduced in triggon v2.0.0 can automatically revert temporary changes to variables and attributes made in a with block.
It also supports local variables, so it's only available on CPython 3.13+.

Code Example

Here's a simple example.

In this example, the variable x is assigned 99 inside the block, but once the block exits, it's restored to its original value, 1.

from triggon import Triggon

x = 1

with Triggon.rollback():
    x = 99
    print(x)
    # 99

print(x)
# 1

You can also pass the names of variables or attributes to rollback(), so only the specified targets will be restored.

class A:
    a = 10

x = 0

# x isn't included in the rollback target
with Triggon.rollback("A.a"):
    x = 99
    A.a = -10
    print(x)
    # 99
    print(A.a)
    # -10

print(x)
# 99
print(A.a)
# 10

Variables defined inside the block aren't restored.

triggon recently had a major update with 8 new APIs.
You can check the details in the release notes.

triggon is basically a label-based library, but rollback() can be used easily without registering labels, variables, or attributes in advance.

It also includes other unique features such as deferred execution and flexible early-return handling, so feel free to check it out if you're interested.

How I Used TPM for Key Encryption in Rust on Linux (Hardware TPM & vTPM)

tsuruko — Wed, 24 Dec 2025 14:26:03 +0000

Following my Windows implementation, this time I implemented key wrapping with a TPM on Linux.
(Windows version: How I Used TPM for Key Encryption in Rust (Using Windows APIs))

I used tss-esapi on Ubuntu (WSL) with a virtual TPM (vTPM).
For the vTPM, I used swtpm (v0.7.3).
By changing the connection target, the same code also works with a hardware TPM.

I’ll walk you through the key-wrapping implementation and explain how it works!

Cargo.toml
Requirements to Build tss-esapi
Implementation
Explanation
- 1. Connect to the TPM
- 2. Create a Context
- 3. Start the TPM
- 4. Get the SRK Handle
- 5. Create and Persist an RSA Key
- 6. Wrap the Key
- Unwrap the Key
- Shut Down the TPM
- Remove a Persistent Key
- Clear the TPM
- About tpm2-tss Logs
Final Thoughts

Cargo.toml

[dependencies]
getrandom = "0.4"
tss-esapi = "7.6"
zeroize = "1.8"

Requirements to Build tss-esapi

gcc (C compiler / build tool)
pkg-config (dependency discovery tool for builds)
libtss2-dev (TPM libraries)

The tss-esapi-sys README says it uses pkg-config at build time to locate tss2-esys, tss2-tctildr, and tss2-mu.
So make sure pkg-config, libtss2-dev (v2.3.3+), and gcc are installed.
libtss2-dev includes those three libraries.

Install on Ubuntu

sudo apt install gcc pkg-config libtss2-dev

Implementation

use std::convert::TryFrom;

use tss_esapi::{
    Context, Result,
    attributes::object::{ObjectAttributes, ObjectAttributesBuilder},
    constants::{
        capabilities::CapabilityType, response_code::Tss2ResponseCodeKind,
        startup_type::StartupType,
    },
    handles::{ObjectHandle, PersistentTpmHandle, TpmHandle},
    interface_types::{
        algorithm::{HashingAlgorithm, PublicAlgorithm},
        key_bits::RsaKeyBits,
        resource_handles::{Hierarchy, Provision},
        session_handles::AuthSession,
    },
    structures::{
        Auth, CapabilityData, Data, HashScheme, Public, PublicBuilder, PublicKeyRsa,
        PublicRsaParameters, PublicRsaParametersBuilder, RsaDecryptionScheme, RsaExponent,
        RsaScheme, SymmetricDefinitionObject,
    },
    tcti_ldr::{DeviceConfig, NetworkTPMConfig, TctiNameConf},
};
use zeroize::Zeroizing;

// Note: This is a simplified version

const RSA_KEY_AUTH: &[u8] = b"AuthValue";

fn build_public(attrs: ObjectAttributes, params: PublicRsaParameters) -> Result<Public> {
    let public = PublicBuilder::new()
        .with_public_algorithm(PublicAlgorithm::Rsa)
        .with_object_attributes(attrs)
        .with_name_hashing_algorithm(HashingAlgorithm::Sha256)
        .with_rsa_parameters(params)
        .with_rsa_unique_identifier(PublicKeyRsa::default())
        .build()?;

    Ok(public)
}

struct KeyWrapper {
    ctx: Context,
}

// With a hardware TPM, the platform often shuts the TPM down automatically.
// If that's the case in your environment, remove this block.
impl Drop for KeyWrapper {
    fn drop(&mut self) {
        if let Err(e) = self.ctx.shutdown(StartupType::Clear) {
            eprintln!("Failed to shut down the TPM: {e}");
        }
    }
}

// Encryption and hashing algorithms are chosen for broad compatibility
// and are widely used and recommended

impl KeyWrapper {
    fn new(use_vtpm: bool) -> Result<Self> {
        let tcti = if use_vtpm {
            // By default, this connects to "localhost:2321"
            TctiNameConf::Swtpm(NetworkTPMConfig::default())
        } else {
            // By default, this connects to "/dev/tpm0"
            TctiNameConf::Device(DeviceConfig::default())
        };

        let mut ctx = Context::new(tcti)?;

        // With a hardware TPM, the platform often starts the TPM automatically.
        // If that's the case in your environment, remove this line.
        ctx.startup(StartupType::Clear)?;

        Ok(Self { ctx })
    }

    fn wrap_key(&mut self, target_key: [u8; 32]) -> Result<Vec<u8>> {
        let target_key = Zeroizing::new(target_key);

        let hrsa = self.ensure_rsa_key()?;

        // Wrap the target key
        let wrapped_key = self.ctx.execute_with_nullauth_session(|ctx| {
            ctx.rsa_encrypt(
                hrsa.into(),
                PublicKeyRsa::try_from(target_key.as_slice())?,
                RsaDecryptionScheme::Null,
                Data::default(),
            )
        })?;

        Ok(wrapped_key.to_vec())
    }

    fn unwrap_key(&mut self, target_key: &[u8]) -> Result<Vec<u8>> {
        let hrsa = self.ensure_rsa_key()?;

        // Set the auth value for the key object
        self.ctx.tr_set_auth(hrsa, Auth::try_from(RSA_KEY_AUTH)?)?;

        // Unwrap the target key
        let unwrapped_key = self.ctx.execute_with_nullauth_session(|ctx| {
            ctx.rsa_decrypt(
                hrsa.into(),
                PublicKeyRsa::try_from(target_key)?,
                RsaDecryptionScheme::Null,
                Data::default(),
            )
        })?;

        Ok(unwrapped_key.to_vec())
    }

    fn ensure_rsa_key(&mut self) -> Result<ObjectHandle> {
        self.ctx.clear_sessions();

        // Create a new SRK and RSA key if they don't exist

        // Persistent handle values are in the range 0x81000000–0x81FFFFFF
        let mut value = 0x81000000;
        let mut srk = None;

        loop {
            let (data, more) = self.ctx.get_capability(CapabilityType::Handles, value, 8)?;

            if let CapabilityData::Handles(h) = data {
                let handles = h.into_inner();
                if handles.is_empty() {
                    // Create a new SRK and RSA key if there are no registered handles
                    let srk = self.create_srk()?;
                    return Ok(self.create_rsa_key(srk)?);
                }

                let last_value = handles.last().unwrap();
                value = u32::from(*last_value) + 1;

                for handle in handles {
                    if let TpmHandle::Persistent(_) = handle {
                        let target_handle = self.ctx.tr_from_tpm_public(handle)?;
                        // Read the target handle's public area
                        let (public, _, _) = self.ctx.read_public(target_handle.into())?;

                        if let Public::Rsa {
                            object_attributes, ..
                        } = public
                        {
                            let attrs = object_attributes;

                            // Find a handle with attributes matching the RSA wrapping key
                            if !attrs.restricted()
                                && attrs.fixed_tpm()
                                && attrs.fixed_parent()
                                && attrs.sensitive_data_origin()
                                && attrs.user_with_auth()
                                && attrs.decrypt()
                            {
                                return Ok(target_handle);
                            } else if attrs.restricted()
                                && attrs.decrypt()
                                && attrs.fixed_tpm()
                                && attrs.fixed_parent()
                                && attrs.sensitive_data_origin()
                                && attrs.no_da()
                            {
                                srk = Some(target_handle);
                            }
                        }
                    }
                }
            }

            if !more {
                // If there are no more handles
                if let None = srk {
                    let srk = self.create_srk()?;
                    return Ok(self.create_rsa_key(srk)?);
                } else {
                    return Ok(self.create_rsa_key(srk.unwrap())?);
                }
            }
        }
    }

    fn make_persistent(&mut self, handle: impl Into<ObjectHandle>) -> Result<ObjectHandle> {
        let mut value = 0x81000001;
        let handle = handle.into();

        loop {
            match self
                .ctx
                // Set a password session
                .execute_with_session(Some(AuthSession::Password), |ctx| {
                    // Make the target object persistent
                    ctx.evict_control(
                        Provision::Owner,
                        handle,
                        PersistentTpmHandle::new(value)?.into(),
                    )
                }) {
                Ok(h) => {
                    println!("Registered the object at handle {value:#x}.");
                    // Remove the transient object
                    let _ = self.ctx.flush_context(handle);
                    return Ok(h);
                }
                Err(e) => {
                    // When the target handle value is already in use
                    if matches!(
                        &e,
                        tss_esapi::Error::Tss2Error(code)
                            if code.kind() == Some(Tss2ResponseCodeKind::NvDefined)
                    ) {
                        value += 1;
                        continue;
                    }

                    return Err(e);
                }
            }
        }
    }

    fn create_rsa_key(&mut self, hsrk: ObjectHandle) -> Result<ObjectHandle> {
        let attrs = ObjectAttributesBuilder::new()
            .with_fixed_tpm(true)
            .with_fixed_parent(true)
            .with_user_with_auth(true)
            .with_sensitive_data_origin(true)
            .with_decrypt(true)
            .build()?;

        let hash_algo = HashScheme::new(HashingAlgorithm::Sha256);
        let params = PublicRsaParametersBuilder::new()
            .with_scheme(RsaScheme::Oaep(hash_algo))
            .with_key_bits(RsaKeyBits::Rsa2048)
            .with_exponent(RsaExponent::ZERO_EXPONENT)
            .build()?;

        let key_result = self.ctx.execute_with_session(
            Some(AuthSession::Password), // Set a password session
            |ctx| {
                // Create a new RSA key
                let key_result = ctx.create(
                    hsrk.into(),
                    build_public(attrs, params)?,
                    Some(Auth::try_from(RSA_KEY_AUTH)?),
                    None,
                    None,
                    None,
                )?;
                // Load the created RSA key into the TPM
                ctx.load(hsrk.into(), key_result.out_private, key_result.out_public)
            },
        )?;

        Ok(self.make_persistent(key_result)?)
    }

    fn create_srk(&mut self) -> Result<ObjectHandle> {
        let attrs = ObjectAttributesBuilder::new()
            .with_fixed_tpm(true)
            .with_fixed_parent(true)
            .with_no_da(true)
            .with_restricted(true)
            .with_user_with_auth(true)
            .with_sensitive_data_origin(true)
            .with_decrypt(true)
            .build()?;

        let params = PublicRsaParametersBuilder::new_restricted_decryption_key(
            SymmetricDefinitionObject::AES_128_CFB,
            RsaKeyBits::Rsa2048,
            RsaExponent::ZERO_EXPONENT,
        )
        .build()?;

        let key_result = self.ctx.execute_with_session(
            Some(AuthSession::Password), // Set a password session
            |ctx| {
                // Create a new SRK
                ctx.create_primary(
                    Hierarchy::Owner,
                    build_public(attrs, params)?,
                    None,
                    None,
                    None,
                    None,
                )
            },
        )?;    

        Ok(self.make_persistent(key_result.key_handle)?)
    }
}

This implementation scans the TPM's persistent handles each time to look for the wrapping key created earlier. It verifies the key by checking its attributes. If it can’t find a match, it creates a new RSA key.

For authorization, it sets up password sessions or HMAC sessions depending on the function. Some functions don’t allow password sessions, or restrict which session attributes can be used, so the appropriate session type should be used for each case.

tr_from_tpm_public(), which constructs an ESYS object, is used to operate on an existing TPM object.

Since this is a simplified version, the password used as the RSA key’s auth value is defined as a const.
In real-world use, you should manage it securely.

To confirm it works, try running the main function below:

fn main() {
    // Connect to vTPM
    let mut key_wrapper = match KeyWrapper::new(true) {
        Ok(t) => t,
        Err(e) => {
            eprintln!("Failed to connect to the TPM: {e}");
            return
        },  
    };

    // Create a key to be wrapped (AES-256)
    let mut key = [0u8; 32];
    getrandom::fill(&mut key).unwrap();
    println!("Original key: {:?}", key);

    let wrapped_key = match key_wrapper.wrap_key(key) {
        Ok(k) => {
            println!("Wrapped key: {:?}", k);
            k
        },
        Err(e) => {
            eprintln!("Failed to wrap the key: {e}");
            return
        },  
    };

    match key_wrapper.unwrap_key(&wrapped_key) {
        Ok(k) => println!("Unwrapped key: {:?}", k),
        Err(e) => eprintln!("Failed to unwrap the key: {e}"),  
    }
}

If you want to delete the key you created:

fn delete_key(&mut self, value: u32) -> Result<()> {
    // `value` is the handle value to remove
    let handle = self.ctx.tr_from_tpm_public(TpmHandle::try_from(value)?)?;

    let _ = self
        .ctx
        .execute_with_session(Some(AuthSession::Password), |ctx| {
            // Remove the persistent handle
            ctx.evict_control(
                Provision::Owner,
                handle,
                PersistentTpmHandle::new(value)?.into(),
            )
        })?;
    println!("Removed the object at handle {value:#x}.");

    Ok(())
}

evict_control() behaves differently depending on whether the target is a transient object or a persistent one.

If the target is a transient object, it’s registered under the specified persistent handle.
If the target is already a persistent object, it's removed instead.

If you run it in the terminal:

# Specify the connection target using an environment variable
export TPM2TOOLS_TCTI="swtpm:host=localhost,port=2321"  # vTPM（swtpm）
export TPM2TOOLS_TCTI="device:/dev/tpm0"                # hardware TPM

# Remove the persistent object at handle 0x81000002
# If the hierarchy has an auth value, specify it with "-P" ("--auth")
tpm2_evictcontrol -c 0x81000002

You can also easily list the current TPM handles:

# List persistent handles
tpm2_getcap handles-persistent
# List the known supported capability names
tpm2_getcap -l

Explanation

I referred to the following resources to learn about TPM 2.0, including its architecture and function parameters:

I also used this resource as a reference for tpm2-tools command usage:

tpm2-tools — official documentation (man pages)

In this section, I’ll explain the key-wrapping workflow and the relevant functions and parameters based on the references above.

1. Connect to the TPM

If you use a hardware TPM, make sure it’s enabled.

To connect to swtpm, you need to start the vTPM server in the terminal.
In this implementation, the connection uses a TCP socket.

# Sample command
swtpm socket \
--tpm2 \
--server type=tcp,port=2321 \
--ctrl type=tcp,port=2322 \
--tpmstate dir=/path/to/dir \
--flags startup-clear

--tpm2

--tpm2

This option selects TPM 2.0.
If not specified, TPM 1.2 is used.

--server

--server [type=tcp][,port=<port>[,bindaddr=<address> [,ifname=<ifname>]]][,fd=<fd>][,disconnect]

This option accepts TCP connections on the given port.

If you specify a port (port), you can also specify a bind address (bindaddr).
The default bind address is 127.0.0.1.
if not specified, you must specify a file descriptor (fd).

If you use a link-local IPv6 address, you must specify the interface name (ifname) to bind to.

Unless disconnect is specified, the connection remains persistent.

--ctrl

--ctrl type=[unixio|tcp][,path=<path>] [,port=<port>[,bindaddr=<address>[,ifname=<ifname>]]][,fd=<filedescriptor>|clientfd=<filedescriptor>] [,mode=<0...>][,uid=<uid>][,gid=<gid>]

This option adds a control channel to the TPM.

You can choose one of the following connection methods:

Unix domain socket
- Connect using either a path (path) or a file descriptor (fd).
TCP socket
- Connect using either a port (port) or a file descriptor (clientfd).

If you specify a port (port), you can also specify a bind address (bindaddr).
The default bind address is 127.0.0.1.

--tpmstate

--tpmstate dir=<dir>[,mode=<0...>]|backend-uri=<uri>

This option stores the TPM’s state in the specified directory.

When the state is saved you’ll see files like:

tpm2-00.permall (non-volatile data)
tpm2-00.volatilestate (volatile data)
tpm-00.savestate (TPM 1.2 only)

The directory can also be specified using the TPM_PATH.
If both are set, this option is used instead of TPM_PATH.

export TPM_PATH=/path/to/dir

--flags

--flags [not-need-init] [,startup-clear|startup-state|startup-deactivated|startup-none]

This option controls the behavior of the TPM_Startup / TPM2_Startup command.

It automatically sends the Startup command unless you use startup-none, or use not-need-init on its own.

startup-clear: Normal initialization (resets PCRs and volatile state)
startup-state: Restore volatile state (except PCRs)
startup-deactivated: TPM 1.2 only (start in deactivated mode)
startup-none: Do not send any Startup command

These options except startup-none imply not-need-init.
The not-need-init flag enables the TPM to accept commands without an INIT being sent.

startup-none seems intended for cases where you send both the INIT and Startup commands yourself.

If none of these options are specified, startup-clear is used by default.

Note:
I tested whether startup-state actually saves the volatile state, but it didn't. I’m not sure if this is unsupported in TPM 2.0.
However, when I ran swtpm_ioctl with the -v option to save the state to a file manually, it worked.

To use this tool, install swtpm-tools.
# Specify the port for the control channel with `--tcp`
# The defaults are server "127.0.0.1" and port "6545"
swtpm_ioctl --tcp :2322 -v

Other Options

If you want to daemonize the process, specify -d (--daemon).

If you want to enable logging, specify --log.
--log [fd=<fd>|file=<path>][,level=<n>][,prefix=<prefix>][,truncate]

You can specify the log file path (file), and the log level (level).
If the log level is 5 or higher, debug tracing for libtpms is enabled.

For other options, refer to the swtpm manual:

Ubuntu swtpm manual

Note:
As a TPM 2.0-specific caution, the TPM_PT_LOCKOUT_COUNTER (dictionary-attack lockout counter) may cause the TPM to become locked out once it reaches its limit.

For example, this counter can increase when you enter an incorrect auth value, or if you disconnect without calling TPM2_Shutdown() after accessing a command that requires authorization.
The TPM checks during TPM2_Startup() whether the previous shutdown was orderly.

Once the TPM is locked out, commands that require authorization will fail with an error on the next attempt.
To prevent this, always call TPM2_Shutdown() at the end.

In swtpm v0.8 and later, TPM2_Shutdown() is sent automatically unless you set disable-auto-shutdown. In earlier versions, you need to do it manually (this behavior is documented in the CHANGES file).

If you want to disable this counter for a specific object, you can set with_no_da(true) when creating that object.

If you do get locked out, you can either wait for the recovery time (the delay until the next auth attempt is allowed) or clear the lockout state using tpm2-tools commands.
# Specify the connection target using an environment variable

# Example: connect to a vTPM (swtpm)
# If not specified, the default IP address is "127.0.0.1" and the port is "2321"
export TPM2TOOLS_TCTI="swtpm:host=localhost,port=2321"

# Example: connect to a physical TPM
# If not specified, the default device path is "/dev/tpm0"
export TPM2TOOLS_TCTI="device:/dev/tpm0"

# Clear the lockout state with "-c"
tpm2_dictionarylockout -c

# Or specify the connection target along with the command
tpm2_dictionarylockout -c -T swtpm:host=localhost,port=2321

tpm2_dictionarylockout(1) - tpm2-tools

🔗 Reference：

Trusted Platform Module 2.0 Library Part 1: Architecture (p.143 Dictionary Attack Protection)

Next, you need to configure the library.

let tcti = if use_vtpm {
    // By default, this connects to "localhost:2321"
    TctiNameConf::Swtpm(NetworkTPMConfig::default())
} else {
    // By default, this connects to "/dev/tpm0"
    TctiNameConf::Device(DeviceConfig::default())
};

In this implementation, I use these defaults.
If you want to connect to a custom port or path, use from_str():

use std::str::FromStr;

// Custom port/host
let tcti = TctiNameConf::from_str("swtpm:port=1234,host=127.0.0.1")?;
// Custom TPM device path
let tcti = TctiNameConf::from_str("device:/dev/tpmrm0")?;

To load the connection settings from an environment variable:

// The lookup order is: TPM2TOOLS_TCTI → TCTI → TEST_TCTI
let tcti = TctiNameConf::from_environment_variable()?;

Other connection options include mssim (Microsoft TPM simulator) and tabrmd (the tpm2-abrmd daemon), but I won’t cover them in this article.

2. Create a Context

Use Context::new() to create an ESYS (Enhanced System API) context from the TCTI you choose.
A Context mainly manages ESAPI state, such as sessions and TPM resources.

For tcti_name_conf, pass the TCTI configuration you defined earlier.

let tcti = if use_vtpm {
    // By default, this connects to "localhost:2321"
    TctiNameConf::Swtpm(NetworkTPMConfig::default())
} else {
    // By default, this connects to "/dev/tpm0"
    TctiNameConf::Device(DeviceConfig::default())
};

// Create a Context with the specified TCTI
let mut ctx = Context::new(tcti)?;

If you want to use the resource manager (tpm2-abrmd), you can create the context with new_with_tabrmd().

3. Start the TPM

After creating a context, may you need to call startup().

With a hardware TPM, the platform often sends TPM2_Startup() during boot, so calling it yourself can run it twice and may cause an error.

(Reference: TCG PC Client Platform TPM Profile Specification for TPM 2.0 (p.31 Power Management))
With swtpm, calling it twice didn’t cause an error in my tests.

let mut ctx = Context::new(tcti)?;

ctx.startup(StartupType::Clear)?;
// Run this function after creating a context.
// But if the platform or swtpm already starts it automatically,
// you can skip it.

For startup_type, pass the startup mode to Clear or State.
Whether the previous volatile state can be restored depends on the argument used in the previous shutdown().

Reset:
Previous: shutdown(StartupType::Clear) → Next: startup(StartupType::Clear)

Most values are initialized to their default values or to new random values.
Persistent data stored in NV (non-volatile) memory is not affected.
If you call startup(StartupType::State), there is no saved state to restore, so it fails.

Restart:
Previous: shutdown(StartupType::State) → Next: startup(StartupType::Clear)

Volatile state (except PCRs) is restored, but PCRs are cleared (initialized).
This allows the next boot measurements to be recorded correctly.

Resume:
Previous: shutdown(StartupType::State) → Next: startup(StartupType::State)

All volatile state saved by shutdown(StartupType::State) is restored, including PCRs.
However, PCRs that aren't saved are initialized.

If you want to do this in the terminal:

# Start with State
tpm2_startup
# Start with Clear
tpm2_startup -c

tpm2_startup(1) - tpm2-tools

What are PCRs?

PCRs (Platform Configuration Registers) are dedicated registers used to validate the platform’s state.

During system boot (and other security-relevant events), measurements are recorded in a log. The measurement itself (or its hash) is sent to the TPM and extended into a PCR, so the PCR value is accumulated as a chain of hashes.
Using this value, you can verify whether the measurement log has been tampered with.

It’s possible to use a single PCR, but in practice, measured boot assigns measurements to specific PCRs, so they’re usually spread across multiple PCRs.

Note:
The number of PCRs and their attributes depend on the platform.

🔗 References：

4. Get the SRK Handle

To create a wrapping key (an RSA key), you need its parent key, the SRK.
On a vTPM, there is often no persisted SRK yet, so you may need to create one and make it persistent.

It’s common to persist the SRK at 0x81000001, so you’ll often find it there.

To read the TPM capabilities, use get_capability().
This function only allows the audit session attribute, so make sure other session attributes are disabled.

// The return value includes the retrieved data and a bool indicating
// whether more data is available
let (data, more) = self.ctx.get_capability(
    CapabilityType::Handles, 
    value, 
    8,
)?;

For capability, pass the type of data you want to retrieve.

For property, it depends on the capability type.
For handles, pass the handle value to start from.

For property_count, pass how many entries to request at once.
Depending on the TPM implementation, it may return fewer entries than requested.
Also, even if you repeat the request with the same parameters, the number of entries returned may vary from call to call.

If you want to do this in the terminal:

# List transient handles
tpm2_getcap handles-transient
# List persistent handles
tpm2_getcap handles-persistent

tpm2_getcap(1) - tpm2-tools

ESYS Object Construction

To operate on an object in the TPM, you need to construct an ESYS object using tr_from_tpm_public().
This function only allows the audit and encrypt session attributes, so make sure other session attributes are disabled.

For tpm_handle, pass the handle you want to read.

Reading the Public Area

read_public() reads the public area of the specified handle.
This function only allows the audit and encrypt session attributes, so make sure other session attributes are disabled.

For key_handle, pass the object handle whose public area you want to read.
Since From<KeyHandle> is implemented for ObjectHandle, you can convert it with into().

// Convert the TPM handle to an ESYS object (handle)
let target_handle = self.ctx.tr_from_tpm_public(handle)?;
// Read the object's public area
let (public, _, _) = self.ctx.read_public(target_handle.into())?;

If you want to do this in the terminal:

# Read the public area from the context file path (or handle value) with "-c"
tpm2_readpublic -c rsa.ctx

tpm2_readpublic(1) - tpm2-tools

5. Create and Persist an RSA Key

Once you have the SRK, you can create an RSA key for key wrapping.
In this section, I’ll also explain how to create an SRK.

In this implementation, it looks for a previously created RSA key on each run. In real-world use, it’s more efficient to store its persistent handle value.

Before calling the key-creation functions, make sure your authorization settings are in place, since these functions require authorization.

Authorization Settings

To set the auth value for an object handle, use tr_set_auth().
If the auth value is an empty byte string, you can skip this call.
The official documentation states that the default auth value for hierarchy handles (and similar handles) is an empty byte string.
(Reference: TCG TPM v2.0 Provisioning Guidance (p.19, Owner Authorizations), Trusted Platform Module 2.0 Library Part 1: Architecture (p.74, Owner Controls))

To configure authorization sessions, use set_sessions().
By default, a session is created with with_continue_session(true), so it remain active even after the function succeeds.
If you want to use HMAC or policy authorization, you need to create a session with start_auth_session().

In the implementation, execute_with_session() is used to apply sessions only to the functions that need them.

For session_handles, set the sessions to use for authorization.

Password is used for simple password authorization only.

HmacSession derives an HMAC key by combining the session key and the object’s auth value. If both are empty, the HMAC key remains an empty byte string.
Even if both are empty, authorization still happens, but using an HMAC session is basically pointless for authorization alone in this case.
Using Password is usually a better choice here because it has lower communication overhead.
(Reference: Trusted Platform Module Library Part 1: Architecture (p.125, No HMAC Authorization))

Note:
The order of setting the auth value and the auth session does not matter, but both must be set before calling the target function.

Key Creation

Use create_primary() for the SRK and create() for the RSA key.

// SRK

let key_result = self.ctx.execute_with_session(
    Some(AuthSession::Password), // Set a password session
    |ctx| {
        // Create a new SRK
        ctx.create_primary(
            Hierarchy::Owner,
            build_public(attrs, params)?,
            None,
            None,
            None,
            None,
        )
    },
)?;      

// RSA key

let key_result = self.ctx.create(
    hsrk.into(),
    build_public(attrs, params)?,
    Some(Auth::try_from(RSA_KEY_AUTH)?),
    None,
    None,
    None,
)?;

For primary_handle / parent_handle, pass the hierarchy handle / parent handle.
These functions require authorization for those handles.
For the SRK, pass the hierarchy you want to create it under (commonly the Owner hierarchy).
For the RSA key, pass the parent SRK handle.

For public, pass an object’s public area as a Public.
You can choose the object type from Rsa, KeyedHash, Ecc, or SymCipher.

For auth_value, pass the auth value for an object as a byte array.
If you pass None, it becomes an empty byte string.
In that code, Auth::try_from() accepts &[u8] and Vec<u8>.

For initial_data / sensitive_data, pass sensitive data as a byte array.
For a symmetric key, this value becomes the key material.
For an asymmetric key, you can’t provide the sensitive data from outside, so pass None.
Also, if you set with_sensitive_data_origin(true) in the object attributes, the sensitive data is generated inside the TPM (except the auth value), so pass None.

For outside_info, pass extra data to include in the creation data as a byte array.
If you don’t need it, pass None.

For creation_pcrs, pass PCR indices to include in the creation data.
You can use this to record the environment at creation time.
If you don’t need it, pass None.

If you want to do this in the terminal:

# Default values are used for the object attributes, 
# the Name hash algorithm, etc

# Create an SRK
# Save the created key to a context file with "-c"
tpm2_createprimary -c srk.ctx

# Create and load an RSA key
# Specify the parent object (context file path or handle) with "-C"
# Set the object attributes with "-a"
# Set the algorithm with "-G" (<type>:<scheme>:<symmetric-details>)
# Set the auth value for the object with "-p"
# Load the created object and output it to a context file with "-c"
tpm2_create \
  -C srk.ctx \
  -a "fixedtpm|fixedparent|sensitivedataorigin|userwithauth|decrypt" \
  -G rsa2048:oaep-sha256 \
  -p AuthValue \
  -c rsa.ctx

# Using "-c" performs the same flow as tpm2_createloaded.
# If the TPM doesn't support it, the command returns an error.

Key Loading

After creating the RSA key, you need to load it into the TPM.
However, create_primary() creates and loads a key, so you can skip this step.

// Load the created key into the TPM
ctx.load(hsrk.into(), key_result.out_private, key_result.out_public)

For parent_handle, pass the parent handle used to load the created key.
The function requires authorization for this handle.
Pass the same handle you used as parent_handle in create().

For private and public, pass a created object's private and public parts.
You can take them from the return values of create():

For private, use out_private, for public, use out_public.

If you want to do this in the terminal:

# Create an RSA key
# Save the public part to a file with "-u"
# Save the private part to a file with "-r"
tpm2_create \
  -C srk.ctx \
  -u rsa.pub \
  -r rsa.priv \
  -a "fixedtpm|fixedparent|sensitivedataorigin|userwithauth|decrypt" \
  -G rsa2048:oaep-sha256 \
  -p AuthValue

# Load the created key into the TPM
# Specify the saved public file with "-u"
# Specify the saved private file with "-r"
# Save the context file with "-c"
tpm2_load \
  -C srk.ctx \
  -u rsa.pub \
  -r rsa.priv \
  -c rsa.ctx

tpm2_load(1) - tpm2-tools

Key Persistence

To make a key persistent, use evict_control().
The transient object is copied to a persistent handle.

match self
    .ctx
    // Set a password session
    .execute_with_session(Some(AuthSession::Password), |ctx| {
        // Make the target object persistent
        ctx.evict_control(
            Provision::Owner,
            handle,
            PersistentTpmHandle::new(value)?.into(),
        )
    }) {

For auth, pass the hierarchy authorization, Owner or Platform.
This function requires authorization for this handle.
If you use Owner, the persistent handle value must be in 0x81000000–0x817FFFFF.
If you use Platform, it must be in 0x81800000–0x81FFFFFF.

For object_handle, pass the object handle to persist.
After creating a key, you can get a KeyHandle from the return value and convert it to an ObjectHandle with into().
For create_primary(), it’s available as the key_handle field in the return value.

For persistent, pass the destination persistent handle value (0x81000000–0x81FFFFFF).
If object_handle is a transient object, it's persisted under this handle value.
If it's already a persistent object, it's removed instead.

If you want to do this in the terminal:

# Persist an object
# Specify the context file path (or handle value) of the target object with "-c"
# Specify the destination persistent handle as the last argument
tpm2_evictcontrol -c rsa.ctx 0x81000002

# If you don’t specify a persistent handle value, it's stored under an available handle value

tpm2_evictcontrol(1) - tpm2-tools

Removing Transient Objects

Even after you make an object persistent, the original transient object remains loaded.
Because the number of transient objects that can be loaded at the same time is limited, it’s best to remove any you no longer need.
With swtpm, I was able to keep up to three transient objects at once (this may vary depending on the environment or version).

flush_context() flushes the context associated with a loaded handle (e.g., a transient object or a session).
This function returns an error if an authorization session is applied.

// Remove the transient object
let _ = self.ctx.flush_context(handle);

For handle, pass the handle of the object (or session) you want to remove.

If you want to do this in the terminal:

# Specify the object to be removed as the last argument
tpm2_flushcontext 0x80000001

# Remove all transient objects with "-t"
tpm2_flushcontext -t

tpm2_flushcontext(1) - tpm2-tools

Public Struct

In this implementation, I use Rsa as the object type.

You can build a Public with PublicBuilder by setting the required fields.

// Build a Public struct
let public = PublicBuilder::new()
    .with_public_algorithm(PublicAlgorithm::Rsa)
    .with_object_attributes(attrs)
    .with_name_hashing_algorithm(HashingAlgorithm::Sha256)
    .with_rsa_parameters(params)
    .with_rsa_unique_identifier(PublicKeyRsa::default())
    .build()?;

object_attributes

For object_attributes, pass the object attributes with ObjectAttributes.

// SRK attributes
let attrs = ObjectAttributesBuilder::new()
    .with_fixed_tpm(true)
    .with_fixed_parent(true)
    .with_no_da(true)
    .with_restricted(true)
    .with_user_with_auth(true)
    .with_sensitive_data_origin(true)
    .with_decrypt(true)
    .build()?;

// RSA key attributes
let attrs = ObjectAttributesBuilder::new()
    .with_fixed_tpm(true)
    .with_fixed_parent(true)
    .with_user_with_auth(true)
    .with_sensitive_data_origin(true)
    .with_decrypt(true)
    .build()?;

In this code, the SRK attributes follow the guidance for a shared SRK.
Since it’s intended to be usable by multiple applications, the guidance recommends setting noDA and leaving the auth policy empty (and typically using an all-zero auth value).

When creating an asymmetric key, you need to set with_sensitive_data_origin(true), and you can't provide sensitive data from outside the TPM.
(Reference: Trusted Platform Module Library Part 1: Architecture (p.183 sensitiveDataOrigin))

Note:
If with_user_with_auth(false) is set, you can’t use password or HMAC authorization for that object.
(Reference: Trusted Platform Module Library Part 1: Architecture (p.184 userWithAuth))

name_hashing_algorithm

For name_hashing_algorithm, pass the hash algorithm used to compute the object’s Name.

For now, Sha256 is widely supported and recommended from a security standpoint.

auth_policy

For auth_policy, pass the policy digest to set on the object as a byte array.

You can use it to restrict how the object can be used.
If you don’t need a policy, pass Digest::default().

parameters

For parameters, pass the internal parameters for the selected object type as PublicRsaParameters.

// SRK parameters
let params = PublicRsaParametersBuilder::new_restricted_decryption_key(
    SymmetricDefinitionObject::AES_128_CFB,
    RsaKeyBits::Rsa2048,
    RsaExponent::ZERO_EXPONENT,
)
.build()?;

// RSA key parameters
let hash_algo = HashScheme::new(HashingAlgorithm::Sha256);
let params = PublicRsaParametersBuilder::new()
    .with_scheme(RsaScheme::Oaep(hash_algo))
    .with_key_bits(RsaKeyBits::Rsa2048)
    .with_exponent(RsaExponent::ZERO_EXPONENT)
    .build()?;

new_restricted_decryption_key() provides parameters typically used for an SRK.

For symmetric, pass the symmetric algorithm to wrap (protect) child keys.

You can also choose one of the constants AES_128_CFB, AES_256_CFB, or SM4_128_CFB.
For most use cases, AES_128_CFB is a reasonable default.

For key_bits, pass a key size (in bits).

For now, Rsa2048 or higher is recommended.

For exponent, pass a public exponent.
ZERO_EXPONENT means you pass 0, which the TPM treats as 65537 (2^16 + 1).

For an RSA key, you set the scheme (padding) instead of a symmetric algorithm.
You can choose from Oaep, RsaEs, or Null.
Oaep is recommended, and in that case you also need to set a hash algorithm.

unique

For unique, pass bytes that uniquely identify the public area.

When creating a key, this field is filled with a value generated inside the TPM (for an asymmetric key, it’s the public key), so any value you pass here is ignored.
You need to set it when loading an external key, for example.
If you don’t need it, use PublicKeyRsa::default().

🔗 References：

6. Wrap the Key

Now we’re finally at the key-wrapping step!

The implementation uses an HMAC session.
Since plaintext is sent to the TPM during key wrapping, it's recommended to set the decrypt attribute.
This attribute encrypts the first function argument before sending it to the TPM, but only if that argument is a size-prefixed buffer.

HMAC session creation

start_auth_session() creates an authentication session.
execute_with_nullauth_session() internally uses this function to create an HMAC session with the decrypt and encrypt attributes set.
Unless you need more fine-grained control, it's easier to use this function.

This function uses AES-128 in CFB mode as the symmetric algorithm and SHA-256 as the hash algorithm.

If you want to do this in the terminal:

# Create an HMAC session
# Save the session context to a file with "-S"
tpm2_startauthsession --hmac-session -S hmacsession.ctx

# Add attributes to the session
# Update the session context file in place
tpm2_sessionconfig --enable-decrypt --enable-encrypt hmacsession.ctx

# Check the current session data
tpm2_sessionconfig hmacsession.ctx

Note:
If a session isn't used for authorization, you must set at least one session attribute.
(Here, "session attributes" refers only to decrypt, encrypt, and audit.)
Depending on the function, the session may not be usable, or only specific attributes may be allowed. For functions that don't require authorization, you can't use a password session.

Key Wrapping

To encrypt (wrap) with an RSA key, use rsa_encrypt().

// Wrap the target key
let wrapped_key = self.ctx.execute_with_nullauth_session(|ctx| {
    ctx.rsa_encrypt(
        hrsa.into(),
        PublicKeyRsa::try_from(target_key.as_slice())?,
        RsaDecryptionScheme::Null,
        Data::default(),
    )
})?;

For key_handle, pass the handle of the key object used for encryption.

For message, pass the data you want to encrypt as a byte array.

For in_scheme, pass the padding scheme.
If the object specified by key_handle has a scheme other than Null, pass either the same scheme or Null. If the object’s scheme is Null, the scheme you pass here will be used.

For label, pass the data to put into OAEP’s L parameter as a byte array.
If you provide a non-empty label, the last byte must be 0.
If you don’t need it, pass Data::default().

If you want to do this in the terminal:

# Specify the key context file (or handle value) with "-c"
# Specify the padding scheme with "-s" (default: RSAES_PKCSV1.5)
# Save the encrypted output to a file with "-o" (otherwise it goes to stdout)
# Specify the file to be encrypted as the last argument
tpm2_rsaencrypt \
  -c rsa.ctx \
  -s null \
  -o msg.enc \
  msg.ptext

tpm2_rsaencrypt(1) - tpm2-tools

🔗 References：

Unwrap the Key

To decrypt (unwrap) with an RSA key, use rsa_decrypt().

This function requires authorization, so you need to configurate authorization in place before calling it.

Authorization Settings

Authorization is required for the RSA key used for decryption.
To set its auth value, use tr_set_auth(). You can skip this if the auth value is an empty byte string.

// Set the auth value for the object
self.ctx.tr_set_auth(hrsa, Auth::try_from(RSA_KEY_AUTH)?)?;

// The auth value isn't validated here.
// It's verified when you run a function that requires authorization.

For object_handle, pass the object handle you want to set the auth value for.

For auth, pass the auth value for the target object as a byte array.

Since unwrapped data is sent back from the TPM, it's recommended to set the encrypt attribute on the session.
As with encryption, the implementation uses execute_with_nullauth_session().

Key Unwrapping

For cipher_text, pass the data you want to decrypt as a byte array.

For the rest of the parameters, pass the same values you used in the encryption step.

// Unwrap the target key
let unwrapped_key = self.ctx.execute_with_nullauth_session(|ctx| {
    ctx.rsa_decrypt(
        hrsa.into(),
        PublicKeyRsa::try_from(target_key)?,
        RsaDecryptionScheme::Null,
        Data::default(),
    )
})?;

If you want to do this in the terminal:

# Specify the key context file (or handle value) with "-c"
# Set the auth value for the specified key with "-p"
# (you can also combine it with a session using the "session:" prefix)
# Specify the padding scheme with "-s" (default: RSAES_PKCSV1.5)
# Save the decrypted data to a file with "-o" (otherwise it goes to stdout)
# Specify the file to be decrypted as the last argument
tpm2_rsadecrypt \
  -c rsa.ctx \
  -p session:hmacsession.ctx+AuthValue \
  -s null \
  -o msg.ptext \
  msg.enc

tpm2_rsadecrypt(1) - tpm2-tools

🔗 Reference：

Trusted Platform Module Library Part 3: Commands (p.98 TPM2_RSA_Decrypt)

Shut Down the TPM

To shut down the TPM, use shutdown().
With a hardware TPM, the platform often sends TPM2_Shutdown() as part of power-state transitions, so you may not need to call it yourself.
(Reference: TCG PC Client Platform TPM Profile Specification for TPM 2.0 (p.31 Power Management))

// Shut down the TPM with Clear
ctx.shutdown(StartupType::Clear)

For shutdown_type, pass either Clear or State.
With Clear, the TPM discards the current volatile state.
With State, the TPM saves the current volatile state, and how it is restored depends on the argument you pass to startup() next time.

If you want to do this in the terminal:

# Shut down with State
tpm2_shutdown
# Shut down with Clear
tpm2_shutdown -c

tpm2_shutdown(1) - tpm2-tools

🔗 Reference：

Trusted Platform Module Library Part 3: Commands (p.46 TPM2_Shutdown)

Remove a Persistent Key

To remove a persistent key, use evict_control().

You also use this function to make a key persistent, but for removal you specify the persistent object you want to remove, and you pass the same persistent handle value.

let _ = self
    .ctx
    // Set a password session
    .execute_with_session(Some(AuthSession::Password), |ctx| {
        // Remove the persistent object
        ctx.evict_control(
            Provision::Owner,
            handle,
            PersistentTpmHandle::new(value)?.into(),
        )
    })?;

Clear the TPM

To clear the TPM state — including objects stored under the Storage/Endorsement hierarchies — use clear().
This function requires authorization, so make sure your authorization settings are in place before calling it.

fn clear_tpm(&mut self) -> Result<()> {
    // If the auth value is non-empty, set it with `tr_set_auth()`.

    self.ctx
        // Set a password session
        .execute_with_session(Some(AuthSession::Password), |ctx| {
            // Clear the TPM
            ctx.clear(AuthHandle::Lockout)
        })?;

    Ok(())
}

For auth_handle, pass the authorization handle, either Lockout or Platform.
If you use Platform, physical presence may be required depending on the platform/firmware configuration.

If you want to do this in the terminal:

# This example uses the Platform hierarchy for authorization

# Specify the hierarchy used for authorization with "-c" (default: lockout)
# Provide the auth value for specified hierarch as the last argument
tpm2_clear -c p <platformAuth>

tpm2_clear(1) - tpm2-tools

About tpm2-tss Logs

If you see log messages from tpm2-tss (included in libtss2-dev), you can adjust the log level using environment variables.

# Disable all log output
export TSS2_LOG=all+NONE
# Show only ERROR and above
export TSS2_LOG=all+ERROR
# Write logs to a file
export TSS2_LOGFILE=tss.log

Final Thoughts

It was my first time using Ubuntu.
It made it really easy to set up a Linux environment.

For this implementation, tss-esapi is a much lower-level API than NCrypt, which I used on Windows, so it was much more challenging.

While writing this explanation, I didn’t just read the docs. I also tried a lot of things myself along the way.
Because of that, it ended up taking me more than a month to finish this article...

It was tough, but it was also more fun to write than I expected!

Thanks for reading!

How I Used TPM for Key Encryption in Rust (Using Windows APIs)

tsuruko — Tue, 07 Oct 2025 14:48:59 +0000

I implemented TPM-based key wrapping on Windows using the windows-sys crate.
(Linux version: How I Used TPM for Key Encryption in Rust on Linux (Hardware TPM & vTPM))

At first, I tried key wrapping with tss-esapi, but since it's designed for Linux, using it on Windows would have required a more complex setup.
So I chose windows-sys for this implementation.

In this article, I’ll walk you through the key-wrapping implementation and explain how it works!

Cargo.toml
Implementation
Error Codes
Explanation
- 1. Open the TPM Provider
- 2. Create a Persistent Key (If It Doesn't Exist)
- 3. Get a Key from the Provider
- 4. Get the Encrypted Data Size
- 5. Wrap the Key
- Unwrap the Key
- Checking and Setting Key Properties
- Delete Registered Key
Final Thoughts

Cargo.toml

[dependencies]
getrandom = "0.4"
windows-sys = { version = "0.61", features = [
    "Win32_Security_Cryptography",
    "Win32_Foundation",
] }
zeroize = "1.8"

Implementation

This crate uses FFI, so you'll need to call the Windows APIs inside an unsafe block.

use std::{ffi::OsStr, os::windows::ffi::OsStrExt, ptr};

use windows_sys::{
    core::HRESULT,
    Win32::{
        Foundation::NTE_BAD_KEYSET, 
        Security::Cryptography::*,
    },
};
use zeroize::Zeroizing;

type TpmResult<T> = Result<T, HRESULT>;

const KEY_NAME: &str = "RSA_KEY";

fn to_utf16(s: &str) -> Vec<u16> {
    let mut utf16: Vec<u16> = OsStr::new(s).encode_wide().collect();
    utf16.push(0);

    utf16
}

struct KeyWrapper {
    hprov: NCRYPT_PROV_HANDLE,
    hkey: NCRYPT_KEY_HANDLE,
}

impl Drop for KeyWrapper {
    fn drop(&mut self) {
        // Free retrieved provider and key handles
        unsafe {
            if self.hkey != 0 {
                NCryptFreeObject(self.hkey);
            }

            if self.hprov != 0 {
                NCryptFreeObject(self.hprov);
            }
        }
    }
}

// The target key is 32 bytes (AES-256), which is generally recommended

// The status is an i32 (HRESULT) value, 
// and 0 means the function was successful

impl KeyWrapper {
    fn open(key_name: &str) -> TpmResult<Self> {
        let hprov: NCRYPT_PROV_HANDLE = Self::open_provider()?;
        let key_name_utf16 = to_utf16(key_name);

        let hkey = match Self::retrieve_key(hprov, key_name_utf16) {
            Ok(h) => h,
            Err(e) => {
                unsafe {
                    NCryptFreeObject(hprov);
                }
                return Err(e);
            }
        };

        Ok(Self { hprov, hkey })
    }

    fn open_provider() -> TpmResult<NCRYPT_PROV_HANDLE> {
        let mut hprov: NCRYPT_PROV_HANDLE = 0;

        let status =
            unsafe { NCryptOpenStorageProvider(&mut hprov, MS_PLATFORM_CRYPTO_PROVIDER, 0) };
        if status != 0 {
            eprintln!("Failed to open the storage provider");
            return Err(status);
        }

        Ok(hprov)
    }

    fn retrieve_key(hprov: NCRYPT_PROV_HANDLE, key_name: Vec<u16>) -> TpmResult<NCRYPT_KEY_HANDLE> {
        let mut hkey: NCRYPT_KEY_HANDLE = 0;

        let status = unsafe { NCryptOpenKey(hprov, &mut hkey, key_name.as_ptr(), 0, 0) };
        match status {
            0 => Ok(hkey),
            NTE_BAD_KEYSET => {
                // If no key with that name exists
                println!("");
                Self::create_rsa_key(hprov, key_name)
            }
            _ => {
                eprintln!("Failed to retrieve the key");
                Err(status)
            }
        }
    }

    fn create_padding_info() -> BCRYPT_OAEP_PADDING_INFO {
        BCRYPT_OAEP_PADDING_INFO {
            pszAlgId: BCRYPT_SHA256_ALGORITHM,
            pbLabel: ptr::null_mut(),
            cbLabel: 0,
        }
    }

    fn create_rsa_key(
        hprov: NCRYPT_PROV_HANDLE,
        key_name: Vec<u16>,
    ) -> TpmResult<NCRYPT_KEY_HANDLE> {
        let mut hkey: NCRYPT_KEY_HANDLE = 0;

        let status = unsafe {
            // Create a persistent RSA key with the given name
            NCryptCreatePersistedKey(
                hprov,
                &mut hkey,
                BCRYPT_RSA_ALGORITHM,
                key_name.as_ptr(),
                0,
                0,
            )
        };
        if status != 0 {
            eprintln!("Failed to create the RSA key");
            return Err(status);
        }

        // Finalize the key for use
        let status = unsafe { NCryptFinalizeKey(hkey, 0) };
        if status != 0 {
            eprintln!("Failed to finalize the key");
            unsafe {
                NCryptFreeObject(hkey);
            }
            return Err(status);
        }

        Ok(hkey)
    }

    fn wrap_key(&self, target_key: [u8; 32]) -> TpmResult<Vec<u8>> {
        let target_key = Zeroizing::new(target_key);

        let padding_info = Self::create_padding_info();
        let mut size: u32 = 0;

        // Get the required output size if needed
        let status = unsafe {
            NCryptEncrypt(
                self.hkey,
                target_key.as_ptr(),
                target_key.len() as u32,
                (&padding_info as *const BCRYPT_OAEP_PADDING_INFO).cast(),
                ptr::null_mut(),
                0,
                &mut size,
                NCRYPT_PAD_OAEP_FLAG,
            )
        };
        if status != 0 {
            eprintln!("Failed to get the required output size");
            return Err(status);
        }

        let mut wrapped_key = vec![0u8; size as usize];

        // Wrap the target key
        let status = unsafe {
            NCryptEncrypt(
                self.hkey,
                target_key.as_ptr(),
                target_key.len() as u32,
                (&padding_info as *const BCRYPT_OAEP_PADDING_INFO).cast(),
                wrapped_key.as_mut_ptr(),
                size,
                &mut size,
                NCRYPT_PAD_OAEP_FLAG,
            )
        };
        if status != 0 {
            eprintln!("Failed to wrap the key");
            return Err(status);
        }

        // Truncate to the actual size
        wrapped_key.truncate(size as usize);

        Ok(wrapped_key)
    }

    fn unwrap_key(&self, target_key: &[u8]) -> TpmResult<Vec<u8>> {
        let padding_info = Self::create_padding_info();
        let mut size: u32 = 0;

        // Get the required output size if needed
        let status = unsafe {
            NCryptDecrypt(
                self.hkey,
                target_key.as_ptr(),
                target_key.len() as u32,
                (&padding_info as *const BCRYPT_OAEP_PADDING_INFO).cast(),
                ptr::null_mut(),
                0,
                &mut size,
                NCRYPT_PAD_OAEP_FLAG,
            )
        };
        if status != 0 {
            eprintln!("Failed to get the required output size");
            return Err(status);
        }

        let mut unwrapped_key = vec![0u8; size as usize];

        // Unwrap the target key
        let status = unsafe {
            NCryptDecrypt(
                self.hkey,
                target_key.as_ptr(),
                target_key.len() as u32,
                (&padding_info as *const BCRYPT_OAEP_PADDING_INFO).cast(),
                unwrapped_key.as_mut_ptr(),
                size,
                &mut size,
                NCRYPT_PAD_OAEP_FLAG,
            )
        };
        if status != 0 {
            eprintln!("Failed to unwrap the key");
            return Err(status);
        }

        // Truncate to the actual size
        unwrapped_key.truncate(size as usize);

        Ok(unwrapped_key)
    }
}

The retrieved provider and key handles need to be freed at the end.
In this implementation, the cleanup is handled in Drop.

I also checked the RSA key length used by the TPM provider with NCryptGetProperty().
In my environment, the default was 2048 bits, and the supported range was 1024 to 2048 bits.

This may vary depending on the environment, so if you want to check it on your own system, see the Checking and Setting Key Properties section.

Try running it in the main function:

fn main() {
    let mut key = [0u8; 32];
    getrandom::fill(&mut key).unwrap();
    println!("Original key: {:?}", key);

    let key_wrapper = match KeyWrapper::open(KEY_NAME) {
        Ok(s) => s,
        Err(e) => {
            eprintln!("Error code: {e}");
            return;
        }
    };

    let wrapped_key = match key_wrapper.wrap_key(key) {
        Ok(k) => {
            println!("Wrapped key: {:?}", k);
            k
        }
        Err(e) => {
            eprintln!("Error code: {e}");
            return;
        }
    };

    match key_wrapper.unwrap_key(&wrapped_key) {
        Ok(k) => println!("Unwrapped key: {:?}", k),
        Err(e) => eprintln!("Error code: {e}"),
    }
}

If you want to delete the key, you can add delete_key() to KeyWrapper and call it:

fn delete_key(&mut self) -> TpmResult<()> {
    let status = unsafe {
        // Delete the key
        NCryptDeleteKey(self.hkey, 0)
    };
    if status != 0 {
        eprintln!("Failed to delete the key");
        return Err(status);
    }

    // NCryptDeleteKey() automatically releases the key handle
    self.hkey = 0;

    Ok(())
}

Error Codes

This is a list of the main error codes, their corresponding constants, and descriptions.

Code (i32)	Code (hex)	Name	Description
0	0x00000000	ERROR_SUCCESS	Operation succeeded
-2146893802	0x80090006	NTE_BAD_KEYSET	The key does not exist or is not registered with the TPM
-2146893809	0x8009000F	NTE_EXISTS	A key with the same name already exists
-2146893786	0x80090026	NTE_INVALID_HANDLE	The handle is invalid (provider or key)
-2146893785	0x80090027	NTE_INVALID_PARAMETER	One or more parameters are invalid
-2146893810	0x8009000E	NTE_NO_MEMORY	Not enough memory to complete the operation
-2146893808	0x80090010	NTE_PERM	Access denied or operation not permitted
-2146893792	0x80090020	NTE_FAIL	An internal error occurred
-2146893783	0x80090029	NTE_NOT_SUPPORTED	The algorithm or option is not supported
-2146893815	0x80090009	NTE_BAD_FLAGS	Invalid flags specified in dwFlags
-2146893784	0x80090028	NTE_BUFFER_TOO_SMALL	Output buffer is too small
-2147479534	0x80090032	NTE_INVALID_STATE	Object is in an invalid state (e.g. not finalized)
-2146893816	0x80090008	NTE_BAD_ALGID	Invalid algorithm identifier
-2146893814	0x8009000A	NTE_BAD_TYPE	The key or object type is invalid

Explanation

I referred to the official Microsoft documentation to choose the right functions and understand each parameter, and I used the windows-sys docs to check the parameter types.

References:

Microsoft documentation for NCrypt → ncrypt.h header
windows-sys documentation → Module Cryptography

In this section, I'll explain each function and parameter used in the implementation, based on these official documents.

1. Open the TPM Provider

First, you need to open the provider using NCryptOpenStorageProvider().

Microsoft Documentation:

windows-sys Documentation:

For phprovider, pass a variable (&mut usize) to receive the provider handle.

For pszprovidername, pass the alias of a key storage provider to load.
If you pass std::ptr::null(), the default key storage provider is loaded.

This implementation uses MS_PLATFORM_CRYPTO_PROVIDER, but if a TPM isn’t available, you can use MS_KEY_STORAGE_PROVIDER instead.

The dwflags parameter is reserved, so it should always be set to 0 for now.

let mut hprov: NCRYPT_PROV_HANDLE = 0;

let status =
    unsafe { NCryptOpenStorageProvider(&mut hprov, MS_PLATFORM_CRYPTO_PROVIDER, 0) };

Some of the return codes:

If this function fails, do not use the provider handle in other functions.
It’s described in the Microsoft documentation:

2. Create a Persistent Key (If It Doesn't Exist)

NCryptCreatePersistedKey() can create a persistent key with a given name.

Microsoft Documentation:

windows-sys Documentation:

For phkey, pass a variable (&mut usize) to receive the key handle.

For pszalgid, pass a null-terminated UTF-16 string that specifies the cryptographic algorithm.

In most cases, you specify one of the CNG Algorithm Identifiers, but you can also specify algorithm identifiers that are registered independently by the provider.
This implementation uses BCRYPT_RSA_ALGORITHM.

For pszkeyname, pass a pointer to a null-terminated UTF-16 string containing the key name.
If the parameter is set to std::ptr::null(), this function will create an ephemeral key that won't be stored.

fn to_utf16(s: &str) -> Vec<u16> {
    let mut utf16: Vec<u16> = OsStr::new(s).encode_wide().collect();
    utf16.push(0);

    utf16
}

encode_wide() converts an &OsStr to UTF-16.
Since pszkeyname needs a null-terminated string, a trailing 0 is appended.

For dwlegacykeyspec, pass a legacy identifier that specifies the key type.

In typical CNG key creation, pass 0, since the other values are for CryptoAPI（CAPI）/CSP compatibility.
If you set it to anything other than 0, it may fail with an error (NTE_NOT_SUPPORTED).

For dwflags, pass flags that modify the behavior of this function.
If no flags are needed, pass 0.

let mut hkey: NCRYPT_KEY_HANDLE = 0;

let status = unsafe {
    // Create a persistent RSA key with the given name
    NCryptCreatePersistedKey(
        hprov,
        &mut hkey,
        BCRYPT_RSA_ALGORITHM,
        key_name.as_ptr(),
        0,
        0,
    )
};

Some of the return codes:

After creating the key, you can use NCryptSetProperty() to configure its properties.
Details about setting the key length are covered in the Checking and Setting Key Properties section.

After creating the key, you need to call NCryptFinalizeKey() to use it.

Microsoft Documentation:

windows-sys Documentation:

For dwflags, pass flags that modify the behavior of this function.
If no flags are needed, pass 0.

NCRYPT_SILENT_FLAG prevents the user interface from being displayed, but it is usually not needed for the TPM-based processing in this example.

let status = unsafe { NCryptFinalizeKey(hkey, 0) };

Some of the return codes:

3. Get a Key from the Provider

If the key already exists, you can retrieve it from the provider using NCryptOpenKey().

Microsoft Documentation:

windows-sys Documentation:

These parameters are mostly the same as those of NCryptCreatePersistedKey().

For dwflags, pass flags that modify the behavior of this function.
If no flags are needed, pass 0.

fn retrieve_key(hprov: NCRYPT_PROV_HANDLE, key_name: Vec<u16>) -> TpmResult<NCRYPT_KEY_HANDLE> {
    let mut hkey: NCRYPT_KEY_HANDLE = 0;

    let status = unsafe { NCryptOpenKey(hprov, &mut hkey, key_name.as_ptr(), 0, 0) };
    match status {
        0 => Ok(hkey),
        NTE_BAD_KEYSET => {
            // If no key with that name exists
            println!("");
            Self::create_rsa_key(hprov, key_name)
        }
        _ => {
            eprintln!("Failed to retrieve the key");
            Err(status)
        }
    }
}

If no key with the specified name exists, NCryptOpenKey() returns NTE_BAD_KEYSET.

Some of the return codes:

4. Get the Encrypted Data Size

You need to get the size of the encrypted data before encryption.
If you already know it, you can skip this step.

Microsoft Documentation:

windows-sys Documentation:

For pbinput, pass a pointer to the buffer to encrypt.

For cdinput, pass the size (in bytes) of the data (pbinput).

For ppaddinginfo, pass a pointer to a BCRYPT_OAEP_PADDING_INFO struct that contains padding information.
If you don’t pass NCRYPT_PAD_OAEP_FLAG in dwflags, or if you’re using a symmetric key, pass std::ptr::null().

For pboutput, pass a pointer to the output buffer for the encrypted data.
If you only want to get the encrypted data size, pass std::ptr::null_mut().

For cboutput, pass the buffer size (pboutput).
If pboutput is std::ptr::null_mut(), this parameter is ignored.
However, in my test, passing a non-zero value caused an NTE_INVALID_PARAMETER error.

For pcbresult, pass a variable (&mut u32) that receives the output size for pboutput.
If pboutput is std::ptr::null_mut(), this parameter receives the required output size.

For dwflags, pass a flag that modifies the behavior of this function.
The allowed flags depend on the key type specified by hkey.

NCRYPT_PAD_OAEP_FLAG is recommended for modern security.
When using this flag, you need to pass a pointer to a BCRYPT_OAEP_PADDING_INFO struct in ppaddinginfo.
For symmetric keys, pass 0.

let padding_info = Self::create_padding_info();
let mut size: u32 = 0;

// Get the required output size if needed
let status = unsafe {
    NCryptEncrypt(
        self.hkey,
        target_key.as_ptr(),
        target_key.len() as u32,
        (&padding_info as *const BCRYPT_OAEP_PADDING_INFO).cast(),
        ptr::null_mut(),
        0,
        &mut size,
        NCRYPT_PAD_OAEP_FLAG,
    )
};

Some of the return codes:

BCRYPT_OAEP_PADDING_INFO

Microsoft Documentation:

windows-sys Documentation:

For pszAlgId, pass the hashing algorithm used to create the padding.
You can find the available hash algorithms in the CNG Algorithm Identifiers.

For pbLabel, pass a pointer to a buffer that contains label data used for OAEP padding.
If you don't need it, pass std::ptr::null_mut().

For cbLabel, pass the size of the pbLabel buffer.
If pbLabel is std::ptr::null_mut(), pass 0.

fn create_padding_info() -> BCRYPT_OAEP_PADDING_INFO {
    BCRYPT_OAEP_PADDING_INFO {
        pszAlgId: BCRYPT_SHA256_ALGORITHM,
        pbLabel: ptr::null_mut(),
        cbLabel: 0,
    }
}

This code uses BCRYPT_SHA256_ALGORITHM as the hash algorithm.

5. Wrap the Key

Finally, wrap the key using NCryptEncrypt().

let mut wrapped_key = vec![0u8; size as usize];

// Wrap the target key
let status = unsafe {
    NCryptEncrypt(
        self.hkey,
        target_key.as_ptr(),
        target_key.len() as u32,
        (&padding_info as *const BCRYPT_OAEP_PADDING_INFO).cast(),
        wrapped_key.as_mut_ptr(),
        size,
        &mut size,
        NCRYPT_PAD_OAEP_FLAG,
    )
};

To get the encrypted data, prepare a buffer with the required size, and pass a pointer to that buffer in pboutput.
If you queried the size with this function, allocate the buffer using the size stored in the variable you passed to pcbresult.

See the previous section for an explanation of NCryptEncrypt().

Lastly, truncate the output buffer to the actual size written, as returned in pcbresult.

wrapped_key.truncate(size as usize);

Unwrap the Key

Decrypting the wrapped key is almost the same as encryption — just replace NCryptEncrypt() with NCryptDecrypt().

fn unwrap_key(&self, target_key: &[u8]) -> TpmResult<Vec<u8>> {
    let padding_info = Self::create_padding_info();
    let mut size: u32 = 0;

    // Get the required output size if needed
    let status = unsafe {
        NCryptDecrypt(
            self.hkey,
            target_key.as_ptr(),
            target_key.len() as u32,
            (&padding_info as *const BCRYPT_OAEP_PADDING_INFO).cast(),
            ptr::null_mut(),
            0,
            &mut size,
            NCRYPT_PAD_OAEP_FLAG,
        )
    };
    if status != 0 {
        eprintln!("Failed to get the required output size");
        return Err(status);
    }

    let mut unwrapped_key = vec![0u8; size as usize];

    // Unwrap the target key
    let status = unsafe {
        NCryptDecrypt(
            self.hkey,
            target_key.as_ptr(),
            target_key.len() as u32,
            (&padding_info as *const BCRYPT_OAEP_PADDING_INFO).cast(),
            unwrapped_key.as_mut_ptr(),
            size,
            &mut size,
            NCRYPT_PAD_OAEP_FLAG,
        )
    };
    if status != 0 {
        eprintln!("Failed to unwrap the key");
        return Err(status);
    }

    // Truncate to the actual size
    unwrapped_key.truncate(size as usize);

    Ok(unwrapped_key)
}

Some of the return codes:

Checking and Setting Key Properties

To check an object's properties, use NCryptGetProperty().

Microsoft documentation:

windows-sys documentation:

For hobject, pass the handle of the target object.
To retrieve key properties, pass a key handle.

For pszproperty, pass the property identifier you want to retrieve.
You can find a list of identifiers in Key Storage Property Identifiers.
If you want to check supported key lengths, the default length, and related values, pass NCRYPT_LENGTHS_PROPERTY.

For pboutput, pass a pointer to the buffer that receives the property value.
If you only want to get the required buffer size, pass std::ptr::null_mut().

For cboutput, pass the size of the output buffer (pboutput) in bytes.
If pboutput is std::ptr::null_mut(), pass 0.

For pcbresult, pass a pointer to a variable (&mut u32) that receives either the number of bytes actually written or the required buffer size.

For dwflags, pass flags that modify the behavior of this function.
If no flags are needed, pass 0.

fn check_key_lengths(&self) -> TpmResult<()> {
    let mut supported_lengths = NCRYPT_SUPPORTED_LENGTHS {
        dwMinLength: 0,
        dwMaxLength: 0,
        dwIncrement: 0,
        dwDefaultLength: 0,
    };
    let mut size: u32 = 0;

    let status = unsafe {
        NCryptGetProperty(
            self.hkey,
            NCRYPT_LENGTHS_PROPERTY,
            (&mut supported_lengths as *mut NCRYPT_SUPPORTED_LENGTHS).cast(),
            size_of::<NCRYPT_SUPPORTED_LENGTHS>() as u32,
            &mut size,
            0,
        )
    };
    if status != 0 {
        eprintln!("Failed to retrieve the key property");
        return Err(status);
    }

    println!(
        "Default length: {} bits, Supported range: {} to {} bits",
        supported_lengths.dwDefaultLength,
        supported_lengths.dwMinLength,
        supported_lengths.dwMaxLength,
    );

    Ok(())
}

To retrieve the current key length, specify NCRYPT_LENGTH_PROPERTY as the property identifier.

fn check_current_key_length(&self) -> TpmResult<()> {
    let mut cur_key_length: u32 = 0;
    let mut size: u32 = 0;

    let status = unsafe {
        NCryptGetProperty(
            self.hkey,
            NCRYPT_LENGTH_PROPERTY,
            (&mut cur_key_length as *mut u32).cast(),
            size_of::<u32>() as u32,
            &mut size,
            0,
        )
    };
    if status != 0 {
        eprintln!("Failed to retrieve the key property");
        return Err(status);
    }

    println!("Current key length: {cur_key_length} bits");

    Ok(())
}

Some of the return codes:

To set an object's properties, use NCryptSetProperty().
For a newly created key, the property must be set before calling NCryptFinalizeKey().

Microsoft documentation:

windows-sys documentation:

For pszproperty, pass the property identifier you want to set.
If you want to set the key length, pass NCRYPT_LENGTH_PROPERTY.

For pbinput, pass a pointer to a buffer that contains the new property value.

For cbinput, pass the size of the buffer passed to pbinput in bytes.

For dwflags, pass flags that modify the behavior of this function.
If no flags are needed, pass 0.

fn set_key_length(hkey: NCRYPT_KEY_HANDLE, length: u32) -> TpmResult<()> {
    let status = unsafe {
        NCryptSetProperty(
            hkey,
            NCRYPT_LENGTH_PROPERTY,
            (&length as *const u32).cast(),
            size_of::<u32>() as u32,
            NCRYPT_PERSIST_FLAG,
        )
    };
    if status != 0 {
        eprintln!("Failed to set the key property");
        return Err(status);
    }

    Ok(())
}

Some of the return codes:

Delete Registered Key

You can delete the registered key using NCryptDeleteKey().

Microsoft Documentation:

windows-sys Documentation:

For dwflags, pass a flag that modifies the behavior of this function.
The only supported value is NCRYPT_SILENT_FLAG.
If no flags are needed, pass 0.

let status = unsafe {
    // Delete the key
    NCryptDeleteKey(self.hkey, 0)
};

If this function succeeds, the key handle is freed automatically.
It’s described in the Microsoft documentation:

Some of the return codes:

Final Thoughts

At first, since I didn’t know much about C++, I struggled to read the function signatures.
But through this implementation, I came to understand them better, and I learned how TPM works.

Thanks for reading!

Dynamically Switch Between Values and Functions — Without if Statements

tsuruko — Thu, 28 Aug 2025 13:01:21 +0000

Python library triggon can dynamically switch values and functions, and it helps clean up your code by reducing the need for if statements.

I'm going to introduce its features with two simple examples.

➀ Switch between values and functions

import random

from triggon import Triggon, TrigFunc

F = TrigFunc() # Wrapper for delayed execution
tg = Triggon("num", new=F.random.randint(1, 100))

def func():
    # If 'num' is active, switch the value from 0 to random.randint(1, 100)
    num = tg.switch_lit("num", org=0)
    print(num) 

func()

tg.set_trigger("num") # Activate the "num" label
func()

tg.revert("num") # Switch to the original value
func()

# == Output ==
0
79 (random number between 1 and 100)
0

switch_lit() automatically executes the function if it is delayed with TrigFunc.

TrigFunc works by simply creating an instance and wrapping the target function, just like a normal function call.

➁ Switch to multiple index values for a single variable

F = TrigFunc()

# "nums" holds the values of (index 0, index 1, index 2, index 3) 
tg = Triggon("nums", new=(1, 2, 3, F.print("Next it'll be 0!")))

x = 0
print(x)

tg.set_trigger("nums") # Activate "nums" label

tg.switch_var("nums", x)          # Switch to index 0
print(x)

tg.switch_var("nums", x, index=1) # Switch to index 1
print(x)

tg.switch_var("nums", x, index=2) # Switch to index 2
print(x)

# If the value is a delayed function with TrigFunc, 
# it will also execute automatically.
tg.switch_var("nums", x, index=3) # Switch to index 3

tg.revert("nums") # Switch to the original value of x
print(x)

# == Output ==
0
1
2
3
Next it'll be 0!
0

revert() can restore the original value even if it's switched multiple times.

Those examples use one label but you can define any number of labels!

About triggon

triggon has been officially released with 2 new functions and over 15 features added!

And it supports the following features:

Dynamically switch values and functions
Call functions and return early at any time
Optionally return a value with an early return
Delay the execution of almost any function

This library is for reducing if statements in your code!
If you’re interested, give it a try!

🔗 PyPI

I also post about the development and my learning logs on X.

Feel free to follow me!

Cleaner logic: triggon vs if-statements

tsuruko — Thu, 17 Jul 2025 15:05:25 +0000

I compared code using my library triggon with traditional if statements.

First Example 👇

This shows a situation where you want to change a message depending on the arguments.

Traditional if version:

def sample(y: int):
    x = 7

    if x > y:
        fmt = "greater than"
    elif x == y:
        fmt = "equal to"
    else:
        fmt = "smaller than"

    print(f"x is {fmt} y.")

sample(10) # Output: x is smaller than y.
sample(7)  # Output: x is equal to y.
sample(0)  # Output: x is greater than y.

With triggon:

tg = Triggon({"A": "greater than", "B": "equal to"})

def sample(y: int):
    x = 7

    tg.set_trigger("A", cond="x > y")
    tg.set_trigger("B", cond="x == y")

    fmt = tg.switch_lit(["A", "B"], org="smaller than")

    print(f"x is {fmt} y.")

sample(10) # Output: x is smaller than y.
sample(7)  # Output: x is equal to y.
sample(0)  # Output: x is greater than y.

The only change is one line,
but it removes three lines inside the function!

Second Example 👇

This shows a situation where you want to delete user data and later recover it.

Traditional if version:

# (This `if` version was auto-written by AI)

@dataclass
class User:
    name: str = "John"
    age: int = 25
    _original_name: str = None
    _original_age: int = None
    _reverted: bool = False

    def apply_deletion(self, delete: bool):
        if delete and not self._reverted:
            # Save original values if not already saved
            self._original_name = self.name
            self._original_age = self.age
            self.name = None
            self.age = None
        elif not delete and not self._reverted:
            # Do nothing if restore not requested yet
            pass
        elif delete and self._reverted:
            # Skip change if values have been reverted
            pass

    def revert(self):
        if self._original_name is not None and self._original_age is not None:
            self.name = self._original_name
            self.age = self._original_age
            self._reverted = True

user = User()

user.apply_deletion(False)
print(f"user name: {user.name}, age: {user.age}")  # Output: user name: John, age: 25

user.apply_deletion(True)
print(f"user name: {user.name}, age: {user.age}")  # Output: user name: None, age: None

user.revert()
print(f"user name: {user.name}, age: {user.age}")  # Output: user name: John, age: 25

user.apply_deletion(True)
print(f"user name: {user.name}, age: {user.age}")  # Output: user name: John, age: 25

That’s a bit too long…

With triggon:

tg = Triggon("del", None)

@dataclass
class User:
    name: str = "John"
    age: int = 25

    def apply_deletion(self, delete: bool):
        tg.switch_var("del", [self.name, self.age])
        tg.set_trigger("del", cond="delete") 

user = User()

user.apply_deletion(False)
print(f"user name: {user.name}, age: {user.age}") # Output: user name: John, age: 25

user.apply_deletion(True)
print(f"user name: {user.name}, age: {user.age}") # Output: user name: None, age: None

# Permanently revert the values
tg.revert("del", disable=True)
print(f"user name: {user.name}, age: {user.age}") # Output: user name: John, age: 25

user.apply_deletion(True)
print(f"user name: {user.name}, age: {user.age}") # Output: user name: John, age: 25

It reduces the code to less than half compared to the if version!

if statements are fine for simple logic,
but for more complex cases—like storing original values, performing multiple toggles, or restoring state—triggon really shines!

I just released v0.1.0b3 of my library triggon today.
But some bugs have already been found...
I'll be fixing them in the next update soon!

You can check out the README here: README

Smarter Conditions, Still No Ifs—Triggon Just Got Better

tsuruko — Sun, 13 Jul 2025 16:00:07 +0000

In this post, I’d like to share one of the 3 5 new features planned for the next update.

triggon allows you to switch values or behavior automatically when a trigger point is activated based on labels.
With the upcoming update, you'll be able to pass conditional expressions to control when those triggers are activated, giving you more control and flexibility.

Example (Planned)

(Excerpt from the README)

tg = Triggon("A", True)

def example(num: int):
    # If the condition "num == 0" is True, the trigger will activate
    tg.set_trigger("A", cond="num == 0") 

    flag = tg.alter_literal("A", False)
    print(flag)

example(10) # Output: False
example(0)  # Output: True

By setting a condition in the keyword argument cond, the trigger will only activate when the condition evaluates to True.
Note: Control structures like if x == 5: are not supported—only simple comparison expressions are allowed."

Internally, it uses ast along with eval(), but it’s designed with safety in mind—any non-comparison expressions will raise an error.

You can find the other two features in the README, along with sample code:
README

The next update (v0.1.0b3) is scheduled for next week,
but the source code is already available on GitHub—feel free to check it out if you're interested!

Switch Values and Logic—No Ifs, Just a Python Library

tsuruko — Wed, 09 Jul 2025 15:53:15 +0000

I recently released my first Python library as a beta version.
In this post, I’ll give a quick overview of what the library does.

About the Library

Library name: triggon

Install with:

pip install triggon

This library lets you automatically switch behavior—such as changing variable values, performing early returns, or calling functions—based on pre-defined labels, without writing any if-statements.

Key features:

Auto-switching literal or variable values
Early return handling based on flags
Dynamically execute functions

Sample Code Overview

Here are 3 simple examples that demonstrate how it works:

➀ Auto-switching a single value

Switch the greeting only if a specific function is called:

from triggon import Triggon

tg = Triggon("msg", new="Good night")  # Set the label and its new value

def switch_msg():
    tg.set_trigger("msg")  # Activate the trigger for 'msg'
    greet()

def greet():
    # Set the original value for the label
    x = tg.alter_literal("msg", org="Good morning")

    print(x)

# First call
greet()

# Second call
switch_msg()

# First output
Good morning

# Second output
Good night

➁ Switching multiple values assigned to a single label

You can assign multiple values to a single label, using index-based control.
You can also bind multiple values to the same index.

(Excerpt from the README)

import random
from triggon import Triggon

# Set two values (index 0 and 1) for each label
tg = Triggon({
    "level_1": ["Normal", 80],
    "level_2": ["Rare", 100],
    "level_3": ["Legendary", 150],
})

level = None
attack = None

def spin_gacha():
    items = ["level_1", "level_2", "level_3"]
    result = random.choice(items)

    tg.set_trigger(result) # Activate the trigger based on result

    tg.alter_var(result, level)            # Index 0
    tg.alter_var(result, attack, index=1)  # Index 1

    print(f"You got a {level} sword!")
    print(f"Attack power: {attack}")

spin_gacha()

# Output (if result is 'level_2')
You got a Rare sword!
Attack power: 100

You can also use a * prefix in labels to indicate the index position
(e.g., '**label' for index 2).
When passing labels as a dictionary, use * instead of keyword arguments, since keywords aren't supported in that case.

➂ Early Return + Function Execution

Here’s an example combining early return and function execution:

from triggon import Triggon, TrigFunc

# Early return returns a predefined value
# Function execution returns the result of the function
tg = Triggon({
    "skip": "Process stopped early!",
    "call": None,
})

F = TrigFunc() # Create an instance for function wrapping

def example():
    print("If the 'call' flag is active, jump to example_2().")
    tg.trigger_func("call", F.example_2())
    return "Finished normally!"

def example_2():
    print("example_2() reached!")
    tg.trigger_return("skip")

# example() works on its own if the trigger isn't activated
result = tg.exit_point("skip", F.example())
print(result)

# Activate the triggers to set off an early return and function call
tg.set_trigger(["skip", "call"])

result = tg.exit_point("skip", F.example())
print(result)

# First output
If the 'call' flag is active, jump to example_2().
Finished normally!

# Second output
If the 'call' flag is active, jump to example_2().
example_2() reached!
Process stopped early!

That’s a quick overview of how triggon works!
It’s especially helpful for temporary overrides or complex conditional flows.

This is still a beta release, so I’m actively fixing bugs and updating features.
The source code is available on GitHub—feel free to check it out!

Bug reports and feature suggestions are always welcome 🙌

📘 For detailed docs and more examples:
README

DEV Community: tsuruko

Automatically Revert Temporary Value Changes in a with Block

Code Example

How I Used TPM for Key Encryption in Rust on Linux (Hardware TPM & vTPM)

Table of Contents

Cargo.toml

Requirements to Build tss-esapi

Implementation

Explanation

1. Connect to the TPM

--tpm2

--server

--ctrl

--tpmstate

--flags

Other Options

2. Create a Context

3. Start the TPM

What are PCRs?

4. Get the SRK Handle

ESYS Object Construction

Reading the Public Area

5. Create and Persist an RSA Key

Authorization Settings

Key Creation

Key Loading

Key Persistence

Removing Transient Objects

Public Struct

object_attributes

name_hashing_algorithm

auth_policy

parameters

unique

6. Wrap the Key

HMAC session creation

Key Wrapping

Unwrap the Key

Authorization Settings

Key Unwrapping

Shut Down the TPM

Remove a Persistent Key

Clear the TPM

About tpm2-tss Logs

Final Thoughts

How I Used TPM for Key Encryption in Rust (Using Windows APIs)

Table of Contents

Cargo.toml

Implementation

Error Codes

Explanation

1. Open the TPM Provider

2. Create a Persistent Key (If It Doesn't Exist)

3. Get a Key from the Provider

4. Get the Encrypted Data Size

BCRYPT_OAEP_PADDING_INFO

5. Wrap the Key

Unwrap the Key

Checking and Setting Key Properties

Delete Registered Key

Final Thoughts

Dynamically Switch Between Values and Functions — Without if Statements

➀ Switch between values and functions

➁ Switch to multiple index values for a single variable

About triggon

Cleaner logic: triggon vs if-statements

First Example 👇

Second Example 👇

Smarter Conditions, Still No Ifs—Triggon Just Got Better

Example (Planned)

Switch Values and Logic—No Ifs, Just a Python Library

About the Library

Sample Code Overview

➀ Auto-switching a single value

➁ Switching multiple values assigned to a single label

➂ Early Return + Function Execution