netbox-dlm 0.1.0__py3-none-any.whl

netbox_dlm/__init__.py

@@ -0,0 +1,24 @@
+from netbox.plugins import PluginConfig
+
+
+class DeviceLifecycleConfig(PluginConfig):
+    name = "netbox_dlm"
+    verbose_name = "Device Lifecycle Management"
+    description = (
+        "Track hardware end-of-life/end-of-support notices, software versions and "
+        "validated-software compliance, CVE/vulnerability exposure, and maintenance "
+        "contracts — modeled after Nautobot's Device Lifecycle Management app."
+    )
+    version = "0.1.0"
+    base_url = "device-lifecycle"
+    min_version = "4.1.0"
+    default_settings = {
+        # Set to a NIST NVD API key to raise CVE-lookup rate limits (optional).
+        "nist_api_key": None,
+        # How many days out a hardware/software EoS date counts as "upcoming"
+        # for dashboard highlighting.
+        "eos_warning_days": 180,
+    }
+
+
+config = DeviceLifecycleConfig

netbox_dlm/admin.py

@@ -0,0 +1,72 @@
+from django.contrib import admin
+
+from .models import (
+    CVE,
+    Contract,
+    DeviceSoftware,
+    HardwareNotice,
+    Provider,
+    SoftwareImageFile,
+    SoftwareVersion,
+    ValidatedSoftware,
+    Vulnerability,
+)
+
+
+@admin.register(Provider)
+class ProviderAdmin(admin.ModelAdmin):
+    list_display = ("name", "phone", "email", "portal_url")
+    search_fields = ("name", "email")
+
+
+@admin.register(Contract)
+class ContractAdmin(admin.ModelAdmin):
+    list_display = ("name", "provider", "support_level", "start_date", "end_date")
+    list_filter = ("provider", "support_level")
+    search_fields = ("name", "contract_number")
+
+
+@admin.register(HardwareNotice)
+class HardwareNoticeAdmin(admin.ModelAdmin):
+    list_display = ("__str__", "end_of_sale", "end_of_support", "end_of_security_patches")
+    list_filter = ("end_of_support",)
+
+
+@admin.register(SoftwareVersion)
+class SoftwareVersionAdmin(admin.ModelAdmin):
+    list_display = ("__str__", "platform", "version", "release_date", "end_of_support", "long_term_support")
+    list_filter = ("platform", "long_term_support")
+    search_fields = ("version", "alias")
+
+
+@admin.register(SoftwareImageFile)
+class SoftwareImageFileAdmin(admin.ModelAdmin):
+    list_display = ("file_name", "software_version", "hashing_algorithm", "default_image")
+    list_filter = ("hashing_algorithm", "default_image")
+    search_fields = ("file_name", "checksum")
+
+
+@admin.register(DeviceSoftware)
+class DeviceSoftwareAdmin(admin.ModelAdmin):
+    list_display = ("device", "software_version", "last_checked")
+    search_fields = ("device__name",)
+
+
+@admin.register(ValidatedSoftware)
+class ValidatedSoftwareAdmin(admin.ModelAdmin):
+    list_display = ("software_version", "start", "end", "preferred", "valid_now")
+    list_filter = ("preferred",)
+
+
+@admin.register(CVE)
+class CVEAdmin(admin.ModelAdmin):
+    list_display = ("cve_id", "name", "severity", "status", "cvss_score", "published_date")
+    list_filter = ("severity", "status")
+    search_fields = ("cve_id", "name", "description")
+
+
+@admin.register(Vulnerability)
+class VulnerabilityAdmin(admin.ModelAdmin):
+    list_display = ("cve", "software_version", "device", "status")
+    list_filter = ("status",)
+    search_fields = ("cve__cve_id", "device__name")

netbox_dlm/api/serializers.py

@@ -0,0 +1,177 @@
+from dcim.api.serializers import (
+    DeviceSerializer,
+    DeviceRoleSerializer,
+    DeviceTypeSerializer,
+    ModuleTypeSerializer,
+    PlatformSerializer,
+)
+from netbox.api.fields import ChoiceField
+from netbox.api.serializers import NetBoxModelSerializer
+from rest_framework import serializers
+
+from ..choices import (
+    ContractSupportLevelChoices,
+    CVESeverityChoices,
+    CVEStatusChoices,
+    HashingAlgorithmChoices,
+    VulnerabilityStatusChoices,
+)
+from ..models import (
+    CVE,
+    Contract,
+    DeviceSoftware,
+    HardwareNotice,
+    Provider,
+    SoftwareImageFile,
+    SoftwareVersion,
+    ValidatedSoftware,
+    Vulnerability,
+)
+
+
+class ProviderSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_dlm-api:provider-detail"
+    )
+
+    class Meta:
+        model = Provider
+        fields = (
+            "id", "url", "display", "name", "physical_address", "phone",
+            "email", "portal_url", "comments", "tags", "custom_fields",
+            "created", "last_updated",
+        )
+
+
+class ContractSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_dlm-api:contract-detail"
+    )
+    provider = ProviderSerializer(nested=True)
+    support_level = ChoiceField(choices=ContractSupportLevelChoices, required=False)
+    devices = DeviceSerializer(nested=True, many=True, required=False)
+
+    class Meta:
+        model = Contract
+        fields = (
+            "id", "url", "display", "provider", "name", "contract_number",
+            "start_date", "end_date", "cost", "currency", "support_level",
+            "devices", "comments", "tags", "custom_fields", "created", "last_updated",
+        )
+
+
+class HardwareNoticeSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_dlm-api:hardwarenotice-detail"
+    )
+    device_type = DeviceTypeSerializer(nested=True, required=False, allow_null=True)
+    module_type = ModuleTypeSerializer(nested=True, required=False, allow_null=True)
+
+    class Meta:
+        model = HardwareNotice
+        fields = (
+            "id", "url", "display", "device_type", "module_type", "end_of_sale",
+            "end_of_support", "end_of_security_patches", "end_of_sw_releases",
+            "documentation_url", "comments", "tags", "custom_fields",
+            "created", "last_updated",
+        )
+
+
+class SoftwareVersionSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_dlm-api:softwareversion-detail"
+    )
+    platform = PlatformSerializer(nested=True)
+
+    class Meta:
+        model = SoftwareVersion
+        fields = (
+            "id", "url", "display", "platform", "version", "alias",
+            "release_date", "end_of_support", "long_term_support",
+            "documentation_url", "comments", "tags", "custom_fields",
+            "created", "last_updated",
+        )
+
+
+class SoftwareImageFileSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_dlm-api:softwareimagefile-detail"
+    )
+    software_version = SoftwareVersionSerializer(nested=True)
+    hashing_algorithm = ChoiceField(choices=HashingAlgorithmChoices, required=False)
+
+    class Meta:
+        model = SoftwareImageFile
+        fields = (
+            "id", "url", "display", "software_version", "file_name", "checksum",
+            "hashing_algorithm", "file_size", "download_url", "default_image",
+            "comments", "tags", "custom_fields", "created", "last_updated",
+        )
+
+
+class DeviceSoftwareSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_dlm-api:devicesoftware-detail"
+    )
+    device = DeviceSerializer(nested=True)
+    software_version = SoftwareVersionSerializer(nested=True)
+
+    class Meta:
+        model = DeviceSoftware
+        fields = (
+            "id", "url", "display", "device", "software_version", "last_checked",
+            "comments", "tags", "custom_fields", "created", "last_updated",
+        )
+
+
+class ValidatedSoftwareSerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_dlm-api:validatedsoftware-detail"
+    )
+    software_version = SoftwareVersionSerializer(nested=True)
+    device_types = DeviceTypeSerializer(nested=True, many=True, required=False)
+    device_roles = DeviceRoleSerializer(nested=True, many=True, required=False)
+    devices = DeviceSerializer(nested=True, many=True, required=False)
+
+    class Meta:
+        model = ValidatedSoftware
+        fields = (
+            "id", "url", "display", "software_version", "device_types",
+            "device_roles", "devices", "start", "end", "preferred",
+            "comments", "tags", "custom_fields", "created", "last_updated",
+        )
+
+
+class CVESerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_dlm-api:cve-detail"
+    )
+    status = ChoiceField(choices=CVEStatusChoices, required=False)
+    severity = ChoiceField(choices=CVESeverityChoices, required=False)
+    affected_software = SoftwareVersionSerializer(nested=True, many=True, required=False)
+
+    class Meta:
+        model = CVE
+        fields = (
+            "id", "url", "display", "cve_id", "name", "description",
+            "published_date", "link", "status", "severity", "cvss_score",
+            "cvss_v2_score", "cvss_v3_score", "affected_software", "comments",
+            "tags", "custom_fields", "created", "last_updated",
+        )
+
+
+class VulnerabilitySerializer(NetBoxModelSerializer):
+    url = serializers.HyperlinkedIdentityField(
+        view_name="plugins-api:netbox_dlm-api:vulnerability-detail"
+    )
+    cve = CVESerializer(nested=True)
+    software_version = SoftwareVersionSerializer(nested=True)
+    device = DeviceSerializer(nested=True, required=False, allow_null=True)
+    status = ChoiceField(choices=VulnerabilityStatusChoices, required=False)
+
+    class Meta:
+        model = Vulnerability
+        fields = (
+            "id", "url", "display", "cve", "software_version", "device",
+            "status", "comments", "tags", "custom_fields", "created", "last_updated",
+        )

netbox_dlm/api/urls.py

@@ -0,0 +1,19 @@
+from netbox.api.routers import NetBoxRouter
+
+from . import views
+
+app_name = "netbox_dlm-api"
+
+router = NetBoxRouter()
+
+router.register("providers", views.ProviderViewSet)
+router.register("contracts", views.ContractViewSet)
+router.register("hardware-notices", views.HardwareNoticeViewSet)
+router.register("software-versions", views.SoftwareVersionViewSet)
+router.register("software-images", views.SoftwareImageFileViewSet)
+router.register("device-software", views.DeviceSoftwareViewSet)
+router.register("validated-software", views.ValidatedSoftwareViewSet)
+router.register("cves", views.CVEViewSet)
+router.register("vulnerabilities", views.VulnerabilityViewSet)
+
+urlpatterns = router.urls

netbox_dlm/api/views.py

@@ -0,0 +1,71 @@
+from netbox.api.viewsets import NetBoxModelViewSet
+
+from .. import filtersets
+from ..models import (
+    CVE,
+    Contract,
+    DeviceSoftware,
+    HardwareNotice,
+    Provider,
+    SoftwareImageFile,
+    SoftwareVersion,
+    ValidatedSoftware,
+    Vulnerability,
+)
+from . import serializers
+
+
+class ProviderViewSet(NetBoxModelViewSet):
+    queryset = Provider.objects.all()
+    serializer_class = serializers.ProviderSerializer
+    filterset_class = filtersets.ProviderFilterSet
+
+
+class ContractViewSet(NetBoxModelViewSet):
+    queryset = Contract.objects.prefetch_related("provider", "devices", "tags")
+    serializer_class = serializers.ContractSerializer
+    filterset_class = filtersets.ContractFilterSet
+
+
+class HardwareNoticeViewSet(NetBoxModelViewSet):
+    queryset = HardwareNotice.objects.prefetch_related("device_type", "module_type", "tags")
+    serializer_class = serializers.HardwareNoticeSerializer
+    filterset_class = filtersets.HardwareNoticeFilterSet
+
+
+class SoftwareVersionViewSet(NetBoxModelViewSet):
+    queryset = SoftwareVersion.objects.prefetch_related("platform", "tags")
+    serializer_class = serializers.SoftwareVersionSerializer
+    filterset_class = filtersets.SoftwareVersionFilterSet
+
+
+class SoftwareImageFileViewSet(NetBoxModelViewSet):
+    queryset = SoftwareImageFile.objects.prefetch_related("software_version", "tags")
+    serializer_class = serializers.SoftwareImageFileSerializer
+    filterset_class = filtersets.SoftwareImageFileFilterSet
+
+
+class DeviceSoftwareViewSet(NetBoxModelViewSet):
+    queryset = DeviceSoftware.objects.prefetch_related("device", "software_version", "tags")
+    serializer_class = serializers.DeviceSoftwareSerializer
+    filterset_class = filtersets.DeviceSoftwareFilterSet
+
+
+class ValidatedSoftwareViewSet(NetBoxModelViewSet):
+    queryset = ValidatedSoftware.objects.prefetch_related(
+        "software_version", "device_types", "device_roles", "devices", "tags"
+    )
+    serializer_class = serializers.ValidatedSoftwareSerializer
+    filterset_class = filtersets.ValidatedSoftwareFilterSet
+
+
+class CVEViewSet(NetBoxModelViewSet):
+    queryset = CVE.objects.prefetch_related("affected_software", "tags")
+    serializer_class = serializers.CVESerializer
+    filterset_class = filtersets.CVEFilterSet
+
+
+class VulnerabilityViewSet(NetBoxModelViewSet):
+    queryset = Vulnerability.objects.prefetch_related("cve", "software_version", "device", "tags")
+    serializer_class = serializers.VulnerabilitySerializer
+    filterset_class = filtersets.VulnerabilityFilterSet

netbox_dlm/choices.py

@@ -0,0 +1,91 @@
+from utilities.choices import ChoiceSet
+
+
+class HashingAlgorithmChoices(ChoiceSet):
+    key = "SoftwareImageFile.hashing_algorithm"
+
+    MD5 = "md5"
+    SHA1 = "sha1"
+    SHA256 = "sha256"
+    SHA512 = "sha512"
+
+    CHOICES = [
+        (MD5, "MD5"),
+        (SHA1, "SHA1"),
+        (SHA256, "SHA256"),
+        (SHA512, "SHA512"),
+    ]
+
+
+class ContractSupportLevelChoices(ChoiceSet):
+    key = "Contract.support_level"
+
+    BASIC = "basic"
+    STANDARD = "standard"
+    ENHANCED = "enhanced"
+    PREMIUM = "premium"
+    NEXT_BUSINESS_DAY = "next_business_day"
+    FOUR_HOUR = "four_hour_onsite"
+    NONE = "none"
+
+    CHOICES = [
+        (BASIC, "Basic"),
+        (STANDARD, "Standard"),
+        (ENHANCED, "Enhanced"),
+        (PREMIUM, "Premium"),
+        (NEXT_BUSINESS_DAY, "Next Business Day"),
+        (FOUR_HOUR, "4-Hour Onsite"),
+        (NONE, "None"),
+    ]
+
+
+class CVESeverityChoices(ChoiceSet):
+    key = "CVE.severity"
+
+    NONE = "none"
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    CRITICAL = "critical"
+
+    CHOICES = [
+        (NONE, "None", "gray"),
+        (LOW, "Low", "blue"),
+        (MEDIUM, "Medium", "yellow"),
+        (HIGH, "High", "orange"),
+        (CRITICAL, "Critical", "red"),
+    ]
+
+
+class CVEStatusChoices(ChoiceSet):
+    key = "CVE.status"
+
+    AWAITING_REVIEW = "awaiting_review"
+    IN_REVIEW = "in_review"
+    RESOLVED = "resolved"
+    FALSE_POSITIVE = "false_positive"
+
+    CHOICES = [
+        (AWAITING_REVIEW, "Awaiting Review", "cyan"),
+        (IN_REVIEW, "In Review", "blue"),
+        (RESOLVED, "Resolved", "green"),
+        (FALSE_POSITIVE, "False Positive", "gray"),
+    ]
+
+
+class VulnerabilityStatusChoices(ChoiceSet):
+    key = "Vulnerability.status"
+
+    OPEN = "open"
+    MITIGATED = "mitigated"
+    RESOLVED = "resolved"
+    ACCEPTED_RISK = "accepted_risk"
+    IGNORED = "ignored"
+
+    CHOICES = [
+        (OPEN, "Open", "red"),
+        (MITIGATED, "Mitigated", "yellow"),
+        (RESOLVED, "Resolved", "green"),
+        (ACCEPTED_RISK, "Accepted Risk", "purple"),
+        (IGNORED, "Ignored", "gray"),
+    ]

netbox_dlm/filtersets.py

@@ -0,0 +1,169 @@
+import django_filters
+from django.db.models import Q
+
+from dcim.models import Device, DeviceRole, DeviceType, ModuleType, Platform
+from netbox.filtersets import NetBoxModelFilterSet
+
+from .choices import (
+    ContractSupportLevelChoices,
+    CVESeverityChoices,
+    CVEStatusChoices,
+    VulnerabilityStatusChoices,
+)
+from .models import (
+    CVE,
+    Contract,
+    DeviceSoftware,
+    HardwareNotice,
+    Provider,
+    SoftwareImageFile,
+    SoftwareVersion,
+    ValidatedSoftware,
+    Vulnerability,
+)
+
+
+class ProviderFilterSet(NetBoxModelFilterSet):
+    class Meta:
+        model = Provider
+        fields = ("id", "name", "phone", "email")
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(
+            Q(name__icontains=value) | Q(email__icontains=value) | Q(phone__icontains=value)
+        )
+
+
+class ContractFilterSet(NetBoxModelFilterSet):
+    provider_id = django_filters.ModelMultipleChoiceFilter(queryset=Provider.objects.all())
+    support_level = django_filters.MultipleChoiceFilter(choices=ContractSupportLevelChoices)
+    device_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="devices", queryset=Device.objects.all()
+    )
+
+    class Meta:
+        model = Contract
+        fields = ("id", "name", "contract_number", "provider_id", "support_level")
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(Q(name__icontains=value) | Q(contract_number__icontains=value))
+
+
+class HardwareNoticeFilterSet(NetBoxModelFilterSet):
+    device_type_id = django_filters.ModelMultipleChoiceFilter(queryset=DeviceType.objects.all())
+    module_type_id = django_filters.ModelMultipleChoiceFilter(queryset=ModuleType.objects.all())
+
+    class Meta:
+        model = HardwareNotice
+        fields = ("id", "device_type_id", "module_type_id")
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(
+            Q(device_type__model__icontains=value) | Q(module_type__model__icontains=value)
+        )
+
+
+class SoftwareVersionFilterSet(NetBoxModelFilterSet):
+    platform_id = django_filters.ModelMultipleChoiceFilter(queryset=Platform.objects.all())
+    long_term_support = django_filters.BooleanFilter()
+
+    class Meta:
+        model = SoftwareVersion
+        fields = ("id", "platform_id", "version", "long_term_support")
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(Q(version__icontains=value) | Q(alias__icontains=value))
+
+
+class SoftwareImageFileFilterSet(NetBoxModelFilterSet):
+    software_version_id = django_filters.ModelMultipleChoiceFilter(
+        queryset=SoftwareVersion.objects.all()
+    )
+
+    class Meta:
+        model = SoftwareImageFile
+        fields = ("id", "software_version_id", "file_name", "default_image")
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(Q(file_name__icontains=value) | Q(checksum__icontains=value))
+
+
+class DeviceSoftwareFilterSet(NetBoxModelFilterSet):
+    device_id = django_filters.ModelMultipleChoiceFilter(queryset=Device.objects.all())
+    software_version_id = django_filters.ModelMultipleChoiceFilter(
+        queryset=SoftwareVersion.objects.all()
+    )
+
+    class Meta:
+        model = DeviceSoftware
+        fields = ("id", "device_id", "software_version_id")
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(Q(device__name__icontains=value))
+
+
+class ValidatedSoftwareFilterSet(NetBoxModelFilterSet):
+    software_version_id = django_filters.ModelMultipleChoiceFilter(
+        queryset=SoftwareVersion.objects.all()
+    )
+    device_type_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="device_types", queryset=DeviceType.objects.all()
+    )
+    device_role_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="device_roles", queryset=DeviceRole.objects.all()
+    )
+    preferred = django_filters.BooleanFilter()
+
+    class Meta:
+        model = ValidatedSoftware
+        fields = ("id", "software_version_id", "preferred")
+
+    def search(self, queryset, name, value):
+        return queryset
+
+
+class CVEFilterSet(NetBoxModelFilterSet):
+    severity = django_filters.MultipleChoiceFilter(choices=CVESeverityChoices)
+    status = django_filters.MultipleChoiceFilter(choices=CVEStatusChoices)
+    affected_software_id = django_filters.ModelMultipleChoiceFilter(
+        field_name="affected_software", queryset=SoftwareVersion.objects.all()
+    )
+
+    class Meta:
+        model = CVE
+        fields = ("id", "cve_id", "severity", "status")
+
+    def search(self, queryset, name, value):
+        if not value.strip():
+            return queryset
+        return queryset.filter(
+            Q(cve_id__icontains=value) | Q(name__icontains=value) | Q(description__icontains=value)
+        )
+
+
+class VulnerabilityFilterSet(NetBoxModelFilterSet):
+    cve_id = django_filters.ModelMultipleChoiceFilter(queryset=CVE.objects.all())
+    device_id = django_filters.ModelMultipleChoiceFilter(queryset=Device.objects.all())
+    software_version_id = django_filters.ModelMultipleChoiceFilter(
+        queryset=SoftwareVersion.objects.all()
+    )
+    status = django_filters.MultipleChoiceFilter(choices=VulnerabilityStatusChoices)
+
+    class Meta:
+        model = Vulnerability
+        fields = ("id", "cve_id", "device_id", "software_version_id", "status")
+
+    def search(self, queryset, name, value):
+        return queryset