nsupdate 0.1.0

An asynchronous DNS UPDATE client for BIND9 with optional TSIG authentication
Documentation
use super::*;
use std::net::{Ipv4Addr, Ipv6Addr};

#[test]
fn test_encodes_absolute_names_and_dns_escapes() {
    for (name, expected) in [
        (".", b"\x00".as_slice()),
        ("example.test", b"\x07example\x04test\x00"),
        ("example.test.", b"\x07example\x04test\x00"),
        (r"a\.b.test", b"\x03a.b\x04test\x00"),
        (r"a\046b.test.", b"\x03a.b\x04test\x00"),
        (r"last\.", b"\x05last.\x00"),
        (r"\000\255.test", b"\x02\x00\xff\x04test\x00"),
        (r"a\\b", b"\x03a\\b\x00"),
        ("_sip._tcp.*.test", b"\x04_sip\x04_tcp\x01*\x04test\x00"),
    ] {
        assert_eq!(encode_domain_name(name).unwrap(), expected, "{name}");
    }
}

#[test]
fn test_rejects_malformed_names_without_normalizing_them() {
    for name in [
        "",
        "..",
        ".test",
        "a..test",
        "a.test..",
        "a b",
        "a\0b",
        "한글.test",
        "a\\",
        r"\1",
        r"\12.",
        r"\1xx",
        r"\256",
    ] {
        assert!(
            matches!(
                encode_domain_name(name),
                Err(EncodeError::InvalidDomainName(_))
            ),
            "{name:?}"
        );
    }
}

#[test]
fn test_domain_length_limits_apply_to_decoded_wire_bytes() {
    assert!(encode_domain_name(&"a".repeat(63)).is_ok());
    assert!(matches!(
        encode_domain_name(&"a".repeat(64)),
        Err(EncodeError::LengthExceeded {
            field: "DNS label",
            length: 64,
            max: 63
        })
    ));
    assert!(encode_domain_name(&r"\097".repeat(63)).is_ok());
    assert!(encode_domain_name(&r"\097".repeat(64)).is_err());
    let max_name = format!(
        "{}.{}.{}.{}",
        "a".repeat(63),
        "b".repeat(63),
        "c".repeat(63),
        "d".repeat(61)
    );
    assert_eq!(encode_domain_name(&max_name).unwrap().len(), 255);
    assert_eq!(
        encode_domain_name(&format!("{max_name}.")).unwrap().len(),
        255
    );
    for oversized in [format!("{max_name}d"), format!("{max_name}d.")] {
        assert!(matches!(
            encode_domain_name(&oversized),
            Err(EncodeError::LengthExceeded {
                field: "DNS name",
                length: 256,
                max: 255
            })
        ));
    }
}

#[test]
fn test_zone_membership_uses_case_insensitive_label_boundaries() {
    let zone = encode_domain_name("example.test").unwrap();
    for name in ["example.test", "a.EXAMPLE.test.", r"a.\101xample.test"] {
        assert!(is_in_zone(&encode_domain_name(name).unwrap(), &zone));
    }
    for name in [
        "notexample.test",
        "example.test.evil",
        r"a\.example.test",
        ".",
    ] {
        assert!(!is_in_zone(&encode_domain_name(name).unwrap(), &zone));
    }
    assert!(is_in_zone(&zone, &[0]));
}

#[test]
fn test_serializes_supported_rdata_in_network_byte_order() {
    let cases = [
        (1, RData::A(Ipv4Addr::new(192, 0, 2, 1)), b"\xc0\x00\x02\x01".to_vec()),
        (28, RData::AAAA(Ipv6Addr::LOCALHOST), vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]),
        (5, RData::CNAME("target.test".into()), b"\x06target\x04test\x00".to_vec()),
        (2, RData::NS("ns.test".into()), b"\x02ns\x04test\x00".to_vec()),
        (12, RData::PTR("ptr.test".into()), b"\x03ptr\x04test\x00".to_vec()),
        (15, RData::MX { preference: 10, exchange: "mx.test".into() }, b"\x00\x0a\x02mx\x04test\x00".to_vec()),
        (6, RData::SOA { mname: "ns.test".into(), rname: "hostmaster.test".into(), serial: 1, refresh: 2, retry: 3, expire: 4, minimum: 5 }, b"\x02ns\x04test\x00\x0ahostmaster\x04test\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05".to_vec()),
        (33, RData::SRV { priority: 1, weight: 2, port: 53, target: ".".into() }, b"\x00\x01\x00\x02\x00\x35\x00".to_vec()),
        (16, RData::TXT("é".into()), b"\x02\xc3\xa9".to_vec()),
    ];
    for (rtype, rdata, expected_data) in cases {
        let record = DnsRecord {
            name: ".".into(),
            rtype,
            rclass: 1,
            ttl: 300,
            rdata,
        };
        let bytes = record.to_bytes().unwrap();
        assert_eq!(&bytes[..1], &[0]);
        assert_eq!(&bytes[1..3], &rtype.to_be_bytes());
        assert_eq!(&bytes[3..9], &[0, 1, 0, 0, 1, 44]);
        assert_eq!(
            usize::from(u16::from_be_bytes(bytes[9..11].try_into().unwrap())),
            expected_data.len()
        );
        assert_eq!(&bytes[11..], &expected_data, "TYPE {rtype}");
    }
}

#[test]
fn test_txt_limits_count_bytes_and_empty_text_is_not_empty_rdata() {
    for text in [String::new(), "x".repeat(255), "é".repeat(127)] {
        let record = DnsRecord {
            name: ".".into(),
            rtype: 16,
            rclass: 1,
            ttl: 0,
            rdata: RData::TXT(text.clone()),
        };
        let bytes = record.to_bytes().unwrap();
        assert_eq!(usize::from(bytes[11]), text.len());
        assert_eq!(&bytes[12..], text.as_bytes());
    }
    for text in ["x".repeat(256), "é".repeat(128)] {
        let record = DnsRecord {
            name: ".".into(),
            rtype: 16,
            rclass: 1,
            ttl: 0,
            rdata: RData::TXT(text),
        };
        assert!(matches!(
            record.to_bytes(),
            Err(EncodeError::LengthExceeded {
                field: "TXT string",
                length: 256,
                max: 255
            })
        ));
    }
}

#[test]
fn test_checks_names_inside_every_domain_rdata_variant() {
    let bad = "bad..test".to_string();
    let cases = [
        (2, RData::NS(bad.clone())),
        (5, RData::CNAME(bad.clone())),
        (12, RData::PTR(bad.clone())),
        (
            15,
            RData::MX {
                preference: 1,
                exchange: bad.clone(),
            },
        ),
        (
            33,
            RData::SRV {
                priority: 1,
                weight: 2,
                port: 3,
                target: bad.clone(),
            },
        ),
        (
            6,
            RData::SOA {
                mname: bad.clone(),
                rname: "valid.test".into(),
                serial: 0,
                refresh: 0,
                retry: 0,
                expire: 0,
                minimum: 0,
            },
        ),
        (
            6,
            RData::SOA {
                mname: "valid.test".into(),
                rname: bad,
                serial: 0,
                refresh: 0,
                retry: 0,
                expire: 0,
                minimum: 0,
            },
        ),
    ];
    for (rtype, rdata) in cases {
        let record = DnsRecord {
            name: ".".into(),
            rtype,
            rclass: 1,
            ttl: 0,
            rdata,
        };
        assert!(matches!(
            record.to_bytes(),
            Err(EncodeError::InvalidDomainName(_))
        ));
    }
}

#[test]
fn test_count_and_message_length_boundaries_do_not_wrap() {
    assert_eq!(checked_count("count", 65535).unwrap(), 65535);
    assert!(matches!(
        checked_count("count", 65536),
        Err(EncodeError::LengthExceeded {
            length: 65536,
            max: 65535,
            ..
        })
    ));
    let mut bytes = vec![0; 65534];
    append_message(&mut bytes, &[1]).unwrap();
    assert!(append_message(&mut bytes, &[2]).is_err());
    assert_eq!(bytes.len(), 65535);
    assert_eq!(bytes[65534], 1);
}