Derive Encode/Decode for Pinned Types

[nixpulvis]

I'm trying to do something like this:

struct NotUnpin(i32, PhantomPinned);

#[derive(Encode, Decode)]
struct Foo(Pin<NotUnpin>);

I assume this should be possible for Encode, I'm not so sure about Decode though.

[finnbear]

I don't see any Pin support in serde or bincode. Can you please point to another format that has it? Do you really need to serialize a !Unpin type, or could you #[bitcode(skip)] that field?

[nixpulvis]

This is a strange use case for sure, and I'm still struggling through the details myself. I'm trying to serialize a Password struct I'm creating, which will use Pin to ensure that the string itself doesn't move around.

[finnbear]

Protections against the password being moved seem very weak, if you're contemplating serializing it.

I propose a different security measure - something like this:

struct Password(String);

impl Drop for Password {
     fn drop(&mut self) {
            let mut bytes = std::mem::take(&mut self.0).into_bytes();
            bytes.iter_mut().for_each(|b| *std::hint::black_box(b) = 0);
     }
}

Theoretically, this provides protection against the memory from being leaked when it's done being used for the password.

You should also consider hashing the password before serializing it.

[nixpulvis]

You should also consider hashing the password before serializing it.

I'm implementing a password manager, so this is actually not the right design. Normally I'd agree completely.

Yea, I already have zeroize integrated. And I agree this is likely somewhat of a meaningless security thing, but when I was reading the zeroize docs it states:

Pin can be leveraged in conjunction with this crate to ensure data kept on the stack isn’t moved.

So I was curious how that would look. I think this might be something like this:

pub type PinEncoder<P> = DerefEncoder<<P as Deref>::Target>;
pub type PinDecoder<'a, P> = FromDecoder<'a, P>;

impl<P: Deref + Encode> Encode for Pin<P>
where
    P::Target: Encode,
{
    type Encoder = PinEncoder<P>;
}
impl<'a, P: Deref + Decode<'a>> Decode<'a> for Pin<P>
where
    Pin<P>: From<P>,
{
    type Decoder = PinDecoder<'a, P>;
}

If you think this is valid, I'm happy to send a PR. It doesn't support the complete original idea, but works for Pin<Box<T>> which is good enough for me. It's unclear how we could implement Decode for Pin<&T> so I'm leaving that out.

[finnbear]

There is a simpler implementation:

// src/derive/impls.rs
impl_smart_ptr!(::core::pin::Pin);

Feel free to send a PR but it matters what @caibear thinks about this. We're skeptical of supporting more features than the extremely-general-purpose serde and bincode crates.

Decode for Pin<&T>

Decode cannot, in general, be implemented for &T so this is also impossible.