examples, projects: migrate to typed parameter API

Update all TA examples and dependent host applications to use the new
typed parameter API:

- Replace `&mut Parameters` with `ParametersAny<'_>` or `ParametersNone`
- Use `ParameterAny::as_value_input()` / `as_memref_output()` helper methods
  instead of unsafe `as_value()` / `as_memref()` + raw buffer access
- Consolidate imports via `use optee_utee::prelude::*`

Author: ivila

crates/optee-utee/src/crypto_op.rs

@@ -1283,7 +1283,7 @@ impl Asymmetric {
     ///             AlgorithmId::RsaesPkcs1V15,
     ///             OperationMode::Encrypt,
     ///             256) {
-    ///             Ok(operation) => {
+    ///             Ok(mut operation) => {
     ///                 operation.set_key(&key)?;
     ///                 match operation.encrypt(&[], &clear) {
     ///                     Ok(ciph_text) => {
@@ -1497,7 +1497,7 @@ impl Asymmetric {
     }
 
     /// Function usage is similar to [Cipher::set_key](Cipher::set_key).
-    pub fn set_key<T: GenericObject>(&self, object: &T) -> Result<()> {
+    pub fn set_key<T: GenericObject>(&mut self, object: &T) -> Result<()> {
         self.0.set_key(object)
     }
 
@@ -1556,7 +1556,7 @@ impl DeriveKey {
     ///     Ok(key_pair_2) => {
     ///         key_pair_2.generate_key(256, &[attr_prime.into(), attr_base.into()])?;
     ///         match DeriveKey::allocate(AlgorithmId::DhDeriveSharedSecret, 256) {
-    ///             Ok(operation) => {
+    ///             Ok(mut operation) => {
     ///                 operation.set_key(&key_pair_2)?;
     ///                 match TransientObject::allocate(TransientObjectType::GenericSecret, 256) {
     ///                     // Derived key is saved as an transient object
@@ -1622,7 +1622,7 @@ impl DeriveKey {
     }
 
     /// Function usage is similar to [Cipher::set_key](Cipher::set_key).
-    pub fn set_key<T: GenericObject>(&self, object: &T) -> Result<()> {
+    pub fn set_key<T: GenericObject>(&mut self, object: &T) -> Result<()> {
         self.0.set_key(object)
     }
 

crates/optee-utee/src/error.rs

@@ -28,9 +28,9 @@ use std::error;
 /// # Examples
 ///
 /// ``` rust,no_run
-/// # use optee_utee::Parameters;
+/// # use optee_utee::prelude::*;
 /// use optee_utee::Result;
-/// fn open_session(params: &mut Parameters) -> Result<()> {
+/// fn open_session(params: &mut ParametersAny) -> Result<()> {
 ///     Ok(())
 /// }
 /// ````

crates/optee-utee/src/object/object_handle.rs

@@ -38,7 +38,6 @@ impl ObjectHandle {
     /// ``` rust,no_run
     /// # use optee_utee::ObjectHandle;
     /// # use optee_utee_sys as raw;
-    /// # let external_handle: raw::TEE_ObjectHandle = core::ptr::null_mut();
     /// # fn main() -> optee_utee::Result<()> {
     /// # let external_handle = core::ptr::null_mut();
     /// // `external_handle` is a handle that is constructed and controlled

examples/acipher-rs/ta/src/main.rs

@@ -20,12 +20,9 @@
 
 extern crate alloc;
 
-use alloc::boxed::Box;
-use optee_utee::{
-    ta_close_session, ta_create, ta_destroy, ta_invoke_command, ta_open_session, trace_println,
-};
+use optee_utee::prelude::*;
 use optee_utee::{AlgorithmId, Asymmetric, OperationMode};
-use optee_utee::{ErrorKind, Parameters, Result};
+use optee_utee::{ErrorKind, Result};
 use optee_utee::{GenericObject, TransientObject, TransientObjectType};
 use proto::Command;
 
@@ -48,7 +45,7 @@ fn create() -> Result<()> {
 }
 
 #[ta_open_session]
-fn open_session(_params: &mut Parameters, _sess_ctx: &mut RsaCipher) -> Result<()> {
+fn open_session(_params: &mut ParametersNone, _sess_ctx: &mut RsaCipher) -> Result<()> {
     trace_println!("[+] TA open session");
     Ok(())
 }
@@ -63,79 +60,53 @@ fn destroy() {
     trace_println!("[+] TA destroy");
 }
 
-fn gen_key(rsa: &mut RsaCipher, params: &mut Parameters) -> Result<()> {
-    let key_size = unsafe { params.0.as_value()?.a() };
+fn gen_key(rsa: &mut RsaCipher, (p0, _, _, _): &mut ParametersAny<'_>) -> Result<()> {
+    let key_size = p0.as_value_input()?.get_a();
     rsa.key = TransientObject::allocate(TransientObjectType::RsaKeypair, key_size as usize)?;
     rsa.key.generate_key(key_size as usize, &[])?;
     Ok(())
 }
 
-fn get_size(rsa: &mut RsaCipher, params: &mut Parameters) -> Result<()> {
+fn get_size(rsa: &mut RsaCipher, (p0, _, _, _): &mut ParametersAny<'_>) -> Result<()> {
     let key_info = rsa.key.info()?;
-    unsafe {
-        params
-            .0
-            .as_value()?
-            .set_a((key_info.object_size() / 8) as u32)
-    };
+    p0.as_value_output()?
+        .set_a((key_info.object_size() / 8) as u32);
     Ok(())
 }
 
-fn encrypt(rsa: &mut RsaCipher, params: &mut Parameters) -> Result<()> {
+fn encrypt(rsa: &mut RsaCipher, (p0, p1, _, _): &mut ParametersAny<'_>) -> Result<()> {
     let key_info = rsa.key.info()?;
-    let mut p0 = unsafe { params.0.as_memref()? };
-    let plain_text = p0.buffer();
-    let mut p1 = unsafe { params.1.as_memref()? };
-    match Asymmetric::allocate(
+    let (p0, p1) = (p0.as_memref_input()?, p1.as_memref_output()?);
+    let mut cipher = Asymmetric::allocate(
         AlgorithmId::RsaesPkcs1V15,
         OperationMode::Encrypt,
         key_info.object_size(),
-    ) {
-        Err(e) => Err(e),
-        Ok(cipher) => {
-            cipher.set_key(&rsa.key)?;
-            match cipher.encrypt(&[], plain_text) {
-                Err(e) => Err(e),
-                Ok(cipher_text) => {
-                    if cipher_text.len() > p1.buffer().len() {
-                        p1.set_updated_size(cipher_text.len());
-                        Err(ErrorKind::ShortBuffer.into())
-                    } else {
-                        p1.buffer().clone_from_slice(&cipher_text);
-                        Ok(())
-                    }
-                }
-            }
-        }
-    }
+    )?;
+    cipher.set_key(&rsa.key)?;
+    let cipher_text = cipher.encrypt(&[], p0.as_slice())?;
+    p1.set_output(cipher_text)?;
+    Ok(())
 }
 
-fn decrypt(rsa: &mut RsaCipher, params: &mut Parameters) -> Result<()> {
+fn decrypt(rsa: &mut RsaCipher, (p0, p1, _, _): &mut ParametersAny<'_>) -> Result<()> {
     let key_info = rsa.key.info()?;
-    let mut p0 = unsafe { params.0.as_memref()? };
-    let cipher_text = p0.buffer();
-    let mut p1 = unsafe { params.1.as_memref()? };
-    match Asymmetric::allocate(
+    let (p0, p1) = (p0.as_memref_input()?, p1.as_memref_output()?);
+    let mut cipher = Asymmetric::allocate(
         AlgorithmId::RsaesPkcs1V15,
         OperationMode::Decrypt,
         key_info.object_size(),
-    ) {
-        Err(e) => Err(e),
-        Ok(cipher) => {
-            cipher.set_key(&rsa.key)?;
-            match cipher.decrypt(&[], cipher_text) {
-                Err(e) => Err(e),
-                Ok(plain_text) => {
-                    p1.buffer().clone_from_slice(&plain_text);
-                    Ok(())
-                }
-            }
-        }
-    }
+    )?;
+    cipher.set_key(&rsa.key)?;
+    let plain_text = cipher.decrypt(&[], p0.as_slice())?;
+    p1.set_output(plain_text)
 }
 
 #[ta_invoke_command]
-fn invoke_command(sess_ctx: &mut RsaCipher, cmd_id: u32, params: &mut Parameters) -> Result<()> {
+fn invoke_command(
+    sess_ctx: &mut RsaCipher,
+    cmd_id: u32,
+    params: &mut ParametersAny<'_>,
+) -> Result<()> {
     trace_println!("[+] TA invoke command");
     match Command::from(cmd_id) {
         Command::GenKey => gen_key(sess_ctx, params),

examples/aes-rs/ta/src/main.rs

@@ -20,15 +20,12 @@
 
 extern crate alloc;
 
-use alloc::boxed::Box;
 use alloc::vec;
 use optee_utee::is_algorithm_supported;
-use optee_utee::{
-    ta_close_session, ta_create, ta_destroy, ta_invoke_command, ta_open_session, trace_println,
-};
+use optee_utee::prelude::*;
 use optee_utee::{AlgorithmId, Cipher, ElementId, OperationMode};
 use optee_utee::{AttributeId, AttributeMemref, TransientObject, TransientObjectType};
-use optee_utee::{ErrorKind, Parameters, Result};
+use optee_utee::{ErrorKind, Result};
 use proto::{Algo, Command, KeySize, Mode};
 
 pub struct AesCipher {
@@ -54,7 +51,7 @@ fn create() -> Result<()> {
 }
 
 #[ta_open_session]
-fn open_session(_params: &mut Parameters, _sess_ctx: &mut AesCipher) -> Result<()> {
+fn open_session(_params: &mut ParametersNone, _sess_ctx: &mut AesCipher) -> Result<()> {
     trace_println!("[+] TA open session");
     Ok(())
 }
@@ -70,7 +67,11 @@ fn destroy() {
 }
 
 #[ta_invoke_command]
-fn invoke_command(sess_ctx: &mut AesCipher, cmd_id: u32, params: &mut Parameters) -> Result<()> {
+fn invoke_command(
+    sess_ctx: &mut AesCipher,
+    cmd_id: u32,
+    params: &mut ParametersAny<'_>,
+) -> Result<()> {
     trace_println!("[+] TA invoke command");
     match Command::from(cmd_id) {
         Command::Prepare => alloc_resources(sess_ctx, params),
@@ -105,10 +106,12 @@ pub fn ta2tee_mode_id(mode: u32) -> Result<OperationMode> {
     }
 }
 
-pub fn alloc_resources(aes: &mut AesCipher, params: &mut Parameters) -> Result<()> {
-    let algo_value = unsafe { params.0.as_value()?.a() };
-    let key_size_value = unsafe { params.1.as_value()?.a() };
-    let mode_id_value = unsafe { params.2.as_value()?.a() };
+pub fn alloc_resources(aes: &mut AesCipher, (p0, p1, p2, _): &mut ParametersAny<'_>) -> Result<()> {
+    let (algo_value, key_size_value, mode_id_value) = (
+        p0.as_value_input()?.get_a(),
+        p1.as_value_input()?.get_a(),
+        p2.as_value_input()?.get_a(),
+    );
 
     aes.key_size = ta2tee_key_size(key_size_value)?;
 
@@ -131,9 +134,8 @@ pub fn alloc_resources(aes: &mut AesCipher, params: &mut Parameters) -> Result<(
     Ok(())
 }
 
-pub fn set_aes_key(aes: &mut AesCipher, params: &mut Parameters) -> Result<()> {
-    let mut param0 = unsafe { params.0.as_memref()? };
-    let key = param0.buffer();
+pub fn set_aes_key(aes: &mut AesCipher, (p0, _, _, _): &mut ParametersAny<'_>) -> Result<()> {
+    let key = p0.as_memref_input()?.as_slice();
 
     if key.len() != aes.key_size {
         trace_println!("[+] Get wrong key size !\n");
@@ -149,31 +151,28 @@ pub fn set_aes_key(aes: &mut AesCipher, params: &mut Parameters) -> Result<()> {
     Ok(())
 }
 
-pub fn reset_aes_iv(aes: &mut AesCipher, params: &mut Parameters) -> Result<()> {
-    let mut param0 = unsafe { params.0.as_memref()? };
-    let iv = param0.buffer();
+pub fn reset_aes_iv(aes: &mut AesCipher, (p0, _, _, _): &mut ParametersAny<'_>) -> Result<()> {
+    let iv = p0.as_memref_input()?.as_slice();
 
     aes.cipher.init(iv);
 
     trace_println!("[+] TA initial vectore reset done!");
     Ok(())
 }
 
-pub fn cipher_buffer(aes: &mut AesCipher, params: &mut Parameters) -> Result<()> {
-    let mut param0 = unsafe { params.0.as_memref()? };
-    let mut param1 = unsafe { params.1.as_memref()? };
+pub fn cipher_buffer(aes: &mut AesCipher, (p0, p1, _, _): &mut ParametersAny<'_>) -> Result<()> {
+    let (input, output) = (p0.as_memref_input()?, p1.as_memref_output()?);
 
-    let input = param0.buffer();
-    let output = param1.buffer();
-
-    if output.len() < input.len() {
+    if output.get_capacity() < input.as_slice().len() {
         return Err(ErrorKind::BadParameters.into());
     }
 
     trace_println!("[+] TA tries to update ciphers!");
 
-    let tmp_size = aes.cipher.update(input, output)?;
-    param1.set_updated_size(tmp_size);
+    let tmp_size = aes
+        .cipher
+        .update(input.as_slice(), unsafe { output.as_mut_slice() })?;
+    output.set_updated_size(tmp_size)?;
     Ok(())
 }