netbox-plugin-dns 1.2.5__py3-none-any.whl → 1.2.7b2__py3-none-any.whl

netbox_dns/__init__.py

@@ -7,7 +7,7 @@ from ipam.choices import IPAddressStatusChoices
 
 from netbox_dns.choices import RecordTypeChoices, RecordStatusChoices, ZoneStatusChoices
 
-__version__ = "1.2.5"
+__version__ = "1.2.7-beta2"
 
 
 def _check_list(setting):
@@ -65,12 +65,26 @@ class DNSConfig(PluginConfig):
         "menu_name": "DNS",
         "top_level_menu": True,
         "convert_names_to_lowercase": False,
+        "dnssec_purge_keys": 7776000,  # P90D
+        "dnssec_publish_safety": 3600,  # PT1H
+        "dnssec_retire_safety": 3600,  # PT1H
+        "dnssec_signatures_jitter": 43200,  # PT12H
+        "dnssec_signatures_refresh": 432000,  # P5D
+        "dnssec_signatures_validity": 1209600,  # P14D
+        "dnssec_signatures_validity_dnskey": 1209600,  # P14D
+        "dnssec_max_zone_ttl": 86400,  # P1D
+        "dnssec_zone_propagation_delay": 300,  # PT5M
+        "dnssec_parent_ds_ttl": 86400,  # P1D
+        "dnssec_parent_propagation_delay": 3600,  # PT1H
+        "dnssec_dnskey_ttl": 3600,  # PT1H
     }
     base_url = "netbox-dns"
 
     def ready(self):
         super().ready()
 
+        import netbox_dns.signals.dnssec  # noqa: F401
+
         if not get_plugin_config("netbox_dns", "dnssync_disabled"):
             import netbox_dns.signals.ipam_dnssync  # noqa: F401
             import netbox_dns.tables.ipam_dnssync  # noqa: F401

netbox_dns/api/serializers.py

@@ -6,6 +6,9 @@ from .serializers_.view import *
 from .serializers_.zone import *
 from .serializers_.zone_template import *
 from .serializers_.record_template import *
+from .serializers_.dnssec_key_template import *
+from .serializers_.dnssec_policy import *
+
 from .serializers_.prefix import *
 
 from .nested_serializers import *

netbox_dns/api/serializers_/dnssec_key_template.py

@@ -0,0 +1,46 @@
+from rest_framework import serializers
+
+from netbox.api.serializers import NetBoxModelSerializer
+from tenancy.api.serializers_.tenants import TenantSerializer
+
+from netbox_dns.models import DNSSECKeyTemplate
+
+
+__all__ = ("DNSSECKeyTemplateSerializer",)
+
+
+class DNSSECKeyTemplateSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_dns-api:dnsseckeytemplate-detail"
+    )
+    tenant = TenantSerializer(required=False, allow_null=True)
+
+    class Meta:
+        model = DNSSECKeyTemplate
+        fields = (
+            "id",
+            "url",
+            "display",
+            "name",
+            "description",
+            "tags",
+            "type",
+            "lifetime",
+            "algorithm",
+            "key_size",
+            "created",
+            "last_updated",
+            "custom_fields",
+            "tenant",
+        )
+        brief_fields = (
+            "id",
+            "url",
+            "display",
+            "name",
+            "type",
+            "lifetime",
+            "algorithm",
+            "key_size",
+            "description",
+        )

netbox_dns/api/serializers_/dnssec_policy.py

@@ -0,0 +1,83 @@
+from django.utils.translation import gettext as _
+from rest_framework import serializers
+
+from netbox.api.serializers import NetBoxModelSerializer
+from tenancy.api.serializers_.tenants import TenantSerializer
+
+from netbox_dns.models import DNSSECPolicy
+
+from .dnssec_key_template import DNSSECKeyTemplateSerializer
+
+
+__all__ = ("DNSSECPolicySerializer",)
+
+
+class DNSSECPolicySerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_dns-api:dnssecpolicy-detail"
+    )
+    key_templates = DNSSECKeyTemplateSerializer(
+        nested=True,
+        many=True,
+        read_only=False,
+        required=False,
+        default=None,
+        help_text=_("Key templates assigned to the policy"),
+    )
+    tenant = TenantSerializer(required=False, allow_null=True)
+
+    class Meta:
+        model = DNSSECPolicy
+        fields = (
+            "id",
+            "url",
+            "display",
+            "name",
+            "description",
+            "status",
+            "tags",
+            "key_templates",
+            "dnskey_ttl",
+            "purge_keys",
+            "publish_safety",
+            "retire_safety",
+            "signatures_jitter",
+            "signatures_refresh",
+            "signatures_validity",
+            "signatures_validity_dnskey",
+            "max_zone_ttl",
+            "zone_propagation_delay",
+            "create_cdnskey",
+            "cds_digest_types",
+            "parent_ds_ttl",
+            "parent_propagation_delay",
+            "use_nsec3",
+            "nsec3_iterations",
+            "nsec3_opt_out",
+            "nsec3_salt_size",
+            "created",
+            "last_updated",
+            "custom_fields",
+            "tenant",
+        )
+        brief_fields = ("id", "url", "display", "name", "description", "status")
+
+    def create(self, validated_data):
+        dnssec_key_templates = validated_data.pop("key_templates", None)
+
+        dnssec_policy = super().create(validated_data)
+
+        if dnssec_key_templates is not None:
+            dnssec_policy.key_templates.set(dnssec_key_templates)
+
+        return dnssec_policy
+
+    def update(self, instance, validated_data):
+        dnssec_key_templates = validated_data.pop("key_templates", None)
+
+        dnssec_policy = super().update(instance, validated_data)
+
+        if dnssec_key_templates is not None:
+            dnssec_policy.key_templates.set(dnssec_key_templates)
+
+        return dnssec_policy

netbox_dns/api/serializers_/zone.py

@@ -9,6 +9,7 @@ from .nameserver import NameServerSerializer
 from .registrar import RegistrarSerializer
 from .registration_contact import RegistrationContactSerializer
 from .zone_template import ZoneTemplateSerializer
+from .dnssec_policy import DNSSECPolicySerializer
 
 from ..nested_serializers import NestedZoneSerializer
 
@@ -62,6 +63,13 @@ class ZoneSerializer(NetBoxModelSerializer):
         required=False,
         help_text=_("RFC2317 child zones of the zone"),
     )
+    dnssec_policy = DNSSECPolicySerializer(
+        nested=True,
+        many=False,
+        read_only=False,
+        required=False,
+        help_text=_("DNSSEC policy to apply to the zone"),
+    )
     registrar = RegistrarSerializer(
         nested=True,
         many=False,
@@ -173,6 +181,8 @@ class ZoneSerializer(NetBoxModelSerializer):
             "rfc2317_parent_managed",
             "rfc2317_parent_zone",
             "rfc2317_child_zones",
+            "dnssec_policy",
+            "inline_signing",
             "registrar",
             "registry_domain_id",
             "registrant",

netbox_dns/api/serializers_/zone_template.py

@@ -10,6 +10,7 @@ from netbox_dns.api.nested_serializers import NestedRecordTemplateSerializer
 from .nameserver import NameServerSerializer
 from .registrar import RegistrarSerializer
 from .registration_contact import RegistrationContactSerializer
+from .dnssec_policy import DNSSECPolicySerializer
 
 
 __all__ = ("ZoneTemplateSerializer",)
@@ -39,6 +40,13 @@ class ZoneTemplateSerializer(NetBoxModelSerializer):
         required=False,
         help_text=_("Record templates assigned to the zone template"),
     )
+    dnssec_policy = DNSSECPolicySerializer(
+        nested=True,
+        many=False,
+        read_only=False,
+        required=False,
+        help_text=_("DNSSEC policy assigned to the zone template"),
+    )
     registrar = RegistrarSerializer(
         nested=True,
         many=False,
@@ -113,20 +121,21 @@ class ZoneTemplateSerializer(NetBoxModelSerializer):
             "id",
             "url",
             "name",
+            "description",
             "display",
             "nameservers",
             "soa_mname",
             "soa_rname",
-            "description",
-            "tags",
-            "created",
-            "last_updated",
+            "dnssec_policy",
             "registrar",
             "registrant",
             "tech_c",
             "admin_c",
             "billing_c",
             "active",
+            "tags",
+            "created",
+            "last_updated",
             "custom_fields",
             "tenant",
             "record_templates",

netbox_dns/api/urls.py

@@ -10,6 +10,8 @@ from netbox_dns.api.views import (
     RegistrationContactViewSet,
     ZoneTemplateViewSet,
     RecordTemplateViewSet,
+    DNSSECKeyTemplateViewSet,
+    DNSSECPolicyViewSet,
     PrefixViewSet,
 )
 
@@ -24,6 +26,8 @@ router.register("registrars", RegistrarViewSet)
 router.register("contacts", RegistrationContactViewSet)
 router.register("zonetemplates", ZoneTemplateViewSet)
 router.register("recordtemplates", RecordTemplateViewSet)
+router.register("dnsseckeytemplates", DNSSECKeyTemplateViewSet)
+router.register("dnssecpolicies", DNSSECPolicyViewSet)
 
 router.register("prefixes", PrefixViewSet)
 

netbox_dns/api/views.py

@@ -16,6 +16,8 @@ from netbox_dns.api.serializers import (
     RegistrationContactSerializer,
     ZoneTemplateSerializer,
     RecordTemplateSerializer,
+    DNSSECKeyTemplateSerializer,
+    DNSSECPolicySerializer,
     PrefixSerializer,
 )
 from netbox_dns.filtersets import (
@@ -27,6 +29,8 @@ from netbox_dns.filtersets import (
     RegistrationContactFilterSet,
     ZoneTemplateFilterSet,
     RecordTemplateFilterSet,
+    DNSSECKeyTemplateFilterSet,
+    DNSSECPolicyFilterSet,
 )
 from netbox_dns.models import (
     View,
@@ -37,6 +41,8 @@ from netbox_dns.models import (
     RegistrationContact,
     ZoneTemplate,
     RecordTemplate,
+    DNSSECKeyTemplate,
+    DNSSECPolicy,
 )
 
 
@@ -135,6 +141,18 @@ class RecordTemplateViewSet(NetBoxModelViewSet):
     filterset_class = RecordTemplateFilterSet
 
 
+class DNSSECKeyTemplateViewSet(NetBoxModelViewSet):
+    queryset = DNSSECKeyTemplate.objects.all()
+    serializer_class = DNSSECKeyTemplateSerializer
+    filterset_class = DNSSECKeyTemplateFilterSet
+
+
+class DNSSECPolicyViewSet(NetBoxModelViewSet):
+    queryset = DNSSECPolicy.objects.all()
+    serializer_class = DNSSECPolicySerializer
+    filterset_class = DNSSECPolicyFilterSet
+
+
 class PrefixViewSet(NetBoxModelViewSet):
     queryset = Prefix.objects.all()
     serializer_class = PrefixSerializer

netbox_dns/choices/__init__.py

@@ -1,2 +1,4 @@
 from .record import *
 from .zone import *
+from .dnssec_key_template import *
+from .dnssec_policy import *

netbox_dns/choices/dnssec_key_template.py

@@ -0,0 +1,63 @@
+from dns.dnssectypes import Algorithm
+
+from django.utils.translation import gettext_lazy as _
+
+from utilities.choices import ChoiceSet
+
+from .utilities import define_choice_attributes
+
+DEPRECATED_ALGORITHMS = (
+    Algorithm.RSAMD5,
+    Algorithm.DH,
+    Algorithm.DSA,
+    Algorithm.ECC,
+    Algorithm.RSASHA1,
+    Algorithm.DSANSEC3SHA1,
+    Algorithm.RSASHA1NSEC3SHA1,
+    Algorithm.RSASHA512,
+    Algorithm.ECCGOST,
+)
+
+
+__all__ = (
+    "DNSSECKeyTemplateTypeChoices",
+    "DNSSECKeyTemplateAlgorithmChoices",
+    "DNSSECKeyTemplateKeySizeChoices",
+)
+
+
+class DNSSECKeyTemplateTypeChoices(ChoiceSet):
+    TYPE_CSK = "CSK"
+    TYPE_KSK = "KSK"
+    TYPE_ZSK = "ZSK"
+
+    CHOICES = [
+        (TYPE_CSK, _("CSK"), "purple"),
+        (TYPE_KSK, _("KSK"), "blue"),
+        (TYPE_ZSK, _("ZSK"), "green"),
+    ]
+
+
+class DNSSECKeyTemplateKeySizeChoices(ChoiceSet):
+    SIZE_512 = 512
+    SIZE_1024 = 1024
+    SIZE_2048 = 2048
+    SIZE_3072 = 3072
+    SIZE_4096 = 4096
+
+    CHOICES = [
+        (SIZE_512, 512),
+        (SIZE_1024, 1024),
+        (SIZE_2048, 2048),
+        (SIZE_3072, 3072),
+        (SIZE_4096, 4096),
+    ]
+
+
+@define_choice_attributes()
+class DNSSECKeyTemplateAlgorithmChoices(ChoiceSet):
+    CHOICES = [
+        (algorithm.name, algorithm.name)
+        for algorithm in sorted(Algorithm, key=lambda a: a.name)
+        if algorithm.value < 252 and algorithm not in DEPRECATED_ALGORITHMS
+    ]

netbox_dns/choices/dnssec_policy.py

@@ -0,0 +1,40 @@
+from dns.dnssectypes import DSDigest
+
+from django.utils.translation import gettext_lazy as _
+
+from utilities.choices import ChoiceSet
+
+from .utilities import define_choice_attributes
+
+DEPRECATED_DIGESTS = (
+    DSDigest.NULL,
+    DSDigest.SHA1,
+    DSDigest.GOST,
+)
+
+
+__all__ = (
+    "DNSSECPolicyDigestChoices",
+    "DNSSECPolicyStatusChoices",
+)
+
+
+@define_choice_attributes()
+class DNSSECPolicyDigestChoices(ChoiceSet):
+    CHOICES = [
+        (digest.name, digest.name)
+        for digest in sorted(DSDigest, key=lambda a: a.name)
+        if digest not in DEPRECATED_DIGESTS
+    ]
+
+
+class DNSSECPolicyStatusChoices(ChoiceSet):
+    key = "DNSSECPolicy.status"
+
+    STATUS_ACTIVE = "active"
+    STATUS_INACTIVE = "inactive"
+
+    CHOICES = [
+        (STATUS_ACTIVE, _("Active"), "blue"),
+        (STATUS_INACTIVE, _("Inactive"), "red"),
+    ]

netbox_dns/choices/record.py

@@ -1,11 +1,11 @@
 from dns import rdatatype, rdataclass
 
 from django.utils.translation import gettext_lazy as _
-from django.core.exceptions import ImproperlyConfigured
 
-from netbox.plugins.utils import get_plugin_config
 from utilities.choices import ChoiceSet
 
+from .utilities import define_choice_attributes
+
 
 __all__ = (
     "RecordTypeChoices",
@@ -15,29 +15,6 @@ __all__ = (
 )
 
 
-def define_choice_attributes(filter_name=None):
-    try:
-        if filter_name is not None:
-            filter_choices = get_plugin_config("netbox_dns", filter_name, [])
-        else:
-            filter_choices = []
-    except ImproperlyConfigured:
-        filter_choices = []
-
-    def decorator(cls):
-        choices = []
-        for choice in cls._choices:
-            if choice[0] not in filter_choices:
-                setattr(cls, choice[0], choice[0])
-                choices.append(choice)
-        cls._choices = choices
-        cls.CHOICES = choices
-
-        return cls
-
-    return decorator
-
-
 @define_choice_attributes()
 class RecordTypeChoices(ChoiceSet):
     CHOICES = [

netbox_dns/choices/utilities.py

@@ -0,0 +1,26 @@
+from django.core.exceptions import ImproperlyConfigured
+
+from netbox.plugins.utils import get_plugin_config
+
+
+def define_choice_attributes(filter_name=None):
+    try:
+        if filter_name is not None:
+            filter_choices = get_plugin_config("netbox_dns", filter_name, [])
+        else:
+            filter_choices = []
+    except ImproperlyConfigured:
+        filter_choices = []
+
+    def decorator(cls):
+        choices = []
+        for choice in cls._choices:
+            if choice[0] not in filter_choices:
+                setattr(cls, choice[0], choice[0])
+                choices.append(choice)
+        cls._choices = choices
+        cls.CHOICES = choices
+
+        return cls
+
+    return decorator

netbox_dns/fields/__init__.py

@@ -2,3 +2,5 @@ from .network import *
 from .address import *
 from .rfc2317 import *
 from .ipam import *
+from .choice_array import *
+from .timeperiod import *

netbox_dns/fields/choice_array.py

@@ -0,0 +1,20 @@
+from django import forms
+from django.contrib.postgres.fields import ArrayField
+
+
+class _TypedMultipleChoiceField(forms.TypedMultipleChoiceField):
+    def __init__(self, *args, **kwargs):
+        kwargs.pop("base_field", None)
+        kwargs.pop("max_length", None)
+
+        super().__init__(*args, **kwargs)
+
+
+class ChoiceArrayField(ArrayField):
+    def formfield(self, **kwargs):
+        return super().formfield(
+            form_class=_TypedMultipleChoiceField,
+            choices=self.base_field.choices,
+            coerce=self.base_field.to_python,
+            **kwargs,
+        )

netbox_dns/fields/timeperiod.py

@@ -0,0 +1,31 @@
+from django.forms import Field
+from django.utils.dateparse import parse_duration
+from django.core.exceptions import ValidationError
+
+
+__all__ = ("TimePeriodField",)
+
+
+class TimePeriodField(Field):
+    def to_python(self, value):
+        if not value:
+            return None
+
+        try:
+            return int(value)
+        except ValueError:
+            try:
+                duration = parse_duration(value)
+                if duration is None:
+                    raise TypeError
+                return int(duration.total_seconds())
+            except TypeError:
+                raise ValidationError(
+                    "Enter a valid integer or ISO 8601 duration (W, M and Y are not supported)"
+                )
+
+    def validate(self, value):
+        super().validate(value)
+
+        if value is not None and value < 0:
+            raise ValidationError("A time period cannot be negative.")

netbox_dns/filtersets/__init__.py

@@ -7,3 +7,6 @@ from .registrar import *
 
 from .zone_template import *
 from .record_template import *
+
+from .dnssec_key_template import *
+from .dnssec_policy import *

netbox_dns/filtersets/dnssec_key_template.py

@@ -0,0 +1,51 @@
+import django_filters
+from django.db.models import Q
+from django.utils.translation import gettext as _
+
+from netbox.filtersets import NetBoxModelFilterSet
+from tenancy.filtersets import TenancyFilterSet
+
+from netbox_dns.models import DNSSECKeyTemplate, DNSSECPolicy
+from netbox_dns.choices import (
+    DNSSECKeyTemplateTypeChoices,
+    DNSSECKeyTemplateAlgorithmChoices,
+    DNSSECKeyTemplateKeySizeChoices,
+)
+
+
+__all__ = ("DNSSECKeyTemplateFilterSet",)
+
+
+class DNSSECKeyTemplateFilterSet(TenancyFilterSet, NetBoxModelFilterSet):
+    type = django_filters.MultipleChoiceFilter(
+        choices=DNSSECKeyTemplateTypeChoices,
+    )
+    algorithm = django_filters.MultipleChoiceFilter(
+        choices=DNSSECKeyTemplateAlgorithmChoices,
+    )
+    key_size = django_filters.MultipleChoiceFilter(
+        choices=DNSSECKeyTemplateKeySizeChoices,
+    )
+
+    policy_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="policies",
+        queryset=DNSSECPolicy.objects.all(),
+        to_field_name="id",
+        label=_("DNSSEC Policy IDs"),
+    )
+    policy = django_filters.ModelMultipleChoiceFilter(
+        field_name="policies__name",
+        queryset=DNSSECPolicy.objects.all(),
+        to_field_name="name",
+        label=_("DNSSEC Policies"),
+    )
+
+    class Meta:
+        model = DNSSECKeyTemplate
+        fields = ("id", "name", "description", "lifetime")
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        qs_filter = Q(name__icontains=value)
+        return queryset.filter(qs_filter)