Captain Nemo: Come Back In Cyber World

What is the Assembly Tutor Project?

The Assembly Tutor project is an open-source educational tool designed to guide you through assembly language programming in a hands-on way. The project offers a series of lessons that cover everything from basic concepts like binary math and registers to advanced topics such as anti-debugging techniques and Return-Oriented Programming (ROP) chains.

With this tutor, you can learn by doing — with clear explanations, code samples, and interactive exercises that solidify your understanding. The project is structured in a way that allows learners to progress through different levels, from beginner to advanced, while also gaining practical skills to use in real-world programming scenarios.

Key Features of Assembly Tutor

1. Structured Lessons

The project is divided into various topics and levels, ensuring that you learn at a pace that works for you. The lessons are categorized into the following groups:

• Introductory Lessons: Learn the basics of assembly, from arithmetic operations to debugging your first programs.

• Intermediate Lessons: Explore function calls, memory addressing, system calls, and control flow.

• Advanced Lessons: Dive deep into advanced topics like anti-debugging techniques, ROP chains, and writing position-independent code.

• Digital World Lessons: Understand networking protocols, file compression formats, malware signatures, and DNS queries.

• Practice Problems: Apply your skills with problems focused on array indexing, system calls, shellcode analysis, and more.

2. Interactive Learning

Each lesson comes with exercises that help reinforce the concepts being taught. You'll be guided through writing and debugging real assembly programs, ensuring that the knowledge you gain is hands-on and practical.

3. Real-World Application

The project doesn’t just teach syntax; it shows you how assembly programming applies to real-world systems, such as working with memory, interacting with the operating system, and understanding how digital systems communicate.

4. Beginner-Friendly Approach

Even though assembly is a low-level language, the tutor starts with simple concepts and gradually increases the complexity, making it accessible for those who are new to the language. The lessons are designed to be understandable and provide plenty of opportunities to practice.

Getting Started with Assembly Tutor

Prerequisites

To use the Assembly Tutor project, you'll need the following:

• Python 3.x: Python is used to run the tutor script and interact with the lessons.

• NASM (Netwide Assembler): This tool is used to compile assembly code. It’s available via most package managers.

• A Unix-like environment: The tutor is designed to work best in Linux or macOS environments. For Windows users, it’s recommended to use Windows Subsystem for Linux (WSL) for a smooth experience.

Running the Tutor

Once you’ve met the prerequisites, getting started with the tutor is simple. After downloading the project, run the following command to launch the tutor:

python launcher.py

This will prompt you to select a lesson and guide you through the interactive exercises, making it easy to learn at your own pace.

Contributing to the Assembly Tutor Project

The Assembly Tutor project is open-source, and contributions are encouraged! If you're passionate about assembly programming and want to help improve the tutor, you can fork the repository, make your changes, and submit a pull request. Contributions can include new lessons, bug fixes, or enhancements to existing content.

Why Learn Assembly Language?

While high-level languages like Python, JavaScript, and Java dominate modern software development, understanding assembly language can provide several benefits:

• Deeper Understanding of Computers: Assembly language gives you insight into how the CPU, memory, and operating system interact. It helps you understand low-level operations that are abstracted away in higher-level languages.

• Optimization: Sometimes, writing in assembly allows you to optimize critical code to make it run faster or more efficiently, especially for performance-critical applications.

• Security: Knowledge of assembly is essential for areas like cybersecurity, reverse engineering, and exploit development. Understanding how programs interact with memory is key to both defending and attacking software systems.

License and Usage

The Assembly Tutor project is licensed under the MIT License, which allows you to freely use, modify, and distribute the code. To find more information about the licensing, refer to the LICENSE file in the project repository.

Conclusion

Whether you're just starting your journey into programming or you're looking to deepen your understanding of low-level systems, the Assembly Tutor project provides an engaging and hands-on way to learn assembly language. With structured lessons, interactive exercises, and real-world applications, you'll gain a solid foundation in assembly programming and improve your overall programming skills.

Check out the project on GitHub today and start learning assembly the right way!

Welcome to Learn RSA Interactively, a beginner-friendly project designed to teach the foundations of RSA encryption and decryption through interactive Python lessons. Whether you're a student, developer, or cybersecurity enthusiast, this project will walk you through the core principles of RSA with real examples and step-by-step guidance.

By the end of this journey, you’ll not only understand how RSA works but also how to implement and even break it under certain conditions!

🧠 Why Learn RSA?

RSA is one of the most widely used public-key cryptosystems. It forms the backbone of digital security—from securing your emails to protecting online transactions. But understanding RSA can be daunting unless it's broken down into digestible, practical lessons.

That’s where this project comes in: interactive, modular, and fun!

📁 Project Structure

The project is organized into Python-based lessons, each tackling a unique concept in RSA. These lessons are launched via a central launcher script, making it easy to navigate.

🗂 Directory Layout

RSA-Teaching-Project/
│
├── lessons/                   # All RSA lessons
│   ├── lesson_1_intro_to_rsa.py
│   ├── lesson_2_key_generation.py
│   ├── lesson_3_encryption_decryption.py
│   ├── lesson_4_security_of_rsa.py
│   ├── lesson_5_hacking_rsa.py
│   ├── lesson_6_euler_totient.py
│   └── lesson_7_practical_rsa.py
│
├── tools/
│   └── rsa_tool.py            # Additional tool for key management and encryption
│
├── launcher.py                # Interactive menu for selecting lessons
└── README.md                  # Documentation and project overview

 Features at a Glance

Here’s what you’ll explore:

1. 🔎 Introduction to RSA
   Understand RSA’s origins and importance in cryptography.

2. 🧮 Key Generation
   Learn how to generate public and private keys using prime numbers and modular math.

3. 🔐 Encryption & Decryption
   Discover how RSA encrypts and decrypts data with hands-on demonstrations.

4. 🛡️ Security of RSA
   Explore why RSA is secure and the mathematics that protects it.

5. 🧨 Hacking RSA
   Get a taste of how weak RSA implementations can be cracked.

6. 📐 Euler’s Totient Function
   Master one of the core functions behind RSA key generation.

7. 🛠️ Practical RSA System
   Build a real working encryption/decryption system with your own keys.

🚀 Getting Started

✅ Requirements

To run the RSA Teaching Project, make sure you have:

• Python 3.x installed

• These Python libraries:

1. pycryptodome (for cryptographic operations)

2. subprocess os(for script management)

Install dependencies with:

pip install pycryptodome

▶️ How to Run the Project

1. Clone the Repository

   git clone https://github.com/nemocyberworld/learn-rsa-interactively.git
   cd rsa-teaching-project
   

2. Launch the Menu

   python launcher.py
   

3. Choose a Lesson to Start Learning
   You’ll see a menu like this:

   Learn RSA Interactively - Launcher
   --------------------------------
   Select a lesson to run:
   1. Introduction to RSA
   2. Key Generation
   3. Encryption and Decryption
   4. Security of RSA
   5. Hacking RSA
   6. Euler's Totient Function
   7. Practical RSA Implementation
   0. Exit
   --------------------------------
   

📚 Lessons Overview

Each lesson is a self-contained Python script with color-coded output and guided commentary.

🥇 Lesson 1: Introduction to RSA

Get a high-level overview of RSA and why it's crucial in cybersecurity.

🧪 Lesson 2: Key Generation

Dive into how RSA keys are created using large prime numbers and modular arithmetic.

✉️ Lesson 3: Encryption and Decryption

Watch the math in action as you encrypt and decrypt sample messages.

🔐 Lesson 4: Security of RSA

Understand why RSA is hard to break—hint: it’s all about factoring large numbers.

💀 Lesson 5: Hacking RSA

Learn about real-world vulnerabilities and how poorly configured RSA can be exploited.

🔢 Lesson 6: Euler’s Totient Function

Discover how φ(n) is used to compute the private key during key generation.

🛠 Lesson 7: Practical RSA Implementation

Put everything together to create your own working RSA system.

🤝 Contributing

Want to make this project even better? Fork the repo, contribute lessons, fix bugs, or enhance features!

Pull requests are always welcome!

📄 License

This project is licensed under the MIT License.
See the LICENSE file for full details.

🙏 Acknowledgments

• RSA was developed by Ron Rivest, Adi Shamir, and Leonard Adleman in 1977.

• This project uses the pycryptodome library for all cryptographic functionality.

🧠 Ready to learn RSA the fun and interactive way?
Clone the repo, launch the menu, and let’s encrypt!

Mr Linux is a gamified, interactive Bash learning platform designed to make you love the terminal. Whether you're a beginner or a seasoned hacker, Mr Linux will sharpen your command-line skills through structured lessons, hands-on practice, and a challenging terminal-based game.

🔧 Built by Captain Nemo
📬 nemo14398@gmail.com
🗓️ Last Updated: 20-04-2025
🌐 Website: nemocyberworld.github.io

🧭 Project Structure

mr-linux/
├── main.sh                # Entry point for the learning interface
├── config.sh              # Global configuration
├── lessons/               # Structured topics and subtopics
│   ├── 01. Intro/
│   ├── 02. File & Directory Management/
│   ├── ...
│   └── 16. Gaming Time/   # Bash-based Mr Linux Game
└── README.md

🚀 Features

• 🧪 250+ interactive Bash lessons

• 📁 Categorized by real Linux topics

• 🎮 A gamified Linux challenge mode with 23 levels

• 🧠 Learn by doing: awk, sed, grep, permissions, networking, scripting, and more

• ✅ Tracks your learning and progress

• 💻 Written 100% in Bash – no external dependencies

🎓 Lesson Categories

🎮 Mr Linux Game

Your skills will be tested in the “Gaming Time” section — a multi-level Bash-based challenge arena.

🧩 Features:

• 23 handcrafted challenges

• Topics include permissions, searching, scripting, networking, logs, regex, and more

• Progress saved to ~/.mr_linux_save

🗂️ Example levels:

• level3_grep_mastery.sh

• level10_networking2_nc.sh

• level22_fork_bomb.sh

• level23_bash_gauntlet.sh

🛠️ Getting Started

Clone the repository

git clone https://github.com/nemcyberworld/mr-linux.git
cd mr-linux
bash main.sh

Run individual lessons manually:

cd "lessons/02. File & Directory Management/ls"
bash lesson.sh

💾 Save System

Your game progress is stored automatically in:

~/.mr_linux_save

Tracks:

• Completed levels

• Total points

To reset your progress, simply delete the file.

📬 Contact

• GitHub: @nemcyberworld

• Email: nemo14398@gmail.com

📄 License

Licensed under the MIT License. Contributions welcome!

🌟 Support Mr Linux

If you find Mr Linux useful or fun:

• ⭐ Star the repo

• 🍴 Fork and add your own lessons

• 🐛 Report issues or suggest improvements

• 📣 Share with fellow Linux learners

“The shell is my sword, and Bash is my spellbook.” — Captain Nemo 🐙