CyberCode Academy

CyberCode Academy
  • 0.0 (0)
  • COURSES
  • UPDATED DAILY

Welcome to CyberCode Academy — your audio classroom for Programming and Cybersecurity. 🎧 Each course is divided into a series of short, focused episodes that take you from beginner to advanced level — one lesson at a time. From Python and web development to ethical hacking and digital defense, our content transforms complex concepts into simple, engaging audio learning. Study anywhere, anytime — and level up your skills with CyberCode Academy. 🚀 Learn. Code. Secure.

  1. Course 21 - Digital Forensics: Windows Shellbags | Episode 2: Forensic System Setup and Local Drive Integration

    4 HR AGO

    Course 21 - Digital Forensics: Windows Shellbags | Episode 2: Forensic System Setup and Local Drive Integration

    In this lesson, you’ll learn about:Preparing a Forensic WorkstationThe purpose of using a controlled forensic setup to safely extract and analyze system artifacts.Why working from an acquired drive or image is critical for maintaining evidentiary integrity.Essential Tools for Shellbag and Registry AnalysisShellbags Explorer: Used to parse and analyze shellbag artifacts associated with user folder navigation.FTK Imager (Lite): A portable, self-contained tool for accessing drives and exporting forensic artifacts without installing software on the target system.Loading a System Drive as EvidenceHow to use “Add Evidence Item” in FTK Imager to load a local physical drive (e.g., the C: drive).Understanding the evidence tree and how FTK represents the file system for forensic browsing.Navigating the File System for Forensic ArtifactsTraversing the directory structure within FTK Imager to locate user-specific data.Focusing on the Users directory and individual user home folders, which contain critical registry files.Target Registry Files for AnalysisIdentifying user-specific registry hives stored within the home directory.Understanding why these files are essential inputs for tools like Shellbags Explorer when reconstructing user activity.By the end of the episode, you’ll be able to set up the required forensic tools, load a system drive as evidence, and confidently locate the registry hives needed to analyze shellbags and other user activity artifacts. You can listen and download our episodes for free on more than 10 different platforms: https://linktr.ee/cybercode_academy

    15 min
  2. Course 21 - Digital Forensics: Windows Shellbags | Episode 1: Windows Shellbags: Forensic Fundamentals and Deep Dive Analysis

    1 DAY AGO

    Course 21 - Digital Forensics: Windows Shellbags | Episode 1: Windows Shellbags: Forensic Fundamentals and Deep Dive Analysis

    In this lesson, you’ll learn about: What Windows Shellbags Are and Why They MatterHow shellbags are registry-based artifacts created by Windows Explorer to store folder view preferences.Why they are a powerful source of user activity evidence, even when files or folders no longer exist.How Shellbags Are Created and UpdatedThe specific user actions that trigger shellbag updates, such as resizing windows or changing icon views.Why even casual folder browsing can leave long-lasting forensic traces.Forensic Value of ShellbagsHow shellbags persist even after folders are deleted or external/network drives are removed.How they enable user attribution, allowing investigators to determine which user accessed which path and when.Registry Locations and Data SourcesThe role of NTUSER.DAT and USRCLASS.DAT in storing shellbag data.The importance of the BagMRU registry key for tracking hierarchical folder navigation.Manual Reconstruction and ValidationHow investigators can manually “walk” BagMRU subkeys to reconstruct exact directory paths.Using hex and Unicode analysis to identify drive letters and folder names.Why manual validation is essential for evidence verification and expert testimony, even when automated tools are used.By the end of the episode, you’ll understand how Windows Shellbags record user navigation activity, where this data lives in the registry, and how to manually reconstruct folder paths to validate forensic findings with confidence. You can listen and download our episodes for free on more than 10 different platforms: https://linktr.ee/cybercode_academy

    14 min
  3. Course 20 - Malware Analysis: Identifying and Defeating Code Obfuscation | Episode 5: Identifying and Analyzing Cryptography in Malware

    2 DAYS AGO

    Course 20 - Malware Analysis: Identifying and Defeating Code Obfuscation | Episode 5: Identifying and Analyzing Cryptography in Malware

    In this lesson, you’ll learn about: Why Malware Uses Cryptography and EncodingHow encryption and encoding are used to conceal payloads, configuration data, and command-and-control traffic.The difference between encoding (obfuscation for transport) and encryption (confidentiality and anti-analysis).Why cryptographic protections are often the final barrier hiding a malware sample’s true behavior.Common Encoding and Encryption TechniquesSimple schemes such as XOR loops and Base64 for lightweight obfuscation.Strong cryptographic algorithms including AES and RC4 to protect embedded payloads and network communications.How multiple layers of encoding and encryption are frequently combined to slow down analysis.Identification TechniquesEntropy analysis to detect encrypted or compressed data, with high entropy values indicating strong obfuscation.Searching for cryptographic constants and algorithm “magic values” used during initialization.Import and library inspection to identify usage of cryptographic APIs or external crypto libraries.Analysis Tools and WorkflowUsing PE Studio for rapid triage to identify packing, suspicious imports, and anomalous strings.Tracing decryption routines in IDA Pro to locate keys, loops, and payload-handling logic.Leveraging dnSpy for .NET malware to view high-level encryption and decryption functions directly in decompiled code.Deobfuscation StrategiesDynamic analysis: pausing execution after decryption occurs to extract clean payloads or strings from memory.Static reimplementation: recreating the decryption logic in scripts or plugins to automatically decode all protected data.Choosing the fastest approach based on malware complexity and the analyst’s objectives. You can listen and download our episodes for free on more than 10 different platforms: https://linktr.ee/cybercode_academy

    19 min
  4. Course 20 - Malware Analysis: Identifying and Defeating Code Obfuscation | Episode 4: Dynamic API Resolution: Walking the PEB and Parsing

    3 DAYS AGO

    Course 20 - Malware Analysis: Identifying and Defeating Code Obfuscation | Episode 4: Dynamic API Resolution: Walking the PEB and Parsing

    In this lesson, you’ll learn about: Why Malware Builds Its Own Import TablesHow bypassing static, dynamic, and runtime linking hides API usage from analysis tools.Why this technique is especially valuable for shellcode, which executes without a normal Windows loader.How custom API resolution breaks automated inspection and signature-based detection.Locating System Libraries via the PEBAccessing the Process Environment Block (PEB) through the FS register (offset 0x30).Navigating PEB_LDR_DATA to enumerate loaded modules.Walking linked lists such as InMemoryOrderModuleList to locate key DLLs.Extracting the image base (DLL base address) from LDR_DATA_TABLE_ENTRY.Manual Parsing of the PE FormatUsing the e_lfanew field (offset 0x3C) to locate the NT Headers.Navigating the PE Data Directory to find the Export Table.Understanding the role of:Address of FunctionsAddress of NamesAddress of Name OrdinalsChecksum-Based API ResolutionIterating through exported function names without storing them in cleartext.Computing a checksum for each name at runtime.Matching computed values against hard-coded checksums embedded in the malware.Resolving the correct function pointer using ordinals and function address tables.Indirect API InvocationStoring resolved function addresses in a custom array.Executing APIs via indirect calls (e.g., call eax) instead of named imports.Why this completely hides functionality from the binary’s static import table. You can listen and download our episodes for free on more than 10 different platforms: https://linktr.ee/cybercode_academy

    16 min
  5. Course 20 - Malware Analysis: Identifying and Defeating Code Obfuscation | Episode 3: Analyzing and Defeating String Obfuscation in Native

    4 DAYS AGO

    Course 20 - Malware Analysis: Identifying and Defeating Code Obfuscation | Episode 3: Analyzing and Defeating String Obfuscation in Native

    In this lesson, you’ll learn about: String Obfuscation in Native Malware:Why string analysis is significantly harder in native code compared to interpreted languages.How compiled binaries store logic as machine instructions inside formats like the Portable Executable (PE), requiring reverse engineering rather than simple string extraction.Core Native String-Hiding Techniques:Stack Strings: Constructing strings dynamically on the stack using assembly instructions instead of storing them in readable sections of the binary.Checksum-Based Resolution: Hiding API and file names by comparing runtime-generated hashes against hard-coded checksums to build dynamic import tables without exposing cleartext strings.Encrypted Strings: Using encryption algorithms to keep strings unreadable until they are decrypted during execution.Static Analysis and String Recovery:Leveraging advanced extraction tools to recover stack strings that standard utilities cannot detect.Manually reconstructing strings in disassembly tools by converting numeric byte values into ASCII characters.Using cross-references (Xrefs) to confirm which functions are responsible for resolving APIs or decrypting strings.Dynamic Analysis and Debugging:Verifying static findings by stepping through execution in a debugger and observing register values and memory changes.Inspecting memory with appropriate commands to correctly display Unicode or multi-byte strings that contain embedded null bytes.Reversing Checksum Logic:Tracing low-level assembly operations such as bit rotations (ROL) and XOR instructions used to generate hashes from strings.Understanding normalization steps, such as converting strings to lowercase, to ensure consistent checksum comparisons across systems. You can listen and download our episodes for free on more than 10 different platforms: https://linktr.ee/cybercode_academy

    15 min
  6. Course 20 - Malware Analysis: Identifying and Defeating Code Obfuscation | Episode 2: Analyzing and Defeating Obfuscation in VBA

    5 DAYS AGO

    Course 20 - Malware Analysis: Identifying and Defeating Code Obfuscation | Episode 2: Analyzing and Defeating Obfuscation in VBA

    In this lesson, you’ll learn about: Obfuscation in Interpreted Code:Why interpreted languages like VBA and PowerShell are still heavily obfuscated despite being easier to access than native binaries.Common tactics such as junk instructions, string and object obfuscation, and nonsensical naming designed to slow analysis rather than prevent it.Analyzing Malicious VBA Macros:Extracting macro code from Office documents using stream-analysis tools.Identifying execution entry points such as AutoOpen to understand how and when malicious logic is triggered.Tracing string operations to uncover indicators of compromise, including URLs, dropped file names, and execution paths.PowerShell Obfuscation and “Living off the Land”:Understanding why attackers favor PowerShell for in-memory execution and stealth.Capturing and decoding obfuscated commands, including Base64 payloads that rely on UTF-16 encoding.Decompressing embedded payloads and inspecting runtime values as scripts de-obfuscate themselves.Dynamic Analysis Techniques:Using process and script inspection tools to observe PowerShell behavior at runtime.Leveraging debugging environments to set breakpoints and examine variables at the exact moment hidden data is revealed.Efficient Analysis Strategies:Refactoring obfuscated scripts by renaming variables and functions for clarity.Filtering out dead or irrelevant code to reduce noise.Allowing malware to execute in a controlled environment so it reveals its own logic, saving significant analysis time. You can listen and download our episodes for free on more than 10 different platforms: https://linktr.ee/cybercode_academy

    19 min
  7. Course 20 - Malware Analysis: Identifying and Defeating Code Obfuscation | Episode 1: Defeating Malware Obfuscation: Fundamentals, Impact

    6 DAYS AGO

    Course 20 - Malware Analysis: Identifying and Defeating Code Obfuscation | Episode 1: Defeating Malware Obfuscation: Fundamentals, Impact

    In this lesson, you’ll learn about: The Purpose of Code Obfuscation:Defining obfuscation as the practice of intentionally making software difficult to read or analyze.How malware authors use obfuscation to hide strings, functions, payloads, and command-and-control communication.The concept of “raising the bar” for analysts by increasing the time and effort required to understand malicious intent.Legitimate uses of obfuscation for protecting intellectual property in commercial software.Obfuscation Across Programming Architectures:The differences between native code (C, C++, Assembly) and interpreted or managed code (Java, .NET, Python).Why native binaries are harder to analyze due to reliance on disassembly rather than source-like output.How interpreted code can often be decompiled into structures that closely resemble the original source, making it generally easier to reverse.Common Obfuscation Techniques:Using meaningless variable and function names to disrupt manual analysis and signature-based detection.Injecting junk code that adds complexity without affecting functionality.Hiding indicators through string encoding or encryption that only resolves at runtime.Manipulating control flow with misleading jumps and unreachable branches to confuse analysis tools.Skills, Environments, and Tools for Deobfuscation:The importance of understanding Assembly language, the Windows API, and the Portable Executable (PE) format.Setting up safe analysis environments using Windows and Linux virtual machines, including REMnux.Leveraging industry-standard tools such as IDA Pro, Ghidra, dnSpy, JD-GUI, and debuggers for static and dynamic analysis. You can listen and download our episodes for free on more than 10 different platforms: https://linktr.ee/cybercode_academy

    15 min
  8. Course 19 - Ultimate Rust Crash Course | Episode 5: Rust Concurrency Fundamentals: Closures, Threads, and Channel Communication

    24 JAN

    Course 19 - Ultimate Rust Crash Course | Episode 5: Rust Concurrency Fundamentals: Closures, Threads, and Channel Communication

    In this lesson, you’ll learn about:Functional Programming with Closures:Defining closures as anonymous functions that capture values from their surrounding scope.Using closures with iterator methods like map, filter, and fold to transform data.The difference between borrowing closures and move closures, and why move semantics are required for safe multi-threaded execution.Multi-threaded Execution in Rust:Spawning threads with thread::spawn and running closures as thread entry points.Using join handles to wait for thread completion and handle potential panics.Understanding performance trade-offs between OS threads and asynchronous models, and when to prefer threads versus async/await.Inter-thread Communication with Channels:Coordinating work between threads using message-passing channels.Working with transmitters (TX) and receivers (RX), including cloning senders for multi-producer setups.Leveraging high-performance channel implementations to support multiple receivers.Synchronization and Program Lifecycle Management:How thread scheduling and sleep timing affect execution order.Ensuring clean shutdowns by closing channel senders and properly joining all threads. You can listen and download our episodes for free on more than 10 different platforms: https://linktr.ee/cybercode_academy

    14 min
See All (134)

About

Welcome to CyberCode Academy — your audio classroom for Programming and Cybersecurity. 🎧 Each course is divided into a series of short, focused episodes that take you from beginner to advanced level — one lesson at a time. From Python and web development to ethical hacking and digital defense, our content transforms complex concepts into simple, engaging audio learning. Study anywhere, anytime — and level up your skills with CyberCode Academy. 🚀 Learn. Code. Secure.

Information

  • Creator
    CyberCode Academy
  • Years Active
    2025 - 2026
  • Episodes
    134
  • Rating
    Clean
  • Copyright
    © Copyright CyberCode Academy
  • Show Website
    CyberCode Academy