scatter/decoding.js at master · d-jo/scatter · GitHub

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
const io = require("./io.js")

const transforms = {
	"index": indexTransform,
	"keys": keyTransform,
	"regex": regexTransform,
};

const decoding = {
	// rsa
	// sha3
	// ...
	raw: rawDecode,
};

function regexTransform(data, manifest_entry) {
	return new Promise((resolve, reject) => {
		try {
			let ret;
			data.match(manifest_entry["regex"]).forEach(v => {
				ret += v;
			})
			resolve(ret);
		} catch (err) {
			reject(err);
		}
	});
}

function indexTransform(data, manifest_entry) {
	return new Promise((resolve, reject) => {
		try {
			resolve(data.substring(manifest_entry["start"], manifest_entry["end"]));
		} catch (err) {
			reject(err);
		}
	})
}

function keyTransform(data, manifest_entry) {
	return new Promise((resolve, reject) => {
		try {
			resolve(data.substring(data.indexOf(manifest_entry["start"]), data.indexOf(manifest_entry["end"])));
		} catch (err) {
			reject(err);
		}
	})
}

function rawDecode(data) {
	return new Promise((resolve, reject) => {
		let str = data;
		resolve(str);
	});
}

function decode(mf) {
	return new Promise((resolve, reject) => {
		let sections = {};
		let index = 0;
		let retrieved = 0;
		let header = false;
		// for each fragment
		mf["fragments"].forEach((fr) => {
			// get retrival method and call it
			let retr = io.procurements[fr["source_type"]];
			console.log("Source      \t" + fr["source"]);
			console.log("Source type \t" + fr["source_type"]);
			console.log("Source size \t" + fr["size"]);
			console.log("==========");

			retr(fr).then(raw_data => {
				// go through the raw data from the fragmnet
				// and parse the different data sections
				if (!header) {
					console.log("Section\tSource\t\tSourceType\tActual\tExpected");
					header = true;
				}
				fr["datas"].forEach(datas_entry => {
					// get the transformation
					let transformation = transforms[datas_entry["type"]];
					// apply the transformation
					transformation(raw_data, datas_entry).then(section => {
						let decod = decoding[datas_entry["decoding"]]
						decod(section).then(fd => {
							datas_entry["locations"].forEach(loc => {
								sections[loc] = fd
							})
							retrieved += fd.length
							console.log(datas_entry["locations"] + "\t" + fr["source"].substring(12, 24) + "\t" + fr["source_type"] + "\t\t" + section.length + "\t" + datas_entry["size"])
							if (retrieved >= mf["size"]) {
								resolve(sections)
							}
						}).catch(err3 => {
							console.log("Error decoding data section " + datas_entry["order"])
							console.log("Using raw_decode as default")
							// todo raw
						})
					}).catch(err2 => {
						console.log("Error extracing data section from source " + fr["source"]);
						console.log("Error message: " + err2.message);
						console.log(datas_entry["size"] + " Bits will be missing from data starting at " + retrieved);
						let str;
						for (let i = 0; i < datas_entry["size"]; i++) {
							str += "0";
						}
						sections[datas_entry["order"]] = str;
						retrieved += datas_entry["size"];
					});
				});
			}).catch(err => {
				console.log("Error fetching source " + fr["source"]);
				console.log("Error message: " + err.message);
				console.log(fr["size"] + " bits will be missing from data starting at " + retrieved);
				let str;
				for (let i = 0; i < datas_entry["size"]; i++) {
					str += "0";
				}
				sections[datas_entry["order"]] = str;
				retrieved += datas_entry["size"];
			});
		});
	});
}

module.exports = {
	transforms,
	decode,
	decoding,
	rawDecode,
	keyTransform,
	indexTransform,
	regexTransform,
};