Warning / Legal Notice: This repository is intended only for lawful, ethical, and educational use in isolated lab environments under explicit permission. The materials reference offensive security concepts for learning defensive and research purposes only. Do not deploy, test, or use any tools or techniques from this repository against systems you do not own or do not have explicit, written authorization to test. Misuse may be illegal and unethical.
- About
- Who this is for
- What you’ll learn
- Projects included (overview)
- Lab & environment (safe, high-level)
- Prerequisites
- Repository structure
- How to use this repo (safe practices)
- Contributing
- Code of Conduct
- License
- Further reading & resources
This repo accompanies a hands-on learning path that teaches Python 3 applied to offensive-security topics in a controlled, ethical manner. The goal is to help learners understand how common offensive tools are built so they can better defend systems, conduct authorized penetration tests, or perform malware analysis and incident response.
This README intentionally summarizes the course content, learning outcomes, and safe ways to practice. It does not include practical exploitation instructions, operational payloads, or any content that meaningfully facilitates wrongdoing.
- Aspiring ethical hackers and penetration testers learning Python.
- Defensive security engineers and malware analysts who want to understand offensive techniques to improve detection and hardening.
- Students and hobbyists building secure, legally-permissible lab skills.
- Python developers interested in security tooling (with a strong emphasis on ethics).
High-level concepts covered (programming + security context):
Python / Programming
- Network socket fundamentals (TCP/UDP) — conceptual overview
- Concurrency & threading patterns
requests,subprocess, file I/O, serialization and parsing- Cross-platform considerations (Windows vs Linux)
- Building CLI utilities and automations
Security / Offensive Concepts (educational)
- Setting up safe, isolated labs for testing
- Anatomy of backdoors, reverse shells, and remote control tools (conceptual)
- Keyloggers, credential stealing patterns (analysis-focused)
- Brute-force attack mechanics (rate-limiting, defenses)
- Network and port scanning fundamentals
- Malware propagation concepts and containment strategies
- Evasion and detection: how antivirus/EDR works at a high level
- Principles of exploit automation (responsible demonstration only)
This repo lists educational projects you will study and implement in a lab (no ready-to-run malicious payloads are provided here). Each project folder contains safe, annotated examples focusing on learning and defensive detection:
ftp-bruteforcer/— Educational demo of password-guessing techniques and defensive mitigations (rate limiting, lockouts).ssh-brute/— Analysis and safe simulations for learning about SSH hardening.reverse-shell/— Conceptual examples showing how remote command channels are implemented; do not run outside lab.keylogger/— For research/detection; includes code stubs and logging-demo only.botnet-framework/— Architectural diagrams, safe simulation controller code (no uncontrolled propagation).worm/— Analysis-only materials describing propagation vectors and mitigation; no propagation code.pdf-cracker/— Educational brute-force example illustrating password-guessing limitations and ethical use-cases.scanner/— Network discovery and port-scanning tools with emphasis on permission and rate control.exploit-automation/— Templates for safe automation of authorized exploits (no weaponized payloads).
Each project includes: a README with learning goals, threat model, detection guidance, and defensive mitigation notes.
To practice safely you must isolate experiments. Recommended approach (conceptual steps only):
- Create a completely isolated network (host-only / internal NAT) inside a hypervisor (VirtualBox, VMware).
- Use disposable VMs: Kali (attacker), multiple target OS images (Windows, Ubuntu). Snapshots are essential.
- Never connect your lab network to the public internet while testing offensive code.
- Use firewall rules and host-only adapters to prevent accidental leakage.
- Maintain logs and clearly document all tests and permissions.
The repo contains a
lab-guides/directory with high-level configuration examples and safety checklists — not step-by-step weaponized tooling.
- Familiarity with Python 3 (basic programming). If you are new to Python, study core syntax first.
- Understanding of operating systems (Windows/Linux basics).
- A virtualization platform (VirtualBox, VMware, or similar).
- Strong ethical and legal awareness; have written permission for any external testing.
/
├─ lab-guides/ # Safety checklists, VM configuration notes
├─ projects/
│ ├─ ftp-bruteforcer/
│ ├─ ssh-brute/
│ ├─ reverse-shell/
│ ├─ keylogger/
│ ├─ botnet-framework/
│ ├─ worm/ # analysis-only materials
│ ├─ pdf-cracker/
│ ├─ scanner/
│ └─ exploit-automation/
├─ docs/ # Threat models, detection writeups, slides
├─ resources/ # Papers, book lists, defensive tooling links
└─ README.md
- Read the legal & ethics notice before doing anything.
- Use only the annotated, non-propagating code samples unless you have a controlled lab and explicit permissions.
- Prefer “simulation” or “analysis” modes in examples; avoid executing code that interacts with live networks without authorization.
- Use the detection & mitigation notes in each project to learn how defenders can protect against similar patterns.
- When in doubt, treat code as educational pseudocode — inspect every line before running.
Contributions that improve the educational value, defensive guidance, documentation, and safety checks are welcome.
Please follow these rules:
- Do not submit or push code that enables unauthorized access, propagation, or real-world exploitation.
- All pull requests must include: purpose, threat model, safe usage notes, and how the change improves defensive understanding.
- Respect the Code of Conduct below.
To contribute:
- Fork the repo.
- Create a branch:
feature/your-change. - Submit a PR with clear motivation and safety considerations.
This project follows a standard code of conduct: be respectful, avoid enabling malicious activity, and prioritize safety and learning. Any contributions or discussions that promote illegal misuse will be rejected and may be reported.
This repository is provided for educational purposes. Consider using a permissive license such as the MIT License and add a clear disclaimer in LICENSE and top-level README about lawful use only.
(Non-exhaustive; curated for defensive learning)
- Official Python docs — language reference and standard library
- OWASP — web security fundamentals
- MITRE ATT&CK — adversary tactics & techniques (useful for detection and red-team exercises)
- Books: Practical Malware Analysis (for analysis, not replication), The Web Application Hacker's Handbook (defensive mindset)
- Defensive tools: OSSEC, Suricata, Zeek, EDR vendor whitepapers
This repository is intentionally conservative: it focuses on education, understanding, and defensive awareness rather than providing weaponized tools. If your goal is to become a professional penetration tester or malware analyst, pair practical lab work (with written authorization) with responsible mentorship, certifications (e.g., OSCP), and strong legal/ethical grounding.