nonymous 0.7.0

DNS protocol and algorithm library
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
123
124

//! Usage:
//!
//! ```sh
//! $ bore --encode -x 10.42.69.0 | cargo run --example dynrdns --features std | bore --decode
//! ```

extern crate eyre;

use std::io::{stdin, stdout, Read, Write};

use nonymous::{
    core::{Class, Opcode, Rcode, Type},
    emit::name::NameBuilder,
    server::response,
};

fn main() -> eyre::Result<()> {
    let mut query = vec![];
    stdin().lock().read_to_end(&mut query)?;

    let response = rdns_response(&query)?;
    stdout().lock().write_all(&response)?;

    Ok(())
}

fn rdns_response(query: &[u8]) -> eyre::Result<Vec<u8>> {
    let mut result = vec![];

    if let Some((query, response)) = response(&query, &mut result, false)? {
        if query.header().opcode() != Opcode::Query || query.header().qdcount() != 1 {
            response.rcode(Rcode::NotImp).finish()?.finish();
            return Ok(result);
        }

        let question = query.qd().next().unwrap();
        if question.qclass() != Class::IN || question.qtype() != Type::PTR {
            response.rcode(Rcode::Refused).finish()?.finish();
            return Ok(result);
        }

        let qname = question.qname();
        let labels = qname
            .labels_not_null()
            .flat_map(|x| x.value())
            .collect::<Vec<_>>();
        let name = match labels[..] {
            [.., b"in-addr", b"arpa"] => {
                if labels.len() != 4 + 2 {
                    response.rcode(Rcode::Refused).finish()?.finish();
                    return Ok(result);
                }
                let octets = labels
                    .iter()
                    .take(4)
                    .rev()
                    .flat_map(|x| std::str::from_utf8(x))
                    .flat_map(|x| x.parse::<u8>())
                    .map(|x| x.to_string())
                    .collect::<Vec<_>>();
                if octets.len() != 4 {
                    response.rcode(Rcode::Refused).finish()?.finish();
                    return Ok(result);
                }
                let result = octets.join("-");

                format!("dyn-{}.isp.example.", result)
            }
            [.., b"ip6", b"arpa"] => {
                if labels.len() != 32 + 2 {
                    response.rcode(Rcode::Refused).finish()?.finish();
                    return Ok(result);
                }
                let nibbles = labels
                    .iter()
                    .take(32)
                    .rev()
                    .flat_map(|x| std::str::from_utf8(x))
                    .flat_map(|x| u16::from_str_radix(x, 16))
                    .filter(|&x| x <= 0xF)
                    .collect::<Vec<_>>();
                if nibbles.len() != 32 {
                    response.rcode(Rcode::Refused).finish()?.finish();
                    return Ok(result);
                }
                let result = nibbles
                    .chunks_exact(4)
                    .map(|x| x.iter().fold(0, |a, x| a << 4 | x))
                    .map(|x| format!("{:x}", x))
                    .collect::<Vec<_>>()
                    .join("-");

                format!("dyn-{}.isp.example.", result)
            }
            _ => {
                response.rcode(Rcode::Refused).finish()?.finish();
                return Ok(result);
            }
        };

        let mut response = response
            .rcode(Rcode::NoError)
            .copy_question(&question)?
            .into_an()
            .record()?
            .name()?;
        for label in &labels {
            response = response.label(label)?;
        }

        response
            .try_into_rdata()?
            .class(Class::IN)
            .r#type(Type::PTR)
            .build_rdata::<NameBuilder<_>>()?
            .labels(name.as_bytes())?
            .return_to_rdata()?
            .finish()?
            .finish()?
            .finish();
    };

    Ok(result)
}