Buckets:

download
raw
15.1 kB
#!/usr/bin/env python3
"""MyWork Security Scanner - Detect secrets, vulnerabilities, and security issues."""
import os
import re
import json
import subprocess
import sys
from pathlib import Path
from datetime import datetime
# Patterns for detecting hardcoded secrets
SECRET_PATTERNS = [
(r'(?:api[_-]?key|apikey)\s*[=:]\s*["\']([a-zA-Z0-9_\-]{20,})["\']', "API Key"),
(r'(?:secret|password|passwd|pwd)\s*[=:]\s*["\']([^"\']{8,})["\']', "Password/Secret"),
(r'(?:token)\s*[=:]\s*["\']([a-zA-Z0-9_\-]{20,})["\']', "Token"),
(r'(?:aws_access_key_id)\s*[=:]\s*["\']?(AKIA[0-9A-Z]{16})["\']?', "AWS Access Key"),
(r'(?:aws_secret_access_key)\s*[=:]\s*["\']?([a-zA-Z0-9/+=]{40})["\']?', "AWS Secret Key"),
(r'sk-[a-zA-Z0-9]{20,}', "OpenAI/Stripe API Key"),
(r'ghp_[a-zA-Z0-9]{36}', "GitHub Personal Access Token"),
(r'glpat-[a-zA-Z0-9\-]{20}', "GitLab Personal Access Token"),
(r'xox[bporsm]-[a-zA-Z0-9\-]{10,}', "Slack Token"),
(r'-----BEGIN (?:RSA |EC |DSA )?PRIVATE KEY-----', "Private Key"),
(r'(?:postgres|mysql|mongodb)://[^\s"\']+:[^\s"\']+@', "Database Connection String"),
(r'Bearer\s+[a-zA-Z0-9_\-\.]{20,}', "Bearer Token"),
]
# Files/dirs to skip
SKIP_DIRS = {'.git', 'node_modules', '__pycache__', '.venv', 'venv', '.tox', 'dist', 'build', '.egg-info'}
SKIP_FILES = {'.env.example', 'security_scanner.py', 'test_security_scanner.py'}
SCAN_EXTENSIONS = {'.py', '.js', '.ts', '.jsx', '.tsx', '.json', '.yaml', '.yml', '.toml', '.cfg', '.ini', '.conf', '.sh', '.env', '.md'}
def scan_secrets(project_path: str, verbose: bool = False) -> list:
"""Scan project for hardcoded secrets."""
findings = []
project = Path(project_path)
MAX_FILE_SIZE = 512_000 # Skip files > 512KB (likely generated/minified)
MAX_LINE_LEN = 2000 # Skip very long lines (avoid regex backtracking)
# Pre-compile patterns for speed
compiled_patterns = [(re.compile(p, re.IGNORECASE), t) for p, t in SECRET_PATTERNS]
for root, dirs, files in os.walk(project):
dirs[:] = [d for d in dirs if d not in SKIP_DIRS]
for fname in files:
if fname in SKIP_FILES:
continue
fpath = Path(root) / fname
if fpath.suffix not in SCAN_EXTENSIONS and not fname.startswith('.env'):
continue
try:
if fpath.stat().st_size > MAX_FILE_SIZE:
continue
content = fpath.read_text(errors='ignore')
except (PermissionError, OSError):
continue
for line_num, line in enumerate(content.splitlines(), 1):
# Skip comments, noqa lines, and overly long lines
if len(line) > MAX_LINE_LEN:
continue
stripped = line.strip()
if stripped.startswith('#') or stripped.startswith('//') or '# noqa: security' in line:
continue
for regex, secret_type in compiled_patterns:
matches = regex.finditer(line)
for match in matches:
rel_path = str(fpath.relative_to(project))
secret_value = match.group(0)
masked = secret_value[:8] + '...' + secret_value[-4:] if len(secret_value) > 16 else '***'
findings.append({
'type': secret_type,
'file': rel_path,
'line': line_num,
'masked_value': masked,
'severity': 'HIGH'
})
return findings
def scan_permissions(project_path: str) -> list:
"""Check for overly permissive file permissions."""
findings = []
project = Path(project_path)
for root, dirs, files in os.walk(project):
dirs[:] = [d for d in dirs if d not in SKIP_DIRS]
for fname in files:
fpath = Path(root) / fname
try:
mode = oct(fpath.stat().st_mode)[-3:]
if mode[2] in ('6', '7') and fpath.suffix in {'.py', '.sh', '.env', '.key', '.pem'}:
findings.append({
'type': 'World-readable/writable',
'file': str(fpath.relative_to(project)),
'detail': f'Permissions: {mode}',
'severity': 'MEDIUM'
})
except OSError:
continue
return findings
def scan_dependencies(project_path: str) -> list:
"""Check for known vulnerable dependency patterns."""
findings = []
project = Path(project_path)
# Check for pip-audit / npm audit availability
req_file = project / 'requirements.txt'
if req_file.exists():
try:
result = subprocess.run(
['pip-audit', '-r', str(req_file), '--format', 'json'],
capture_output=True, text=True, timeout=60, cwd=project_path
)
if result.returncode == 0:
vulns = json.loads(result.stdout)
for v in vulns.get('dependencies', []):
for vuln in v.get('vulns', []):
findings.append({
'type': 'Vulnerable Dependency',
'package': v['name'],
'version': v['version'],
'vuln_id': vuln.get('id', 'unknown'),
'severity': 'HIGH'
})
except (subprocess.TimeoutExpired, FileNotFoundError, json.JSONDecodeError):
pass
pkg_json = project / 'package.json'
if pkg_json.exists():
try:
result = subprocess.run(
['npm', 'audit', '--json'],
capture_output=True, text=True, timeout=60, cwd=project_path
)
audit_data = json.loads(result.stdout)
for vuln_name, vuln_info in audit_data.get('vulnerabilities', {}).items():
findings.append({
'type': 'Vulnerable Dependency',
'package': vuln_name,
'severity_level': vuln_info.get('severity', 'unknown').upper(),
'severity': 'HIGH' if vuln_info.get('severity') in ('high', 'critical') else 'MEDIUM'
})
except (subprocess.TimeoutExpired, FileNotFoundError, json.JSONDecodeError):
pass
return findings
def scan_gitignore(project_path: str) -> list:
"""Check if sensitive files are properly gitignored."""
findings = []
project = Path(project_path)
gitignore = project / '.gitignore'
sensitive_patterns = ['.env', '*.pem', '*.key', '*.p12', 'credentials.json', 'secrets.json', '*.sqlite', '*.db']
if gitignore.exists():
content = gitignore.read_text()
for pattern in sensitive_patterns:
if pattern not in content:
findings.append({
'type': 'Missing .gitignore entry',
'detail': f'"{pattern}" not in .gitignore',
'severity': 'MEDIUM'
})
else:
findings.append({
'type': 'No .gitignore',
'detail': 'Project has no .gitignore file',
'severity': 'HIGH'
})
return findings
def scan_code_patterns(project_path: str) -> list:
"""Scan for dangerous code patterns."""
findings = []
project = Path(project_path)
dangerous_patterns = [
(r'\beval\s*\(', 'eval() usage', 'MEDIUM'), # noqa: security
(r'\bexec\s*\(', 'exec() usage', 'MEDIUM'), # noqa: security
(r'subprocess\.call\([^)]*shell\s*=\s*True', 'shell=True in subprocess', 'MEDIUM'),
(r'os\.system\s*\(', 'os.system() usage', 'LOW'), # noqa: security
(r'pickle\.loads?\s*\(', 'Unsafe pickle deserialization', 'HIGH'), # noqa: security
(r'yaml\.load\s*\([^)]*\)(?!.*Loader)', 'Unsafe YAML load (no Loader)', 'MEDIUM'),
(r'__import__\s*\(', 'Dynamic import', 'LOW'),
(r'markupsafe|\.safe\s*=\s*True|autoescape\s*=\s*False', 'Potential XSS', 'MEDIUM'), # noqa: security
(r'CORS\s*\(\s*app\s*\)', 'Unrestricted CORS', 'MEDIUM'),
(r'verify\s*=\s*False', 'SSL verification disabled', 'HIGH'), # noqa: security
]
for root, dirs, files in os.walk(project):
dirs[:] = [d for d in dirs if d not in SKIP_DIRS]
for fname in files:
fpath = Path(root) / fname
if fpath.suffix not in {'.py', '.js', '.ts'}:
continue
try:
content = fpath.read_text(errors='ignore')
except (PermissionError, OSError):
continue
for line_num, line in enumerate(content.splitlines(), 1):
# Skip lines with noqa: security comment
if '# noqa: security' in line:
continue
for pattern, desc, severity in dangerous_patterns:
if re.search(pattern, line):
findings.append({
'type': desc,
'file': str(fpath.relative_to(project)),
'line': line_num,
'severity': severity
})
return findings
def full_scan(project_path: str, verbose: bool = False) -> dict:
"""Run all security scans on a project."""
project_path = os.path.abspath(project_path)
results = {
'project': project_path,
'timestamp': datetime.now().isoformat(),
'secrets': scan_secrets(project_path, verbose),
'permissions': scan_permissions(project_path),
'dependencies': scan_dependencies(project_path),
'gitignore': scan_gitignore(project_path),
'code_patterns': scan_code_patterns(project_path),
}
# Summary
total = sum(len(v) for k, v in results.items() if isinstance(v, list))
high = sum(1 for k, v in results.items() if isinstance(v, list) for f in v if f.get('severity') == 'HIGH')
medium = sum(1 for k, v in results.items() if isinstance(v, list) for f in v if f.get('severity') == 'MEDIUM')
low = sum(1 for k, v in results.items() if isinstance(v, list) for f in v if f.get('severity') == 'LOW')
results['summary'] = {
'total_findings': total,
'high': high,
'medium': medium,
'low': low,
'score': max(0, 100 - (high * 15) - (medium * 5) - (low * 2))
}
return results
def print_report(results: dict):
"""Print a formatted security report."""
summary = results['summary']
score = summary['score']
# Score color
if score >= 80:
grade = '๐ŸŸข A'
elif score >= 60:
grade = '๐ŸŸก B'
elif score >= 40:
grade = '๐ŸŸ  C'
else:
grade = '๐Ÿ”ด D'
print(f"\n{'='*60}")
print(f" ๐Ÿ”’ MyWork Security Report")
print(f"{'='*60}")
print(f" Project: {results['project']}")
print(f" Date: {results['timestamp'][:19]}")
print(f" Score: {score}/100 {grade}")
print(f"{'='*60}")
print(f" Findings: {summary['total_findings']} total")
print(f" ๐Ÿ”ด HIGH: {summary['high']}")
print(f" ๐ŸŸก MEDIUM: {summary['medium']}")
print(f" ๐ŸŸข LOW: {summary['low']}")
print(f"{'='*60}\n")
sections = [
('secrets', '๐Ÿ”‘ Hardcoded Secrets'),
('permissions', '๐Ÿ“‚ File Permissions'),
('dependencies', '๐Ÿ“ฆ Vulnerable Dependencies'),
('gitignore', '๐Ÿ“‹ .gitignore Issues'),
('code_patterns', 'โš ๏ธ Dangerous Code Patterns'),
]
for key, title in sections:
findings = results[key]
if not findings:
print(f" {title}: โœ… Clean")
continue
print(f" {title}: {len(findings)} issue(s)")
for f in findings[:10]: # Limit output
severity = f.get('severity', '?')
icon = '๐Ÿ”ด' if severity == 'HIGH' else '๐ŸŸก' if severity == 'MEDIUM' else '๐ŸŸข'
file_info = f.get('file', '')
line_info = f':L{f["line"]}' if 'line' in f else ''
detail = f.get('detail', f.get('masked_value', f.get('package', '')))
print(f" {icon} [{f.get('type', '?')}] {file_info}{line_info} โ€” {detail}")
if len(findings) > 10:
print(f" ... and {len(findings) - 10} more")
print()
if score >= 80:
print(" ๐Ÿ’ช Good security posture! Keep it up.\n")
elif score >= 60:
print(" โšก Some issues to address. Fix HIGH severity first.\n")
else:
print(" ๐Ÿšจ Significant security issues found. Remediate immediately.\n")
def main():
import argparse
parser = argparse.ArgumentParser(description='MyWork Security Scanner')
parser.add_argument('command', nargs='?', default='scan', choices=['scan', 'secrets', 'deps', 'patterns', 'report'])
parser.add_argument('path', nargs='?', default='.')
parser.add_argument('--json', action='store_true', help='Output as JSON')
parser.add_argument('--verbose', '-v', action='store_true')
parser.add_argument('--save', help='Save report to file')
args = parser.parse_args()
project_path = os.path.abspath(args.path)
if args.command == 'secrets':
findings = scan_secrets(project_path, args.verbose)
if args.json:
print(json.dumps(findings, indent=2))
else:
for f in findings:
print(f"๐Ÿ”ด [{f['type']}] {f['file']}:L{f['line']} โ€” {f['masked_value']}")
print(f"\n{len(findings)} secret(s) found.")
elif args.command == 'deps':
findings = scan_dependencies(project_path)
if args.json:
print(json.dumps(findings, indent=2))
else:
for f in findings:
print(f"๐Ÿ“ฆ {f.get('package', '?')} โ€” {f.get('vuln_id', f.get('severity_level', '?'))}")
print(f"\n{len(findings)} vulnerability(ies) found.")
elif args.command == 'patterns':
findings = scan_code_patterns(project_path)
if args.json:
print(json.dumps(findings, indent=2))
else:
for f in findings:
print(f"โš ๏ธ [{f['type']}] {f['file']}:L{f['line']}")
print(f"\n{len(findings)} pattern(s) found.")
else: # scan or report
results = full_scan(project_path, args.verbose)
if args.json:
print(json.dumps(results, indent=2))
else:
print_report(results)
if args.save:
with open(args.save, 'w') as f:
json.dump(results, f, indent=2)
print(f" ๐Ÿ“„ Report saved to {args.save}")
return 0
if __name__ == '__main__':
sys.exit(main())

Xet Storage Details

Size:
15.1 kB
ยท
Xet hash:
fd66aa64f2ece64ded70eae75b42e95bf99b38289b91f77342017df48570fbb0

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.