ntdsextract2 0.9.0

Display contents of Active Directory database files (ntds.dit)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use std::{hash::Hash, rc::Rc, collections::{HashSet, HashMap}, cell::RefCell, fmt::Display};

use libesedb::Table;
use termtree::Tree;

use crate::{column_info_mapping::ColumnInfoMapping, esedb_utils::iter_records};
use anyhow::{Result, bail};


pub (crate) struct ObjectTreeEntry {
    name: String,
    id: i32,
    //parent: Option<Weak<ObjectTreeEntry>>,
    children: RefCell<HashSet<Rc<ObjectTreeEntry>>>
}

impl Eq for ObjectTreeEntry {
}

impl PartialEq for ObjectTreeEntry {
    fn eq(&self, other: &Self) -> bool {
        self.name == other.name && self.id == other.id
    }
}

impl Hash for ObjectTreeEntry {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.name.hash(state);
        self.id.hash(state);
    }
}

impl Display for ObjectTreeEntry {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{} (id={})", self.name, self.id)
    }
}

impl ObjectTreeEntry {

    pub(crate) fn from<'a>(data_table: &Table<'a>, mapping: &ColumnInfoMapping) -> Result<Rc<ObjectTreeEntry>> {
        Self::populate_object_tree(data_table, mapping)
    }

    pub (crate)fn to_tree(me:&Rc<ObjectTreeEntry>, max_depth: u8) -> Tree<Rc<ObjectTreeEntry>> {
        let tree = Tree::new(Rc::clone(me));
        if max_depth > 0 {
            let leaves: Vec<Tree<Rc<ObjectTreeEntry>>> = me
                .children.borrow()
                .iter()
                .map(|c| Self::to_tree(c, max_depth - 1)).collect();
            tree.with_leaves(leaves)
        } else {
            tree
        }
    }
/*
    pub(crate) fn parent(&self) -> Option<Rc<ObjectTreeEntry>> {
        self.parent.as_ref().and_then(|p| p.upgrade())
    }
*/
/*
    pub (crate) fn get_by_path(&self, mut path: Vec<&str>) -> Option<Rc<ObjectTreeEntry>> {
        if let Some(next_folder) = path.pop() {
            match self.children.borrow().iter().find(|c| c.name == next_folder) {
                None => None,
                Some(child) => {
                    if path.len() == 0 {
                        Some(Rc::clone(child))
                    } else {
                        Self::get_by_path(&self, path)
                    }
                }
            }
        } else {
            None
        }
    }
*/
    fn populate_object_tree<'a>(data_table: &Table<'a>, mapping: &ColumnInfoMapping) -> Result<Rc<ObjectTreeEntry>> {

        log::info!("populating the object tree");

        let mut downlinks = HashMap::new();
        let mut uplinks = HashMap::new();
        let mut names = HashMap::new();

        for record in iter_records(data_table) {
            let id = match record.ds_record_id(mapping)? {
                Some(v) => v,
                None => bail!("missing record id")
            };

            let parent_id = match record.ds_parent_record_id(mapping)? {
                Some(v) => v,
                None => bail!("missing parent record id")
            };

            let name = match record.ds_object_name2(mapping)? {
                Some(v) => v,
                None => bail!("missing name")
            };

            names.insert(id, name);
            uplinks.insert(id, parent_id);
            downlinks.entry(parent_id).or_insert_with(HashSet::new).insert(id);
        }

        log::debug!("found {} entries in the DIT", names.len());
        log::debug!("ordering those elements in a tree structure now");
    
        Self::create_tree_node(0, None, &downlinks, &uplinks, &mut names)
    }

    fn create_tree_node(object_id: i32, _parent: Option<&Rc<ObjectTreeEntry>>, downlinks: &HashMap<i32, HashSet<i32>>, uplinks: &HashMap<i32, i32>, names: &mut HashMap<i32, String>) -> Result<Rc<ObjectTreeEntry>> {
        let name = if object_id == 0 {
            String::new()
        } else {
            names.remove(&object_id).unwrap_or_else(|| panic!("missing name for object with id '{object_id}'"))
        };

        //log::trace!("inserting new object '{}'", name);

        let my_object = Rc::new(ObjectTreeEntry {
            name,
            id: object_id,
            //parent: parent.and_then(|p| Some(Rc::downgrade(p))),
            children: RefCell::new(HashSet::new()),
        });

        for (child_id, _) in uplinks.iter().filter(|(_, parent)| **parent == object_id) {
            let child = Self::create_tree_node(
                *child_id, Some(&my_object), downlinks, uplinks, names)?;
            my_object.children.borrow_mut().insert(child);
        }
        Ok(my_object)
    }
}