wnfs 0.3.0

WebNative filesystem core implementation
Documentation 
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

use crate::private::{
    FileContent, PrivateDirectory, PrivateForestContent, PrivateNode, PrivateRef, SnapshotKey,
    TemporalKey,
    forest::{hamt::HamtForest, traits::PrivateForest},
};
use anyhow::Result;
use bytes::Bytes;
use ipld_core::ipld::Ipld;
use rand_core::CryptoRngCore;
use wnfs_common::utils::{Arc, BytesToIpld, CondSend, SnapshotBlockStore};
use wnfs_nameaccumulator::Name;

struct EncryptedBlockHandler {
    snapshot_key: SnapshotKey,
}

impl BytesToIpld for EncryptedBlockHandler {
    fn convert(&self, bytes: &Bytes) -> Result<Ipld> {
        Ok(serde_ipld_dagcbor::from_slice(
            &self.snapshot_key.decrypt(bytes.as_ref())?,
        )?)
    }
}

struct KeyWrappedBlockHandler {
    temporal_key: TemporalKey,
}

impl BytesToIpld for KeyWrappedBlockHandler {
    fn convert(&self, bytes: &Bytes) -> Result<Ipld> {
        Ok(serde_ipld_dagcbor::from_slice(
            &self.temporal_key.key_wrap_decrypt(bytes.as_ref())?,
        )?)
    }
}

struct FileShardHandler {
    key: SnapshotKey,
}

impl BytesToIpld for FileShardHandler {
    fn convert(&self, bytes: &Bytes) -> Result<Ipld> {
        Ok(Ipld::Bytes(self.key.decrypt(bytes.as_ref())?))
    }
}

//--------------------------------------------------------------------------------------------------
// Functions
//--------------------------------------------------------------------------------------------------

pub(crate) async fn walk_dir(
    store: &mut SnapshotBlockStore,
    forest: &mut Arc<HamtForest>,
    root_dir: &Arc<PrivateDirectory>,
    rng: &mut (impl CryptoRngCore + CondSend),
) -> Result<()> {
    let mut stack = vec![root_dir.clone()];
    while let Some(dir) = stack.pop() {
        let private_ref: PrivateRef = dir.store(forest, store, rng).await?;
        let temporal_key = private_ref.temporal_key;
        let snapshot_key = temporal_key.derive_snapshot_key();
        store.add_block_handler(
            private_ref.content_cid,
            Arc::new(EncryptedBlockHandler { snapshot_key }),
        );
        store.add_block_handler(
            dir.header.store(store, forest).await?,
            Arc::new(KeyWrappedBlockHandler { temporal_key }),
        );

        let entries = dir.ls(&[], true, forest, store).await?;
        for (name, _) in entries.iter() {
            let node = dir.lookup_node(name, true, forest, store).await?;
            match node.as_ref() {
                Some(PrivateNode::Dir(dir)) => {
                    stack.push(dir.clone());
                }
                Some(PrivateNode::File(file)) => {
                    let private_ref: PrivateRef = file.store(forest, store, rng).await?;
                    let temporal_key = private_ref.temporal_key;
                    let snapshot_key = temporal_key.derive_snapshot_key();
                    store.add_block_handler(
                        private_ref.content_cid,
                        Arc::new(EncryptedBlockHandler { snapshot_key }),
                    );
                    store.add_block_handler(
                        file.header.store(store, forest).await?,
                        Arc::new(KeyWrappedBlockHandler { temporal_key }),
                    );
                    if let FileContent::External(PrivateForestContent {
                        key,
                        block_count,
                        base_name,
                        ..
                    }) = &file.content.content
                    {
                        for name in PrivateForestContent::generate_shard_labels(
                            key,
                            0,
                            *block_count,
                            &Name::new(base_name.clone(), []),
                        ) {
                            match forest.get_encrypted(&name, store).await? {
                                Some(cids) => {
                                    let key = key.clone();
                                    store.add_block_handler(
                                        *cids.first().unwrap(),
                                        Arc::new(FileShardHandler { key }),
                                    )
                                }
                                None => unreachable!(),
                            };
                        }
                    }
                }
                None => unreachable!(),
            }
        }
    }

    Ok(())
}