Neko’s Knowledge Vault
#python #security-scripting #pentest #reverse-engineering #lesson-1 #core-python

Python Essentials for Security Scripting

A review of core Python syntax, data structures, and file I/O with an emphasis on writing clean, maintainable security scripts for pentest automation, scraping, and binary analysis.

Why This Matters for Security Work

Security scripts are rarely "write once and throw away." They are reused, shared, and modified under pressure. Clean code, predictable data structures, and robust file I/O make the difference between a fragile one-off hack and a reliable tool.

Core Syntax Essentials

  • Variables & naming: Use descriptive names. Security scripts often deal with ambiguous data, so raw_bytes, decoded_payload, and target_hosts are clearer than x, y, z.
  • Conditionals & loops: if/elif/else, for, while. Common patterns include iterating over file lines, parsed records, or network responses.
  • Functions: Encapsulate repeatable logic. Return values instead of printing inside functions when possible — this makes code easier to test and reuse.
  • Error handling: Use try/except around file, network, and parsing operations. Catch specific exceptions rather than bare except:.
  • String handling: F-strings, bytes vs. strings, and regular expressions are central to parsing logs, protocols, and binary data.

Key Data Structures

Structure Best For Security Example
list Ordered collections, iteration Storing target IPs from a scan
dict Key-value lookups, fast association Mapping IP addresses to hostnames or vulnerabilities
set Deduplication, membership testing Unique open ports or extracted URLs
tuple Immutable records Storing (ip, port) pairs

Prefer the right structure for the job. For example, use a set when you need to deduplicate a list of discovered subdomains.

File I/O Patterns

  • Reading: with open(path, 'r') as f: ensures files are closed automatically, even on errors.
  • Writing: Same pattern; choose text ('w') or binary ('wb') mode based on whether you're handling text or raw bytes.
  • CSV/JSON: Use the csv and json standard library modules for structured data. Avoid manual parsing when standard tools exist.
  • Line-by-line processing: For large logs or captures, iterate over the file object to avoid loading everything into memory.

Clean Script Structure

  1. Imports at the top — group standard library, third-party, and local imports.
  2. Constants and configuration — use UPPER_CASE names for values like file paths, default ports, or API endpoints.
  3. Functions for logic — keep main() focused on orchestration.
  4. Guard clause: if __name__ == "__main__": main() lets the file be imported as a module without running the script.

Quick Example: Processing a Target List

#!/usr/bin/env python3
"""Read a list of targets, deduplicate, and write to a clean file."""

import sys
from pathlib import Path


def read_targets(filepath):
    """Return a set of unique, non-empty hostnames from a file."""
    path = Path(filepath)
    if not path.exists():
        raise FileNotFoundError(f"Target file not found: {filepath}")

    with path.open('r', encoding='utf-8') as f:
        return {line.strip() for line in f if line.strip()}


def write_targets(targets, output_path):
    """Write sorted targets to a file."""
    with open(output_path, 'w', encoding='utf-8') as f:
        for target in sorted(targets):
            f.write(f"{target}\n")


def main():
    if len(sys.argv) != 3:
        print(f"Usage: {sys.argv[0]} <input_file> <output_file>")
        sys.exit(1)

    input_file, output_file = sys.argv[1], sys.argv[2]
    targets = read_targets(input_file)
    write_targets(targets, output_file)
    print(f"Wrote {len(targets)} unique targets to {output_file}")


if __name__ == "__main__":
    main()

Common Pitfalls

  • Mixing bytes and strings without decoding/encoding.
  • Using bare except: and silently swallowing errors.
  • Loading huge files into memory instead of streaming them.
  • Hard-coding paths or credentials inside functions.