Location Research Breakthrough Possible @S-Logix pro@slogix.in

LightGBM-Based Prediction of Software Dependency Vulnerability Risk in OpenProject Using Public Package Metadata and Vulnerability Records

Description

Modern software applications rely on third-party libraries, frameworks, and packages to provide application functionality. These dependencies can introduce security risks when they contain known vulnerabilities, use outdated versions, or have other security-related weaknesses.

OpenProject is an existing open-source project management application that uses software dependencies to support its functionality. The security of these dependencies is an important consideration because vulnerable components may introduce weaknesses into the application.

Traditional vulnerability scanners identify known vulnerabilities by matching installed or declared package versions against available vulnerability databases. Although this process is useful for identifying known issues, organizations may also require a way to prioritize dependency reviews based on the available package information and historical vulnerability records.

In this use case, OpenProject is used as the target application for software dependency risk analysis. The application is deployed within an isolated Ubuntu and Kali Linux laboratory environment. Existing public package metadata and vulnerability records are used as the primary data sources for the machine-learning stage.

The available dataset is inspected to determine whether it contains suitable package attributes and reliable labels for the intended vulnerability-risk classification task. The selected records are processed into numerical features suitable for the LightGBM machine-learning algorithm.

LightGBM is trained to classify dependency records according to the risk categories supported by the selected dataset. The trained model is evaluated using held-out records to measure its classification performance.

Syft is used to generate a Software Bill of Materials (SBOM) from compatible OpenProject artifacts. OSV-Scanner is used to identify known vulnerabilities in supported dependencies, while Grype or Trivy may be used as an additional vulnerability-scanning tool. The scanner findings provide security evidence that can be compared with the machine-learning predictions.

Python integrates package-data processing, model training, risk prediction, evaluation, and dashboard functionality. Streamlit provides an interactive dashboard that displays dependency information, known vulnerability findings, predicted risk categories, and model evaluation results.

The predicted risk is treated as a prioritization aid rather than proof that a package is vulnerable. Known vulnerability findings are independently verified against available security records.

The complete security-validation workflow is:
OpenProject
→
Dependency Collection
→
SBOM Generation
→
Package Metadata Extraction
→
Public Vulnerability Dataset
→
Data Preprocessing
→
Feature Extraction
→
LightGBM Training
→
Dependency Risk Prediction
→
Vulnerability Scanner Validation
→
Risk Prioritization
→
SQLite Storage
→
Streamlit Dashboard
→
Security Review
→
Final Risk Assessment

Existing Security Problem

Application: OpenProject

OpenProject is the target application in this use case. It provides project management functionality and relies on software dependencies to support its operation.

The application is deployed within the authorized laboratory environment. Its available dependency information is examined to identify components that can be assessed against public vulnerability records.

Existing Problem:

Software applications may contain numerous direct and transitive dependencies. A direct dependency is included by the application itself, while a transitive dependency is introduced through another dependency.

Some dependencies may have publicly documented vulnerabilities. Other components may have limited metadata, outdated versions, or insufficient information to determine their security status immediately.

Traditional vulnerability scanners help identify known vulnerabilities, but security teams may still need to prioritize which packages require further investigation first.

Manual prioritization becomes difficult when the application has a large dependency inventory and the available security information comes from multiple sources.

The security problem is:
OpenProject Application
→
Third-Party Software Dependencies
→
Package Metadata and Version Information
→
Potentially Vulnerable Components
→
Public Vulnerability Records
→
Dependency Risk Assessment
→
Multiple Components Requiring Security Review
→
Manual Risk Prioritization
→
Requirement for ML-Based Risk Classification
→
Evidence-Based Security Verification

The proposed solution introduces a LightGBM-based risk-classification workflow that learns patterns from suitable labelled package records and assigns predicted risk categories to compatible dependency records.

Attack

Specific Attack: Software Dependency Vulnerability Risk Scenario

The security scenario evaluates whether dependencies used by OpenProject contain known vulnerabilities or exhibit package characteristics associated with the risk categories represented in the training dataset.

The project does not require the creation or execution of a malicious package. Instead, it examines software dependency risk using existing public security data and the actual dependency information available from the target application.

The assessment uses public package metadata, vulnerability records, the generated SBOM, and controlled security-scanning results to evaluate the dependency-risk prediction workflow.

A dependency identified as potentially high risk by the model is reviewed using available vulnerability records and scanner evidence. A high-risk prediction alone does not establish that the component is vulnerable or exploitable.

Attack Behavior:
OpenProject Application
→
Third-Party Dependency Inventory
→
Potentially Vulnerable Dependency
→
Public Vulnerability Record Matching
→
Package Metadata Extraction
→
LightGBM Risk Classification
→
Predicted Risk Category
→
Known Vulnerability Verification
→
Security Finding Review
→
Dependency Risk Prioritization
→
Remediation Recommendation

Security Concept

Machine-Learning-Based Software Dependency Vulnerability-Risk Prediction

The primary security concept is Machine-Learning-Based Software Dependency Vulnerability-Risk Prediction.

The first objective is to establish a suitable package-level dataset using existing public package metadata and vulnerability records. The selected data must contain appropriate features and sufficiently reliable labels to support the intended classification task.

The second objective is to train a LightGBM model using the prepared package features. The model learns relationships represented in the training data and predicts the risk category associated with compatible dependency records.

The third objective is to compare the model predictions with known vulnerability information and security-scanning results. This helps evaluate whether the model can support dependency-risk prioritization without treating predicted risk as confirmed vulnerability evidence.

The assessment follows:
OpenProject Dependency Analysis
→
SBOM Generation
→
Package Metadata Collection
→
Public Vulnerability Dataset
→
Dataset Suitability Assessment
→
Data Preprocessing
→
Feature Extraction
→
LightGBM Model Training
→
Held-Out Model Evaluation
→
Dependency Risk Prediction
→
Known Vulnerability Verification
→
Risk-Based Prioritization
→
Dashboard Reporting
→
Final Security Validation

Defensive Mechanism

The security concept defines the overall dependency-risk assessment strategy.

The following are the specific defensive mechanisms implemented.

Software Dependency Inventory :

Syft generates an SBOM from compatible OpenProject artifacts to identify software components and their available package metadata.

Purpose: Establish a structured inventory of the software dependencies included in the assessment.
Public Vulnerability Record Correlation :

Public vulnerability records are matched against available package names, ecosystems, and versions.

Purpose: Public vulnerability records are matched against available package names, ecosystems, and versions.

Package Metadata Preprocessing

Package metadata and vulnerability-related records are cleaned and transformed into a consistent feature representation.

Purpose
  • Prepare suitable model inputs while preserving the information required for security verification.

LightGBM-Based Risk Classification

LightGBM classifies dependency records using patterns learned from the selected labelled training data.

Purpose
  • Estimate the risk category associated with compatible dependency records.

Vulnerability Scanner Validation

OSV-Scanner identifies known vulnerability matches in supported dependency inputs. Grype or Trivy may provide additional scanning evidence.

Purpose
  • Compare predicted risk categories with independently obtained vulnerability findings.

Risk-Based Dependency Prioritization

Dependencies are organized for further review using model predictions, known vulnerability findings, and other available security evidence.

Purpose
  • Help security analysts prioritize components requiring investigation.

Security Evidence Storage

SQLite stores package details, model predictions, scanner findings, and evaluation results.

Purpose
  • Maintain structured evidence for review and repeatable analysis.

Dashboard-Based Security Reporting

Streamlit presents dependency inventory, vulnerability matches, predicted risk categories, and model evaluation results.

Purpose
  • Provide an interactive interface for examining and prioritizing dependency risks.

Post-Assessment Validation

The final findings are reviewed against the original package records and known vulnerability information.

Purpose
  • Confirm which findings are supported by security evidence and distinguish them from model-generated predictions.

Security Tools

Primary Machine-Learning Algorithm: LightGBM

LightGBM is the machine-learning algorithm used to classify package vulnerability-risk categories.

Purpose
  • Train a model using suitable labelled package records.
  • Learn patterns from the available package metadata and related features.
  • Generate risk-category predictions for compatible dependency records.
  • Support risk-based prioritization.

Target Application: OpenProject

OpenProject provides the existing software application whose dependencies are examined.

Purpose
  • Provide the target application for dependency analysis.
  • Supply the available dependency declarations and package information.
  • Support SBOM generation and security assessment.
  • Provide an application-specific environment for validation.

Software Composition Analysis Tool: Syft

Syft generates an SBOM from supported application artifacts.

Purpose
  • Identify software components in supported artifacts.
  • Extract package names, versions, and available identifiers.
  • Generate a structured component inventory.
  • Provide input for vulnerability correlation.

Primary Vulnerability Scanning Tool: OSV-Scanner

OSV-Scanner checks supported dependency inputs against vulnerability information from OSV.

Purpose
  • Identify known vulnerabilities associated with supported dependencies.
  • Compare package names and versions with available vulnerability records.
  • Produce scanner findings for independent verification.
  • Support post-remediation validation.

Additional Vulnerability Scanning Tool: Grype

Grype is an optional additional scanner for supported software artifacts and SBOMs.

Purpose
  • Identify known vulnerability matches in supported component inventories.
  • Provide additional scanning evidence.
  • Compare findings with the primary scanner.
  • Support verification of selected dependency risks.

Alternative Vulnerability Scanning Tool: Trivy

Trivy is an optional alternative or supplementary scanner for supported application artifacts and dependencies.

Purpose
  • Identify known vulnerabilities in supported software artifacts.
  • Provide additional dependency-security findings.
  • Support comparison with the machine-learning results.

Vulnerability Information Source: OSV.dev

OSV.dev provides public vulnerability records for supported package ecosystems.

Purpose
  • Supply known vulnerability information.
  • Support package-version correlation.
  • Provide evidence for validating scanner findings.
  • Help establish reference information for dataset preparation.

Programming and Automation Tool: Python

Python provides the main implementation environment.

Purpose
  • Integrate package-data collection and preprocessing.
  • Implement the LightGBM training and prediction workflow.
  • Connect vulnerability-scanning outputs with model results.
  • Generate dashboard-ready analysis records.

Data Processing Tool: Pandas

Pandas is used to organize and process the available package metadata and vulnerability records.

Purpose
  • Load and inspect dataset records.
  • Clean and transform package information.
  • Organize features and classification labels.
  • Prepare results for storage and visualization.

Numerical Processing Tool: NumPy

NumPy supports numerical data processing.

Purpose
  • Perform numerical transformations.
  • Prepare numerical arrays where required.
  • Support data processing and model evaluation.

Model Evaluation Tool: Scikit-learn

Scikit-learn provides classification metrics and suitable data-splitting utilities.

Purpose
  • Prepare training and evaluation partitions.
  • Calculate precision, recall, and F1-score.
  • Generate confusion-matrix results.
  • Evaluate the LightGBM model against known labels.

Dashboard Framework: Streamlit

Streamlit provides the interactive dependency-risk dashboard.

Purpose
  • Display dependency inventory and scanner findings.
  • Show predicted risk categories.
  • Present risk-distribution charts.
  • Display model evaluation results.
  • Support export of analysis reports.

Local Database: SQLite

SQLite stores the results produced by the analysis workflow.

Purpose
  • Store dependency records.
  • Maintain predicted risk categories.
  • Preserve vulnerability-scanner findings.
  • Store model evaluation and validation results.

Operating System: Ubuntu Linux

Ubuntu provides the primary application and analysis environment.

Purpose
  • Host OpenProject according to the selected deployment method.
  • Execute Python and the security-analysis workflow.
  • Run supported scanning and SBOM tools.
  • Host the Streamlit dashboard and SQLite database.

Security Testing Platform: Kali Linux

Kali Linux provides a separate security-testing environment where required.

Purpose
  • Support authorized security assessment.
  • Access the target application within the laboratory network.
  • Perform permitted service discovery where applicable.
  • Support security-validation activities.

Network Discovery Tool: Nmap

Nmap is optional for discovering network services associated with the authorized laboratory deployment.

Purpose
  • Identify exposed application services.
  • Validate expected laboratory network exposure.
  • Provide supplementary infrastructure information.

Virtualization Platform: VirtualBox

VirtualBox provides the isolated laboratory infrastructure.

Purpose
  • Host Ubuntu and Kali Linux virtual machines.
  • Separate the target application and testing environment.
  • Support controlled and repeatable experiments.
  • Reduce unintended interaction with external systems.

Process

STEP 01

Prepare the Isolated Software Supply-Chain Security Environment

  • Create the laboratory environment using VirtualBox.
  • Configure Ubuntu Linux as the primary application and analysis system.
  • Configure Kali Linux as the security-testing system where required.
  • Establish the intended laboratory network connectivity.
  • Verify that the target application and analysis environment are accessible as required.
  • Confirm that dependency analysis and security testing are restricted to the authorized environment.
  • Record the initial virtual-machine configuration.
Tools: VirtualBox + Ubuntu Linux + Kali Linux
STEP 02

Deploy OpenProject

  • Deploy OpenProject in the Ubuntu laboratory using its supported installation method.
  • Configure the required application components.
  • Start the application services.
  • Verify that OpenProject is operational.
  • Record the application version and deployment method.
  • Identify the available dependency declarations and supported artifacts that can be examined.
Tools: OpenProject + Ubuntu Linux
STEP 03

Establish the Application and Dependency Baseline

  • Inspect the OpenProject installation and its available dependency information.
  • Identify the relevant project manifests, lockfiles, or supported application artifacts.
  • Record the application version and the source of the dependency information.
  • Verify that the selected files represent the intended application version.
  • Preserve the original dependency files before analysis.
  • Determine which dependency records can be extracted reliably.
Tools: OpenProject + Ubuntu Linux + Python
STEP 04

Generate the Software Bill of Materials

  • Use Syft to generate an SBOM from a compatible OpenProject artifact or deployment image.
  • Select an appropriate supported SBOM format, such as CycloneDX or SPDX.
  • Inspect the generated component records.
  • Verify that package names, versions, and other available identifiers are present where supported.
  • Record the SBOM generation method and source artifact.
  • If the selected deployment method does not expose all dependencies, document that limitation rather than assuming the SBOM is complete.
Tools: Syft + OpenProject + Ubuntu Linux
STEP 05

Collect Package Metadata

  • Extract package metadata from the generated SBOM and compatible dependency records.
  • Collect available attributes such as package name, version, ecosystem, and package identifier.
  • Preserve direct and transitive dependency information where available.
  • Normalize package names and version representations where appropriate.
  • Record missing or ambiguous metadata.
  • Maintain a reference to the source component for subsequent vulnerability verification.
Tools: Syft + Python + Pandas
STEP 06

Obtain the Existing Public Vulnerability Dataset

  • Identify a suitable existing public dataset containing package metadata and vulnerability-related records.
  • Review its documentation, usage conditions, record structure, available features, and classification labels.
  • Determine whether the data supports the intended package-level risk-classification task.
  • Check whether the dataset contains enough information to distinguish the selected risk categories.
  • Preserve the original dataset and its documentation.
  • Do not assume that every public vulnerability feed provides labelled examples suitable for supervised LightGBM training.
Tools: Python + Pandas + OSV.dev
STEP 07

Inspect Dataset Suitability and Labels

  • Load the selected public dataset into Python.
  • Inspect the available fields and classification labels.
  • Determine how the dataset defines its risk categories.
  • Check whether the labels represent known vulnerability status, severity categories, or another risk-related outcome.
  • Ensure that the chosen target label is consistent throughout the dataset.
  • If the data contains only vulnerability records without suitable negative examples or classification labels, identify an appropriate labelled dataset or revise the model objective before training.
Tools: Python + Pandas + NumPy
STEP 08

Preprocess the Package and Vulnerability Data

  • Clean malformed or unusable records where necessary.
  • Normalize supported package identifiers, ecosystem names, and version fields.
  • Handle missing values according to the meaning of each field.
  • Remove duplicate records only when duplication is confirmed to be unnecessary.
  • Preserve the original records and their references.
  • Prepare a consistent working dataset for feature extraction.
Tools: Python + Pandas + NumPy
STEP 09

Extract Features for LightGBM

  • Identify features supported by the dataset and relevant to the chosen prediction task.
  • Possible features include package ecosystem, version-related attributes, available package metadata, historical vulnerability information, and other verified fields.
  • Encode categorical attributes and handle missing values using a consistent preprocessing pipeline.
  • Separate the input features from the target labels.
  • Check that the features are available at the time the intended prediction would be made.
  • Avoid using information that directly reveals the target label, as this can cause data leakage.
  • Record the feature-extraction configuration.
Tools: Python + Pandas + NumPy + LightGBM
STEP 10

Prepare Training, Validation, and Test Data

  • Split the prepared dataset into training and evaluation partitions.
  • Preserve the verified target labels.
  • Where possible, use appropriate grouping or time-aware splitting to reduce leakage between related package records.
  • Review the class distribution in each partition.
  • Ensure that the held-out test records are not used to fit the model or tune its settings.
  • Record the final dataset size and split configuration.
Tools: Python + Pandas + Scikit-learn
STEP 11

Train the LightGBM Model

  • Configure the LightGBM classifier according to the selected target categories.
  • Provide the processed training features and corresponding labels.
  • Train the model using the existing public dataset.
  • Monitor the training process and review the available validation results.
  • Adjust model settings only using the designated training and validation data.
  • Save the trained model and its preprocessing configuration.
  • Confirm that the model can generate predictions for compatible records.
Tools: Python + LightGBM + Scikit-learn
STEP 12

Evaluate the Trained Model

  • Evaluate the model using the held-out test partition.
  • Generate predictions for the test records.
  • Compare the predicted categories with the known test labels.
  • Calculate precision, recall, F1-score, and other appropriate classification metrics.
  • Generate a confusion matrix to examine the classification errors.
  • Review false positives and false negatives.
  • Record the actual evaluation results rather than assuming that the model achieves a particular accuracy.
Tools: Python + LightGBM + Scikit-learn + Pandas
STEP 13

Scan OpenProject Dependencies for Known Vulnerabilities

  • Use OSV-Scanner to examine supported OpenProject dependency inputs or compatible SBOM data.
  • Review the scanner output and identify known vulnerability matches.
  • Use Grype or Trivy as an optional additional scanner where appropriate.
  • Preserve the original scan reports.
  • Record package identifiers, affected versions, vulnerability identifiers, and available severity information.
  • Distinguish scanner-confirmed vulnerability matches from the model's predicted risk categories.
Tools: OSV-Scanner + Syft + OpenProject + Ubuntu Linux
STEP 14

Prepare OpenProject Components for Model Prediction

  • Match the extracted OpenProject package metadata with the feature representation used during model training.
  • Apply the same preprocessing configuration and feature transformations.
  • Verify that required features are available for the selected dependency records.
  • Check that feature names, ordering, data types, and dimensions are compatible with the trained model.
  • Do not invent missing package attributes to force a prediction.
  • If the public training data and OpenProject component records are incompatible, revise the feature mapping or select a more suitable dataset before proceeding.
Tools: Python + Pandas + NumPy + LightGBM
STEP 15

Generate Dependency Risk Predictions

  • Load the trained LightGBM model and its preprocessing configuration.
  • Provide compatible OpenProject dependency records to the model.
  • Generate the predicted risk category for each eligible dependency.
  • Record model probabilities or confidence-related outputs where supported by the implementation.
  • Associate every prediction with its original package identifier and version.
  • Store the predictions separately from the known vulnerability findings.
  • Flag records requiring further investigation according to the defined risk-prioritization criteria.
Tools: Python + LightGBM + Pandas
STEP 16

Correlate Predictions with Vulnerability Evidence

  • Compare the predicted dependency-risk categories with OSV-Scanner findings and available public vulnerability records.
  • Review package names, ecosystems, versions, vulnerability identifiers, and severity information.
  • Identify components that have both a high predicted risk and a known vulnerability match.
  • Identify components predicted as high risk without a known vulnerability match for further investigation.
  • Identify known vulnerable components that receive lower predicted risk categories.
  • Do not treat the absence of a scanner finding as proof that a package is safe.
  • Preserve the evidence supporting each assessment.
Tools: Python + Pandas + OSV-Scanner + SQLite
STEP 17

Store Results and Create the Streamlit Dashboard

  • Create the SQLite database for the dependency-risk analysis.
  • Store the package inventory, known vulnerability findings, model predictions, and validation results.
  • Develop a Streamlit dashboard to display the OpenProject analysis.
  • Include dependency counts, known vulnerability matches, predicted risk categories, risk-distribution charts, and package-level details.
  • Provide a clear distinction between model predictions and independently verified vulnerability findings.
  • Where appropriate, provide CSV export for the analysis results.
  • Verify that dashboard information matches the stored records and original scan evidence.
Tools: Python + SQLite + Streamlit + Pandas
STEP 18

Perform Final Security Validation and Risk Review

  • Repeat the dependency analysis where required.
  • Review the SBOM and confirm that the selected package records correspond to the intended OpenProject version.
  • Review the model evaluation metrics and the limitations of the training dataset.
  • Compare the model predictions with known vulnerability records and scanner results.
  • Investigate false positives, false negatives, and discrepancies between the predicted categories and available security evidence.
  • Document the dataset source, preprocessing configuration, model settings, and validation results.
  • Record dependencies requiring further security review and the evidence supporting each recommendation.
  • Finalize the software dependency vulnerability-risk assessment.
Tools: LightGBM + Python + OSV-Scanner + Syft + SQLite + Streamlit + Ubuntu Linux

Outcome

OpenProject is deployed within an isolated Ubuntu laboratory environment, providing an existing software application for dependency-risk analysis.

A Software Bill of Materials is generated from compatible OpenProject artifacts, providing a structured inventory of the software components included in the assessment.

Existing public package metadata and vulnerability records are inspected to determine whether they contain suitable features and reliable labels for the proposed machine-learning task.

The selected package records are preprocessed and transformed into numerical features suitable for LightGBM training.

The LightGBM model is trained and evaluated using held-out records, providing measurable evidence of classification performance.

OSV-Scanner identifies known vulnerability matches in supported dependency inputs, while an optional additional scanner provides supplementary validation evidence.

Compatible OpenProject dependency records are evaluated by the trained model to generate predicted vulnerability-risk categories.

Model predictions are compared with known vulnerability information and scanner findings, helping identify dependencies requiring further investigation.

A Streamlit dashboard displays the dependency inventory, known vulnerability findings, predicted risk categories, model evaluation metrics, and package-level analysis results.

The complete workflow demonstrates software dependency collection, SBOM generation, public vulnerability-data processing, LightGBM-based risk classification, scanner-based verification, risk prioritization, dashboard reporting, and final security validation. The resulting system supports dependency-risk assessment while preserving the distinction between predicted risk and confirmed vulnerability evidence.