1#![allow(non_camel_case_types)]
2#[path="../../structs/mod.rs"] mod structs;
3#[path="../../connect.rs"] mod connect;
4use connect::connect;
5use serde::{Serialize,de::DeserializeOwned as DOwned};
6use rmp_serde::{Serializer,decode::Error as derror,from_read};
7use crate::client::Client;
8use crate::error::{MsfError,Error as E};
9use structs::request as req;
10
11pub fn list<T:DOwned>(client:Client) -> Result<T,E> {
12 let mut body=Vec::new();
13 let mut buf=vec![];
14 let mut se=Serializer::new(&mut body);
15 let byte=req::sessions::list("session.list".to_string(),client.token.unwrap());
16 byte.serialize(&mut se).unwrap();
17 let con = connect(client.url,body,&mut buf);
18 let new_buf=buf.clone();
19 match con {
20 Ok(_) => {
21 let ret:Result<T,derror>=from_read(new_buf.as_slice());
22 match ret {
23 Ok(val) => {
24 Ok(val)
25 },
26 Err(_) => {
27 let ret2:Result<MsfError,derror>=from_read(new_buf.as_slice());
28 match ret2 {
29 Ok(val) => {
30 Err(E::MsfError(val))
31 },
32 Err(e) => {
33 Err(E::DError(e))
34 },
35 }
36 }
37 }
38 },
39 Err(e) => {
40 Err(E::ConnectionError(e))
41 },
42 }
43}
44pub fn stop<T:DOwned>(client:Client,sessionidstr:&str) -> Result<T,E> {
45 let sessionid:String=sessionidstr.to_string();
46 let mut body=Vec::new();
47 let mut buf=vec![];
48 let mut se=Serializer::new(&mut body);
49 let byte=req::sessions::stop("session.stop".to_string(),client.token.unwrap(),sessionid);
50 byte.serialize(&mut se).unwrap();
51 let con = connect(client.url,body,&mut buf);
52 let new_buf=buf.clone();
53 match con {
54 Ok(_) => {
55 let ret:Result<T,derror>=from_read(new_buf.as_slice());
56 match ret {
57 Ok(val) => {
58 Ok(val)
59 },
60 Err(_) => {
61 let ret2:Result<MsfError,derror>=from_read(new_buf.as_slice());
62 match ret2 {
63 Ok(val) => {
64 Err(E::MsfError(val))
65 },
66 Err(e) => {
67 Err(E::DError(e))
68 },
69 }
70 }
71 }
72 },
73 Err(e) => {
74 Err(E::ConnectionError(e))
75 },
76 }
77}
78pub struct shell;
79impl shell {
80 pub fn read<T:DOwned>(client:Client,sessionidstr:&str,readpointer:Option<i32>) -> Result<T,E> {
81 let sessionid:String=sessionidstr.to_string();
82 let mut body=Vec::new();
83 let mut buf=vec![];
84 let mut se=Serializer::new(&mut body);
85 match readpointer {
86 Some(_) => {
87 let byte=req::sessions::shell_read_with_pointer("session.shell_read".to_string(),client.token.unwrap(),sessionid,readpointer.unwrap());
88 byte.serialize(&mut se).unwrap();
89 },
90 None => {
91 let byte=req::sessions::shell_read("session.shell_read".to_string(),client.token.unwrap(),sessionid);
92 byte.serialize(&mut se).unwrap();
93 },
94 }
95 let con = connect(client.url,body,&mut buf);
96 let new_buf=buf.clone();
97 match con {
98 Ok(_) => {
99 let ret:Result<T,derror>=from_read(new_buf.as_slice());
100 match ret {
101 Ok(val) => {
102 Ok(val)
103 },
104 Err(_) => {
105 let ret2:Result<MsfError,derror>=from_read(new_buf.as_slice());
106 match ret2 {
107 Ok(val) => {
108 Err(E::MsfError(val))
109 },
110 Err(e) => {
111 Err(E::DError(e))
112 },
113 }
114 }
115 }
116 },
117 Err(e) => {
118 Err(E::ConnectionError(e))
119 },
120 }
121 }
122 pub fn write<T:DOwned>(client:Client,sessionidstr:&str,datastr:&str) -> Result<T,E> {
123 let sessionid:String=sessionidstr.to_string();
124 let data:String=datastr.to_string();
125 let mut body=Vec::new();
126 let mut buf=vec![];
127 let mut se=Serializer::new(&mut body);
128 let byte=req::sessions::shell_write("session.shell_write".to_string(),client.token.unwrap(),sessionid,data);
129 byte.serialize(&mut se).unwrap();
130 let con = connect(client.url,body,&mut buf);
131 let new_buf=buf.clone();
132 match con {
133 Ok(_) => {
134 let ret:Result<T,derror>=from_read(new_buf.as_slice());
135 match ret {
136 Ok(val) => {
137 Ok(val)
138 },
139 Err(_) => {
140 let ret2:Result<MsfError,derror>=from_read(new_buf.as_slice());
141 match ret2 {
142 Ok(val) => {
143 Err(E::MsfError(val))
144 },
145 Err(e) => {
146 Err(E::DError(e))
147 },
148 }
149 }
150 }
151 },
152 Err(e) => {
153 Err(E::ConnectionError(e))
154 },
155 }
156 }
157}
158pub struct meterpreter {
159 pub sessionid:String,
160 pub client:Client,
161}
162impl meterpreter {
163 pub fn new(client:Client,sessionidstr:&str) -> Self {
164 meterpreter {
165 sessionid:sessionidstr.to_string(),
166 client:client,
167 }
168 }
169 fn serialize(&self,body:&mut Vec<u8>,method:&str,param:Option<String>) {
170 let mut se=Serializer::new(body);
171 match param {
172 Some(val) => {
173 let byte=req::sessions::meterpreter_with_two(method.to_string(),self.client.token.as_ref().unwrap().to_string(),self.sessionid.clone(),val);
174 byte.serialize(&mut se).unwrap();
175 },
176 None => {
177 let byte=req::sessions::meterpreter_with_one(method.to_string(),self.client.token.as_ref().unwrap().to_string(),self.sessionid.clone());
178 byte.serialize(&mut se).unwrap();
179 },
180 }
181 }
182 fn deserialize<T:DOwned>(&self,new_buf:Vec<u8>) -> Result<T,E> {
183 let ret:Result<T,derror>=from_read(new_buf.as_slice());
184 match ret {
185 Ok(val) => {
186 Ok(val)
187 },
188 Err(_) => {
189 let ret2:Result<MsfError,derror>=from_read(new_buf.as_slice());
190 match ret2 {
191 Ok(val) => {
192 Err(E::MsfError(val))
193 },
194 Err(e) => {
195 Err(E::DError(e))
196 },
197 }
198 }
199 }
200 }
201 pub fn write<T:DOwned>(&self,datastr:&str) -> Result<T,E> {
202 let data:String=datastr.to_string();
203 let mut body=Vec::new();
204 let mut buf=vec![];
205 self.serialize(&mut body,"session.meterpreter_write",Some(data));
206 let con=connect(self.client.url.clone(),body,&mut buf);
207 let new_buf=buf.clone();
208 match con {
209 Ok(_) => {
210 self.deserialize(new_buf)
211 },
212 Err(e) => {
213 Err(E::ConnectionError(e))
214 },
215 }
216 }
217 pub fn read<T:DOwned>(&self) -> Result<T,E> {
218 let mut body=Vec::new();
219 let mut buf=vec![];
220 self.serialize(&mut body,"session.meterpreter_read",None);
221 let con=connect(self.client.url.clone(),body,&mut buf);
222 let new_buf=buf.clone();
223 match con {
224 Ok(_) => {
225 self.deserialize(new_buf)
226 },
227 Err(e) => {
228 Err(E::ConnectionError(e))
229 },
230 }
231 }
232 pub fn run_single<T:DOwned>(&self,commandstr:&str) -> Result<T,E> {
233 let command:String=commandstr.to_string();
234 let mut body=Vec::new();
235 let mut buf=vec![];
236 self.serialize(&mut body,"session.meterpreter_run_single",Some(command));
237 let con=connect(self.client.url.clone(),body,&mut buf);
238 let new_buf=buf.clone();
239 match con {
240 Ok(_) => {
241 self.deserialize(new_buf)
242 },
243 Err(e) => {
244 Err(E::ConnectionError(e))
245 },
246 }
247 }
248 pub fn script<T:DOwned>(&self,scriptnamestr:&str) -> Result<T,E> {
249 let scriptname:String=scriptnamestr.to_string();
250 let mut body=Vec::new();
251 let mut buf=vec![];
252 self.serialize(&mut body,"session.meterpreter_script",Some(scriptname));
253 let con=connect(self.client.url.clone(),body,&mut buf);
254 let new_buf=buf.clone();
255 match con {
256 Ok(_) => {
257 self.deserialize(new_buf)
258 },
259 Err(e) => {
260 Err(E::ConnectionError(e))
261 },
262 }
263 }
264 pub fn detach_session<T:DOwned>(&self) -> Result<T,E> {
265 let mut body=Vec::new();
266 let mut buf=vec![];
267 self.serialize(&mut body,"session.meterpreter_session_detach",None);
268 let con=connect(self.client.url.clone(),body,&mut buf);
269 let new_buf=buf.clone();
270 match con {
271 Ok(_) => {
272 self.deserialize(new_buf)
273 },
274 Err(e) => {
275 Err(E::ConnectionError(e))
276 },
277 }
278 }
279 pub fn kill_session<T:DOwned>(&self) -> Result<T,E> {
280 let mut body=Vec::new();
281 let mut buf=vec![];
282 self.serialize(&mut body,"session.meterpreter_session_kill",None);
283 let con=connect(self.client.url.clone(),body,&mut buf);
284 let new_buf=buf.clone();
285 match con {
286 Ok(_) => {
287 self.deserialize(new_buf)
288 },
289 Err(e) => {
290 Err(E::ConnectionError(e))
291 },
292 }
293 }
294 pub fn tabs<T:DOwned>(&self,inputlinestr:&str) -> Result<T,E> {
295 let inputline=inputlinestr.to_string();
296 let mut body=Vec::new();
297 let mut buf=vec![];
298 self.serialize(&mut body,"session.meterpreter_tabs",Some(inputline));
299 let con=connect(self.client.url.clone(),body,&mut buf);
300 let new_buf=buf.clone();
301 match con {
302 Ok(_) => {
303 self.deserialize(new_buf)
304 },
305 Err(e) => {
306 Err(E::ConnectionError(e))
307 },
308 }
309 }
310 pub fn compactible_modules<T:DOwned>(&self) -> Result<T,E> {
311 let mut body=Vec::new();
312 let mut buf=vec![];
313 self.serialize(&mut body,"session.compatible_modules",None);
314 let con=connect(self.client.url.clone(),body,&mut buf);
315 let new_buf=buf.clone();
316 match con {
317 Ok(_) => {
318 self.deserialize(new_buf)
319 },
320 Err(e) => {
321 Err(E::ConnectionError(e))
322 },
323 }
324 }
325}
326pub fn shell_upgrade<T:DOwned>(client:Client,sessionidstr:&str,connecthoststr:&str,connectport:i32) -> Result<T,E> {
327 let sessionid:String=sessionidstr.to_string();
328 let connecthost:String=connecthoststr.to_string();
329 let mut body=Vec::new();
330 let mut buf=vec![];
331 let mut se=Serializer::new(&mut body);
332 let byte=req::sessions::shell_upgrade("session.shell_upgrade".to_string(),client.token.as_ref().unwrap().to_string(),sessionid,connecthost,connectport);
333 byte.serialize(&mut se).unwrap();
334 let con=connect(client.url,body,&mut buf);
335 let new_buf=buf.clone();
336 match con {
337 Ok(_) => {
338 let ret:Result<T,derror>=from_read(new_buf.as_slice());
339 match ret {
340 Ok(val) => {
341 Ok(val)
342 },
343 Err(_) => {
344 let ret2:Result<MsfError,derror>=from_read(new_buf.as_slice());
345 match ret2 {
346 Ok(val) => {
347 Err(E::MsfError(val))
348 },
349 Err(e) => {
350 Err(E::DError(e))
351 },
352 }
353 }
354 }
355 },
356 Err(e) => {
357 Err(E::ConnectionError(e))
358 },
359 }
360}
361pub struct ring {
362 client:Client,
363 sessionid:String,
364}
365impl ring {
366 pub fn new(client:Client,sessionid:&str) -> Self {
367 ring {
368 client:client,
369 sessionid:sessionid.to_string(),
370 }
371 }
372 fn serialize(&self,body:&mut Vec<u8>,method:&str,arg:Option<String>) {
373 let mut se=Serializer::new(body);
374 match arg {
375 Some(val) => {
376 let byte=req::sessions::ring_with_arg(method.to_string(),self.client.token.as_ref().unwrap().to_string(),self.sessionid.clone(),val);
377 byte.serialize(&mut se).unwrap();
378 },
379 None => {
380 let byte_new=req::sessions::ring_without_arg(method.to_string(),self.client.token.as_ref().unwrap().to_string(),self.sessionid.clone());
381 byte_new.serialize(&mut se).unwrap();
382 },
383 }
384 }
385 fn deserialize<T:DOwned>(&self,new_buf:Vec<u8>) -> Result<T,E> {
386 let ret:Result<T,derror>=from_read(new_buf.as_slice());
387 match ret {
388 Ok(val) => {
389 Ok(val)
390 },
391 Err(_) => {
392 let ret2:Result<MsfError,derror>=from_read(new_buf.as_slice());
393 match ret2 {
394 Ok(val) => {
395 Err(E::MsfError(val))
396 },
397 Err(e) => {
398 Err(E::DError(e))
399 },
400 }
401 }
402 }
403 }
404 pub fn clear<T:DOwned>(&self) -> Result<T,E> {
405 let mut body=Vec::new();
406 let mut buf=vec![];
407 self.serialize(&mut body,"session.ring_clear",None);
408 let con=connect(self.client.url.clone(),body,&mut buf);
409 let new_buf=buf.clone();
410 match con {
411 Ok(_) => {
412 self.deserialize(new_buf)
413 },
414 Err(e) => {
415 Err(E::ConnectionError(e))
416 },
417 }
418 }
419 pub fn last<T:DOwned>(&self) -> Result<T,E> {
420 let mut body=Vec::new();
421 let mut buf=vec![];
422 self.serialize(&mut body,"session.ring_last",None);
423 let con=connect(self.client.url.clone(),body,&mut buf);
424 let new_buf=buf.clone();
425 match con {
426 Ok(_) => {
427 self.deserialize(new_buf)
428 },
429 Err(e) => {
430 Err(E::ConnectionError(e))
431 },
432 }
433 }
434 pub fn put<T:DOwned>(&self,datastr:&str) -> Result<T,E> {
435 let data:String=datastr.to_string();
436 let mut body=Vec::new();
437 let mut buf=vec![];
438 self.serialize(&mut body,"session.ring_put",Some(data));
439 let con=connect(self.client.url.clone(),body,&mut buf);
440 let new_buf=buf.clone();
441 match con {
442 Ok(_) => {
443 self.deserialize(new_buf)
444 },
445 Err(e) => {
446 Err(E::ConnectionError(e))
447 },
448 }
449 }
450}