Initial Bug Bounty & Pentesting Explorer Space

README.md

@@ -1,12 +1,44 @@
 ---
-title: Bug Bounty Pentest Explorer
-emoji: 📉
-colorFrom: green
-colorTo: yellow
+title: Bug Bounty & Pentesting Explorer
+emoji: 🛡️
+colorFrom: red
+colorTo: purple
 sdk: gradio
-sdk_version: 6.5.1
+sdk_version: 5.50.0
 app_file: app.py
-pinned: false
+pinned: true
+license: mit
+short_description: Bug bounty methodologies, techniques, tools in FR/EN
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Bug Bounty & Pentesting Explorer
+
+An interactive explorer for bug bounty and penetration testing resources, built with Gradio.
+
+## Features
+
+- **Methodologies** – Browse pentesting methodologies with phases, scope, and deliverables
+- **Checklists** – Filter security checklists by target type (Web, API, Mobile, Cloud, AD)
+- **Attack Techniques** – Explore techniques by category with impact, exploitation steps, payloads, and remediation
+- **Platforms** – Compare bug bounty platforms, payout models, and top programs
+- **Report Templates** – View and use vulnerability report templates
+- **Tools** – Discover security tools filtered by category
+- **Q&A** – Browse common questions and answers about bug bounty and pentesting
+- **Statistics** – Visualize data with charts on categories, bounty ranges, and technique distribution
+
+## Datasets
+
+- [AYI-NEDJIMI/bug-bounty-pentest-fr](https://huggingface.co/datasets/AYI-NEDJIMI/bug-bounty-pentest-fr) (French)
+- [AYI-NEDJIMI/bug-bounty-pentest-en](https://huggingface.co/datasets/AYI-NEDJIMI/bug-bounty-pentest-en) (English)
+
+## Disclaimer
+
+⚠️ This resource is strictly for **authorized security testing** and **educational purposes** only.
+
+## Author
+
+**AYI-NEDJIMI Consultants**
+- 🌐 [ayinedjimi-consultants.fr](https://ayinedjimi-consultants.fr)
+- 💼 [LinkedIn](https://linkedin.com/in/ayi-nedjimi)
+- 🐙 [GitHub](https://github.com/ayi-nedjimi)
+- 🐦 [Twitter/X](https://x.com/ayi_nedjimi)

app.py

@@ -0,0 +1,486 @@
+import gradio as gr
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from datasets import load_dataset
+import json
+import re
+
+# ---------------------------------------------------------------------------
+# Load datasets
+# ---------------------------------------------------------------------------
+
+def load_data(lang="en"):
+    """Load the bug-bounty-pentest dataset for the given language."""
+    repo = f"AYI-NEDJIMI/bug-bounty-pentest-{lang}"
+    try:
+        ds = load_dataset(repo, split="train")
+        return ds.to_pandas()
+    except Exception as e:
+        print(f"Error loading {repo}: {e}")
+        return pd.DataFrame()
+
+df_en = load_data("en")
+df_fr = load_data("fr")
+
+DATASETS = {"EN": df_en, "FR": df_fr}
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def get_df(lang):
+    return DATASETS.get(lang, df_en)
+
+def safe(val):
+    """Return a cleaned string representation; handle NaN / None / lists."""
+    if val is None or (isinstance(val, float) and pd.isna(val)):
+        return ""
+    if isinstance(val, list):
+        return "\n".join(str(v) for v in val)
+    return str(val)
+
+def safe_json_list(val):
+    """Try to interpret a value as a list (JSON string or Python list)."""
+    if val is None or (isinstance(val, float) and pd.isna(val)):
+        return []
+    if isinstance(val, list):
+        return val
+    s = str(val).strip()
+    if s.startswith("["):
+        try:
+            return json.loads(s)
+        except Exception:
+            pass
+    return [s] if s else []
+
+def bullet_list(items):
+    """Format a list as a Markdown bullet list."""
+    lst = safe_json_list(items)
+    if not lst:
+        return "_No items_"
+    return "\n".join(f"- {item}" for item in lst)
+
+def filter_type(df, entry_type):
+    subset = df[df["type"] == entry_type] if "type" in df.columns else pd.DataFrame()
+    return subset.reset_index(drop=True)
+
+def unique_vals(df, col):
+    if col not in df.columns:
+        return []
+    vals = df[col].dropna().unique().tolist()
+    return sorted(set(str(v) for v in vals))
+
+# ---------------------------------------------------------------------------
+# CSS
+# ---------------------------------------------------------------------------
+
+CUSTOM_CSS = """
+footer.custom-footer {
+    text-align: center; padding: 18px 10px 10px 10px;
+    font-size: 0.92em; color: #888; border-top: 1px solid #ddd; margin-top: 20px;
+}
+footer.custom-footer a { color: #5b7ff5; text-decoration: none; margin: 0 8px; }
+footer.custom-footer a:hover { text-decoration: underline; }
+.disclaimer-box {
+    background: #fff3cd; border-left: 4px solid #ffc107; padding: 12px 16px;
+    margin: 10px 0; border-radius: 4px; font-size: 0.95em; color: #856404;
+}
+"""
+
+FOOTER_HTML = """
+<footer class="custom-footer">
+    <p>⚠️ <strong>Disclaimer:</strong> This resource is for <em>authorized security testing</em> and <em>educational purposes</em> only.</p>
+    <p>
+        <a href="https://ayinedjimi-consultants.fr" target="_blank">🌐 ayinedjimi-consultants.fr</a>
+        <a href="https://linkedin.com/in/ayi-nedjimi" target="_blank">💼 LinkedIn</a>
+        <a href="https://github.com/ayi-nedjimi" target="_blank">🐙 GitHub</a>
+        <a href="https://x.com/ayi_nedjimi" target="_blank">🐦 Twitter / X</a>
+    </p>
+    <p style="font-size:0.85em;">© 2026 AYI-NEDJIMI Consultants – Built with ❤️ and Gradio</p>
+</footer>
+"""
+
+# ---------------------------------------------------------------------------
+# Tab builders
+# ---------------------------------------------------------------------------
+
+def build_methodologies(lang):
+    df = filter_type(get_df(lang), "methodology")
+    if df.empty:
+        return "No methodology entries found."
+    parts = []
+    for _, row in df.iterrows():
+        name = safe(row.get("methodology_name", ""))
+        org = safe(row.get("organization", ""))
+        phases = bullet_list(row.get("phases"))
+        scope = safe(row.get("scope", ""))
+        targets = safe(row.get("target_types", ""))
+        deliverables = bullet_list(row.get("deliverables"))
+        parts.append(
+            f"## {name}\n"
+            f"**Organization:** {org}\n\n"
+            f"**Scope:** {scope}\n\n"
+            f"**Target Types:** {targets}\n\n"
+            f"### Phases\n{phases}\n\n"
+            f"### Deliverables\n{deliverables}\n\n---\n"
+        )
+    return "\n".join(parts) if parts else "No methodology entries found."
+
+def build_checklists(lang, target_type_filter="All"):
+    df = filter_type(get_df(lang), "checklist")
+    if df.empty:
+        return "No checklist entries found.", []
+    targets = ["All"] + unique_vals(df, "target_type")
+    if target_type_filter and target_type_filter != "All":
+        df = df[df["target_type"].astype(str) == target_type_filter]
+    parts = []
+    for _, row in df.iterrows():
+        cname = safe(row.get("checklist_name", ""))
+        ttype = safe(row.get("target_type", ""))
+        items = bullet_list(row.get("items"))
+        parts.append(
+            f"## {cname}\n**Target Type:** {ttype}\n\n### Items\n{items}\n\n---\n"
+        )
+    md = "\n".join(parts) if parts else "No checklists match the filter."
+    return md, targets
+
+def build_techniques(lang, category_filter="All"):
+    df = filter_type(get_df(lang), "technique")
+    if df.empty:
+        return "No technique entries found.", []
+    cats = ["All"] + unique_vals(df, "category")
+    if category_filter and category_filter != "All":
+        df = df[df["category"].astype(str) == category_filter]
+    parts = []
+    for _, row in df.iterrows():
+        tname = safe(row.get("technique_name", ""))
+        cat = safe(row.get("category", ""))
+        impact = safe(row.get("impact", ""))
+        steps = bullet_list(row.get("exploitation_steps"))
+        payloads = bullet_list(row.get("payload_examples"))
+        remed = safe(row.get("remediation", ""))
+        bounty = safe(row.get("bounty_range_usd", ""))
+        cvss = safe(row.get("cvss_range", ""))
+        parts.append(
+            f"## {tname}\n"
+            f"**Category:** {cat} &nbsp;|&nbsp; **Impact:** {impact} &nbsp;|&nbsp; "
+            f"**CVSS:** {cvss} &nbsp;|&nbsp; **Bounty Range (USD):** {bounty}\n\n"
+            f"### Exploitation Steps\n{steps}\n\n"
+            f"### Payload Examples\n{payloads}\n\n"
+            f"### Remediation\n{remed}\n\n---\n"
+        )
+    md = "\n".join(parts) if parts else "No techniques match the filter."
+    return md, cats
+
+def build_platforms(lang):
+    df = filter_type(get_df(lang), "platform")
+    if df.empty:
+        return "No platform entries found."
+    parts = []
+    for _, row in df.iterrows():
+        pname = safe(row.get("platform_name", ""))
+        payout = safe(row.get("payout_model", ""))
+        programs = bullet_list(row.get("top_programs"))
+        vtype = safe(row.get("vulnerability_type", ""))
+        bounty = safe(row.get("bounty_range_usd", ""))
+        parts.append(
+            f"## {pname}\n"
+            f"**Payout Model:** {payout}\n\n"
+            f"**Average Bounty Range:** {bounty}\n\n"
+            f"### Top Programs\n{programs}\n\n---\n"
+        )
+    return "\n".join(parts) if parts else "No platform entries found."
+
+def build_reports(lang, vuln_filter="All"):
+    df = filter_type(get_df(lang), "report_template")
+    if df.empty:
+        return "No report template entries found.", []
+    vtypes = ["All"] + unique_vals(df, "vulnerability_type")
+    if vuln_filter and vuln_filter != "All":
+        df = df[df["vulnerability_type"].astype(str) == vuln_filter]
+    parts = []
+    for _, row in df.iterrows():
+        title = safe(row.get("title_template", ""))
+        vtype = safe(row.get("vulnerability_type", ""))
+        steps = bullet_list(row.get("steps_to_reproduce"))
+        impact = safe(row.get("impact", ""))
+        remed = safe(row.get("remediation", ""))
+        bounty = safe(row.get("bounty_range_usd", ""))
+        cvss = safe(row.get("cvss_range", ""))
+        parts.append(
+            f"## {title}\n"
+            f"**Vulnerability Type:** {vtype} &nbsp;|&nbsp; **CVSS:** {cvss} &nbsp;|&nbsp; "
+            f"**Bounty Range (USD):** {bounty}\n\n"
+            f"### Steps to Reproduce\n{steps}\n\n"
+            f"### Impact\n{impact}\n\n"
+            f"### Remediation\n{remed}\n\n---\n"
+        )
+    md = "\n".join(parts) if parts else "No report templates match the filter."
+    return md, vtypes
+
+def build_tools(lang, category_filter="All"):
+    df = filter_type(get_df(lang), "tool")
+    if df.empty:
+        return "No tool entries found.", []
+    cats = ["All"] + unique_vals(df, "category")
+    if category_filter and category_filter != "All":
+        df = df[df["category"].astype(str) == category_filter]
+    parts = []
+    for _, row in df.iterrows():
+        name = safe(row.get("name", ""))
+        desc = safe(row.get("description", ""))
+        cat = safe(row.get("category", ""))
+        usage = bullet_list(row.get("usage_examples"))
+        parts.append(
+            f"## {name}\n**Category:** {cat}\n\n{desc}\n\n"
+            f"### Usage Examples\n{usage}\n\n---\n"
+        )
+    md = "\n".join(parts) if parts else "No tools match the filter."
+    return md, cats
+
+def build_qa(lang):
+    df = filter_type(get_df(lang), "qa")
+    if df.empty:
+        return "No Q&A entries found."
+    parts = []
+    for _, row in df.iterrows():
+        q = safe(row.get("question", ""))
+        a = safe(row.get("answer", ""))
+        diff = safe(row.get("difficulty", ""))
+        badge = ""
+        if diff:
+            badge = f" `{diff}`"
+        parts.append(f"### ❓ {q}{badge}\n\n{a}\n\n---\n")
+    return "\n".join(parts) if parts else "No Q&A entries found."
+
+# ---------------------------------------------------------------------------
+# Statistics
+# ---------------------------------------------------------------------------
+
+def build_statistics(lang):
+    df = get_df(lang)
+    if df.empty:
+        return None, None, None, "No data available for statistics."
+
+    figs = []
+
+    # 1. Entry type distribution
+    if "type" in df.columns:
+        type_counts = df["type"].value_counts().reset_index()
+        type_counts.columns = ["Type", "Count"]
+        fig1 = px.pie(type_counts, names="Type", values="Count",
+                       title="Entry Type Distribution",
+                       color_discrete_sequence=px.colors.qualitative.Set2)
+        fig1.update_layout(template="plotly_white")
+    else:
+        fig1 = go.Figure()
+    figs.append(fig1)
+
+    # 2. Technique category distribution
+    tech_df = filter_type(df, "technique")
+    if not tech_df.empty and "category" in tech_df.columns:
+        cat_counts = tech_df["category"].value_counts().reset_index()
+        cat_counts.columns = ["Category", "Count"]
+        fig2 = px.bar(cat_counts, x="Category", y="Count",
+                       title="Technique Distribution by Category",
+                       color="Category",
+                       color_discrete_sequence=px.colors.qualitative.Vivid)
+        fig2.update_layout(template="plotly_white", showlegend=False)
+    else:
+        fig2 = go.Figure()
+    figs.append(fig2)
+
+    # 3. Bounty range chart
+    bounty_rows = df.dropna(subset=["bounty_range_usd"]) if "bounty_range_usd" in df.columns else pd.DataFrame()
+    if not bounty_rows.empty:
+        labels = []
+        lows = []
+        highs = []
+        for _, row in bounty_rows.iterrows():
+            label = safe(row.get("technique_name") or row.get("title_template") or row.get("platform_name") or row.get("name") or "")
+            br = safe(row.get("bounty_range_usd", ""))
+            nums = re.findall(r"[\d,]+", br.replace(",", ""))
+            if len(nums) >= 2:
+                try:
+                    lows.append(int(nums[0]))
+                    highs.append(int(nums[1]))
+                    labels.append(label[:40])
+                except ValueError:
+                    pass
+            elif len(nums) == 1:
+                try:
+                    lows.append(0)
+                    highs.append(int(nums[0]))
+                    labels.append(label[:40])
+                except ValueError:
+                    pass
+        if labels:
+            bdf = pd.DataFrame({"Label": labels, "Min": lows, "Max": highs})
+            bdf = bdf.sort_values("Max", ascending=True).tail(20)
+            fig3 = go.Figure()
+            fig3.add_trace(go.Bar(y=bdf["Label"], x=bdf["Min"], orientation="h",
+                                   name="Min", marker_color="#66bb6a"))
+            fig3.add_trace(go.Bar(y=bdf["Label"], x=bdf["Max"] - bdf["Min"], orientation="h",
+                                   name="Max", marker_color="#ef5350", base=bdf["Min"]))
+            fig3.update_layout(title="Bounty Ranges (USD) – Top 20",
+                                barmode="stack", template="plotly_white",
+                                height=max(400, len(bdf)*28),
+                                yaxis=dict(automargin=True))
+        else:
+            fig3 = go.Figure()
+    else:
+        fig3 = go.Figure()
+    figs.append(fig3)
+
+    # 4. Difficulty distribution for Q&A
+    qa_df = filter_type(df, "qa")
+    if not qa_df.empty and "difficulty" in qa_df.columns:
+        diff_counts = qa_df["difficulty"].value_counts().reset_index()
+        diff_counts.columns = ["Difficulty", "Count"]
+        fig4 = px.pie(diff_counts, names="Difficulty", values="Count",
+                       title="Q&A Difficulty Distribution",
+                       color_discrete_sequence=px.colors.qualitative.Pastel)
+        fig4.update_layout(template="plotly_white")
+    else:
+        fig4 = go.Figure()
+    figs.append(fig4)
+
+    total = len(df)
+    type_summary = ""
+    if "type" in df.columns:
+        for t, c in df["type"].value_counts().items():
+            type_summary += f"- **{t}**: {c} entries\n"
+    summary = f"### Dataset Summary ({lang})\n**Total entries:** {total}\n\n{type_summary}"
+
+    return figs[0], figs[1], figs[2], figs[3], summary
+
+# ---------------------------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------------------------
+
+def create_app():
+    with gr.Blocks(
+        title="Bug Bounty & Pentesting Explorer",
+        css=CUSTOM_CSS,
+        theme=gr.themes.Soft(primary_hue="red", secondary_hue="purple"),
+    ) as app:
+        gr.Markdown(
+            "# 🛡️ Bug Bounty & Pentesting Explorer\n"
+            "Browse **146 entries** covering methodologies, checklists, attack techniques, "
+            "platforms, report templates, tools, and Q&A — in **French** and **English**."
+        )
+        gr.HTML('<div class="disclaimer-box">⚠️ <strong>Disclaimer:</strong> All content is intended for <em>authorized security testing</em> and <em>educational purposes</em> only. Unauthorized access to computer systems is illegal.</div>')
+
+        lang = gr.Radio(["EN", "FR"], value="EN", label="🌐 Language / Langue", interactive=True)
+
+        # ---- Tabs ----
+        with gr.Tabs():
+            # 1. Methodologies
+            with gr.Tab("📋 Methodologies"):
+                meth_output = gr.Markdown()
+                def refresh_meth(l):
+                    return build_methodologies(l)
+                lang.change(refresh_meth, inputs=lang, outputs=meth_output)
+                app.load(refresh_meth, inputs=lang, outputs=meth_output)
+
+            # 2. Checklists
+            with gr.Tab("✅ Checklists"):
+                cl_filter = gr.Dropdown(choices=["All", "Web", "API", "Mobile", "Cloud", "AD"],
+                                         value="All", label="Filter by Target Type", interactive=True)
+                cl_output = gr.Markdown()
+                def refresh_cl(l, f):
+                    md, targets = build_checklists(l, f)
+                    return md
+                cl_filter.change(refresh_cl, inputs=[lang, cl_filter], outputs=cl_output)
+                lang.change(refresh_cl, inputs=[lang, cl_filter], outputs=cl_output)
+                app.load(refresh_cl, inputs=[lang, cl_filter], outputs=cl_output)
+
+            # 3. Attack Techniques
+            with gr.Tab("⚔️ Attack Techniques"):
+                tech_filter = gr.Dropdown(choices=["All"], value="All",
+                                           label="Filter by Category", interactive=True)
+                tech_output = gr.Markdown()
+                def refresh_tech(l, f):
+                    md, cats = build_techniques(l, f)
+                    return md, gr.update(choices=cats, value=f if f in cats else "All")
+                def init_tech(l):
+                    md, cats = build_techniques(l, "All")
+                    return md, gr.update(choices=cats, value="All")
+                tech_filter.change(refresh_tech, inputs=[lang, tech_filter], outputs=[tech_output, tech_filter])
+                lang.change(init_tech, inputs=lang, outputs=[tech_output, tech_filter])
+                app.load(init_tech, inputs=lang, outputs=[tech_output, tech_filter])
+
+            # 4. Platforms
+            with gr.Tab("🏢 Platforms"):
+                plat_output = gr.Markdown()
+                def refresh_plat(l):
+                    return build_platforms(l)
+                lang.change(refresh_plat, inputs=lang, outputs=plat_output)
+                app.load(refresh_plat, inputs=lang, outputs=plat_output)
+
+            # 5. Report Templates
+            with gr.Tab("📝 Report Templates"):
+                rpt_filter = gr.Dropdown(choices=["All"], value="All",
+                                          label="Filter by Vulnerability Type", interactive=True)
+                rpt_output = gr.Markdown()
+                def refresh_rpt(l, f):
+                    md, vtypes = build_reports(l, f)
+                    return md, gr.update(choices=vtypes, value=f if f in vtypes else "All")
+                def init_rpt(l):
+                    md, vtypes = build_reports(l, "All")
+                    return md, gr.update(choices=vtypes, value="All")
+                rpt_filter.change(refresh_rpt, inputs=[lang, rpt_filter], outputs=[rpt_output, rpt_filter])
+                lang.change(init_rpt, inputs=lang, outputs=[rpt_output, rpt_filter])
+                app.load(init_rpt, inputs=lang, outputs=[rpt_output, rpt_filter])
+
+            # 6. Tools
+            with gr.Tab("🔧 Tools"):
+                tool_filter = gr.Dropdown(choices=["All"], value="All",
+                                           label="Filter by Category", interactive=True)
+                tool_output = gr.Markdown()
+                def refresh_tools(l, f):
+                    md, cats = build_tools(l, f)
+                    return md, gr.update(choices=cats, value=f if f in cats else "All")
+                def init_tools(l):
+                    md, cats = build_tools(l, "All")
+                    return md, gr.update(choices=cats, value="All")
+                tool_filter.change(refresh_tools, inputs=[lang, tool_filter], outputs=[tool_output, tool_filter])
+                lang.change(init_tools, inputs=lang, outputs=[tool_output, tool_filter])
+                app.load(init_tools, inputs=lang, outputs=[tool_output, tool_filter])
+
+            # 7. Q&A
+            with gr.Tab("❓ Q&A"):
+                qa_output = gr.Markdown()
+                def refresh_qa(l):
+                    return build_qa(l)
+                lang.change(refresh_qa, inputs=lang, outputs=qa_output)
+                app.load(refresh_qa, inputs=lang, outputs=qa_output)
+
+            # 8. Statistics
+            with gr.Tab("📊 Statistics"):
+                stats_summary = gr.Markdown()
+                stats_fig1 = gr.Plot(label="Entry Type Distribution")
+                stats_fig2 = gr.Plot(label="Technique Category Distribution")
+                stats_fig3 = gr.Plot(label="Bounty Ranges (USD)")
+                stats_fig4 = gr.Plot(label="Q&A Difficulty Distribution")
+                def refresh_stats(l):
+                    f1, f2, f3, f4, summary = build_statistics(l)
+                    return f1, f2, f3, f4, summary
+                lang.change(refresh_stats, inputs=lang,
+                            outputs=[stats_fig1, stats_fig2, stats_fig3, stats_fig4, stats_summary])
+                app.load(refresh_stats, inputs=lang,
+                         outputs=[stats_fig1, stats_fig2, stats_fig3, stats_fig4, stats_summary])
+
+        # Footer
+        gr.HTML(FOOTER_HTML)
+
+    return app
+
+# ---------------------------------------------------------------------------
+# Launch
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    app = create_app()
+    app.launch()

requirements.txt

@@ -0,0 +1,4 @@
+gradio==5.50.0
+plotly
+pandas
+datasets