Major TOML file update and refactoring of printed text PT.2

ParzivalHack · ParzivalHack · commit ffa6b80841b8 · 2025-09-12T21:46:12.000+02:00
diff --git a/build/lib.win-amd64-cpython-312/pyspector/_rust_core.cp312-win_amd64.pyd b/build/lib.win-amd64-cpython-312/pyspector/_rust_core.cp312-win_amd64.pyd
diff --git a/build/lib.win-amd64-cpython-312/pyspector/rules/96-built-in-rules.toml b/build/lib.win-amd64-cpython-312/pyspector/rules/96-built-in-rules.toml
diff --git a/build/lib.win-amd64-cpython-312/pyspector/rules/built-in-rules.toml b/build/lib.win-amd64-cpython-312/pyspector/rules/built-in-rules.toml
diff --git a/build/lib.win-amd64-cpython-312/pyspector/rules/original-built-in-rules.toml b/build/lib.win-amd64-cpython-312/pyspector/rules/original-built-in-rules.toml
diff --git a/src/pyspector.egg-info/PKG-INFO b/src/pyspector.egg-info/PKG-INFO
@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: pyspector
+Version: 0.1.0b0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: click>=8.0
+Requires-Dist: toml>=0.10
+Requires-Dist: sarif-om>=1.0
+Requires-Dist: jinja2>=3.0
+Requires-Dist: textual>=0.60
+Requires-Dist: importlib_resources; python_version < "3.9"
diff --git a/src/pyspector.egg-info/SOURCES.txt b/src/pyspector.egg-info/SOURCES.txt
@@ -0,0 +1,19 @@
+MANIFEST.in
+pyproject.toml
+setup.cfg
+setup.py
+src/pyspector/__init__.py
+src/pyspector/cli.py
+src/pyspector/config.py
+src/pyspector/reporting.py
+src/pyspector/triage.py
+src/pyspector.egg-info/PKG-INFO
+src/pyspector.egg-info/SOURCES.txt
+src/pyspector.egg-info/dependency_links.txt
+src/pyspector.egg-info/entry_points.txt
+src/pyspector.egg-info/not-zip-safe
+src/pyspector.egg-info/requires.txt
+src/pyspector.egg-info/top_level.txt
+src/pyspector/rules/__init__.py
+src/pyspector/rules/built-in-rules.toml
+src/pyspector/rules/original-built-in-rules.toml
diff --git a/src/pyspector.egg-info/dependency_links.txt b/src/pyspector.egg-info/dependency_links.txt
@@ -0,0 +1 @@
+
diff --git a/src/pyspector.egg-info/entry_points.txt b/src/pyspector.egg-info/entry_points.txt
@@ -0,0 +1,2 @@
+[console_scripts]
+pyspector = pyspector.cli:cli
diff --git a/src/pyspector.egg-info/not-zip-safe b/src/pyspector.egg-info/not-zip-safe
@@ -0,0 +1 @@
+
diff --git a/src/pyspector.egg-info/requires.txt b/src/pyspector.egg-info/requires.txt
@@ -0,0 +1,8 @@
+click>=8.0
+toml>=0.10
+sarif-om>=1.0
+jinja2>=3.0
+textual>=0.60
+
+[:python_version < "3.9"]
+importlib_resources
diff --git a/src/pyspector.egg-info/top_level.txt b/src/pyspector.egg-info/top_level.txt
@@ -0,0 +1 @@
+pyspector
diff --git a/src/pyspector/_rust_core/src/analysis/mod.rs b/src/pyspector/_rust_core/src/analysis/mod.rs
@@ -20,7 +20,7 @@ pub struct AnalysisContext<'a> {
 }
 
 pub fn run_analysis(context: AnalysisContext) -> Vec<Issue> {
-    println!("DEBUG: Starting analysis with {} rules", context.ruleset.rules.len());
+    println!("[*] Starting analysis with {} rules", context.ruleset.rules.len());
     
     let root_path = Path::new(&context.root_path);
     let mut files_to_scan: Vec<String> = Vec::new();
@@ -33,61 +33,61 @@ pub fn run_analysis(context: AnalysisContext) -> Vec<Issue> {
         }
     }
     
-    println!("DEBUG: Found {} Python files to scan", files_to_scan.len());
+    println!("[+] Found {} Python files to scan", files_to_scan.len());
     
     let mut issues: Vec<Issue> = files_to_scan
         .par_iter()
         .flat_map(|file_path| {
-            println!("DEBUG: Scanning file: {}", file_path);
+            println!("[*] Scanning file: {}", file_path);
             if let Ok(content) = fs::read_to_string(file_path) {
                 config_analysis::scan_file(file_path, &content, &context.ruleset)
             } else { 
-                println!("DEBUG: Failed to read file: {}", file_path);
+                println!("[!] Failed to read file: {}", file_path);
                 Vec::new() 
             }
         })
         .collect();
 
-    println!("DEBUG: Found {} issues from config analysis", issues.len());
+    println!("[+] Found {} issues from config analysis", issues.len());
 
     let python_issues: Vec<Issue> = context.py_files
         .par_iter()
         .flat_map(|py_file| {
-            println!("DEBUG: Processing Python file: {}", py_file.file_path);
+            println!("[*] Processing Python file: {}", py_file.file_path);
             let mut findings = Vec::new();
             if is_excluded(Path::new(&py_file.file_path), &context.exclusions) { 
-                println!("DEBUG: File excluded: {}", py_file.file_path);
+                println!("[!] File excluded: {}", py_file.file_path);
                 return findings; 
             }
             
             findings.extend(config_analysis::scan_file(&py_file.file_path, &py_file.content, &context.ruleset));
-            println!("DEBUG: Config analysis found {} issues in {}", findings.len(), py_file.file_path);
+            println!("[+] Config analysis found {} issues in {}", findings.len(), py_file.file_path);
             
             if let Some(ast) = &py_file.ast {
                 let ast_findings = ast_analysis::scan_ast(ast, &py_file.file_path, &py_file.content, &context.ruleset);
-                println!("DEBUG: AST analysis found {} issues in {}", ast_findings.len(), py_file.file_path);
+                println!("[+] AST analysis found {} issues in {}", ast_findings.len(), py_file.file_path);
                 findings.extend(ast_findings);
             } else {
-                println!("DEBUG: No AST available for {}", py_file.file_path);
+                println!("[!] No AST available for {}", py_file.file_path);
             }
             findings
         })
         .collect();
         
-    println!("DEBUG: Found {} issues from Python AST analysis", python_issues.len());
+    println!("[+] {} issues from Python AST analysis", python_issues.len());
     issues.extend(python_issues);
 
     // Build the call graph and run taint analysis
     let call_graph = call_graph_builder::build_call_graph(context.py_files);
     let taint_issues = taint_analysis::analyze_program_for_taint(&call_graph, &context.ruleset);
-    println!("DEBUG: Found {} issues from taint analysis", taint_issues.len());
+    println!("[+] Found {} issues from taint analysis", taint_issues.len());
     issues.extend(taint_issues);
     
     // Remove duplicates
     let mut seen = HashSet::new();
     issues.retain(|issue| seen.insert(issue.get_fingerprint()));
 
-    println!("DEBUG: Total issues after deduplication: {}", issues.len());
+    println!("[*] Total issues after deduplication: {}", issues.len());
     issues
 }
 
diff --git a/src/pyspector/_rust_core/src/analysis/taint_analysis.rs b/src/pyspector/_rust_core/src/analysis/taint_analysis.rs
@@ -6,32 +6,32 @@ use std::collections::HashSet;
 
 // Main entry point for inter-procedural taint analysis
 pub fn analyze_program_for_taint(call_graph: &CallGraph, ruleset: &RuleSet) -> Vec<Issue> {
-    println!("DEBUG: Starting taint analysis with {} functions", call_graph.functions.len());
-    println!("DEBUG: Taint sources: {}, sinks: {}", ruleset.taint_sources.len(), ruleset.taint_sinks.len());
+    println!("[*] Starting taint analysis with {} functions", call_graph.functions.len());
+    println!("[+] Taint sources: {}, sinks: {}", ruleset.taint_sources.len(), ruleset.taint_sinks.len());
     
     let mut issues = Vec::new();
     let mut tainted_vars: HashSet<(String, String)> = HashSet::new(); // (func_id, var_name)
 
     // First pass: find all initial sources across all functions
     for (func_id, func_node) in &call_graph.functions {
-        println!("DEBUG: Analyzing function: {}", func_id);
+        println!("[*] Analyzing function: {}", func_id);
         let mut assignments = Vec::new();
         find_assignments(func_node, &mut assignments);
         
         for assign_node in assignments {
             if let Some(value_node) = assign_node.children.get("value").and_then(|v| v.get(0)) {
                 if value_node.node_type == "Call" {
                     let call_name = get_full_call_name(value_node);
-                    println!("DEBUG: Found call: {}", call_name);
+                    println!("[+] Found call: {}", call_name);
                     
                     for source in &ruleset.taint_sources {
                         if call_name.contains(&source.function_call) || source.function_call.contains(&call_name) {
-                            println!("DEBUG: Found taint source: {} matches {}", call_name, source.function_call);
+                            println!("[+] Found taint source: {} matches {}", call_name, source.function_call);
                             
                             if let Some(targets) = assign_node.children.get("targets") {
                                 for target in targets {
                                     if let Some(name) = get_name_from_node(target) {
-                                        println!("DEBUG: Tainting variable: {} in {}", name, func_id);
+                                        println!("[+] Tainting variable: {} in {}", name, func_id);
                                         tainted_vars.insert((func_id.clone(), name));
                                     }
                                 }
@@ -43,7 +43,7 @@ pub fn analyze_program_for_taint(call_graph: &CallGraph, ruleset: &RuleSet) -> V
         }
     }
 
-    println!("DEBUG: Found {} tainted variables", tainted_vars.len());
+    println!("[+] Found {} tainted variables", tainted_vars.len());
 
     // Second pass: find all sinks and check if arguments are tainted
     for (func_id, func_node) in &call_graph.functions {
@@ -61,16 +61,16 @@ pub fn analyze_program_for_taint(call_graph: &CallGraph, ruleset: &RuleSet) -> V
             
             for sink in &ruleset.taint_sinks {
                 if callee_name.contains(&sink.function_call) || sink.function_call.contains(&callee_name) {
-                    println!("DEBUG: Found potential sink: {} matches {}", callee_name, sink.function_call);
+                    println!("[+] Found potential sink: {} matches {}", callee_name, sink.function_call);
                     
                     if let Some(args) = call_node.children.get("args") {
                         if args.len() > sink.vulnerable_parameter_index {
                             let arg = &args[sink.vulnerable_parameter_index];
                             if let Some(arg_name) = get_name_from_node(arg) {
-                                println!("DEBUG: Checking if argument '{}' is tainted", arg_name);
+                                println!("[*] Checking if argument '{}' is tainted", arg_name);
                                 
                                 if tainted_vars.contains(&(func_id.clone(), arg_name.clone())) {
-                                    println!("DEBUG: VULNERABILITY FOUND! Tainted data flows to sink");
+                                    println!("[!] VULNERABILITY FOUND! Tainted data flows to sink");
                                     report_issue(ruleset, &sink.vulnerability_id, file_path, call_node, content, &mut issues);
                                 }
                             }
@@ -80,8 +80,6 @@ pub fn analyze_program_for_taint(call_graph: &CallGraph, ruleset: &RuleSet) -> V
             }
         }
     }
-    
-    println!("DEBUG: Taint analysis found {} issues", issues.len());
     issues
 }
 
diff --git a/src/pyspector/_rust_core/src/graph/call_graph_builder.rs b/src/pyspector/_rust_core/src/graph/call_graph_builder.rs
@@ -13,14 +13,14 @@ pub struct CallGraph<'a> {
 
 // Builds a call graph from all parsed Python files.
 pub fn build_call_graph(py_files: &[PythonFile]) -> CallGraph {
-    println!("DEBUG: Building call graph from {} files", py_files.len());
+    println!("[*] Building call graph from {} files", py_files.len());
     
     let mut call_graph = CallGraph::default();
     let mut all_funcs = HashMap::new();
 
     // First pass: find all function definitions and store their content.
     for file in py_files {
-        println!("DEBUG: Processing file: {}", file.file_path);
+        println!("[*] Processing file: {}", file.file_path);
         
         if let Some(ast) = &file.ast {
             let mut funcs_in_file = Vec::new();
@@ -29,7 +29,7 @@ pub fn build_call_graph(py_files: &[PythonFile]) -> CallGraph {
             for func_node in funcs_in_file {
                 if let Some(func_name) = get_name_from_node(func_node) {
                     let func_id = format!("{}::{}", file.file_path, func_name);
-                    println!("DEBUG: Found function: {}", func_id);
+                    println!("[*] Found function: {}", func_id);
                     all_funcs.insert(func_id, func_node);
                 }
             }
@@ -38,7 +38,7 @@ pub fn build_call_graph(py_files: &[PythonFile]) -> CallGraph {
     }
     
     call_graph.functions = all_funcs;
-    println!("DEBUG: Found {} total functions", call_graph.functions.len());
+    println!("[+] Found {} total functions", call_graph.functions.len());
 
     // Second pass: find all call sites in each function.
     for (func_id, func_node) in &call_graph.functions {
diff --git a/src/pyspector/rules/built-in-rules.toml b/src/pyspector/rules/built-in-rules.toml

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+[console_scripts]`
	`2`	`+pyspector = pyspector.cli:cli`