tweak: add route for fetching Delphi issue type schema, abstract Labrinth away from issue types

Author: AlexTMjugador

apps/labrinth/migrations/20250810155316_delphi-reports.sql

@@ -2,29 +2,6 @@ CREATE TYPE delphi_report_severity AS ENUM ('low', 'medium', 'high', 'severe');
 
 CREATE TYPE delphi_report_issue_status AS ENUM ('pending', 'approved', 'rejected');
 
-CREATE TYPE delphi_report_issue_type AS ENUM (
-	'reflection_indirection',
-	'xor_obfuscation',
-	'included_libraries',
-	'suspicious_binaries',
-	'corrupt_classes',
-	'suspicious_classes',
-	'url_usage',
-	'classloader_usage',
-	'processbuilder_usage',
-	'runtime_exec_usage',
-	'jni_usage',
-	'main_method',
-	'native_loading',
-	'malformed_jar',
-	'nested_jar_too_deep',
-	'failed_decompilation',
-	'analysis_failure',
-	'malware_easyforme',
-	'malware_simplyloader',
-	'unknown'
-);
-
 -- A Delphi analysis report for a project version
 CREATE TABLE delphi_reports (
 	id BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
@@ -46,7 +23,7 @@ CREATE TABLE delphi_report_issues (
 	report_id BIGINT NOT NULL REFERENCES delphi_reports (id)
 		ON DELETE CASCADE
 		ON UPDATE CASCADE,
-	issue_type DELPHI_REPORT_ISSUE_TYPE NOT NULL,
+	issue_type TEXT NOT NULL,
 	status DELPHI_REPORT_ISSUE_STATUS NOT NULL,
 	UNIQUE (report_id, issue_type)
 );

apps/labrinth/src/database/models/delphi_report_item.rs

@@ -70,7 +70,7 @@ pub enum DelphiReportSeverity {
 pub struct DBDelphiReportIssue {
     pub id: DelphiReportIssueId,
     pub report_id: DelphiReportId,
-    pub issue_type: DelphiReportIssueType,
+    pub issue_type: String,
     pub status: DelphiReportIssueStatus,
 }
 
@@ -141,7 +141,7 @@ impl DBDelphiReportIssue {
                 RETURNING id
                 ",
                 self.report_id as DelphiReportId,
-                self.issue_type as DelphiReportIssueType,
+                self.issue_type,
                 self.status as DelphiReportIssueStatus,
             )
             .fetch_one(&mut **transaction)
@@ -150,7 +150,7 @@ impl DBDelphiReportIssue {
     }
 
     pub async fn find_all_by(
-        ty: Option<DelphiReportIssueType>,
+        ty: Option<String>,
         status: Option<DelphiReportIssueStatus>,
         order_by: Option<DelphiReportListOrder>,
         count: Option<u16>,
@@ -161,7 +161,7 @@ impl DBDelphiReportIssue {
             r#"
             SELECT
                 delphi_report_issues.id AS "id", report_id,
-                issue_type AS "issue_type: DelphiReportIssueType",
+                issue_type,
                 delphi_report_issues.status AS "status: DelphiReportIssueStatus",
 
                 file_id, delphi_version, artifact_url, created, severity AS "severity: DelphiReportSeverity",
@@ -187,7 +187,7 @@ impl DBDelphiReportIssue {
             OFFSET $5
             LIMIT $4
             "#,
-            ty as Option<DelphiReportIssueType>,
+            ty,
             status as Option<DelphiReportIssueStatus>,
             order_by.map(|order_by| order_by.to_string()),
             count.map(|count| count as i64),
@@ -221,50 +221,6 @@ impl DBDelphiReportIssue {
     }
 }
 
-/// A type of issue found by Delphi for an artifact.
-#[derive(
-    Deserialize, Serialize, Debug, Clone, Copy, PartialEq, Eq, Hash, sqlx::Type,
-)]
-#[serde(rename_all = "snake_case")]
-#[sqlx(type_name = "delphi_report_issue_type", rename_all = "snake_case")]
-pub enum DelphiReportIssueType {
-    ReflectionIndirection,
-    XorObfuscation,
-    IncludedLibraries,
-    SuspiciousBinaries,
-    CorruptClasses,
-    SuspiciousClasses,
-
-    UrlUsage,
-    ClassloaderUsage,
-    ProcessbuilderUsage,
-    RuntimeExecUsage,
-    #[serde(rename = "jni_usage")]
-    #[sqlx(rename = "jni_usage")]
-    JNIUsage,
-
-    MainMethod,
-    NativeLoading,
-
-    MalformedJar,
-    NestedJarTooDeep,
-    FailedDecompilation,
-    AnalysisFailure,
-
-    MalwareEasyforme,
-    MalwareSimplyloader,
-
-    /// An issue reported by Delphi but not known by labrinth yet.
-    #[serde(other)]
-    Unknown,
-}
-
-impl Display for DelphiReportIssueType {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        self.serialize(f)
-    }
-}
-
 /// A Java class affected by a Delphi report issue. Every affected
 /// Java class belongs to a specific issue, and an issue can have zero,
 /// one, or more affected classes. (Some issues may be artifact-wide,

apps/labrinth/src/routes/internal/delphi.rs

@@ -1,9 +1,11 @@
-use std::{collections::HashMap, fmt::Write, sync::LazyLock};
+use std::{collections::HashMap, fmt::Write, sync::LazyLock, time::Instant};
 
 use actix_web::{HttpRequest, HttpResponse, get, post, put, web};
 use chrono::{DateTime, Utc};
+use reqwest::header::{HeaderMap, HeaderValue, USER_AGENT};
 use serde::Deserialize;
 use sqlx::PgPool;
+use tokio::sync::Mutex;
 use tracing::info;
 
 use crate::{
@@ -15,9 +17,8 @@ use crate::{
             delphi_report_item::{
                 DBDelphiReport, DBDelphiReportIssue,
                 DBDelphiReportIssueJavaClass, DecompiledJavaClassSource,
-                DelphiReportIssueStatus, DelphiReportIssueType,
-                DelphiReportListOrder, DelphiReportSeverity,
-                InternalJavaClassName,
+                DelphiReportIssueStatus, DelphiReportListOrder,
+                DelphiReportSeverity, InternalJavaClassName,
             },
         },
         redis::RedisPool,
@@ -38,10 +39,26 @@ pub fn config(cfg: &mut web::ServiceConfig) {
             .service(_run)
             .service(version)
             .service(issues)
-            .service(update_issue),
+            .service(update_issue)
+            .service(issue_type_schema),
     );
 }
 
+static DELPHI_CLIENT: LazyLock<reqwest::Client> = LazyLock::new(|| {
+    reqwest::Client::builder()
+        .default_headers({
+            HeaderMap::from_iter([(
+                USER_AGENT,
+                HeaderValue::from_static(concat!(
+                    "Labrinth/",
+                    env!("COMPILATION_DATE")
+                )),
+            )])
+        })
+        .build()
+        .unwrap()
+});
+
 #[derive(Deserialize)]
 struct DelphiReport {
     pub url: String,
@@ -53,7 +70,7 @@ struct DelphiReport {
     /// Delphi version that generated this report.
     pub delphi_version: i32,
     pub issues: HashMap<
-        DelphiReportIssueType,
+        String,
         HashMap<InternalJavaClassName, Option<DecompiledJavaClassSource>>,
     >,
     pub severity: DelphiReportSeverity,
@@ -169,9 +186,6 @@ pub async fn run(
     .fetch_one(exec)
     .await?;
 
-    static DELPHI_CLIENT: LazyLock<reqwest::Client> =
-        LazyLock::new(reqwest::Client::new);
-
     tracing::debug!(
         "Running Delphi for project {}, version {}, file {}",
         file_data.project_id.0,
@@ -241,7 +255,7 @@ async fn version(
 #[derive(Deserialize)]
 struct DelphiIssuesSearchOptions {
     #[serde(rename = "type")]
-    ty: Option<DelphiReportIssueType>,
+    ty: Option<String>,
     status: Option<DelphiReportIssueStatus>,
     order_by: Option<DelphiReportListOrder>,
     count: Option<u16>,
@@ -254,7 +268,7 @@ async fn issues(
     pool: web::Data<PgPool>,
     redis: web::Data<RedisPool>,
     session_queue: web::Data<AuthQueue>,
-    search_options: web::Query<DelphiIssuesSearchOptions>,
+    web::Query(search_options): web::Query<DelphiIssuesSearchOptions>,
 ) -> Result<HttpResponse, ApiError> {
     check_is_moderator_from_headers(
         &req,
@@ -324,3 +338,50 @@ async fn update_issue(
         Ok(HttpResponse::Created().finish())
     }
 }
+
+#[get("issue_type/schema")]
+async fn issue_type_schema(
+    req: HttpRequest,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    check_is_moderator_from_headers(
+        &req,
+        &**pool,
+        &redis,
+        &session_queue,
+        Scopes::PROJECT_READ,
+    )
+    .await?;
+
+    // This route is expected to be called often by the frontend, and Delphi is not necessarily
+    // built to scale beyond malware analysis, so cache the result of its quasi-constant-valued
+    // schema route to alleviate the load on it
+
+    static CACHED_ISSUE_TYPE_SCHEMA: Mutex<
+        Option<(serde_json::Map<String, serde_json::Value>, Instant)>,
+    > = Mutex::const_new(None);
+
+    match &mut *CACHED_ISSUE_TYPE_SCHEMA.lock().await {
+        Some((schema, last_fetch)) if last_fetch.elapsed().as_secs() < 60 => {
+            Ok(HttpResponse::Ok().json(schema))
+        }
+        cache_entry => Ok(HttpResponse::Ok().json(
+            &cache_entry
+                .insert((
+                    DELPHI_CLIENT
+                        .get(format!("{}/schema", dotenvy::var("DELPHI_URL")?))
+                        .send()
+                        .await
+                        .and_then(|res| res.error_for_status())
+                        .map_err(ApiError::Delphi)?
+                        .json::<serde_json::Map<String, serde_json::Value>>()
+                        .await
+                        .map_err(ApiError::Delphi)?,
+                    Instant::now(),
+                ))
+                .0,
+        )),
+    }
+}