302 lines
7.2 KiB
Python
302 lines
7.2 KiB
Python
#! /bin/env python3
|
|
import argparse
|
|
import collections
|
|
import configparser
|
|
import logging
|
|
|
|
import dns.name
|
|
import dns.rdataset
|
|
import dns.rdatatype
|
|
from dns.rdtypes.ANY import CNAME, DNAME, MX, NS, SOA, SSHFP, TXT
|
|
from dns.rdtypes.IN import AAAA, SRV, A
|
|
|
|
# dns name object '@'
|
|
AT = dns.name.Name(())
|
|
|
|
def format_rname(mail: str):
|
|
"""
|
|
Format a email given by re2o API to a rname dnspython object.
|
|
|
|
Given an email address in the standard string format `mail@example.tld`
|
|
return an email address in the format required by RFC 1035
|
|
`mail.example.tld.`
|
|
|
|
Be careful when using this function. It is a very simple email parsing
|
|
function and does support the wide range of possible emails format. It also
|
|
does not check is email is valid and does not escape caracters.
|
|
|
|
Return a `dns.name.Name` object.
|
|
"""
|
|
|
|
local, domain = mail.split("@")
|
|
rname = dns.name.Name((local, *dns.name.from_text(domain)))
|
|
|
|
return rname
|
|
|
|
|
|
def format_mname(name: str):
|
|
"""
|
|
Format a zone name given by the re2o API to a mname dnspython object.
|
|
|
|
Given a a name of the format `.zone.domain.tld` output the
|
|
`zone.domain.tld.`, formatted accordingly to the RFC 1035.
|
|
|
|
Return a `dns.name.name` object.
|
|
"""
|
|
|
|
if name[0] == ".":
|
|
name = name[1:]
|
|
|
|
mname = dns.name.from_text(name)
|
|
|
|
return mname
|
|
|
|
|
|
def soa_handler(zone, records):
|
|
"""Handler for SOA record"""
|
|
|
|
soa = zone["soa"]
|
|
logging.debug(f"SOA = {soa}")
|
|
|
|
rd = dns.rdataset.Rdataset(dns.rdataclass.IN, dns.rdatatype.SOA)
|
|
|
|
soa_obj = SOA.SOA(
|
|
dns.rdataclass.IN,
|
|
dns.rdatatype.SOA,
|
|
format_mname(soa["name"]),
|
|
format_rname(soa["mail"]),
|
|
#soa["serial"],
|
|
0,
|
|
soa["refresh"],
|
|
soa["retry"],
|
|
soa["expire"],
|
|
soa["ttl"],
|
|
)
|
|
|
|
rd.add(soa_obj)
|
|
records[AT].rdatasets.append(rd)
|
|
|
|
|
|
def originv4_handler(zone, records):
|
|
"""Handler for the IPv4 origin"""
|
|
|
|
ipv4_addr = zone["originv4"]["ipv4"]
|
|
logging.debug(f"originv4 = {zone['originv4']}")
|
|
|
|
rd = dns.rdataset.Rdataset(dns.rdataclass.IN, dns.rdatatype.A)
|
|
|
|
originv4_obj = A.A(
|
|
dns.rdataclass.IN,
|
|
dns.rdatatype.A,
|
|
ipv4_addr
|
|
)
|
|
|
|
rd.add(originv4_obj)
|
|
records[AT].rdatasets.append(rd)
|
|
|
|
|
|
def originv6_handler(zone, records):
|
|
"""Handler for the IPv6 origin"""
|
|
|
|
ipv6_addr = zone["originv6"] # Yes, re2o is this weird and inconsistent
|
|
logging.debug(f"originv6 = {zone['originv6']}")
|
|
|
|
rd = dns.rdataset.Rdataset(dns.rdataclass.IN, dns.rdatatype.AAAA)
|
|
|
|
originv6_obj = AAAA.AAAA(
|
|
dns.rdataclass.IN,
|
|
dns.rdatatype.AAAA,
|
|
ipv6_addr
|
|
)
|
|
|
|
rd.add(originv6_obj)
|
|
records[AT].rdatasets.append(rd)
|
|
|
|
|
|
def ns_records_handler(zone, records):
|
|
"""Handler for the NS record"""
|
|
|
|
for record in zone["ns_records"]:
|
|
|
|
logging.debug(f"NS target = {record}")
|
|
|
|
target = record["target"]
|
|
target_obj = dns.name.from_text(target)
|
|
|
|
NS_obj = NS.NS(
|
|
dns.rdataclass.IN,
|
|
dns.rdatatype.NS,
|
|
target_obj
|
|
)
|
|
|
|
rd = dns.rdataset.Rdataset(dns.rdataclass.IN, dns.rdatatype.NS)
|
|
rd.add(NS_obj)
|
|
records[AT].rdatasets.append(rd)
|
|
|
|
|
|
def sshfp_record_handler(zone, records):
|
|
"""Handler for the SSHFP record"""
|
|
|
|
for record in zone["sshfp"]:
|
|
|
|
# DNS Name object for Hostname
|
|
hostname = record["hostname"]
|
|
key_name = dns.name.Name(hostname)
|
|
|
|
for fp in record["sshfp"]:
|
|
logging.debug(f"SSHFP = {fp}")
|
|
|
|
algorithm = fp["algo_id"]
|
|
|
|
for fp_type in fp["hash"]:
|
|
|
|
fingerprint = fp["hash"][fp_type]
|
|
|
|
records[key_name].rdatasets.append(
|
|
SSHFP.SSHFP(
|
|
dns.rdataclass.IN,
|
|
dns.rdatatype.SSHFP,
|
|
algorithm,
|
|
fp_type,
|
|
fingerprint,
|
|
)
|
|
)
|
|
|
|
|
|
def mx_records_handler(zone, records):
|
|
"""Handler for the MX record"""
|
|
|
|
# dns name object '@'
|
|
key_name = dns.name.Name(())
|
|
|
|
for record in zone["mx_records"]:
|
|
|
|
logging.debug(f"MX = {record}")
|
|
|
|
preference = record["priority"]
|
|
exchange = record["target"]
|
|
|
|
records[key_name].rdatasets.append(
|
|
MX.MX(
|
|
dns.rdataclass.IN,
|
|
dns.rdatatype.MX,
|
|
preference,
|
|
exchange
|
|
)
|
|
)
|
|
|
|
|
|
def txt_records_handler(zone, records):
|
|
"""Handler for TXT record"""
|
|
|
|
for record in zone["txt_records"]:
|
|
|
|
logging.debug(f"TXT = {record}")
|
|
|
|
# DNS Name object for field1
|
|
name = record["field1"]
|
|
key_name = dns.name.Name((name,))
|
|
|
|
records[key_name].rdatasets.append(
|
|
TXT.TXT(
|
|
dns.rdataclass.IN,
|
|
dns.rdatatype.TXT,
|
|
record["field2"]
|
|
)
|
|
)
|
|
|
|
|
|
def srv_records_handler(zone, records):
|
|
"""Handler for SRV record"""
|
|
|
|
for record in zone["srv_records"]:
|
|
|
|
logging.debug(f"SRV = {record}")
|
|
|
|
# DNS Name obj for SRV
|
|
key_name = dns.name.from_text(f"{record['service']}_{record['protocol']}")
|
|
|
|
records[key_name].rdatasets.append(
|
|
SRV.SRV(
|
|
dns.rdataclass.IN,
|
|
dns.rdatatype.SRV,
|
|
record["priority"],
|
|
record["weight"],
|
|
record["port"],
|
|
record["target"]
|
|
)
|
|
)
|
|
|
|
|
|
def a_records_handler(zone, records):
|
|
"""Handler for A Record"""
|
|
|
|
for record in zone["a_records"]:
|
|
|
|
logging.debug(f"A = {record}")
|
|
|
|
# DNS Name object for Hostname
|
|
hostname = record["hostname"]
|
|
key_name = dns.name.Name((hostname,))
|
|
|
|
ipv4_addr = record["ipv4"]
|
|
|
|
rd = dns.rdataset.Rdataset(dns.rdataclass.IN, dns.rdatatype.A)
|
|
|
|
A_obj = A.A(
|
|
dns.rdataclass.IN,
|
|
dns.rdatatype.A,
|
|
ipv4_addr
|
|
)
|
|
|
|
rd.add(A_obj)
|
|
records[key_name].rdatasets.append(rd)
|
|
|
|
|
|
def aaaa_records_handler(zone, records):
|
|
"""Handler for AAAA Record"""
|
|
|
|
for record in zone["aaaa_records"]:
|
|
|
|
logging.debug(f"AAAA = {record}")
|
|
|
|
if record["ipv6"] == []:
|
|
logging.debug("AAAA record does not have an IPv6. Skipping.")
|
|
return
|
|
|
|
ipv6_addr = record["ipv6"][0]["ipv6"] # thanks re2o
|
|
|
|
AAAA_obj = AAAA.AAAA(
|
|
dns.rdataclass.IN,
|
|
dns.rdatatype.AAAA,
|
|
ipv6_addr
|
|
)
|
|
|
|
# DNS Name object for Hostname
|
|
hostname = record["hostname"]
|
|
key_name = dns.name.Name((hostname,))
|
|
|
|
rd = dns.rdataset.Rdataset(dns.rdataclass.IN, dns.rdatatype.AAAA)
|
|
rd.add(AAAA_obj)
|
|
records[key_name].rdatasets.append(rd)
|
|
|
|
|
|
def pass_handler(zone, records):
|
|
pass
|
|
|
|
|
|
HANDLERS = {
|
|
"soa": soa_handler,
|
|
"originv4": originv4_handler,
|
|
"originv6": originv6_handler,
|
|
"ns_records": ns_records_handler,
|
|
"sshfp": sshfp_record_handler,
|
|
"mx_records": mx_records_handler,
|
|
"txt_records": txt_records_handler,
|
|
"srv_records": srv_records_handler,
|
|
"a_records": a_records_handler,
|
|
"aaaa_records": aaaa_records_handler,
|
|
"name": pass_handler,
|
|
"cname_records": pass_handler,
|
|
"dname_records": pass_handler,
|
|
}
|