dnscat 0.1.1

DNSCAT2 protocol
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

mod echo;
mod split;

pub mod dns;

use std::future::Future;

use failure::Fail;

pub use self::echo::PacketEchoTransport;
pub use self::split::*;

pub use crate::util::{hex, Decode, Encode};

pub trait Datagram: Encode + Decode + Send + 'static {}

impl<T> Datagram for T where T: Encode + Decode + Send + 'static {}

#[derive(Debug, Fail)]
pub enum DatagramError<D: Fail> {
    #[fail(display = "Decode error: {}", _0)]
    Decode(D),
    #[fail(display = "Datagram underflow")]
    Underflow,
    #[fail(display = "Hex decode error: {}", _0)]
    Hex(hex::DecodeError),
    #[fail(display = "Split datagram error: {}", _0)]
    Split(SplitDatagramError),
}

impl<D: Fail> From<hex::DecodeError> for DatagramError<D> {
    fn from(err: hex::DecodeError) -> Self {
        Self::Hex(err)
    }
}

impl<D: Fail> From<SplitDatagramError> for DatagramError<D> {
    fn from(err: SplitDatagramError) -> Self {
        Self::Split(err)
    }
}

pub trait ExchangeTransport<CS, SC = CS>
where
    CS: Datagram<Error = SC::Error>,
    SC: Datagram,
{
    /// Possible error that can occur during the exchange.
    type Error: Fail;

    /// Future representing an asynchronous exchange.
    type Future: Future<Output = Result<SC, Self::Error>> + 'static;

    /// Exchange a client datagram for a server datagram.
    fn exchange(&mut self, datagram: CS) -> Self::Future;

    /// Returns the max datagram size this transport supports.
    fn max_datagram_size(&self) -> usize;
}