credlock 1.0.0__py3-none-any.whl

credlock/__init__.py

@@ -0,0 +1,8 @@
+"""CredLock - Prevent accidental secret commits to Git"""
+
+__version__ = "1.0.0"
+__author__ = "Your Name"
+__description__ = "Automatic credential detection in your code"
+
+# Version info
+VERSION = __version__

credlock/cli.py

@@ -0,0 +1,244 @@
+"""
+CredLock CLI
+Command-line interface for CredLock
+"""
+
+import typer
+import time
+import os
+from pathlib import Path
+from typing import Optional
+from .scanner import scan_directory, scan_file, check_dangerous_files
+from .formatter import (
+    print_scan_start, print_no_secrets, print_secrets_found,
+    print_dangerous_files, print_scan_summary, print_history,
+    print_config_info, print_setup_success, print_error, print_success
+)
+from .storage import save_scan, get_history, get_storage_path
+from .config import load_config, add_custom_pattern
+from . import __version__
+
+
+app = typer.Typer(
+    name="credlock",
+    help="🔐 Prevent accidental credential commits to Git"
+)
+
+
+@app.command()
+def scan(
+    directory: str = typer.Argument(".", help="Directory to scan"),
+    exit_on_secrets: bool = typer.Option(True, help="Exit with code 1 if secrets found")
+):
+    """
+    Scan directory for secrets
+    
+    Usage:
+        credlock scan              # Scan current directory
+        credlock scan /path/to/dir # Scan specific directory
+    """
+    print_scan_start(directory)
+    
+    start_time = time.time()
+    
+    # Scan directory
+    findings = scan_directory(directory)
+    
+    # Check for dangerous files
+    dangerous_files = check_dangerous_files(directory)
+    
+    # Count total files scanned
+    total_files = sum(1 for p in Path(directory).rglob("*") if p.is_file())
+    
+    duration = time.time() - start_time
+    
+    # Save scan to history
+    scan_data = {
+        "directory": directory,
+        "secrets_found": len(findings),
+        "dangerous_files": len(dangerous_files),
+        "total_files": total_files,
+        "duration": duration,
+        "findings": [
+            {
+                "file": f.file,
+                "line": f.line_number,
+                "pattern": f.pattern_name,
+                "content": f.line_content[:100]
+            } for f in findings
+        ]
+    }
+    scan_id = save_scan(scan_data)
+    
+    # Print results
+    if findings:
+        print_secrets_found(findings, scan_id)
+        if dangerous_files:
+            print_dangerous_files(dangerous_files)
+    else:
+        print_no_secrets()
+    
+    # Print dangerous files if found
+    if dangerous_files:
+        print_dangerous_files(dangerous_files)
+    
+    print_scan_summary(total_files, findings, duration)
+    
+    # Exit with appropriate code
+    if exit_on_secrets and (findings or dangerous_files):
+        raise typer.Exit(code=1)
+    
+    raise typer.Exit(code=0)
+
+
+@app.command()
+def setup_git():
+    """
+    Install Git pre-commit hook
+    
+    This command installs a pre-commit hook that runs CredLock
+    automatically before every git push.
+    """
+    git_dir = Path(".git")
+    if not git_dir.exists():
+        print_error("Not a git repository. Run 'git init' first.")
+        raise typer.Exit(code=1)
+    
+    hooks_dir = git_dir / "hooks"
+    hooks_dir.mkdir(exist_ok=True)
+    
+    pre_commit_path = hooks_dir / "pre-commit"
+    
+    # Create pre-commit hook script
+    hook_script = """#!/bin/bash
+# CredLock - Automatic Secret Detection
+# This hook prevents accidental secret commits
+
+credlock scan
+
+if [ $? -ne 0 ]; then
+    echo ""
+    echo "[CredLock] Secrets detected. Push blocked."
+    echo "Fix the issues above before trying again."
+    exit 1
+fi
+
+exit 0
+"""
+    
+    # Write hook file
+    with open(pre_commit_path, 'w') as f:
+        f.write(hook_script)
+    
+    # Make executable
+    os.chmod(pre_commit_path, 0o755)
+    
+    print_setup_success()
+
+
+@app.command()
+def history(
+    limit: int = typer.Option(10, help="Number of scans to show")
+):
+    """
+    View scan history
+    
+    Usage:
+        credlock history           # Show last 10 scans
+        credlock history --limit=5 # Show last 5 scans
+    """
+    scans = get_history(limit)
+    
+    if not scans:
+        print_error("No scan history found")
+        raise typer.Exit(code=0)
+    
+    # Format scans for display
+    formatted_scans = []
+    for scan in scans:
+        formatted_scans.append({
+            "scan_id": scan.get("scan_id", "unknown"),
+            "timestamp": scan.get("timestamp", "unknown")[:19],
+            "secrets_found": scan.get("secrets_found", 0),
+            "dangerous_files": scan.get("dangerous_files", 0),
+            "duration": f"{scan.get('duration', 0):.3f}s"
+        })
+    
+    print_history(formatted_scans)
+
+
+@app.command()
+def configure():
+    """
+    Configure CredLock settings
+    
+    Interactive configuration wizard
+    """
+    config = load_config()
+    
+    print_config_info(config)
+    
+    typer.echo("\nWhat would you like to do?")
+    typer.echo("1. Add custom pattern")
+    typer.echo("2. View all patterns")
+    typer.echo("3. Reset to defaults")
+    typer.echo("4. Exit")
+    
+    choice = typer.prompt("Enter your choice (1-4)", type=int)
+    
+    if choice == 1:
+        name = typer.prompt("Pattern name")
+        regex = typer.prompt("Regex pattern")
+        add_custom_pattern(name, regex)
+        print_success(f"Custom pattern '{name}' added!")
+    
+    elif choice == 2:
+        typer.echo("\nBuilt-in patterns: 50+")
+        typer.echo("Custom patterns: " + str(len(config.get("custom_patterns", {}))))
+    
+    elif choice == 3:
+        from .config import _config
+        _config.save(_config.get_default_config())
+        print_success("Configuration reset to defaults")
+    
+    else:
+        typer.echo("Exiting...")
+        raise typer.Exit(code=0)
+
+
+@app.command()
+def version():
+    """
+    Show version information
+    """
+    typer.echo(f"CredLock v{__version__}")
+    typer.echo("🔐 Prevent accidental credential commits to Git")
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    show_version: bool = typer.Option(False, "--version", help="Show version"),
+):
+    """
+    CredLock - Automatic credential detection in your code
+    
+    Prevent accidental secret commits to Git with automatic pre-commit scanning.
+    
+    Usage:
+        credlock scan              Scan current directory
+        credlock setup-git         Install Git pre-commit hook
+        credlock history           View scan history
+        credlock configure         Configure settings
+    """
+    if show_version:
+        typer.echo(f"CredLock v{__version__}")
+        raise typer.Exit(code=0)
+    
+    # If no command provided, show help
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+
+
+if __name__ == "__main__":
+    app()

credlock/config.py

@@ -0,0 +1,95 @@
+"""
+CredLock Config
+Configuration management
+"""
+
+import yaml
+from pathlib import Path
+from typing import Dict
+
+
+class Config:
+    """Manage CredLock configuration"""
+    
+    def __init__(self):
+        """Initialize configuration"""
+        self.config_dir = Path.home() / ".credlock"
+        self.config_file = self.config_dir / "config.yaml"
+        self.config_dir.mkdir(exist_ok=True)
+    
+    def load(self) -> Dict:
+        """Load configuration from file"""
+        if not self.config_file.exists():
+            return self.get_default_config()
+        
+        try:
+            with open(self.config_file, 'r') as f:
+                config = yaml.safe_load(f)
+                return config if config else self.get_default_config()
+        except:
+            return self.get_default_config()
+    
+    def save(self, config: Dict):
+        """Save configuration to file"""
+        with open(self.config_file, 'w') as f:
+            yaml.dump(config, f, default_flow_style=False)
+    
+    def get_default_config(self) -> Dict:
+        """Get default configuration"""
+        return {
+            "patterns_enabled": 50,
+            "custom_patterns": {},
+            "ignored_files": [
+                ".git/*",
+                "node_modules/*",
+                "__pycache__/*",
+                "venv/*",
+                "env/*",
+                "*.pyc",
+            ],
+            "auto_scan": True,
+            "scan_depth": "recursive",
+            "report_format": "terminal",
+        }
+    
+    def add_custom_pattern(self, name: str, regex: str):
+        """Add custom pattern"""
+        config = self.load()
+        config["custom_patterns"][name] = regex
+        self.save(config)
+    
+    def remove_custom_pattern(self, name: str):
+        """Remove custom pattern"""
+        config = self.load()
+        if name in config["custom_patterns"]:
+            del config["custom_patterns"][name]
+        self.save(config)
+    
+    def get_custom_patterns(self) -> Dict:
+        """Get custom patterns"""
+        config = self.load()
+        return config.get("custom_patterns", {})
+
+
+# Global config instance
+_config = Config()
+
+
+def load_config() -> Dict:
+    """Load configuration"""
+    return _config.load()
+
+
+def save_config(config: Dict):
+    """Save configuration"""
+    return _config.save(config)
+
+
+def get_default_config() -> Dict:
+    """Get default configuration"""
+    return _config.get_default_config()
+
+
+def add_custom_pattern(name: str, regex: str):
+    """Add custom pattern"""
+    return _config.add_custom_pattern(name, regex)

credlock/formatter.py

@@ -0,0 +1,231 @@
+"""
+CredLock Formatter
+Format and display scan results with colors and tables
+"""
+
+from typing import List, Dict
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from .scanner import Finding
+
+
+console = Console()
+
+
+class Formatter:
+    """Format scan results for terminal output"""
+    
+    @staticmethod
+    def print_scan_start(directory: str):
+        """Print scan start message"""
+        console.print(f"\n🔍 Scanning {directory} for secrets...\n", style="blue")
+    
+    @staticmethod
+    def print_no_secrets():
+        """Print when no secrets found"""
+        console.print("✅ No secrets found. Scan clean!\n", style="green bold")
+    
+    @staticmethod
+    def print_secrets_found(findings: List[Finding], scan_id: str = None):
+        """
+        Print secrets found with formatted output
+        
+        Args:
+            findings: List of Finding objects
+            scan_id: Scan ID for tracking
+        """
+        if not findings:
+            Formatter.print_no_secrets()
+            return False
+        
+        # Group findings by file
+        by_file: Dict[str, List[Finding]] = {}
+        for finding in findings:
+            if finding.file not in by_file:
+                by_file[finding.file] = []
+            by_file[finding.file].append(finding)
+        
+        # Print header
+        panel_text = f"⛔ SECRETS DETECTED! Found {len(findings)} potential secrets"
+        console.print(Panel(panel_text, style="red bold"), end="\n")
+        
+        # Print by file
+        for filepath, file_findings in sorted(by_file.items()):
+            console.print(f"\n📄 [bold red]{filepath}[/bold red]", end="")
+            console.print(f" ({len(file_findings)} secret{'s' if len(file_findings) > 1 else ''})\n")
+            
+            # Create table for this file
+            table = Table(show_header=False, box=None, padding=(0, 2))
+            
+            for i, finding in enumerate(file_findings, 1):
+                line_str = f"Line {finding.line_number}:"
+                pattern_str = f"[{finding.pattern_name}]"
+                
+                table.add_row(
+                    Text(line_str, style="yellow"),
+                    Text(pattern_str, style="magenta"),
+                    Text(finding.line_content[:60], style="dim")
+                )
+            
+            console.print(table)
+        
+        # Print recommendations
+        console.print("\n" + "="*60)
+        console.print("[bold red]❌ PUSH BLOCKED[/bold red]")
+        console.print("="*60 + "\n")
+        
+        console.print("[bold]Recommendations:[/bold]")
+        console.print("1. Review each secret above")
+        console.print("2. Move secrets to .env file (add to .gitignore)")
+        console.print("3. Use environment variables in your code:")
+        console.print("   const API_KEY = process.env.API_KEY;")
+        console.print("4. Remove secrets from Git history:")
+        console.print("   $ git rm --cached <file>")
+        console.print("   $ git commit --amend")
+        console.print("")
+        
+        if scan_id:
+            console.print(f"Scan ID: {scan_id}", style="dim")
+        
+        console.print("")
+        return True
+    
+    @staticmethod
+    def print_dangerous_files(dangerous_files: List[str]):
+        """Print dangerous files that exist"""
+        if not dangerous_files:
+            return
+        
+        console.print("\n[bold yellow]⚠️  DANGEROUS FILES DETECTED:[/bold yellow]\n")
+        
+        for filename in dangerous_files:
+            console.print(f"  ❌ {filename}")
+            console.print(f"     └─ This file should NEVER be committed!")
+        
+        console.print()
+    
+    @staticmethod
+    def print_scan_summary(total_files: int, findings: List[Finding], duration: float):
+        """Print scan summary"""
+        console.print("\n" + "="*60)
+        console.print("[bold]SCAN SUMMARY[/bold]")
+        console.print("="*60)
+        console.print(f"Files scanned: {total_files}")
+        console.print(f"Secrets found: {len(findings)}")
+        console.print(f"Duration: {duration:.3f} seconds")
+        console.print("="*60 + "\n")
+    
+    @staticmethod
+    def print_history(scans: List[Dict]):
+        """Print scan history"""
+        if not scans:
+            console.print("No scan history found.\n")
+            return
+        
+        console.print("\n[bold]📋 CREDLOCK SCAN HISTORY[/bold]\n")
+        
+        table = Table(title="Recent Scans")
+        table.add_column("Scan ID", style="cyan")
+        table.add_column("Timestamp", style="yellow")
+        table.add_column("Status", style="magenta")
+        table.add_column("Secrets", justify="right")
+        
+        for scan in scans[:10]:  # Show last 10
+            status = "✅ PASSED" if scan["secrets_found"] == 0 else f"❌ BLOCKED ({scan['secrets_found']})"
+            table.add_row(
+                scan["scan_id"],
+                scan["timestamp"],
+                status,
+                str(scan["secrets_found"])
+            )
+        
+        console.print(table)
+        console.print()
+    
+    @staticmethod
+    def print_config_info(config: Dict):
+        """Print configuration information"""
+        console.print("\n[bold]📝 CREDLOCK CONFIGURATION[/bold]\n")
+        
+        table = Table(show_header=False)
+        table.add_column("Setting", style="cyan")
+        table.add_column("Value")
+        
+        table.add_row("Patterns enabled", str(config.get("patterns_enabled", 50)))
+        table.add_row("Custom patterns", str(config.get("custom_patterns", 0)))
+        table.add_row("Config location", config.get("config_path", "~/.credlock/config.yaml"))
+        
+        console.print(table)
+        console.print()
+    
+    @staticmethod
+    def print_setup_success():
+        """Print successful setup message"""
+        console.print("\n" + "="*60)
+        console.print("[bold green]✅ SETUP SUCCESSFUL[/bold green]")
+        console.print("="*60)
+        console.print("\nCredLock Git pre-commit hook installed!")
+        console.print("\nFrom now on:")
+        console.print("  • Secrets will be detected before you push")
+        console.print("  • Dangerous files will be flagged")
+        console.print("  • Scan history will be saved locally")
+        console.print("\nTo verify:")
+        console.print("  $ cat .git/hooks/pre-commit")
+        console.print("\n" + "="*60 + "\n")
+    
+    @staticmethod
+    def print_error(message: str):
+        """Print error message"""
+        console.print(f"\n[bold red]❌ ERROR:[/bold red] {message}\n")
+    
+    @staticmethod
+    def print_success(message: str):
+        """Print success message"""
+        console.print(f"\n[bold green]✅ {message}[/bold green]\n")
+
+
+# Create global formatter instance
+_formatter = Formatter()
+
+
+# Export functions
+def print_scan_start(directory: str):
+    return _formatter.print_scan_start(directory)
+
+
+def print_no_secrets():
+    return _formatter.print_no_secrets()
+
+
+def print_secrets_found(findings: List[Finding], scan_id: str = None):
+    return _formatter.print_secrets_found(findings, scan_id)
+
+
+def print_dangerous_files(dangerous_files: List[str]):
+    return _formatter.print_dangerous_files(dangerous_files)
+
+
+def print_scan_summary(total_files: int, findings: List[Finding], duration: float):
+    return _formatter.print_scan_summary(total_files, findings, duration)
+
+
+def print_history(scans: List[Dict]):
+    return _formatter.print_history(scans)
+
+
+def print_config_info(config: Dict):
+    return _formatter.print_config_info(config)
+
+
+def print_setup_success():
+    return _formatter.print_setup_success()
+
+
+def print_error(message: str):
+    return _formatter.print_error(message)
+
+
+def print_success(message: str):
+    return _formatter.print_success(message)

credlock/git_hook.py

@@ -0,0 +1,85 @@
+"""
+CredLock Git Hook (FIXED)
+Manage Git pre-commit hooks - removed emoji for Windows compatibility
+"""
+
+import os
+from pathlib import Path
+
+
+class GitHookManager:
+    """Manage Git pre-commit hooks"""
+    
+    @staticmethod
+    def install_hook(repo_path: str = ".") -> bool:
+        """
+        Install pre-commit hook
+        
+        Args:
+            repo_path: Path to git repository
+            
+        Returns:
+            True if successful
+        """
+        git_dir = Path(repo_path) / ".git"
+        if not git_dir.exists():
+            return False
+        
+        hooks_dir = git_dir / "hooks"
+        hooks_dir.mkdir(exist_ok=True)
+        
+        hook_file = hooks_dir / "pre-commit"
+        
+        # FIXED: Removed emoji characters that break Windows CP1252 encoding
+        hook_content = """#!/bin/bash
+# CredLock - Automatic Secret Detection
+# Prevents accidental secret commits
+
+credlock scan
+
+if [ $? -ne 0 ]; then
+    echo ""
+    echo "[CredLock] Secrets detected. Commit blocked."
+    echo "Fix the issues above before trying again."
+    exit 1
+fi
+
+exit 0
+"""
+        
+        try:
+            # FIXED: Explicitly use UTF-8 encoding for Windows compatibility
+            with open(hook_file, 'w', encoding='utf-8') as f:
+                f.write(hook_content)
+            
+            os.chmod(hook_file, 0o755)
+            return True
+        except Exception as e:
+            print(f"Error installing hook: {e}")
+            return False
+    
+    @staticmethod
+    def uninstall_hook(repo_path: str = ".") -> bool:
+        """
+        Remove pre-commit hook
+        
+        Args:
+            repo_path: Path to git repository
+            
+        Returns:
+            True if successful
+        """
+        hook_file = Path(repo_path) / ".git" / "hooks" / "pre-commit"
+        
+        try:
+            if hook_file.exists():
+                hook_file.unlink()
+            return True
+        except:
+            return False
+    
+    @staticmethod
+    def hook_exists(repo_path: str = ".") -> bool:
+        """Check if pre-commit hook exists"""
+        hook_file = Path(repo_path) / ".git" / "hooks" / "pre-commit"
+        return hook_file.exists()