syfscan 0.1.0__py3-none-any.whl

ia/claude_summarizer.py

@@ -0,0 +1,121 @@
+# ia/claude_summarizer.py
+import anthropic
+from dotenv import load_dotenv
+from rich.console import Console
+from rich.rule import Rule
+import os
+
+load_dotenv()
+
+client = anthropic.Anthropic()
+
+console = Console()
+
+
+def generate_summary(report):
+    vulnerabilities_text = build_vulnerabilities_text(report)
+
+    if not vulnerabilities_text:
+        return None
+
+    message = client.messages.create(
+        model="claude-opus-4-6",
+        max_tokens=400,
+        messages=[
+            {
+                "role": "user",
+                "content": f"""You are a security expert. Analyze these vulnerabilities and respond in exactly this format:
+
+HOW TO FIX
+[One paragraph. List every package to upgrade and to which version.]
+
+RISKS
+[One paragraph. What could concretely happen if left unpatched.]
+
+ADDITIONAL MEASURES
+[3 bullet points max. Practical extra steps the developer can take.]
+
+Vulnerabilities:
+{vulnerabilities_text}"""
+            }
+        ]
+    )
+
+    return message.content[0].text
+
+
+def display_summary(ai_text):
+    sections = {
+        "HOW TO FIX":          ("🔧 How to Fix",          "green"),
+        "RISKS":               ("⚠️  Risks",               "red"),
+        "ADDITIONAL MEASURES": ("🛡️  Additional Measures", "yellow"),
+    }
+
+    console.print()
+    console.rule("[bold]AI Summary[/bold]")
+    console.print()
+
+    current_section = None
+    current_lines = []
+
+    for line in ai_text.splitlines():
+        line = line.strip()
+
+        matched = False
+        for key in sections:
+            if key in line.upper():
+                if current_section and current_lines:
+                    title, color = sections[current_section]
+                    content = "\n".join(current_lines).strip()
+                    console.print(f"[bold {color}]{title}[/bold {color}]")
+                    console.print(content)
+                    console.print()
+
+                current_section = key
+                current_lines = []
+                matched = True
+                break
+
+        if not matched and line:
+            current_lines.append(line)
+
+    # Flush last section
+    if current_section and current_lines:
+        title, color = sections[current_section]
+        content = "\n".join(current_lines).strip()
+        console.print(f"[bold {color}]{title}[/bold {color}]")
+        console.print(content)
+        console.print()
+
+
+def get_fixed_version(vuln):
+    try:
+        for affected in vuln.get("affected", []):
+            for r in affected.get("ranges", []):
+                for event in r.get("events", []):
+                    if "fixed" in event:
+                        return event["fixed"]
+    except (KeyError, IndexError):
+        pass
+    return None
+
+
+def build_vulnerabilities_text(report):
+    lines = []
+
+    for dep in report:
+        if not dep["vulnerabilites"]:
+            continue
+        for vuln in dep["vulnerabilites"]:
+            fixed = get_fixed_version(vuln)
+            severity = vuln.get("database_specific", {}).get("severity", "UNKNOWN")
+            line = (
+                f"- {dep['nom']} {dep['version']} : "
+                f"{vuln.get('id', 'UNKNOWN')} | "
+                f"{vuln.get('summary', 'No description')} | "
+                f"Severity: {severity} | "
+                f"Fixed in: {fixed or 'unknown'}"
+            )
+            lines.append(line)
+
+    return "\n".join(lines)

output/html.py

@@ -0,0 +1,96 @@
+import json
+from .terminal import get_label, get_score, score_couleur
+
+# Aide IA pour cette fonction car orange3 n'existe pas en HTML, et orange n'offre pas le bon affichage au niveau du terminal
+def convert_couleur_html(couleur):
+    map = {
+        "red":"red",
+        "yellow":"gold",
+        "orange3":"orange"
+    }
+    return map.get(couleur, "black")
+
+def rapport_html (rapport, output_path, max_vulns):
+    
+#https://www.w3schools.com/tags/tryit.asp?filename=tryhtml_span
+#https://www-sololearn-com.translate.goog/en/Discuss/2715062/how-to-code-html-in-python?_x_tr_sl=en&_x_tr_tl=fr&_x_tr_hl=fr&_x_tr_pto=rq#
+
+    html="""
+         <!DOCTYPE html>
+                <html>
+                <head>
+                <meta charset ="UTF-8">
+                   <style>
+                   
+                   body {
+                   background-color: white;
+                   font-family: arial;
+                   }
+                   h1{
+                   color: black
+                   }
+                   h2{
+                   color: darkred
+                   }
+                   p{
+                   color: black
+                   }
+                   </style>
+                </head>
+                <body>
+                <h1>Rapport syfscan </h1>
+                   """
+
+
+
+    for dep in rapport:
+        nom = dep["nom"]
+        version = dep["version"]
+        vulns = dep["vulnerabilites"]
+
+        if max_vulns is not None:
+            vulns = vulns[:max_vulns]
+        couleur_h2 = "green" if not vulns else"darkred"
+
+        html+=f"<h2 style='color:{couleur_h2}'>{nom} {version}</h2>"
+
+        if not vulns:
+            html+=f"<p>Aucune vulnérabilité détectée</p>"
+            continue
+ 
+        
+        html+=f"<p>{len(vulns)} vulnérabilités détectées"
+        for v in vulns:
+
+            score = get_score(v)
+            couleur = convert_couleur_html(score_couleur(score))
+            cve = get_label(v)
+            summary = v.get("summary", "no description")
+            
+            html+=f"""  
+            <p>
+            <span style="color:{couleur}; font-weight:bold">{cve}
+            </span>
+            > Score: {score} <br>
+            {summary}
+            </p>
+            """
+
+        
+        
+    html+="""
+    </body>
+    </html>
+    
+"""
+
+    with open(output_path, "w", encoding="utf-8") as f :
+        f.write(html)
+        
+
+
+
+
+
+
+

output/json.py

@@ -0,0 +1,57 @@
+import json
+from .terminal import get_label, get_score, score_couleur
+
+def rapport_json (rapport, output_path, max_vulns):
+    
+    results =[]
+
+    for dep in rapport:
+        nom = dep["nom"]
+        version = dep["version"]
+        vulns = dep["vulnerabilites"]
+
+        if max_vulns is not None:
+            vulns = vulns[:max_vulns]
+
+        if not vulns:
+            results.append({
+                "nom": nom,
+                "version": version,
+                "statut" : "non vulnerable",
+                "nombre de vulnerabilite(s)": 0,
+
+            },)
+            continue
+ 
+        vulns_list=[]
+
+        for v in vulns:
+
+            score = get_score(v)
+            couleur = score_couleur(score)
+            cve = get_label(v)
+            summary = v.get("summary", "no description")
+            vulns_list.append({
+                "score": score,
+                "cve": cve,
+                "summary": summary,
+            },)
+        
+        results.append({
+            "nom": nom,
+            "version": version,
+            "statut" : "vulnerable",
+            "nombre de vulnerabilite(s)": len(vulns),
+            "vulnerabilites": vulns_list
+        },)
+
+    with open(output_path, "w") as f :
+        json.dump(results, f, indent=4)         #conversion en json de la liste results
+        
+
+
+
+
+
+
+

output/pdf.py

@@ -0,0 +1,74 @@
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+from reportlab.lib import colors
+from .terminal import get_label, get_score, score_couleur
+def rapport_pdf(rapport, output_path, max_vulns=None):
+    c = canvas.Canvas(str(output_path), pagesize=letter)
+    width, height = letter
+
+    y = height - 40
+
+    c.setFont("Helvetica-Bold", 14)
+    c.drawString(40, y, "Rapport SyfScan - Vulnérabilités")
+
+    y -= 30
+
+    c.setFont("Helvetica", 10)
+
+    for dep in rapport:
+        nom = dep.get("nom")
+        version = dep.get("version")
+        vulns = dep.get("vulnerabilites", [])
+
+        if max_vulns:
+            vulns = vulns[:max_vulns]
+        if not vulns :
+            c.setFillColor(colors.green)
+        else:
+            c.setFillColor(colors.red)
+        
+
+        c.setFont("Helvetica-Bold", 11)
+        c.drawString(40, y, f"{nom} ({version})")
+        y -= 15
+
+        if not vulns:
+            
+            c.setFont("Helvetica", 10)
+            c.drawString(60, y, "Non vulnérable")
+            y -= 20
+            continue
+        
+
+
+        
+        c.setFont("Helvetica", 10)
+        c.drawString(60, y, f"{len(vulns)} vulnérabilité(s)")
+        y -= 15
+
+        for v in vulns:
+            #cve = v.get("id", "N/A")
+            cve=get_label(v)
+            summary = v.get("summary", "no description")
+            score = get_score(v)
+            couleur = score_couleur(score)
+            text = f"- {cve}: {summary[:60]}"
+
+            if couleur =="red":
+                c.setFillColor(colors.red)
+            elif couleur =="orange3":
+                c.setFillColor(colors.orange)
+            else:
+                c.setFillColor(colors.gold)
+
+            if y < 40:
+                c.showPage()
+                c.setFont("Helvetica", 10)
+                y = height - 40
+
+            c.drawString(80, y, text)
+            y -= 15
+
+        y -= 10
+
+    c.save()

output/terminal.py

@@ -0,0 +1,72 @@
+from rich.console import Console
+
+console = Console()
+
+# https://ossf.github.io/osv-schema/#database_specific-field
+def get_score(vuln):
+    # Si on a le score dans severity[]
+    for severity in vuln.get("severity", []):
+        if severity.get("type") in ("CVSS_V3", "CVSS_V2"):
+            try:
+                return float(severity.get("score", 0.0))
+            except ValueError:
+                pass
+
+    score_dictionnary = {"CRITICAL": 9.5, "HIGH": 8.0, "MEDIUM": 5.0, "LOW": 2.0}
+
+    # Si le score est dans database_specific
+    db_severity = vuln.get("database_specific", {}).get("severity", "")
+    if db_severity.upper() in score_dictionnary:
+        return score_dictionnary[db_severity.upper()]
+
+    # Si le score est dans affected[0].ecosystem_specific
+    affected = vuln.get("affected", [])
+    if affected:
+        eco_severity = affected[0].get("ecosystem_specific", {}).get("severity", "")
+        if eco_severity.upper() in score_dictionnary:
+            return score_dictionnary[eco_sev.upper()]
+
+    return 0.0
+
+
+def score_couleur(score):
+    if score >= 9.0:
+        return "red"
+    elif score >= 7.0:
+        return "orange3"
+    else:
+        return "yellow"
+
+
+# Fonction faite avec IA
+def get_label(vuln):
+    aliases = vuln.get("aliases", [])
+    return next((a for a in aliases if a.startswith("CVE-")), vuln.get("id", "N/A"))
+
+
+def display_report(rapport, max_vulns=None):
+    console.print("\n[bold green]// Rapport syfscan[/bold green]\n")
+
+    for dep in rapport:
+        nom = dep["nom"]
+        version = dep["version"]
+        vulns = dep["vulnerabilites"]
+
+        if max_vulns is not None:
+            vulns = vulns[:max_vulns]
+
+        if not vulns:
+            console.print(f"[green]{nom} {version} — 0 vulnérabilité[/green]")
+            console.print()
+            continue
+
+        console.print(f"[red]{nom} {version} — {len(vulns)} vulnérabilité(s)[/red]")
+
+        for v in vulns:
+            score = get_score(v)
+            couleur = score_couleur(score)
+            cve = get_label(v)
+            summary = v.get("summary", "no description")
+            console.print(f"  [dim]>[/dim] [{couleur}]{cve} — {summary}[/{couleur}]")
+
+        console.print()

parsers/requirement.py

@@ -0,0 +1,41 @@
+from packaging.requirements import Requirement
+from rich.console import Console
+
+console = Console()
+
+def parse_requirements(fichier):
+    finale_liste =[]
+    try :
+        with open (fichier, "r") as f :
+            lignes = f.readlines()
+            
+            for ligne in lignes :
+                ligne = ligne.strip()
+
+                if not ligne or ligne.startswith('#'):
+                    continue
+                
+                try :
+                    req = Requirement(ligne)
+                    nom = req.name
+                    version ="0.0.0"
+
+                    if req.specifier :#determiner la bonne version si elle existe (borne basse)
+                        for spec in req.specifier :
+                            if spec.operator in ["==", ">=", "~=", "==="]:
+                                version =spec.version
+                                break
+                    finale_liste.append({"nom":nom, "version" :version})
+                
+                except Exception :
+                    console.print(f"[yellow][ WARNING ][/yellow] [dim]Ligne ignorée —[/dim] [cyan]{ligne}[/cyan]")
+
+                        
+                    
+
+    except Exception as e :
+                    console.print(f"[bold red][ ERROR ][/bold red] [red]impossible de lire le fichier — {e}[/red]")
+                    cons
+
+    console.print()
+    return finale_liste

scanner/osv.py

@@ -0,0 +1,48 @@
+import requests
+from rich.console import Console
+
+from output.terminal import get_score
+
+console = Console()
+
+OSV_API_URL = "https://api.osv.dev/v1/query"
+
+def scan_dependencies(dependencies):
+ 
+    rapport = []
+
+    for dep in dependencies:
+        nom = dep["nom"]
+        version = dep["version"]
+
+        console.print(f"[green]>[/green] [dim]Scan[/dim] [cyan]{nom}[/cyan] [dim]{version}[/dim]")
+
+        try:
+            response = requests.post(OSV_API_URL, json={
+                "package": {
+                    "name": nom,
+                    "ecosystem": "PyPI"
+                },
+                "version": version
+            })
+            response.raise_for_status()
+            data = response.json()
+
+            vulns = sorted(data.get("vulns", []), key=get_score, reverse=True)
+
+            rapport.append({
+                "nom": nom,
+                "version": version,
+                "vulnerabilites": vulns
+            })
+
+        except requests.exceptions.RequestException as e:
+            console.print(f"[bold red][ ERROR ][/bold red] [red]{nom} — {e}[/red]")            
+            rapport.append({
+                "nom": nom,
+                "version": version,
+                "vulnerabilites": [],
+                "erreur": str(e)
+            })
+
+    return rapport

syfscan/__main__.py

@@ -0,0 +1,4 @@
+from syfscan.cli import main
+
+if __name__== "__main__":
+    main()

syfscan/cli.py

@@ -0,0 +1,120 @@
+import argparse
+import sys
+from pathlib import Path
+from rich.console import Console
+
+from parsers.requirement import parse_requirements
+from scanner.osv import scan_dependencies
+from ia.claude_summarizer import generate_summary, display_summary
+from output.terminal import display_report
+from output.json import rapport_json 
+from output.html import rapport_html
+from output.pdf import rapport_pdf
+
+console = Console()
+
+BANNER = """
+[green]
+ ███████╗██╗   ██╗███████╗███████╗ ██████╗ █████╗ ███╗   ██╗
+ ██╔════╝╚██╗ ██╔╝██╔════╝██╔════╝██╔════╝██╔══██╗████╗  ██║
+ ███████╗ ╚████╔╝ █████╗  ███████╗██║     ███████║██╔██╗ ██║
+ ╚════██║  ╚██╔╝  ██╔══╝  ╚════██║██║     ██╔══██║██║╚██╗██║
+ ███████║   ██║   ██║     ███████║╚██████╗██║  ██║██║ ╚████║
+ ╚══════╝   ╚═╝   ╚═╝     ╚══════╝ ╚═════╝╚═╝  ╚═╝╚═╝  ╚═══╝
+[/green][dim green] v1.0 — Python dependency vulnerability scanner. [/dim green]
+"""
+
+def main():
+    # Fait avec https://docs.python.org/3/library/argparse.html
+    parser = argparse.ArgumentParser(
+        prog="syfscan",
+        description="SyfScan — Détecteur de vulnérabilités de dépendances",
+        epilog="Exemple : syfscan requirements.txt"
+    )
+
+    parser.add_argument(
+        "file",
+        help="Chemin vers le fichier requirements.txt"
+    )
+
+    parser.add_argument(
+        "-xvuln",
+        type=int,
+        default=None,
+        metavar="X",
+        help="Afficher uniquement les X vulnérabilités les plus graves (ex: -xvuln 5)"
+    )
+
+    parser.add_argument(
+        "--no-ai",
+        action="store_true",
+        help="Désactiver le résumé IA"
+    )
+
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Générer un fichier au format JSON"
+    )
+
+    parser.add_argument(
+        "--html",
+        action="store_true",
+        help="Générer un fichier au format HTML"
+    )
+
+    parser.add_argument(
+        "--pdf",
+        action="store_true",
+        help="Générer un fichier au format PDF"
+    )
+
+
+    args = parser.parse_args()
+    file = Path(args.file)
+
+    console.print(BANNER)
+
+    # Verification validité des entrées clients
+    if not file.exists():
+        console.print(f"[bold red][ERREUR][/bold red] Fichier '{file}' introuvable.")
+        sys.exit(1)
+    
+
+
+    if file.name != "requirements.txt":
+        console.print("[bold red][ERREUR][/bold red] SyfScan accepte uniquement les fichiers requirements.txt")    
+        sys.exit(1)
+
+    #  Parsing
+    console.print(f"[green]>[/green] [dim]Fichier cible :[/dim][cyan]{file}[/cyan]")
+    dependencies = parse_requirements(file) # fonction parse à récupérer dans parser/requirements.py
+
+
+    #  Interrogation OSV.dev 
+    report = scan_dependencies(dependencies) # fonction scan_dependencies à récupérer dans scanner/osv.py 
+
+    #  Output 
+
+      #permet de choisir sous quel format exporter les données, par defaut dans le terminal
+    if args.json:
+        rapport_json(report, Path("rapport.json"), args.xvuln)
+        console.print("\n[bold green]Rapport JSON généré :[/bold green] rapport.json\n")
+    elif args.html:
+        rapport_html(report, Path("rapport.html"), args.xvuln)
+        console.print("\n[bold green]Rapport HTML généré :[/bold green] rapport.html\n")
+    elif args.pdf:
+        rapport_pdf(report, Path("rapport.pdf"), args.xvuln)
+        console.print("\n[bold green]Rapport PDF généré :[/bold green] rapport.pdf\n")
+    
+    else :
+        display_report(report, args.xvuln)
+
+        #  Résumé IA 
+    if not args.no_ai:
+        print("Generating AI summary...")
+        ai_report = generate_summary(report)
+        display_summary(ai_report)
+
+if __name__ == "__main__" :
+    main()

syfscan-0.1.0.dist-info/METADATA

@@ -0,0 +1,4 @@
+Metadata-Version: 2.4
+Name: syfscan
+Version: 0.1.0
+Summary: Détecteur de vulnérabilités de dépendances

syfscan-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+ia/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ia/claude_summarizer.py,sha256=bX2XOZZFZchMhFc1JX6Z5aeLjEyG9Eman7HHoKlFrQk,3385
+output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+output/html.py,sha256=2WiqM__dQhE5u_WhwqPfY3yhzek00SHYB1D8OjTIgQg,2393
+output/json.py,sha256=Yvf2lfhmArpPW3HIvkXrGSqAqCB6aSE1Uajtwvx_teI,1322
+output/pdf.py,sha256=jNW2fLfwZpxGLefqfdjJz9Q8HO7556He2Te483cqgL0,1917
+output/terminal.py,sha256=uK1vj1VNXgykBaVsuOeqKWf-mnZ8kENyvXti7Ag7ucQ,2216
+parsers/requirement.py,sha256=pbJh-G-6StlNT3nPTWlh3Pr5Fe6CexFaS30uL70ykbQ,1390
+scanner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scanner/osv.py,sha256=ZyRbTxj_qgN7m2yf1fDPOe_nQbjLjOE4_8cK1QHPoyc,1302
+syfscan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+syfscan/__main__.py,sha256=WDqExrefwrXk1MOBmjwtXPnIihVito76Cd1vcfnFxTI,66
+syfscan/cli.py,sha256=rNKvzelSr0ZIuK9askkfohhqBMtrVBHogMu7aheBEag,4266
+syfscan-0.1.0.dist-info/METADATA,sha256=Ajv03QPBOORZq5gv_7wWc2uvprOSc7R9RQk8ur__zIM,107
+syfscan-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+syfscan-0.1.0.dist-info/entry_points.txt,sha256=Xil9FSfre8F43iD4aBexk4GSMsKurKm5YhnSO_YC3wc,50
+syfscan-0.1.0.dist-info/top_level.txt,sha256=PnPb582uRcmoEcQe3TcydY9IteXc-ZhlX0JzPJRNj6M,34
+syfscan-0.1.0.dist-info/RECORD,,

syfscan-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

syfscan-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+syfscan = syfscan.__main__:main

syfscan-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,5 @@
+ia
+output
+parsers
+scanner
+syfscan