Initial upload

bind.py

@@ -0,0 +1,7 @@
+import os
+from zone import Zone
+
+
+class Bind(Zone):
+    def __init__(self, entries):
+        super().__init__(entries, 'bind')

entry.py

@@ -0,0 +1,9 @@
+class entry:
+    def __init__(self, domain, type='A', content='127.0.0.1'):
+        self.domain = domain
+        self.type = type
+        self.content = content
+        self.subdomains = list()
+
+    def add_subdomain(self, entry):
+        self.subdomains.append(entry)

generatedns

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+python main.py "$@"

knot.py

@@ -0,0 +1,18 @@
+from zone import Zone
+
+
+class Knot(Zone):
+    def __init__(self, entries):
+        super().__init__(entries, 'knot')
+
+    def named(self, dnssec):
+        with open('{0}/named.conf'.format(self.program), 'w') as f:
+            f.write('zone:\n')
+            for entry in self.entries:
+                f.write('- domain: \"{z.domain}\"\n'.format(z=entry))
+                if dnssec:
+                    f.write('  file: \"/etc/{0}/zones/{z.domain}.signed\"\n'.format(self.program, z=entry))
+                    f.write('  dnssec-signing: on\n')
+                else:
+                    f.write('  file: \"/etc/{0}/zones/{z.domain}\"\n'.format(self.program, z=entry))
+                f.write('\n')

main.py

@@ -0,0 +1,80 @@
+import argparse
+import string
+import itertools
+from entry import entry
+from namebench import namebench
+from bind import Bind
+from pdns import Pdns
+from nsd import Nsd
+from knot import Knot
+from yadifa import Yadifa
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Generate fake DNS zonefiles and corresponding namebench file')
+    parser.add_argument('--subdomains', type=bool, default=True, help='Generate subdomains too')
+    parser.add_argument('--postfix', type=str, default='.test', help='Domain postfix eg .test or .com')
+    parser.add_argument('--no-namebench', type=bool, default=False, help='Skip generation of namebench file')
+    parser.add_argument('--no-zonefile', type=bool, default=False, help='Skip generation of zonefiles')
+    parser.add_argument('--dnssec', type=bool, default=False, help='Prepare generation for DNSSEC')
+    parser.add_argument('program', metavar='P', type=str, help='Program to generate (BIND, PDNS, NSD, KNOT, YADIFA, *ALL*)')
+    parser.add_argument('domains', metavar='N', type=int, help='Number of domains to generate')
+
+    args = parser.parse_args()
+
+    if args.dnssec is not False:
+        args.dnssec = True
+    else:
+        args.dnssec = False
+
+    print(args)
+
+    chars = list(string.ascii_lowercase)
+
+    names = list(itertools.product(chars, repeat=4))
+
+    entries = list()
+
+    for i in range(0, args.domains):
+        domain = ''.join(names[i]) + args.postfix
+        record = entry(domain)
+
+        if(args.subdomains):
+            record.add_subdomain(entry('www', 'A', '127.0.0.1'))
+            record.add_subdomain(entry('sub', 'A', '127.0.0.2'))
+
+        entries.append(record)
+
+    print('Generated {0} DNS domains'.format(len(entries)))
+
+    if not args.no_namebench:
+        print('Creating namebench file \'namebench.txt\'')
+        nb = namebench()
+        for record in entries:
+            nb.generate_to_buffer(record)
+        nb.write_buffer()
+
+    if not args.no_zonefile:
+        programs = {
+            'BIND': Bind(entries),
+            'PDNS': Pdns(entries),
+            'NSD': Nsd(entries),
+            'KNOT': Knot(entries),
+            'YADIFA': Yadifa(entries),
+        }
+
+        if args.program == 'ALL':
+            for i in programs:
+                print('Creating zones for {0}'.format(i))
+                programs[i].named(args.dnssec)
+                programs[i].zones()
+        else:
+            p = programs.get(args.program, 'UNKNOWN')
+
+            if p != 'UNKNOWN':
+                p.named(args.dnssec)
+                p.zones()
+            else:
+                print('Unknown program {0}'.format(args.program))
+
+    print('Done')

namebench.py

@@ -0,0 +1,14 @@
+from entry import entry
+
+class namebench:
+
+    def __init__(self):
+        self.buffer = list()
+
+    def generate_to_buffer(self, domain):
+        self.buffer.append('{0} {1}'.format(domain.type, domain.domain))
+
+    def write_buffer(self):
+        with open('namebench.txt', 'w') as f:
+            for line in self.buffer:
+                f.write('{0}\n'.format(line))

nsd.py

@@ -0,0 +1,17 @@
+from zone import Zone
+
+
+class Nsd(Zone):
+    def __init__(self, entries):
+        super().__init__(entries, 'nsd')
+
+    def named(self, dnssec):
+        with open('{0}/named.conf'.format(self.program), 'w') as f:
+            for entry in self.entries:
+                f.write('zone:\n'.format(z=entry))
+                f.write('\tname: \"{z.domain}\"\n'.format(z=entry))
+                if dnssec:
+                    f.write('\tzonefile: \"/etc/{0}/zones/{z.domain}.signed\"\n'.format(self.program, z=entry))
+                else:
+                    f.write('\tzonefile: \"/etc/{0}/zones/{z.domain}\"\n'.format(self.program, z=entry))
+                f.write('\n')

pdns.py

@@ -0,0 +1,6 @@
+from zone import Zone
+
+
+class Pdns(Zone):
+    def __init__(self, entries):
+        super().__init__(entries, 'powerdns')

yadifa.py

@@ -0,0 +1,18 @@
+from zone import Zone
+
+
+class Yadifa(Zone):
+    def __init__(self, entries):
+        super().__init__(entries, 'yadifa')
+
+    def named(self, dnssec):
+        with open('{0}/named.conf'.format(self.program), 'w') as f:
+            for entry in self.entries:
+                f.write('<zone>\n')
+                f.write('\ttype\tmaster\n')
+                f.write('\tdomain\t{z.domain}\n'.format(z=entry))
+                if dnssec:
+                    f.write('\tfile\tzones/{z.domain}.signed\n'.format(z=entry))
+                else:
+                    f.write('\tfile\tzones/{z.domain}\n'.format(z=entry))
+                f.write('</zone>\n\n')

zone.py

@@ -0,0 +1,40 @@
+import os
+
+class Zone:
+    def __init__(self, entries, program):
+        self.entries = entries
+        self.program = program
+
+        if not os.path.exists('{0}/zones'.format(self.program)):
+            os.makedirs('{0}/zones'.format(self.program))
+
+    def zones(self):
+        for entry in self.entries:
+            with open('{0}/zones/{z.domain}'.format(self.program, z=entry), 'w') as f:
+                f.write('$ORIGIN {z.domain}.\n'.format(z=entry))
+                f.write('$TTL 86400\n')
+                f.write('@\t\tIN\t\tSOA\t\tdns.master.test.\t\thost.master.test. (\n')
+                f.write('\t\t\t\t\t\t20200327\n')
+                f.write('\t\t\t\t\t\t21600\n')
+                f.write('\t\t\t\t\t\t3600\n')
+                f.write('\t\t\t\t\t\t604800\n')
+                f.write('\t\t\t\t\t\t86400 )\n')
+                f.write('\n')
+                f.write('\t\tIN\t\tNS\t\tdns.master.test.\n')
+
+                f.write('\t\tIN\t\tA\t\t{z.content}\n'.format(z=entry))
+                for record in entry.subdomains:
+                    if record.type == 'A':
+                        f.write('{z.domain}\tIN\t\tA\t\t{z.content}\n'.format(z=record))
+
+    def named(self, dnssec):
+        with open('{0}/named.conf.local'.format(self.program), 'w') as f:
+            for entry in self.entries:
+                f.write('zone\t \"{z.domain}\"\t{{\n'.format(z=entry))
+                f.write('\t\ttype master;\n')
+                if dnssec:
+                    f.write('\t\tfile\t\"/etc/{0}/zones/{z.domain}.signed\";\n'.format(self.program, z=entry))
+                else:
+                    f.write('\t\tfile\t\"/etc/{0}/zones/{z.domain}\";\n'.format(self.program, z=entry))
+                f.write('};\n')
+                f.write('\n')