fix: input validation for edge parser and path traversal prevention, add SECURITY.md

security_fix: Two hardening improvements:

1. Edge-list parser (Main.java): Previously crashed with
   ArrayIndexOutOfBoundsException on malformed lines (fewer than 4
   fields) and NumberFormatException on non-numeric weights. Now
   validates field count (>= 4), catches NumberFormatException, and
   rejects NaN/Infinity weights. Malformed lines are skipped with
   stderr warnings instead of crashing the application.

2. Network.generateFile() path traversal (Network.java): Added
   canonical path validation ensuring the output file resolves within
   the working directory. Prevents directory traversal via paths like
   '../../etc/something'. Throws SecurityException on violation.

doc_update: Added comprehensive SECURITY.md documenting:
- Security model and threat categories with mitigation status
- Database security (parameterized queries, credential management)
- File I/O security (path validation, input validation, XML escaping)
- Analysis engine defensive patterns (null checks, immutable results)
- Dependency audit with upgrade recommendations
- Vulnerability reporting guidance

Author: sauravbhattacharya001

Gvisual/src/app/Network.java

@@ -19,7 +19,10 @@ public class Network {
      * Connects to database and writes out the edge-list from the meeting DB table, forming edges of kind:
      * friends, classmates, study-groups, strangers and familiar strangers (depending upon parameters).
      *
-     * @param path
+     * <p>The output path is validated to prevent directory traversal —
+     * it must resolve to a location within the current working directory.</p>
+     *
+     * @param path output file path (must be within the working directory)
      * @param Month
      * @param Date
      * @param dThresF
@@ -36,6 +39,15 @@ public class Network {
      */
     public static void generateFile(String path, String Month, String Date, int dThresF, int CThresF, int dThresFS, int CThresFS, int dThresC, int CThresC, int dThresS, int CThresS, int dThresSg, int CThresSg) throws Exception {
 
+        // Validate output path — prevent directory traversal attacks
+        File outputFile = new File(path).getCanonicalFile();
+        File workingDir = new File(".").getCanonicalFile();
+        if (!outputFile.toPath().startsWith(workingDir.toPath())) {
+            throw new SecurityException(
+                "Output path must be within the working directory. "
+                + "Resolved path: " + outputFile.getAbsolutePath());
+        }
+
         System.out.println("connecting...");
 
         // Parameterized query template for location-based meeting queries.

Gvisual/src/gvisual/Main.java

@@ -643,15 +643,35 @@ public void addGraph() throws ParserConfigurationException, IOException, SAXExce
                 } else {
                     if (count == 0) {
                         final String[] nodeParam = line.split(" ");
+                        if (nodeParam.length < 1 || nodeParam[0].isEmpty()) {
+                            continue; // skip malformed node lines
+                        }
                         g.addVertex(nodeParam[0]);
                         //graphLayout.setLocation(nodeParam[0], new Point(Integer.parseInt(nodeParam[1]), Integer.parseInt(nodeParam[2])));
                     } else {
 
 
 
                         String[] edgeParam = line.split(" ");
+                        // Validate edge line: need at least 4 fields
+                        // (type, vertex1, vertex2, weight)
+                        if (edgeParam.length < 4) {
+                            System.err.println("Skipping malformed edge line: " + line);
+                            continue;
+                        }
+                        float weight;
+                        try {
+                            weight = Float.parseFloat(edgeParam[3]);
+                        } catch (NumberFormatException nfe) {
+                            System.err.println("Skipping edge with invalid weight: " + line);
+                            continue;
+                        }
+                        if (Float.isNaN(weight) || Float.isInfinite(weight)) {
+                            System.err.println("Skipping edge with non-finite weight: " + line);
+                            continue;
+                        }
                         edge curEdge = new edge(edgeParam[0], edgeParam[1], edgeParam[2]);
-                        curEdge.setWeight(Float.parseFloat(edgeParam[3]));
+                        curEdge.setWeight(weight);
 
                         // Classify edge by type and add to the appropriate list
                         EdgeType edgeType = EdgeType.fromCode(edgeParam[0]);

SECURITY.md

@@ -0,0 +1,133 @@
+# Security
+
+This document describes the security model, threat surface, and
+mitigations in GraphVisual.
+
+## Reporting Vulnerabilities
+
+If you discover a security vulnerability, please **do not** open a public
+issue. Instead, email the maintainer directly or use GitHub's private
+vulnerability reporting feature.
+
+## Security Model
+
+GraphVisual is a desktop Swing application that processes Bluetooth
+proximity data from a PostgreSQL database and renders social network
+graphs. Its security posture is shaped by two distinct surfaces:
+
+1. **Database access** — connects to PostgreSQL using credentials from
+   environment variables
+2. **File I/O** — reads edge-list files and writes exports (GraphML, PNG)
+
+### Threat Categories
+
+| Threat | Surface | Status |
+|--------|---------|--------|
+| SQL injection | Database queries | ✅ Mitigated — all queries use `PreparedStatement` with parameterized bindings |
+| Credential exposure | Database connection | ✅ Mitigated — credentials read from `DB_HOST`, `DB_USER`, `DB_PASS` environment variables; never hardcoded |
+| XML injection in exports | GraphML export | ✅ Mitigated — `GraphMLExporter.escapeXml()` escapes `&`, `<`, `>`, `"`, `'` |
+| Path traversal | File output | ✅ Mitigated — `Network.generateFile()` validates output path is within working directory |
+| Malformed input files | Edge-list parser | ✅ Mitigated — validates field count and weight format before constructing edge objects |
+| NaN/Infinity weights | Edge-list parser | ✅ Mitigated — rejects `NaN` and `Infinity` weight values |
+| Denial of service (large graphs) | Graph analysis | ⚠️ Partial — analyzers have no built-in size limits; very large graphs can exhaust memory |
+
+## Database Security
+
+### Parameterized Queries
+
+All SQL queries in the `app/` package use `PreparedStatement` with `?`
+placeholders. There is no string concatenation of user input into SQL:
+
+- `Network.java` — 5 parameterized queries for relationship extraction
+- `matchImei.java` — 4 parameterized queries for IMEI matching
+- `addLocation.java` — 3 parameterized queries for WiFi AP lookup
+- `findMeetings.java` — parameterized queries for meeting extraction
+
+### Credential Management
+
+Database credentials are loaded exclusively from environment variables
+via `Util.java`:
+
+```java
+String host = envOrDefault("DB_HOST", DEFAULT_HOST);
+String user = requireEnv("DB_USER");  // throws if missing
+String pass = requireEnv("DB_PASS");  // throws if missing
+```
+
+Missing required variables cause an immediate `IllegalStateException`
+with a clear error message rather than falling through to a default
+or null credential.
+
+## File I/O Security
+
+### Output Path Validation
+
+`Network.generateFile()` validates that the output file path resolves
+to a location within the current working directory using canonical path
+comparison:
+
+```java
+File outputFile = new File(path).getCanonicalFile();
+File workingDir = new File(".").getCanonicalFile();
+if (!outputFile.toPath().startsWith(workingDir.toPath())) {
+    throw new SecurityException("Output path must be within the working directory.");
+}
+```
+
+This prevents directory traversal attacks via paths like
+`../../etc/crontab`.
+
+### Edge-List Input Validation
+
+The edge-list parser in `Main.java` validates each line before
+constructing edge objects:
+
+- **Field count** — requires at least 4 fields (type, vertex1, vertex2,
+  weight); malformed lines are skipped with a warning
+- **Weight parsing** — catches `NumberFormatException` from invalid
+  weight strings
+- **Non-finite weights** — rejects `NaN` and `Infinity` values that
+  could corrupt analysis results
+
+### GraphML Export
+
+`GraphMLExporter.escapeXml()` handles all five XML special characters
+(`& < > " '`), preventing injection of arbitrary XML elements or
+attributes into exported files.
+
+## Analysis Engine Security
+
+All analyzer constructors validate their input:
+
+```java
+if (graph == null) {
+    throw new IllegalArgumentException("Graph must not be null");
+}
+```
+
+Result objects wrap collections in `Collections.unmodifiable*()` to
+prevent mutation after creation.
+
+## Dependencies
+
+| Dependency | Version | Notes |
+|------------|---------|-------|
+| JUNG | 2.0.1 | Graph library — no known CVEs |
+| PostgreSQL JDBC | 8.3-604 | Legacy driver — consider upgrading for TLS improvements |
+| Commons IO | 1.4 | File utilities — consider upgrading for security patches |
+| JUnit | 4.13.2 | Test-only dependency |
+
+### Recommendations
+
+- **Upgrade PostgreSQL JDBC** to 42.x for TLS 1.3 support and
+  security fixes
+- **Upgrade Commons IO** to 2.x for path traversal fixes in utility
+  methods
+- **Run with least-privilege database credentials** — the application
+  only needs SELECT on `nic_aziala` tables and SELECT/INSERT/UPDATE on
+  `nic_apps` tables
+
+## CodeQL
+
+This repository has [CodeQL](https://github.com/sauravbhattacharya001/GraphVisual/actions)
+configured for automated security scanning on every push.