Add Rust NVD import cutover flow

Author: ewilhelm1979-netizen

apps/vulnerability_intelligence/services.py

@@ -172,13 +172,11 @@ def upsert_cve(cve_id: str, *, assume_normalized: bool = False):
         if rust_only:
             if not RustBackendClient.is_configured():
                 raise RuntimeError('VULN_INTEL_RUST_ONLY ist aktiv, aber RUST_BACKEND_URL ist nicht gesetzt.')
-            cve, payload = NVDService.fetch_cve(normalized)
-            persisted_cve_id = RustBackendClient.upsert_nvd_cve(cve=cve, raw_payload=payload, fallback_cve_id=normalized)
+            persisted_cve_id = RustBackendClient.import_nvd_cve(normalized)
             return CVERecord.objects.get(cve_id=persisted_cve_id)
 
         if RustBackendClient.is_configured():
-            cve, payload = NVDService.fetch_cve(normalized)
-            persisted_cve_id = RustBackendClient.upsert_nvd_cve(cve=cve, raw_payload=payload, fallback_cve_id=normalized)
+            persisted_cve_id = RustBackendClient.import_nvd_cve(normalized)
             return CVERecord.objects.get(cve_id=persisted_cve_id)
 
         cve, payload = NVDService.fetch_cve(normalized)
@@ -312,6 +310,35 @@ def upsert_nvd_cve(*, cve: dict, raw_payload: dict, fallback_cve_id: str = '', t
             raise RuntimeError('Rust-Backend hat keine persistierte CVE-ID geliefert.')
         return cve_id
 
+    @staticmethod
+    def import_nvd_cve(cve_id: str, timeout: int = 30) -> str:
+        base = RustBackendClient._base_url()
+        if not base:
+            raise RuntimeError('RUST_BACKEND_URL ist nicht gesetzt.')
+        request = Request(
+            f'{base}/api/v1/nvd/import',
+            data=json.dumps({'cve_id': cve_id}).encode('utf-8'),
+            method='POST',
+        )
+        request.add_header('Content-Type', 'application/json')
+        request.add_header('Accept', 'application/json')
+        try:
+            with urlopen(request, timeout=timeout) as response:
+                payload = json.loads(response.read().decode('utf-8'))
+        except HTTPError as exc:
+            detail = ''
+            try:
+                error_payload = json.loads(exc.read().decode('utf-8'))
+                detail = str(error_payload.get('error_code') or error_payload.get('message') or '').strip()
+            except Exception:
+                detail = str(exc.reason or '').strip()
+            raise RuntimeError(f'Rust-Backend NVD-Import fehlgeschlagen ({exc.code}): {detail}') from exc
+
+        imported_cve_id = str(payload.get('cve_id') or '').strip().upper()
+        if not imported_cve_id:
+            raise RuntimeError('Rust-Backend hat keine importierte CVE-ID geliefert.')
+        return imported_cve_id
+
     @staticmethod
     def calculate_priority(*, score: float, exposure: str, criticality: str, epss_score=None,
                            in_kev_catalog: bool = False, exploit_maturity: str = 'UNKNOWN',

apps/vulnerability_intelligence/tests.py

@@ -84,20 +84,15 @@ def test_upsert_cve_requires_rust_when_rust_only_enabled(self):
 
     @override_settings(RUST_BACKEND_URL='http://rust-backend:9000')
     def test_upsert_cve_uses_rust_persistence_when_rust_only_enabled(self):
-        cve = {'id': 'CVE-2026-4242', 'descriptions': [{'lang': 'en', 'value': 'Rust CVE'}]}
-        payload = {'vulnerabilities': [{'cve': cve}]}
-
-        def _rust_upsert(**_kwargs):
+        def _rust_import(_cve_id):
             return CVERecord.objects.create(cve_id='CVE-2026-4242', description='Rust CVE').cve_id
 
-        with patch.object(NVDService, 'fetch_cve', return_value=(cve, payload)) as mocked_fetch, \
-             patch.object(RustBackendClient, 'upsert_nvd_cve', side_effect=_rust_upsert) as mocked_rust_upsert, \
+        with patch.object(RustBackendClient, 'import_nvd_cve', side_effect=_rust_import) as mocked_rust_import, \
              patch.object(NVDService, 'upsert_from_payload') as mocked_python_upsert:
             record = NVDService.upsert_cve('CVE-2026-4242', assume_normalized=True)
 
         self.assertEqual(record.cve_id, 'CVE-2026-4242')
-        mocked_fetch.assert_called_once_with('CVE-2026-4242')
-        mocked_rust_upsert.assert_called_once_with(cve=cve, raw_payload=payload, fallback_cve_id='CVE-2026-4242')
+        mocked_rust_import.assert_called_once_with('CVE-2026-4242')
         mocked_python_upsert.assert_not_called()
 
 
@@ -201,6 +196,47 @@ def test_upsert_nvd_cve_surfaces_rust_error_code(self):
             with self.assertRaisesRegex(RuntimeError, 'database_not_configured'):
                 RustBackendClient.upsert_nvd_cve(cve={'id': 'CVE-2026-4242'}, raw_payload={})
 
+    @override_settings(RUST_BACKEND_URL='http://rust-backend:9000')
+    def test_import_nvd_cve_uses_rust_response(self):
+        response_mock = Mock()
+        response_mock.read.return_value = json.dumps({
+            'accepted': True,
+            'api_version': 'v1',
+            'cve_id': 'CVE-2026-4242',
+            'persisted': True,
+        }).encode('utf-8')
+        response_ctx = Mock()
+        response_ctx.__enter__ = Mock(return_value=response_mock)
+        response_ctx.__exit__ = Mock(return_value=False)
+
+        with patch('apps.vulnerability_intelligence.services.urlopen', return_value=response_ctx) as mocked_urlopen:
+            cve_id = RustBackendClient.import_nvd_cve(' cve-2026-4242 ')
+
+        self.assertEqual(cve_id, 'CVE-2026-4242')
+        request = mocked_urlopen.call_args.args[0]
+        self.assertEqual(request.full_url, 'http://rust-backend:9000/api/v1/nvd/import')
+        payload = json.loads(request.data.decode('utf-8'))
+        self.assertEqual(payload['cve_id'], ' cve-2026-4242 ')
+
+    @override_settings(RUST_BACKEND_URL='http://rust-backend:9000')
+    def test_import_nvd_cve_surfaces_rust_error_code(self):
+        error = HTTPError(
+            url='http://rust-backend:9000/api/v1/nvd/import',
+            code=404,
+            msg='Not Found',
+            hdrs=None,
+            fp=io.BytesIO(json.dumps({
+                'accepted': False,
+                'api_version': 'v1',
+                'error_code': 'cve_not_found',
+                'message': 'nicht gefunden',
+            }).encode('utf-8')),
+        )
+
+        with patch('apps.vulnerability_intelligence.services.urlopen', side_effect=error):
+            with self.assertRaisesRegex(RuntimeError, 'cve_not_found'):
+                RustBackendClient.import_nvd_cve('CVE-2026-4242')
+
     @override_settings(RUST_BACKEND_URL='http://rust-backend:9000')
     def test_calculate_priority_uses_rust_response(self):
         response_mock = Mock()

docs/RUST_CUTOVER_STATUS.md

@@ -1,6 +1,6 @@
 # ISCY Rust-Cutover-Status
 
-Stand: 2026-04-24
+Stand: 2026-04-25
 
 ## Kurzfassung
 
@@ -46,13 +46,13 @@ Der alte Django-Runserver ist damit nicht mehr der lokale Standardpfad.
 
 ## Bereits nach Rust verschoben
 
-- CVE-/NVD-Normalisierung, Upsert- und Canary-Pfade.
+- CVE-/NVD-Normalisierung, Einzelimport-, Upsert- und Canary-Pfade.
 - Lokaler LLM-Endpunkt, Risiko-Priorisierung, Guidance-Auswertung und CVE-Report-Summary.
 - Dashboard-, Report-, Catalog-, Requirements-, Asset-, Process- und Assessment-Read-Flows.
 - Risk-Register Read-, Detail-, Create- und Update-Flows.
 - Evidence Read-/Detail-Flows, Evidence-Need-Sync und Evidence-Dateiuploads ueber Rust-Web/API.
 - Rust-Web-Shell mit Kontext-Formular sowie datengetriebenem Dashboard, Guidance Navigator, Catalog, Requirements, Assessments, Organizations, Risk-Register, Evidence-Ueberblick, Reports, Roadmap, Assets, Imports, Processes und Product Security.
-- Rust-CVE-Slice mit `GET /api/v1/cves`, `GET /api/v1/cves/{cve_id}`, `GET /api/v1/cve-assessments`, `POST /api/v1/cve-assessments`, `GET /api/v1/cve-assessments/{assessment_id}` sowie Webrouten `/cves/`, `/cves/assessments/{assessment_id}` und `/cves/llm-test/` fuer Feed, tenantgebundene Assessment-Reads, Assessment-Create-/Update-Upserts, automatische Risk-/Vulnerability-Verknuepfung und LLM-Runtime-Checks.
+- Rust-CVE-Slice mit `GET /api/v1/cves`, `GET /api/v1/cves/{cve_id}`, `GET /api/v1/cve-assessments`, `POST /api/v1/cve-assessments`, `GET /api/v1/cve-assessments/{assessment_id}`, `POST /api/v1/nvd/import` sowie Webrouten `/cves/`, `/cves/{assessment_id}/`, `/cves/assessments/{assessment_id}` und `/cves/llm-test/` fuer Feed, tenantgebundene Assessment-Reads, Assessment-Create-/Update-Upserts, echten Rust-NVD-Einzelimport, automatische Risk-/Vulnerability-Verknuepfung und LLM-Runtime-Checks.
 - Rust-DB-Admin-CLI mit `migrate`, `seed-demo` und `init-demo` fuer Rust-eigenen SQLite/PostgreSQL-Bootstrap der operativen Kern-Tabellen inklusive Product-Security sowie vollstaendigem Katalog-/Requirement-Seed.
 - Rust-Session-Schicht mit `iscy_auth_session`, `/api/v1/auth/sessions`, `/api/v1/auth/session`, Logout, Cookie/Bearer-Aufloesung, Django-kompatibler `pbkdf2_sha256`-Passwortpruefung und Web-Kontext ohne Query-Parameter.
 - Rust-RBAC-Grundlage mit `accounts_role`, `accounts_userrole`, Session-Rollencodes, Header-Rollen-Fallback und Schreibschutz fuer migrierte Write-Endpunkte.
@@ -71,14 +71,14 @@ Der alte Django-Runserver ist damit nicht mehr der lokale Standardpfad.
 1. **Weboberflaeche:** Rust liefert fuer `/dashboard/`, `/navigator/`, `/catalog/`, `/requirements/`, `/assessments/`, `/organizations/`, `/risks/`, `/evidence/`, `/reports/`, `/roadmap/`, `/assets/`, `/imports/`, `/processes/`, `/product-security/` und `/cves/` bereits echte serverseitige Seiten. Die restlichen Detail-/Form-Flows, Zwischenwizard-Schritte und spezialisierten Exporte liegen noch in Django-Templates und Django-Views.
 2. **Auth, Sessions und Admin:** Rust-Sessions, Passwort-Login, Rollen-/Schreibrechte sowie Account-Administration fuer User/Rollen-/Gruppen-/Direktrechtewechsel sind vorhanden. Die Django-kompatiblen Tabellen fuer Gruppen, Permissions und User-Zuordnung sind gebootstrapped; vollstaendige Django-Admin-Paritaet ist noch nicht komplett ersetzt.
 3. **Migrations und Seeds:** Ein Rust-eigener Bootstrap fuer operative Kern-Tabellen inklusive Product-Security, Catalog und Requirements ist vorhanden. Einzelne historische Django-Schema-Details ausserhalb dieser Cutover-Slices sind noch nicht vollstaendig abgeloest.
-4. **Formulare und Uploads:** Evidence-Dateiuploads sowie Import-Center Datei-Upload, CSV/XLSX/XLSM-Parsing und Mapping-Vorschau laufen direkt ueber Rust-Web/API. Weitere Django-Formreste ausserhalb dieser Cutover-Slices muessen noch ersetzt werden; im CVE-Bereich sind die tenantgebundenen Assessment-Upserts inklusive automatischer Risikoanreicherung jetzt in Rust, offen bleiben vor allem Restparitaet fuer NVD-Sync-/Edge-Flows.
+4. **Formulare und Uploads:** Evidence-Dateiuploads sowie Import-Center Datei-Upload, CSV/XLSX/XLSM-Parsing und Mapping-Vorschau laufen direkt ueber Rust-Web/API. Weitere Django-Formreste ausserhalb dieser Cutover-Slices muessen noch ersetzt werden; im CVE-Bereich sind tenantgebundene Assessment-Upserts inklusive automatischer Risikoanreicherung und der NVD-Einzelimport jetzt in Rust, offen bleiben vor allem Bulk-/Sync-Orchestrierung und letzte Edge-Paritaet.
 5. **Python-Dateien im Repo:** CI und lokaler Start sind Rust-first. Python/Django-Dateien bleiben noch als Legacy-Kompatibilitaet und muessen nach Abschluss von Auth/Web/Form-Flows gezielt entfernt werden.
 
 ## Naechster fachlich sinnvoller Cutover-Schritt
 
 Der naechste Abschlussblock ist nicht mehr ein weiterer einzelner API-Endpunkt, sondern die Web- und Betriebsablösung:
 
-1. Letzte Admin-Paritaet in Rust finalisieren.
+1. Letzte `vulnerability_intelligence`- und Admin-Reste fachlich auf Rust umhaengen.
 2. Django-Templates durch Rust-Web oder ein separates Frontend auf Rust-API ersetzen.
 3. Verbleibende Django-Template-/Form-Reste systematisch durch Rust-Web oder ein separates Frontend auf Rust-API ersetzen.
 4. Python-Dateien, Requirements, Django-Settings und Django-Startpfade entfernen.

docs/RUST_REWRITE_ROADMAP.md

@@ -118,13 +118,14 @@ ISCY schrittweise von Django/Python auf Rust ueberfuehren, ohne Fachfunktionalit
 - `vulnerability_intelligence` hat nun einen Rust-Read-Slice fuer globalen CVE-Feed, tenantgebundene Assessments und LLM-Runtime-Checks:
   - `GET /api/v1/cves` liefert Kennzahlen und die aktuelle CVE-Liste aus `vulnerability_intelligence_cverecord`
   - `GET /api/v1/cves/{cve_id}` liefert Schwachstellen-Detaildaten inklusive Weaknesses, Referenzen, KEV-Flags und Raw-JSON
+  - `POST /api/v1/nvd/import` importiert eine einzelne CVE direkt aus der NVD in Rust, persistiert sie im Rust-Store und ersetzt damit den Python-fetch-plus-upsert-Pfad fuer Einzelimporte
   - `GET /api/v1/cve-assessments` liefert tenantgebundene CVE-Assessments inklusive Summary, Prioritaet, Produkt- und Risiko-Bezug
   - `POST /api/v1/cve-assessments` legt tenantgebundene CVE-Assessments in Rust an oder aktualisiert sie per Natural-Key-Upsert, zieht Defaultwerte aus CVE/Tenant, berechnet Prioritaet/Faelligkeit, haengt den lokalen LLM-Stub an und verknuepft bei Bedarf automatisch Produkt-Security-Vulnerability und Risiko
   - `GET /api/v1/cve-assessments/{assessment_id}` liefert den tenantgebundenen Assessment-Detailbaum inklusive LLM-Ergebnis, empfohlenen Massnahmen und benoetigten Evidenzen
   - `/cves/` rendert CVE-Feed plus letzte tenantgebundene Assessments direkt aus dem Rust-Store und bietet den neuen Rust-Webflow fuer Assessment-Anlage/-Update
-  - `/cves/assessments/{assessment_id}` rendert die Assessment-Detailansicht direkt aus dem Rust-Store
+  - `/cves/{assessment_id}/` und `/cves/assessments/{assessment_id}` rendert die Assessment-Detailansicht direkt aus dem Rust-Store und haengt die alte Django-URL-Form an den Rust-Webslice
   - `/cves/llm-test/` prueft die lokale Rust-LLM-Runtime direkt ueber die Web-Shell
-  - offen bleiben im CVE-Bereich vor allem Restparitaet fuer NVD-Sync-/Edge-Flows und das anschliessende Django-Abraumen
+  - offen bleiben im CVE-Bereich vor allem Bulk-/Sync-Orchestrierung, letzte Edge-Paritaet und das anschliessende Django-Abraumen
 
 ## App-Migrationsreihenfolge