netbox-plugin-dns 0.21.4__py3-none-any.whl → 1.4.7__py3-none-any.whl

netbox_dns/validators/dnssec.py

@@ -0,0 +1,148 @@
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
+
+from netbox_dns.choices import (
+    DNSSECKeyTemplateTypeChoices,
+    DNSSECKeyTemplateAlgorithmChoices,
+    DNSSECKeyTemplateKeySizeChoices,
+)
+
+__all__ = (
+    "validate_key_template",
+    "validate_key_template_assignment",
+    "validate_key_template_lifetime",
+)
+
+
+def validate_key_template(key_template):
+    if key_template.key_size is None:
+        return
+
+    if key_template.key_size not in DNSSECKeyTemplateKeySizeChoices.values():
+        raise ValidationError(
+            {
+                "key_size": _("{key_size} is not a supported key size.").format(
+                    key_size=key_template.key_size
+                )
+            }
+        )
+
+    if key_template.algorithm != DNSSECKeyTemplateAlgorithmChoices.RSASHA256:
+        raise ValidationError(
+            {
+                "key_size": _(
+                    "Specifying the key size is not supported for algorithm {algorithm}."
+                ).format(algorithm=key_template.algorithm)
+            }
+        )
+
+
+def validate_key_template_assignment(key_templates):
+    if key_templates is None:
+        return
+
+    csk = key_templates.filter(type=DNSSECKeyTemplateTypeChoices.TYPE_CSK)
+    ksk = key_templates.filter(type=DNSSECKeyTemplateTypeChoices.TYPE_KSK)
+    zsk = key_templates.filter(type=DNSSECKeyTemplateTypeChoices.TYPE_ZSK)
+
+    if csk and (ksk or zsk):
+        raise ValidationError(
+            {
+                "key_templates": _(
+                    "Specifying a CSK together with any other key template type is not allowed."
+                )
+            }
+        )
+
+    if any(
+        (
+            csk.count() > 1,
+            ksk.count() > 1,
+            zsk.count() > 1,
+        )
+    ):
+        raise ValidationError(
+            {
+                "key_templates": _(
+                    "At most one key template per type (CSK, KSK and ZSK) is allowed."
+                )
+            }
+        )
+
+    if (ksk and zsk) and (ksk.first().algorithm != zsk.first().algorithm):
+        raise ValidationError(
+            {"key_templates": _("KSK and ZSK must use the same algorithm.")}
+        )
+
+
+def validate_key_template_lifetime(key_template, policy, raise_exception=True):
+    key_lifetime = key_template.lifetime
+
+    if not key_lifetime:
+        return
+
+    dnskey_ttl = policy.get_effective_value("dnskey_ttl")
+    publish_safety = policy.get_effective_value("publish_safety")
+    zone_propagation_delay = policy.get_effective_value("zone_propagation_delay")
+    max_zone_ttl = policy.get_effective_value("max_zone_ttl")
+    retire_safety = policy.get_effective_value("retire_safety")
+
+    validation_errors = []
+
+    if (
+        dnskey_ttl is not None
+        and publish_safety is not None
+        and zone_propagation_delay is not None
+        and key_lifetime < (dnskey_ttl + publish_safety + zone_propagation_delay)
+    ):
+        validation_errors.append(
+            _(
+                "Key Lifetime {lifetime} is less than DNSKEY TTL + Publish Safety + Zone Propagation Delay."
+            ).format(lifetime=key_lifetime)
+        )
+
+    if (
+        max_zone_ttl is not None
+        and retire_safety is not None
+        and zone_propagation_delay is not None
+        and key_lifetime < (max_zone_ttl + retire_safety + zone_propagation_delay)
+    ):
+        validation_errors.append(
+            _(
+                "Key Lifetime {lifetime} is less than Max Zone TTL + Retire Safety + Zone Propagation Delay."
+            ).format(lifetime=key_lifetime)
+        )
+
+    if key_template.type == DNSSECKeyTemplateTypeChoices.TYPE_ZSK:
+        signatures_validity = policy.get_effective_value("signatures_validity")
+        signatures_refresh = policy.get_effective_value("signatures_refresh")
+
+        if (
+            signatures_validity is not None
+            and signatures_validity is not None
+            and key_lifetime < signatures_validity - signatures_refresh
+        ):
+            validation_errors.append(
+                _(
+                    "Key Lifetime {lifetime} is less than Signatures Validity - Signatures Refresh."
+                )
+            ).format(lifetime=key_lifetime)
+    else:
+        parent_ds_ttl = policy.get_effective_value("parent_ds_ttl")
+        parent_propagation_delay = policy.get_effective_value(
+            "parent_propagation_delay"
+        )
+
+        if (
+            parent_ds_ttl is not None
+            and retire_safety is not None
+            and parent_propagation_delay is not None
+            and parent_ds_ttl < retire_safety + parent_propagation_delay
+        ):
+            validation_errors.append(
+                _(
+                    "Key Lifetime {lifetime} is less than Parent DS TTL + Retire Safety + Parent Propagation Delay."
+                ).format(lifetime=key_lifetime)
+            )
+
+    return validation_errors

netbox_dns/validators/rfc2317.py

@@ -0,0 +1,28 @@
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext as _
+
+
+__all__ = (
+    "validate_prefix",
+    "validate_ipv4",
+    "validate_rfc2317",
+)
+
+
+def validate_prefix(prefix):
+    if prefix.ip != prefix.cidr.ip:
+        raise ValidationError(
+            _("{prefix} is not a valid prefix. Did you mean {cidr}?").format(
+                prefix=prefix, cidr=prefix.cidr
+            )
+        )
+
+
+def validate_ipv4(prefix):
+    if prefix.version != 4:
+        raise ValidationError(_("RFC2317 requires an IPv4 prefix."))
+
+
+def validate_rfc2317(prefix):
+    if prefix.prefixlen <= 24:
+        raise ValidationError(_("RFC2317 requires at least 25 bit prefix length."))

netbox_dns/views/__init__.py

@@ -2,5 +2,9 @@ from .view import *
 from .zone import *
 from .nameserver import *
 from .record import *
-from .contact import *
+from .registration_contact import *
 from .registrar import *
+from .zone_template import *
+from .record_template import *
+from .dnssec_key_template import *
+from .dnssec_policy import *

netbox_dns/views/dnssec_key_template.py

@@ -0,0 +1,78 @@
+from netbox.views import generic
+from utilities.views import register_model_view
+
+from netbox_dns.filtersets import DNSSECKeyTemplateFilterSet
+from netbox_dns.forms import (
+    DNSSECKeyTemplateImportForm,
+    DNSSECKeyTemplateFilterForm,
+    DNSSECKeyTemplateForm,
+    DNSSECKeyTemplateBulkEditForm,
+)
+from netbox_dns.models import DNSSECKeyTemplate
+from netbox_dns.tables import DNSSECKeyTemplateTable, DNSSECPolicyDisplayTable
+
+
+__all__ = (
+    "DNSSECKeyTemplateView",
+    "DNSSECKeyTemplateListView",
+    "DNSSECKeyTemplateEditView",
+    "DNSSECKeyTemplateDeleteView",
+    "DNSSECKeyTemplateBulkEditView",
+    "DNSSECKeyTemplateBulkImportView",
+    "DNSSECKeyTemplateBulkDeleteView",
+)
+
+
+@register_model_view(DNSSECKeyTemplate, "list", path="", detail=False)
+class DNSSECKeyTemplateListView(generic.ObjectListView):
+    queryset = DNSSECKeyTemplate.objects.all()
+    filterset = DNSSECKeyTemplateFilterSet
+    filterset_form = DNSSECKeyTemplateFilterForm
+    table = DNSSECKeyTemplateTable
+
+
+@register_model_view(DNSSECKeyTemplate)
+class DNSSECKeyTemplateView(generic.ObjectView):
+    queryset = DNSSECKeyTemplate.objects.prefetch_related("policies")
+
+    def get_extra_context(self, request, instance):
+        if instance.policies.exists():
+            policy_table = DNSSECPolicyDisplayTable(data=instance.policies.all())
+            policy_table.configure(request)
+            return {"policy_table": policy_table}
+
+        return {}
+
+
+@register_model_view(DNSSECKeyTemplate, "add", detail=False)
+@register_model_view(DNSSECKeyTemplate, "edit")
+class DNSSECKeyTemplateEditView(generic.ObjectEditView):
+    queryset = DNSSECKeyTemplate.objects.all()
+    form = DNSSECKeyTemplateForm
+
+
+@register_model_view(DNSSECKeyTemplate, "delete")
+class DNSSECKeyTemplateDeleteView(generic.ObjectDeleteView):
+    queryset = DNSSECKeyTemplate.objects.all()
+
+
+@register_model_view(DNSSECKeyTemplate, "bulk_import", detail=False)
+class DNSSECKeyTemplateBulkImportView(generic.BulkImportView):
+    queryset = DNSSECKeyTemplate.objects.all()
+    model_form = DNSSECKeyTemplateImportForm
+    table = DNSSECKeyTemplateTable
+
+
+@register_model_view(DNSSECKeyTemplate, "bulk_edit", path="edit", detail=False)
+class DNSSECKeyTemplateBulkEditView(generic.BulkEditView):
+    queryset = DNSSECKeyTemplate.objects.all()
+    filterset = DNSSECKeyTemplateFilterSet
+    table = DNSSECKeyTemplateTable
+    form = DNSSECKeyTemplateBulkEditForm
+
+
+@register_model_view(DNSSECKeyTemplate, "bulk_delete", path="delete", detail=False)
+class DNSSECKeyTemplateBulkDeleteView(generic.BulkDeleteView):
+    queryset = DNSSECKeyTemplate.objects.all()
+    filterset = DNSSECKeyTemplateFilterSet
+    table = DNSSECKeyTemplateTable

netbox_dns/views/dnssec_policy.py

@@ -0,0 +1,146 @@
+from django.utils.translation import gettext_lazy as _
+
+from netbox.views import generic
+from utilities.views import ViewTab, register_model_view
+
+from netbox_dns.filtersets import (
+    DNSSECPolicyFilterSet,
+    ZoneFilterSet,
+    ZoneTemplateFilterSet,
+)
+from netbox_dns.forms import (
+    DNSSECPolicyImportForm,
+    DNSSECPolicyFilterForm,
+    DNSSECPolicyForm,
+    DNSSECPolicyBulkEditForm,
+)
+from netbox_dns.models import DNSSECPolicy, Zone, ZoneTemplate
+from netbox_dns.tables import (
+    DNSSECPolicyTable,
+    ZoneDisplayTable,
+    ZoneTemplateDisplayTable,
+)
+from netbox_dns.validators import validate_key_template_lifetime
+from netbox_dns.choices import DNSSECKeyTemplateTypeChoices
+
+
+__all__ = (
+    "DNSSECPolicyView",
+    "DNSSECPolicyListView",
+    "DNSSECPolicyEditView",
+    "DNSSECPolicyDeleteView",
+    "DNSSECPolicyBulkEditView",
+    "DNSSECPolicyBulkImportView",
+    "DNSSECPolicyBulkDeleteView",
+)
+
+
+@register_model_view(DNSSECPolicy, "list", path="", detail=False)
+class DNSSECPolicyListView(generic.ObjectListView):
+    queryset = DNSSECPolicy.objects.all()
+    filterset = DNSSECPolicyFilterSet
+    filterset_form = DNSSECPolicyFilterForm
+    table = DNSSECPolicyTable
+
+
+@register_model_view(DNSSECPolicy)
+class DNSSECPolicyView(generic.ObjectView):
+    queryset = DNSSECPolicy.objects.prefetch_related(
+        "key_templates", "zones", "zone_templates"
+    )
+
+    def get_extra_context(self, request, instance):
+        context = {}
+
+        key_errors = {
+            key_template.pk: validate_key_template_lifetime(key_template, instance)
+            for key_template in instance.key_templates.all()
+        }
+
+        context["key_template_errors"] = key_errors
+
+        if not instance.key_templates.filter(
+            type__in=(
+                DNSSECKeyTemplateTypeChoices.TYPE_ZSK,
+                DNSSECKeyTemplateTypeChoices.TYPE_CSK,
+            )
+        ).exists():
+            context["policy_warning"] = _(
+                "No key for signing zones (CSK or ZSK) is assigned."
+            )
+
+        return context
+
+
+@register_model_view(DNSSECPolicy, "add", detail=False)
+@register_model_view(DNSSECPolicy, "edit")
+class DNSSECPolicyEditView(generic.ObjectEditView):
+    queryset = DNSSECPolicy.objects.all()
+    form = DNSSECPolicyForm
+
+
+@register_model_view(DNSSECPolicy, "delete")
+class DNSSECPolicyDeleteView(generic.ObjectDeleteView):
+    queryset = DNSSECPolicy.objects.all()
+
+
+@register_model_view(DNSSECPolicy, "bulk_import", detail=False)
+class DNSSECPolicyBulkImportView(generic.BulkImportView):
+    queryset = DNSSECPolicy.objects.all()
+    model_form = DNSSECPolicyImportForm
+    table = DNSSECPolicyTable
+
+
+@register_model_view(DNSSECPolicy, "bulk_edit", path="edit", detail=False)
+class DNSSECPolicyBulkEditView(generic.BulkEditView):
+    queryset = DNSSECPolicy.objects.all()
+    filterset = DNSSECPolicyFilterSet
+    table = DNSSECPolicyTable
+    form = DNSSECPolicyBulkEditForm
+
+
+@register_model_view(DNSSECPolicy, "bulk_delete", path="delete", detail=False)
+class DNSSECPolicyBulkDeleteView(generic.BulkDeleteView):
+    queryset = DNSSECPolicy.objects.all()
+    filterset = DNSSECPolicyFilterSet
+    table = DNSSECPolicyTable
+
+
+@register_model_view(DNSSECPolicy, "zones")
+class DNSSECPolicyZoneListView(generic.ObjectChildrenView):
+    queryset = DNSSECPolicy.objects.all()
+    child_model = Zone
+    table = ZoneDisplayTable
+    filterset = ZoneFilterSet
+    template_name = "netbox_dns/zone/child.html"
+    hide_if_empty = True
+
+    tab = ViewTab(
+        label=_("Zones"),
+        permission="netbox_dns.view_zones",
+        badge=lambda obj: obj.zones.count(),
+        hide_if_empty=True,
+    )
+
+    def get_children(self, request, parent):
+        return parent.zones.restrict(request.user, "view")
+
+
+@register_model_view(DNSSECPolicy, "zonetemplates")
+class DNSSECPolicyZoneTemplateListView(generic.ObjectChildrenView):
+    queryset = DNSSECPolicy.objects.all()
+    child_model = ZoneTemplate
+    table = ZoneTemplateDisplayTable
+    filterset = ZoneTemplateFilterSet
+    template_name = "netbox_dns/zonetemplate/child.html"
+    hide_if_empty = True
+
+    tab = ViewTab(
+        label=_("Zone Templates"),
+        permission="netbox_dns.view_zonetemplates",
+        badge=lambda obj: obj.zone_templates.count(),
+        hide_if_empty=True,
+    )
+
+    def get_children(self, request, parent):
+        return parent.zone_templates.restrict(request.user, "view")

netbox_dns/views/nameserver.py

@@ -1,9 +1,11 @@
 from dns import name as dns_name
 
+from django.utils.translation import gettext_lazy as _
+
 from netbox.views import generic
 from utilities.views import ViewTab, register_model_view
 
-from netbox_dns.filters import NameServerFilter, ZoneFilter
+from netbox_dns.filtersets import NameServerFilterSet, ZoneFilterSet
 from netbox_dns.forms import (
     NameServerImportForm,
     NameServerFilterForm,
@@ -14,15 +16,28 @@ from netbox_dns.models import Zone, NameServer
 from netbox_dns.tables import NameServerTable, ZoneTable
 
 
+__all__ = (
+    "NameServerView",
+    "NameServerListView",
+    "NameServerEditView",
+    "NameServerDeleteView",
+    "NameServerBulkEditView",
+    "NameServerBulkImportView",
+    "NameServerBulkDeleteView",
+)
+
+
+@register_model_view(NameServer, "list", path="", detail=False)
 class NameServerListView(generic.ObjectListView):
     queryset = NameServer.objects.all()
-    filterset = NameServerFilter
+    filterset = NameServerFilterSet
     filterset_form = NameServerFilterForm
     table = NameServerTable
 
 
+@register_model_view(NameServer)
 class NameServerView(generic.ObjectView):
-    queryset = NameServer.objects.all().prefetch_related("zones")
+    queryset = NameServer.objects.prefetch_related("zones")
 
     def get_extra_context(self, request, instance):
         name = dns_name.from_text(instance.name)
@@ -34,47 +49,51 @@ class NameServerView(generic.ObjectView):
         return {}
 
 
+@register_model_view(NameServer, "add", detail=False)
+@register_model_view(NameServer, "edit")
 class NameServerEditView(generic.ObjectEditView):
     queryset = NameServer.objects.all()
     form = NameServerForm
-    default_return_url = "plugins:netbox_dns:nameserver_list"
 
 
+@register_model_view(NameServer, "delete")
 class NameServerDeleteView(generic.ObjectDeleteView):
     queryset = NameServer.objects.all()
-    default_return_url = "plugins:netbox_dns:nameserver_list"
 
 
+@register_model_view(NameServer, "bulk_import", detail=False)
 class NameServerBulkImportView(generic.BulkImportView):
     queryset = NameServer.objects.all()
     model_form = NameServerImportForm
     table = NameServerTable
-    default_return_url = "plugins:netbox_dns:nameserver_list"
 
 
+@register_model_view(NameServer, "bulk_edit", path="edit", detail=False)
 class NameServerBulkEditView(generic.BulkEditView):
     queryset = NameServer.objects.all()
-    filterset = NameServerFilter
+    filterset = NameServerFilterSet
     table = NameServerTable
     form = NameServerBulkEditForm
 
 
+@register_model_view(NameServer, "bulk_delete", path="delete", detail=False)
 class NameServerBulkDeleteView(generic.BulkDeleteView):
     queryset = NameServer.objects.all()
+    filterset = NameServerFilterSet
     table = NameServerTable
 
 
 @register_model_view(NameServer, "zones")
 class NameServerZoneListView(generic.ObjectChildrenView):
-    queryset = NameServer.objects.all().prefetch_related("zones")
+    queryset = NameServer.objects.prefetch_related("zones")
     child_model = Zone
     table = ZoneTable
-    filterset = ZoneFilter
+    filterset = ZoneFilterSet
     template_name = "netbox_dns/zone/child.html"
     hide_if_empty = True
 
     tab = ViewTab(
-        label="Zones",
+        label=_("Zones"),
         permission="netbox_dns.view_zone",
         badge=lambda obj: obj.zones.count(),
         hide_if_empty=True,
@@ -86,19 +105,19 @@ class NameServerZoneListView(generic.ObjectChildrenView):
 
 @register_model_view(NameServer, "soa_zones")
 class NameServerSOAZoneListView(generic.ObjectChildrenView):
-    queryset = NameServer.objects.all().prefetch_related("zones_soa")
+    queryset = NameServer.objects.prefetch_related("soa_zones")
     child_model = Zone
     table = ZoneTable
-    filterset = ZoneFilter
+    filterset = ZoneFilterSet
     template_name = "netbox_dns/zone/child.html"
     hide_if_empty = True
 
     tab = ViewTab(
-        label="SOA Zones",
+        label=_("SOA Zones"),
         permission="netbox_dns.view_zone",
-        badge=lambda obj: obj.zones_soa.count(),
+        badge=lambda obj: obj.soa_zones.count(),
         hide_if_empty=True,
     )
 
     def get_children(self, request, parent):
-        return parent.zones_soa
+        return parent.soa_zones