rust: use str_from_null_terminated_ptr

The two instances in the commit implemented that ad-hoc.

Author: benma

src/rust/bitbox02/src/app_eth.rs

@@ -23,14 +23,42 @@ pub fn erc20_params_get(chain_id: u64, contract_address: [u8; 20]) -> Option<ERC
         bitbox02_sys::app_eth_erc20_params_get(chain_id, contract_address.as_ptr()).as_ref()?
     };
     Some(ERC20Params {
-        unit: {
-            let s = unsafe {
-                let len = crate::util::strlen_ptr(params.unit);
-                core::slice::from_raw_parts(params.unit, len as _)
-            };
-            core::str::from_utf8(s).unwrap()
-        },
+        unit: unsafe { crate::util::str_from_null_terminated_ptr(params.unit).unwrap() },
         contract_address: params.contract_address,
         decimals: params.decimals,
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_erc20_params_get() {
+        // Not found for chainID 0.
+        assert!(erc20_params_get(
+            0,
+            *b"\x0f\x72\x71\x4b\x35\xa3\x66\x28\x5d\xf8\x58\x86\xa2\xee\x17\x46\x01\x29\x2a\x17"
+        )
+        .is_none());
+
+        // Contract address doesn't exist on chainID 1.
+        assert!(erc20_params_get(
+            1,
+            *b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17"
+        )
+        .is_none());
+
+        let params = erc20_params_get(
+            1,
+            *b"\x00\x00\x00\x00\x00\x08\x5d\x47\x80\xb7\x31\x19\xb6\x44\xae\x5e\xcd\x22\xb3\x76",
+        )
+        .unwrap();
+        assert_eq!(params.unit, "TUSD");
+        assert_eq!(
+            params.contract_address,
+            *b"\x00\x00\x00\x00\x00\x08\x5d\x47\x80\xb7\x31\x19\xb6\x44\xae\x5e\xcd\x22\xb3\x76"
+        );
+        assert_eq!(params.decimals, 18);
+    }
+}

src/rust/bitbox02/src/keystore.rs

@@ -138,11 +138,11 @@ pub fn get_bip39_word(idx: u16) -> Result<zeroize::Zeroizing<String>, ()> {
     match unsafe { bitbox02_sys::keystore_get_bip39_word(idx, &mut word_ptr) } {
         false => Err(()),
         true => {
-            let word = unsafe {
-                let len = crate::util::strlen_ptr(word_ptr);
-                let slice = core::slice::from_raw_parts(word_ptr, len as _);
-                zeroize::Zeroizing::new(core::str::from_utf8(slice).unwrap().into())
-            };
+            let word = zeroize::Zeroizing::new(unsafe {
+                crate::util::str_from_null_terminated_ptr(word_ptr)
+                    .unwrap()
+                    .into()
+            });
             unsafe {
                 bitbox02_sys::wally_free_string(word_ptr as _);
             }

src/rust/bitbox02/src/util.rs

@@ -15,19 +15,6 @@
 extern crate alloc;
 use alloc::vec::Vec;
 
-/// Must be given a null-terminated string
-/// # Safety
-/// ptr must be not NULL and the memory must be valid until a null byte.
-pub unsafe fn strlen_ptr(ptr: *const u8) -> isize {
-    let mut end = ptr;
-    loop {
-        if *end == 0 {
-            return end.offset_from(ptr);
-        }
-        end = end.offset(1);
-    }
-}
-
 /// Parses a utf-8 string out of a null terminated buffer. Returns `Err(())` if there
 /// is no null terminator or if the bytes before the null terminator is invalid UTF8.
 pub fn str_from_null_terminated(input: &[u8]) -> Result<&str, ()> {
@@ -123,14 +110,6 @@ mod tests {
         assert_eq!(truncate_str("test", 6), "test");
     }
 
-    #[test]
-    fn test_strlen_ptr() {
-        assert_eq!(unsafe { strlen_ptr(b"\0".as_ptr()) }, 0);
-        assert_eq!(unsafe { strlen_ptr(b"a\0".as_ptr()) }, 1);
-        assert_eq!(unsafe { strlen_ptr(b"abcdef\0".as_ptr()) }, 6);
-        assert_eq!(unsafe { strlen_ptr(b"abcdef\0defghji".as_ptr()) }, 6);
-    }
-
     #[test]
     fn test_str_from_null_terminated() {
         assert_eq!(str_from_null_terminated(b"\0"), Ok(""));