@orionscanner/cli 0.1.0

package/src/orion/engine/cfg/engine.py

@@ -0,0 +1,509 @@
+"""Control Flow Graph engine for detecting unreachable code, infinite loops, missing returns, and complex branches."""
+import ast
+from typing import Dict, List, Set, Optional, Any, Tuple
+from dataclasses import dataclass, field
+from collections import defaultdict
+from orion.engine.config import EngineConfig, ResourceLimits
+from orion.engine.ir import OrionIR
+from orion.engine.results import EngineResult, Finding
+
+
+@dataclass
+class CFGNode:
+    id: int
+    lineno: int
+    end_lineno: int
+    node_type: str
+    ast_node: ast.AST
+    predecessors: List[int] = field(default_factory=list)
+    successors: List[int] = field(default_factory=list)
+    reachable: bool = True
+
+
+@dataclass
+class FunctionCFG:
+    name: str
+    nodes: List[CFGNode] = field(default_factory=list)
+    entry: int = 0
+    exits: List[int] = field(default_factory=list)
+    has_return: bool = False
+    is_generator: bool = False
+    is_async: bool = False
+    complexity: int = 1
+
+
+class CFGBuilder(ast.NodeVisitor):
+    def __init__(self, filename: str, source_lines: List[str]):
+        self.filename = filename
+        self.source_lines = source_lines
+        self.findings: List[Finding] = []
+        self.current_function: Optional[FunctionCFG] = None
+        self.function_cfgs: Dict[str, FunctionCFG] = {}
+        self.node_counter = 0
+        self.current_class: Optional[str] = None
+        self.loop_stack: List[int] = []
+        self.try_stack: List[int] = []
+
+    def get_snippet(self, node: ast.AST, context: int = 2) -> str:
+        start = max(0, node.lineno - 1 - context)
+        end = min(len(self.source_lines), 
+                  getattr(node, 'end_lineno', node.lineno) + context if hasattr(node, 'end_lineno') else node.lineno + context)
+        return "\n".join(self.source_lines[start:end])
+
+    def new_node(self, node: ast.AST, node_type: str) -> CFGNode:
+        cfg_node = CFGNode(
+            id=self.node_counter,
+            lineno=node.lineno,
+            end_lineno=getattr(node, 'end_lineno', node.lineno),
+            node_type=node_type,
+            ast_node=node
+        )
+        self.node_counter += 1
+        return cfg_node
+
+    def add_edge(self, from_id: int, to_id: int, cfg: FunctionCFG):
+        cfg.nodes[from_id].successors.append(to_id)
+        cfg.nodes[to_id].predecessors.append(from_id)
+
+    def visit_ClassDef(self, node: ast.ClassDef):
+        old_class = self.current_class
+        self.current_class = node.name
+        self.generic_visit(node)
+        self.current_class = old_class
+
+    def visit_FunctionDef(self, node: ast.FunctionDef):
+        self._visit_function(node, is_async=False)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef):
+        self._visit_function(node, is_async=True)
+
+    def _visit_function(self, node: ast.FunctionDef, is_async: bool):
+        old_function = self.current_function
+        old_counter = self.node_counter
+        
+        qual_name = f"{self.current_class}.{node.name}" if self.current_class else node.name
+        
+        cfg = FunctionCFG(name=qual_name, is_async=is_async)
+        self.current_function = cfg
+        self.node_counter = 0
+        
+        entry_node = self.new_node(node, "entry")
+        cfg.nodes.append(entry_node)
+        cfg.entry = 0
+        
+        prev_node = entry_node
+        
+        for stmt in node.body:
+            stmt_node = self.new_node(stmt, type(stmt).__name__)
+            cfg.nodes.append(stmt_node)
+            self.add_edge(prev_node.id, stmt_node.id, cfg)
+            self._visit_statement(stmt, cfg, stmt_node.id)
+            prev_node = stmt_node
+        
+        exit_node = self.new_node(node, "exit")
+        cfg.nodes.append(exit_node)
+        self.add_edge(prev_node.id, exit_node.id, cfg)
+        cfg.exits.append(exit_node.id)
+        
+        self._analyze_function(cfg)
+        self.function_cfgs[qual_name] = cfg
+        
+        self.current_function = old_function
+        self.node_counter = old_counter
+
+    def _visit_statement(self, node: ast.AST, cfg: FunctionCFG, node_id: int):
+        if isinstance(node, ast.If):
+            self._visit_if(node, cfg, node_id)
+        elif isinstance(node, ast.For):
+            self._visit_for(node, cfg, node_id)
+        elif isinstance(node, ast.While):
+            self._visit_while(node, cfg, node_id)
+        elif isinstance(node, ast.Try):
+            self._visit_try(node, cfg, node_id)
+        elif isinstance(node, ast.With):
+            self._visit_with(node, cfg, node_id)
+        elif isinstance(node, ast.Return):
+            cfg.has_return = True
+        elif isinstance(node, ast.Yield) or isinstance(node, ast.YieldFrom):
+            cfg.is_generator = True
+        elif isinstance(node, ast.Raise):
+            pass
+        elif isinstance(node, ast.Break) or isinstance(node, ast.Continue):
+            pass
+        else:
+            for child in ast.iter_child_nodes(node):
+                self._visit_statement(child, cfg, node_id)
+
+    def _visit_if(self, node: ast.If, cfg: FunctionCFG, node_id: int):
+        cfg.complexity += 1
+        test_node = self.new_node(node.test, "if_test")
+        cfg.nodes.append(test_node)
+        self.add_edge(node_id, test_node.id, cfg)
+        
+        then_start = self.new_node(node, "if_then_start")
+        cfg.nodes.append(then_start)
+        self.add_edge(test_node.id, then_start.id, cfg)
+        
+        else_start = self.new_node(node, "if_else_start")
+        cfg.nodes.append(else_start)
+        self.add_edge(test_node.id, else_start.id, cfg)
+        
+        prev_then = then_start
+        for stmt in node.body:
+            stmt_node = self.new_node(stmt, type(stmt).__name__)
+            cfg.nodes.append(stmt_node)
+            self.add_edge(prev_then.id, stmt_node.id, cfg)
+            self._visit_statement(stmt, cfg, stmt_node.id)
+            prev_then = stmt_node
+        
+        prev_else = else_start
+        has_else = bool(node.orelse)
+        for stmt in node.orelse:
+            stmt_node = self.new_node(stmt, type(stmt).__name__)
+            cfg.nodes.append(stmt_node)
+            self.add_edge(prev_else.id, stmt_node.id, cfg)
+            self._visit_statement(stmt, cfg, stmt_node.id)
+            prev_else = stmt_node
+        
+        merge_node = self.new_node(node, "if_merge")
+        cfg.nodes.append(merge_node)
+        self.add_edge(prev_then.id, merge_node.id, cfg)
+        self.add_edge(prev_else.id, merge_node.id, cfg)
+
+    def _visit_for(self, node: ast.For, cfg: FunctionCFG, node_id: int):
+        cfg.complexity += 1
+        self.loop_stack.append(node_id)
+        
+        iter_node = self.new_node(node.iter, "for_iter")
+        cfg.nodes.append(iter_node)
+        self.add_edge(node_id, iter_node.id, cfg)
+        
+        loop_start = self.new_node(node, "for_loop_start")
+        cfg.nodes.append(loop_start)
+        self.add_edge(iter_node.id, loop_start.id, cfg)
+        
+        body_start = self.new_node(node, "for_body_start")
+        cfg.nodes.append(body_start)
+        self.add_edge(loop_start.id, body_start.id, cfg)
+        
+        prev = body_start
+        for stmt in node.body:
+            stmt_node = self.new_node(stmt, type(stmt).__name__)
+            cfg.nodes.append(stmt_node)
+            self.add_edge(prev.id, stmt_node.id, cfg)
+            self._visit_statement(stmt, cfg, stmt_node.id)
+            prev = stmt_node
+        
+        self.add_edge(prev.id, loop_start.id, cfg)
+        
+        else_start = self.new_node(node, "for_else_start")
+        cfg.nodes.append(else_start)
+        self.add_edge(loop_start.id, else_start.id, cfg)
+        
+        prev_else = else_start
+        for stmt in node.orelse:
+            stmt_node = self.new_node(stmt, type(stmt).__name__)
+            cfg.nodes.append(stmt_node)
+            self.add_edge(prev_else.id, stmt_node.id, cfg)
+            self._visit_statement(stmt, cfg, stmt_node.id)
+            prev_else = stmt_node
+        
+        merge_node = self.new_node(node, "for_merge")
+        cfg.nodes.append(merge_node)
+        self.add_edge(prev.id, merge_node.id, cfg)
+        self.add_edge(prev_else.id, merge_node.id, cfg)
+        
+        self.loop_stack.pop()
+
+    def _visit_while(self, node: ast.While, cfg: FunctionCFG, node_id: int):
+        cfg.complexity += 1
+        self.loop_stack.append(node_id)
+        
+        test_node = self.new_node(node.test, "while_test")
+        cfg.nodes.append(test_node)
+        self.add_edge(node_id, test_node.id, cfg)
+        
+        body_start = self.new_node(node, "while_body_start")
+        cfg.nodes.append(body_start)
+        self.add_edge(test_node.id, body_start.id, cfg)
+        
+        prev = body_start
+        for stmt in node.body:
+            stmt_node = self.new_node(stmt, type(stmt).__name__)
+            cfg.nodes.append(stmt_node)
+            self.add_edge(prev.id, stmt_node.id, cfg)
+            self._visit_statement(stmt, cfg, stmt_node.id)
+            prev = stmt_node
+        
+        self.add_edge(prev.id, test_node.id, cfg)
+        
+        else_start = self.new_node(node, "while_else_start")
+        cfg.nodes.append(else_start)
+        self.add_edge(test_node.id, else_start.id, cfg)
+        
+        prev_else = else_start
+        for stmt in node.orelse:
+            stmt_node = self.new_node(stmt, type(stmt).__name__)
+            cfg.nodes.append(stmt_node)
+            self.add_edge(prev_else.id, stmt_node.id, cfg)
+            self._visit_statement(stmt, cfg, stmt_node.id)
+            prev_else = stmt_node
+        
+        merge_node = self.new_node(node, "while_merge")
+        cfg.nodes.append(merge_node)
+        self.add_edge(prev.id, merge_node.id, cfg)
+        self.add_edge(prev_else.id, merge_node.id, cfg)
+        
+        if self._is_infinite_loop(node):
+            self.findings.append(Finding(
+                engine="cfg",
+                severity="medium",
+                title="Potential infinite loop",
+                description=f"While loop with constant True condition and no break statement detected",
+                location=f"{self.filename}:{node.lineno}",
+                metadata={
+                    "snippet": self.get_snippet(node),
+                    "cwe": "CWE-835",
+                    "confidence": 0.8,
+                    "check": "infinite_loop",
+                }
+            ))
+        
+        self.loop_stack.pop()
+
+    def _is_infinite_loop(self, node: ast.While) -> bool:
+        if isinstance(node.test, ast.Constant) and node.test.value is True:
+            for stmt in ast.walk(node):
+                if isinstance(stmt, ast.Break):
+                    return False
+            return True
+        return False
+
+    def _visit_try(self, node: ast.Try, cfg: FunctionCFG, node_id: int):
+        self.try_stack.append(node_id)
+        
+        try_start = self.new_node(node, "try_start")
+        cfg.nodes.append(try_start)
+        self.add_edge(node_id, try_start.id, cfg)
+        
+        prev = try_start
+        for stmt in node.body:
+            stmt_node = self.new_node(stmt, type(stmt).__name__)
+            cfg.nodes.append(stmt_node)
+            self.add_edge(prev.id, stmt_node.id, cfg)
+            self._visit_statement(stmt, cfg, stmt_node.id)
+            prev = stmt_node
+        
+        for handler in node.handlers:
+            handler_start = self.new_node(handler, "except_handler")
+            cfg.nodes.append(handler_start)
+            self.add_edge(try_start.id, handler_start.id, cfg)
+            
+            handler_prev = handler_start
+            for stmt in handler.body:
+                stmt_node = self.new_node(stmt, type(stmt).__name__)
+                cfg.nodes.append(stmt_node)
+                self.add_edge(handler_prev.id, stmt_node.id, cfg)
+                self._visit_statement(stmt, cfg, stmt_node.id)
+                handler_prev = stmt_node
+            
+            self.add_edge(handler_prev.id, prev.id, cfg)
+        
+        if node.orelse:
+            else_start = self.new_node(node, "try_else")
+            cfg.nodes.append(else_start)
+            self.add_edge(prev.id, else_start.id, cfg)
+            
+            else_prev = else_start
+            for stmt in node.orelse:
+                stmt_node = self.new_node(stmt, type(stmt).__name__)
+                cfg.nodes.append(stmt_node)
+                self.add_edge(else_prev.id, stmt_node.id, cfg)
+                self._visit_statement(stmt, cfg, stmt_node.id)
+                else_prev = stmt_node
+            
+            self.add_edge(else_prev.id, prev.id, cfg)
+        
+        if node.finalbody:
+            finally_start = self.new_node(node, "try_finally")
+            cfg.nodes.append(finally_start)
+            self.add_edge(prev.id, finally_start.id, cfg)
+            
+            finally_prev = finally_start
+            for stmt in node.finalbody:
+                stmt_node = self.new_node(stmt, type(stmt).__name__)
+                cfg.nodes.append(stmt_node)
+                self.add_edge(finally_prev.id, stmt_node.id, cfg)
+                self._visit_statement(stmt, cfg, stmt_node.id)
+                finally_prev = stmt_node
+            
+            self.add_edge(finally_prev.id, prev.id, cfg)
+        
+        self.try_stack.pop()
+
+    def _visit_with(self, node: ast.With, cfg: FunctionCFG, node_id: int):
+        with_start = self.new_node(node, "with_start")
+        cfg.nodes.append(with_start)
+        self.add_edge(node_id, with_start.id, cfg)
+        
+        prev = with_start
+        for stmt in node.body:
+            stmt_node = self.new_node(stmt, type(stmt).__name__)
+            cfg.nodes.append(stmt_node)
+            self.add_edge(prev.id, stmt_node.id, cfg)
+            self._visit_statement(stmt, cfg, stmt_node.id)
+            prev = stmt_node
+        
+        with_end = self.new_node(node, "with_end")
+        cfg.nodes.append(with_end)
+        self.add_edge(prev.id, with_end.id, cfg)
+
+    def _analyze_function(self, cfg: FunctionCFG):
+        self._check_unreachable_code(cfg)
+        self._check_missing_return(cfg)
+        self._check_high_complexity(cfg)
+
+    def _check_unreachable_code(self, cfg: FunctionCFG):
+        reachable = set()
+        
+        def dfs(node_id: int):
+            if node_id in reachable:
+                return
+            reachable.add(node_id)
+            for succ in cfg.nodes[node_id].successors:
+                dfs(succ)
+        
+        dfs(cfg.entry)
+        
+        for node in cfg.nodes:
+            if node.id not in reachable and node.node_type not in ("exit", "entry"):
+                self.findings.append(Finding(
+                    engine="cfg",
+                    severity="low",
+                    title="Unreachable code",
+                    description=f"Code at line {node.lineno} is unreachable",
+                    location=f"{self.filename}:{node.lineno}",
+                    metadata={
+                        "snippet": self.get_snippet(node.ast_node),
+                        "cwe": "CWE-561",
+                        "confidence": 0.85,
+                        "check": "unreachable_code",
+                    }
+                ))
+
+    def _check_missing_return(self, cfg: FunctionCFG):
+        if cfg.is_generator or cfg.is_async:
+            return
+        
+        if cfg.name.startswith("__init__") or cfg.name.startswith("__new__"):
+            return
+        
+        has_explicit_return = any(
+            isinstance(n.ast_node, ast.Return) and n.ast_node.value is not None
+            for n in cfg.nodes
+        )
+        
+        if not has_explicit_return and cfg.has_return:
+            for exit_id in cfg.exits:
+                pred_nodes = [cfg.nodes[p] for p in cfg.nodes[exit_id].predecessors]
+                for pred in pred_nodes:
+                    if not isinstance(pred.ast_node, ast.Return):
+                        self.findings.append(Finding(
+                            engine="cfg",
+                            severity="low",
+                            title="Missing return statement",
+                            description=f"Function {cfg.name} has paths without explicit return value",
+                            location=f"{self.filename}:{pred.lineno}",
+                            metadata={
+                                "snippet": self.get_snippet(pred.ast_node),
+                                "cwe": "CWE-393",
+                                "confidence": 0.7,
+                                "check": "missing_return",
+                                "function": cfg.name,
+                            }
+                        ))
+
+    def _check_high_complexity(self, cfg: FunctionCFG):
+        if cfg.complexity > 20:
+            self.findings.append(Finding(
+                engine="cfg",
+                severity="medium",
+                title="High cyclomatic complexity",
+                description=f"Function {cfg.name} has cyclomatic complexity of {cfg.complexity} (threshold: 20)",
+                location=f"{self.filename}:{cfg.nodes[0].lineno if cfg.nodes else 0}",
+                metadata={
+                    "snippet": self.get_snippet(cfg.nodes[0].ast_node) if cfg.nodes else "",
+                    "cwe": "CWE-1121",
+                    "confidence": 0.9,
+                    "check": "high_complexity",
+                    "complexity": cfg.complexity,
+                    "function": cfg.name,
+                }
+            ))
+
+    def generic_visit(self, node: ast.AST):
+        if self.current_function is None:
+            super().generic_visit(node)
+
+
+class Engine:
+    name = "cfg"
+    version = "1.0.0"
+
+    async def check_availability(self) -> bool:
+        return True
+
+    def resource_limits(self) -> ResourceLimits:
+        return ResourceLimits(max_cpu_seconds=60, max_memory_mb=512, max_files=50000)
+
+    async def run(self, ctx, config: EngineConfig) -> EngineResult:
+        # Handle both single IR and list of IRs
+        if not isinstance(ctx, list):
+            ctx = [ctx]
+        all_findings = []
+        errors = []
+        files_processed = 0
+        total_functions = 0
+        total_complexity = 0
+
+        exclude_patterns = config.toggles.get("exclude", []) if config.toggles else []
+
+        for ir in ctx:
+            try:
+                if not ir.metadata.get("language") == "python":
+                    continue
+
+                rel_path = ir.metadata.get("path", "unknown.py")
+                if any(pattern in rel_path for pattern in exclude_patterns):
+                    continue
+
+                content = ir.content.decode("utf-8", errors="replace")
+                source_lines = content.splitlines()
+                tree = ast.parse(content, filename=rel_path)
+
+                builder = CFGBuilder(rel_path, source_lines)
+                builder.visit(tree)
+
+                all_findings.extend(builder.findings)
+                total_functions += len(builder.function_cfgs)
+                total_complexity += sum(f.complexity for f in builder.function_cfgs.values())
+                files_processed += 1
+
+            except SyntaxError as e:
+                errors.append(f"Syntax error in {ir.metadata.get('path', 'unknown')}: {e}")
+            except Exception as e:
+                errors.append(f"Error processing {ir.metadata.get('path', 'unknown')}: {e}")
+
+        return EngineResult(
+            engine=self.name,
+            findings=all_findings,
+            errors=errors,
+            metrics={
+                "files_processed": files_processed,
+                "functions_analyzed": total_functions,
+                "total_complexity": total_complexity,
+                "avg_complexity": round(total_complexity / total_functions, 2) if total_functions > 0 else 0,
+                "findings_count": len(all_findings),
+            },
+            ok=len(errors) == 0
+        )