@lkundrak yep exactly ;-) keep calm, carry on and worship satan

@lkundrak ok except for zmodem i'm working on "bcachefs of zmodem implementations": https://codeberg.org/jarkko/zmodem2

:-)

i might continue from that to a replacement of https://en.wikipedia.org/wiki/SMODEM, which is the competitor to the pre-existing MS-DOS version of the protocol.

@lkundrak yeah, i satisfy with modest stuff like that :-) i like most of the time sofware to do that does not exist rather than replacement for software that already exist. kent can do the god mode replacement afterwards

@lkundrak sounds like it's for smarter people than me, i would not pass the IQ test to become a legit power user of bcachefs ;-) what can you do if you're born as an idiot.

@lkundrak for this i chose rust because google made some nice tools for the dislayout itself: https://github.com/google/gpt-disk-rs

I was able to write a rus program that generates ESP+rootfs GPT partition layout to an image and then it with mkfs.ext4 and mkfs.fat generates partition slices of same size which I rewrite to the apprpriate slots.

@lkundrak i know the name "kent overstreet" and "bcachefs". i've read about those from various geek yellow page media outlets ;-) that's really all i know about that topic

@lkundrak i don't think i have any systems yet that would even use btrfs yet because ext4 has well umh worked :D love it

@lkundrak lol no xD i just do a small tool that i can incorporate to my makefile based kernel testing shenanigans. i.e. unprivileged generate disk image with placeholder partitions for ESP and rootfs

https://github.com/tsatke/mkfs

i'll try this

does any of the ext4 crates for rust *initialize* a partition? I don't care of being able to read or write it, only "mkfs" part is interesting.

no SIZE constant anymore in the new TpmSized as no stack allocation is required:

/// Provides a `dyn`-safe way to get the exact size of a zero-copy cast object.
pub trait TpmSizedCast {
    /// Returns the exact serialized size of the object.
    fn len(&self) -> usize;

    /// Returns `true` if the object has a serialized length of zero.
    fn is_empty(&self) -> bool {
        self.len() == 0
    }
}

This ought to be renamed as TpmSized as full migration is over :-) Applies also to all other *Cast.

some of the e.g., list code is in some place "quite shitty" but migrating from compile-only to compile-test is more important than anything else... now it's easy to polish and expand :-)

from nothing to something type of commit considering zerocopy semantics:

https://git.kernel.org/pub/scm/linux/kernel/git/jarkko/tpm2-protocol.git/commit/?id=28664f46cdcf2c5527d0c3e409a292dad2501bba

now it will be downhill :-)

#linux #rust #tpm

i've finally found my preference for command line arguments in rust: argh. it's like "between the extremes". does not get in the way but neither does "overdo"

i created an experimental "slice and compose" style disk image builder just to build appropriate EFI bootable disk images for kernel testing. i might release this at some point once it "productizes"

And once the disease is spread fully, "parse" and "build" become unnecessary. Bytes are the type and "build" is `as_slice`. Most likely 0.11 size will shrink from the current 8K line to something like 5K once all of this is done. It's a pretty decent number taking into account that the care is fully self-contained with no external dependencies.

This makes me think what's really the point of using "higher level" framework like TSS2 after one has more idiomatic and easier access to the actual core architectural type ... It's pretty quick to build resource managers and stuff like that on need and per application after you have such a tool.

In some ways this does rise an existential challenge to pre-existing sofware stacks, at least to the level that I personally rather build more software around this core than have focus on getting tpm2-protocol integrated anywhere really. I have MockTPM in good progress and some pieces for tpm2-policy module. I guess you can call that an "SDK" or something.

Even tho still only "compile-tested" code the from_slice implementation in TpmList and associated iterator is enough evidence that the approach is in fact effective:

https://git.kernel.org/pub/scm/linux/kernel/git/jarkko/tpm2-protocol.git/tree/src/list.rs

Translates pretty well (from_slice is lacking some RC related checks just PoC code):

pub struct TpmRcCast<'a>(TpmUint32<'a>);

impl<'a> crate::TpmCast<'a> for TpmRcCast<'a> {
    fn from_slice(slice: &'a [u8]) -> TpmResult<Self> {
        Ok(TpmRcCast(TpmUint32::from_slice(slice)?))
    }

    fn as_slice(&self) -> &'a [u8] {
        self.0.as_slice()
    }
}

In the end of the day this is superior despite adding up a new trick to my sack of random macro hacks:

tpm_integer!(u8, TpmUint8, Unsigned);
tpm_integer!(i8, TpmInt8, Signed);
tpm_integer!(u16, TpmUint16, Unsigned);
tpm_integer!(i32, TpmInt32, Signed);
tpm_integer!(u32, TpmUint32, Unsigned);
tpm_integer!(u64, TpmUint64, Unsigned);

Now the names match TCG specification names, and they are also first fully zerocopy migrated types. This way previously redundant looking field now is actually self-documenting field.

Other zerocopy types will get the nasty “Cast” postfix up until migration is complete (e.g., TpmBufferCast).

For the record, the last field is used to address exactly one quirk related to TCG specs: TPM_CLOCK_TIME, meaning that “invalid discriminant error” needs too versions :-/

I’m sure we would get numbers going from zero to six, and “get this complex science” as e.g., most of have ability to read, and understand nuances such as the difference between slower and faster… This is DailyWTF proximity enough level bad definition that I tend to like that TPM_CLOCK_TIME exist…

Great now I think I have solid base traits in place i.e., TpmCast, TpmCastMut, TpmHasCast and TpmHasCastMut:

https://git.kernel.org/pub/scm/linux/kernel/git/jarkko/tpm2-protocol.git/commit/?id=815f08de3d7efccd23d9a334cb8f6e8e46e3c9fd

I also relaxed the contribution guidelines just a little bit:

 //! * `alloc` is disallowed.
 //! * Dependencies are disallowed.
 //! * Developer dependencies are disallowed.
-//! * Panics are disallowed.
+//! * Panics are allowed disallowed by default, except concrete type casts in
+//!   `TpmCast::as_slice` is allowed to use `unwrap` as long as
+//!   `TpmCast::from_slice` meets the documented contract.