Struct SecureString

pub struct SecureString { /* private fields */ }

A securely allocated, growable UTF-8 string, analogous to std::string::String.

It is a wrapper around SecureVec<u8> and inherits all of its security guarantees, ensuring that sensitive string data like passwords, API keys, or personal information is handled with care.

Security Model

SecureString enforces the same security model as SecureVec:

• Zeroization on Drop: The string’s buffer is securely wiped clean.
• Memory Locking & Encryption: When the std feature is enabled, the buffer is protected against OS-level spying via disk swaps or memory inspection tools.

Access to the string contents is provided through scoped methods like str_scope, which ensure the memory is only unlocked for the briefest possible time.

Security Considerations

While the crate protects the memory, you must still be careful not to leak the data. For example, creating a new, unsecured String from the unlocked slice and returning it from the scope would leak the sensitive data if not handled correctly.

Examples

use secure_types::SecureString;

// Create a SecureString
let mut secret = SecureString::from("my_super_secret");

// The memory is locked here

// Safely append more data.
secret.push_str("_password");

// The memory is locked here.

// Use a scope to safely access the content as a &str.
secret.str_scope(|exposed_str| {
    assert_eq!(exposed_str, "my_super_secret_password");
});

// When `secret` is dropped, its data zeroized.

Implementations

impl SecureString

pub fn new() -> Result<Self, Error>

pub fn new_with_capacity(capacity: usize) -> Result<Self, Error>

pub fn erase(&mut self)

pub fn len(&self) -> usize

pub fn drain(&mut self, range: Range<usize>)

pub fn char_len(&self) -> usize

pub fn push_str(&mut self, string: &str)

Push a &str into the SecureString

pub fn str_scope<F, R>(&self, f: F) -> R

where F: FnOnce(&str) -> R,

Access the SecureString as &str

Use with caution

You can actually return a new allocated String from this function

If you do that you are responsible for zeroizing its contents

pub fn mut_scope<F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut SecureString) -> R,

Mutable access to the SecureString

Use with caution

You can actually return a new allocated String from this function

If you do that you are responsible for zeroizing its contents

pub fn insert_text_at_char_idx( &mut self, char_idx: usize, text_to_insert: &str, ) -> usize

pub fn delete_text_char_range(&mut self, char_range: Range<usize>)

Trait Implementations

impl Clone for SecureString

fn clone(&self) -> SecureString

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl From<&str> for SecureString

fn from(s: &str) -> SecureString

Converts to this type from the input type.

impl From<SecureVec<u8>> for SecureString

fn from(vec: SecureVec<u8>) -> Self

Converts to this type from the input type.

impl From<String> for SecureString

fn from(s: String) -> SecureString

Converts to this type from the input type.