Skip to main content

ProtectedBlob

Struct ProtectedBlob 

Source
pub struct ProtectedBlob {
    pub key_identifier: KeyIdentifier,
    pub encrypted_key: Vec<u8>,
    pub key_wrap_oid: String,
    pub content_cipher_oid: String,
    pub nonce: Vec<u8>,
    pub tag_len: usize,
    pub encrypted_content: Vec<u8>,
}
Expand description

A parsed DPAPI-NG blob, ready to decrypt once the KEK is known.

Fields§

§key_identifier: KeyIdentifier

Which KDS root key and tree node the content key was wrapped for.

§encrypted_key: Vec<u8>

The content-encryption key, AES-wrapped under the KEK.

§key_wrap_oid: String

OID of the key-wrap algorithm (expected OID_AES256_WRAP).

§content_cipher_oid: String

OID of the content cipher (expected OID_AES256_GCM).

§nonce: Vec<u8>

GCM nonce for the content cipher.

§tag_len: usize

Authentication-tag length in bytes, as declared in the GCM parameters.

§encrypted_content: Vec<u8>

Ciphertext, tag appended (as CMS stores it).

Implementations§

Source§

impl ProtectedBlob

Source

pub fn parse(b: &[u8]) -> Result<ProtectedBlob>

Parse a DPAPI-NG blob — the raw bytes of msLAPS-EncryptedPassword (minus its 16-byte header) or of a gMSA/dMSA protected password.

Examples found in repository?
examples/inspect_blob.rs (line 52)
16fn main() -> ExitCode {
17    let args: Vec<String> = std::env::args().skip(1).collect();
18    let raw_mode = args.iter().any(|a| a == "--raw");
19    let Some(path) = args.iter().find(|a| !a.starts_with("--")) else {
20        eprintln!("usage: inspect_blob [--raw] <blob.bin>");
21        return ExitCode::FAILURE;
22    };
23
24    let bytes = match std::fs::read(path) {
25        Ok(b) => b,
26        Err(e) => {
27            eprintln!("cannot read {path}: {e}");
28            return ExitCode::FAILURE;
29        }
30    };
31
32    let blob_bytes = if raw_mode {
33        bytes
34    } else {
35        match LapsBlob::parse(&bytes) {
36            Ok(l) => {
37                println!(
38                    "LAPS header: updated {} (FILETIME {}), {} byte blob",
39                    filetime_to_iso(l.update_timestamp),
40                    l.update_timestamp,
41                    l.blob.len()
42                );
43                l.blob
44            }
45            Err(e) => {
46                eprintln!("not a LAPS attribute value ({e}); retry with --raw if this is a bare CMS blob");
47                return ExitCode::FAILURE;
48            }
49        }
50    };
51
52    let blob = match ProtectedBlob::parse(&blob_bytes) {
53        Ok(b) => b,
54        Err(e) => {
55            eprintln!("CMS parse failed: {e}");
56            return ExitCode::FAILURE;
57        }
58    };
59
60    let id = &blob.key_identifier;
61    println!("key identifier");
62    println!("  version            {}", id.version);
63    println!("  flags              {:#010x}{}", id.flags, if id.is_public_key() { " (public key)" } else { "" });
64    println!("  root key           {}", id.root_key_id);
65    println!("  tree node          L0 {} · L1 {} · L2 {}", id.l0, id.l1, id.l2);
66    println!("  kdf                {} ", id.kdf_algorithm);
67    match id.hash() {
68        Ok(h) => println!("  kdf hash           {}", h.name()),
69        Err(e) => println!("  kdf hash           UNPARSED: {e}"),
70    }
71    println!("  secret algorithm   {}", id.secret_algorithm);
72    println!("  private/public len {} / {}", id.private_key_length, id.public_key_length);
73    println!("  domain / forest    {} / {}", id.domain_name, id.forest_name);
74    println!("content");
75    println!("  key wrap           {}", blob.key_wrap_oid);
76    println!("  content cipher     {}", blob.content_cipher_oid);
77    println!("  nonce              {} ({} bytes)", hex(&blob.nonce), blob.nonce.len());
78    println!("  tag length         {}", blob.tag_len);
79    println!("  wrapped key        {} bytes", blob.encrypted_key.len());
80    println!("  ciphertext         {} bytes", blob.encrypted_content.len());
81    println!(
82        "\nTo decrypt: ask a DC for root key {} at L0 {} (MS-GKDI GetKey), then\n\
83         GroupKeyEnvelope::parse(response) and dpapi_ng::decrypt(&blob, &envelope).",
84        id.root_key_id, id.l0
85    );
86
87    ExitCode::SUCCESS
88}

Trait Implementations§

Source§

impl Clone for ProtectedBlob

Source§

fn clone(&self) -> ProtectedBlob

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for ProtectedBlob

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.