feat: improve GF-pattern identification logic and normalize finding metadata for the frontend

Author: h0tak88r

internal/api/scan_results_api.go

@@ -1419,16 +1419,27 @@ func parseFindingFromObject(v map[string]interface{}, fallback string) parsedFin
 		}
 	}
 
-	template := firstNonEmpty(
-		fmt.Sprint(v["finding"]),
-		fmt.Sprint(v["template-id"]),
-		fmt.Sprint(v["template_id"]),
-		fmt.Sprint(v["template"]),
-		fmt.Sprint(v["id"]),
-		fmt.Sprint(v["name"]),
-		fmt.Sprint(v["title"]),
-		fmt.Sprint(v["issue"]),
-	)
+	// For GF-pattern findings: use template-id (e.g. "gf-ssrf") as the label,
+	// not the generic "Pattern-matched URL candidate" string stored in "finding".
+	findingVal := strings.TrimSpace(fmt.Sprint(v["finding"]))
+	templateIDVal := firstNonEmpty(fmt.Sprint(v["template-id"]), fmt.Sprint(v["template_id"]))
+	patternVal := strings.TrimSpace(fmt.Sprint(v["pattern"]))
+	isGFPattern := strings.EqualFold(strings.TrimSpace(fmt.Sprint(v["module"])), "gf-patterns")
+	var template string
+	if isGFPattern {
+		// Prefer explicit pattern name → template-id → fallback to finding
+		template = firstNonEmpty(templateIDVal, patternVal, findingVal)
+	} else {
+		template = firstNonEmpty(
+			findingVal,
+			templateIDVal,
+			fmt.Sprint(v["template"]),
+			fmt.Sprint(v["id"]),
+			fmt.Sprint(v["name"]),
+			fmt.Sprint(v["title"]),
+			fmt.Sprint(v["issue"]),
+		)
+	}
 	target := firstNonEmpty(
 		fmt.Sprint(v["matched-at"]),
 		fmt.Sprint(v["matched_at"]),
@@ -1476,10 +1487,20 @@ func parseFindingFromObject(v map[string]interface{}, fallback string) parsedFin
 	}
 	// Normalise nuclei hyphenated keys to underscored equivalents so the
 	// frontend can access them consistently (e.g. template-id → template_id).
-	normRaw := make(map[string]interface{}, len(v))
+	normRaw := make(map[string]interface{}, len(v)+4)
 	for k, val := range v {
 		normRaw[strings.ReplaceAll(k, "-", "_")] = val
 	}
+	// For GF findings: ensure pattern and template_id are always reachable
+	// by the frontend registry (some older scan JSON may only have template-id).
+	if isGFPattern {
+		if patternVal != "" {
+			normRaw["pattern"] = patternVal
+		}
+		if templateIDVal != "" {
+			normRaw["template_id"] = templateIDVal
+		}
+	}
 	return parsedFinding{
 		Severity: sev,
 		Target:   target,

internal/api/ui/pages/module-registry.js

@@ -193,33 +193,55 @@
     gf: {
       columns: [
         { id: 'target',  label: 'TARGET',  flex: '2', type: 'link'       },
+        { id: 'sev',     label: 'SEV',     w: '68px', type: 'sev-badge',  align: 'center' },
         { id: 'pattern', label: 'PATTERN', flex: '1', type: 'badge-pill'  },
-        { id: 'value',   label: 'VALUE',   flex: '3', type: 'mono-trunc'  },
-        { id: 'source',  label: 'SOURCE',  flex: '1', type: 'muted-trunc' },
+        { id: 'value',   label: 'MATCHED URL', flex: '3', type: 'mono-trunc' },
       ],
       extract(r) {
+        const raw = r.raw || {};
         const target = s(r.host || r.target || '-');
-        
-        let patternName = s(r.pattern || r.finding_type || '');
+
+        // Resolve pattern name: prefer explicit raw.pattern → raw.template_id → r.finding → filename
+        let patternName = s(raw.pattern || raw.template_id || '');
         if (!patternName && r.file) {
-           patternName = r.file.replace(/\.txt$/i, '').replace(/^gf-/i, '');
-        }
-        if (!patternName) patternName = s(r.module || '—');
-        
-        let valueStr = s(r.value || r.finding || '-');
-        if (valueStr.toLowerCase() === 'gf-patterns' || valueStr.toLowerCase() === s(r.module).toLowerCase()) {
-            valueStr = '-';
+          patternName = r.file.replace(/\.txt$/i, '').replace(/^gf-/i, '').replace(/-results$/i, '');
         }
+        if (!patternName) patternName = s(r.finding || r.module || '—');
+        // Strip leading "gf-" prefix for display (gf-ssrf → ssrf)
+        const displayName = patternName.replace(/^gf-/i, '');
+
+        // Pattern → colour mapping
+        const patternColors = {
+          ssrf: '#f87171', rce: '#f87171', lfi: '#f87171', sqli: '#f87171', ssti: '#f87171',
+          xss: '#fb923c', redirect: '#fbbf24', idor: '#fbbf24', iparams: '#fbbf24', debug_logic: '#fbbf24',
+          iext: '#4ade80', 'img-traversal': '#4ade80', isubs: '#22d3ee', jsvar: '#22d3ee',
+        };
+        const color = patternColors[displayName.toLowerCase()] || '#a78bfa';
+
+        // VALUE column: the actual matched URL (stored in target/host after backend parsing)
+        const value = s(r.target || r.host || '-');
 
         return {
           target:  { href: toHref(target), label: target },
-          pattern: { label: patternName, color: '#a78bfa' },
-          value:   valueStr,
-          source:  s(r.file || r.source || '—'),
+          sev:     sevMeta(r.severity),
+          pattern: { label: displayName || patternName, color },
+          value,
         };
       },
+      detail(r) {
+        const raw = r.raw || {};
+        const patternName = s(raw.pattern || raw.template_id || r.finding || '');
+        return buildFields([
+          ['Pattern',     patternName.replace(/^gf-/i, '')],
+          ['Full ID',     patternName],
+          ['Matched URL', s(r.target || r.host || ''), { isLink: true }],
+          ['Severity',    s(r.severity)],
+          ['Source File', s(r.file || raw.module || '')],
+        ]);
+      },
     },
 
+
     /* ── JS Analysis ────────────────────────────────────────────────────── */
     js: {
       columns: [