Peleke

Gist 479929a3d2e3a21ebdca56c228f18ddd

This example shows a shell script that automates the setup of a Linux-based scavenger hunt environment for students. It creates a local directory, downloads a Vagrantfile from a TinyURL link, and runs `vagrant up` to launch a virtual machine. The script then extracts the SSH host and port from `vagrant ssh-config` and prints connection instructions. The code relies on the Vagrant CLI, `curl`, and standard Unix utilities like `grep`, `awk`, and `sed`.

Jun 17, 2020

Gist bdd81a44fd94730b3b03cf3c2c936766

This Vagrantfile configuration sets up a single Linux virtual machine using the `cybersecurity/linux-scavenger` box. It shows a minimal, self-contained Vagrant setup for an isolated scavenger-hunt environment. The code uses the Vagrant Ruby DSL, specifically the `Vagrant.configure` block and the `config.vm.define` method, to declare the VM. It configures networking via `linux.vm.network` with a private static IP, disables the synced folder with `linux.vm.synced_folder`, and assigns provider settings for VirtualBox through the `vbox` provider block, allocating 1024 MB of memory and one CPU.

Jun 17, 2020

Gist a9811ea9c0293f1b19277f7a6995b236

This example shows a bash script that automates the setup of a Linux scavenger-hunt lab environment. It downloads an SSH deploy key, clones a Git repository from GitLab, initializes submodules, and uses Vagrant to provision the virtual machine. The script concludes by parsing `vagrant ssh-config` output with `awk` and `sed` to display the student’s SSH connection details, including hostname and port.

Gist b26bbc6a33a02bf25f57402d560ffdef

This example visualizes a network of nodes and links using a force-directed layout. The code employs d3.forceSimulation to compute positions and uses SVG elements for rendering. It reads data from a local JSON file containing nodes and edges, with node size and color mapping to connected degree. The interaction includes dragging nodes, which re-heats the simulation, and a zoom/pan behavior on the containing group. The implementation relies on d3.drag and d3.zoom to manage these user-driven updates.

Gist 74282189d04fc464e79dab8da61a8e5b

This example demonstrates a force-directed network layout where nodes are grouped into three distinct clusters, with edges connecting them. The visualization uses `d3.forceSimulation` to compute the physics-based positioning of nodes and links, while SVG paths are rendered for each connection. Node positions are updated through the simulation loop, and the code includes a utility to log simulation statistics. The graph appears to be generated from an arbitrary dataset, as no external data file is referenced. The implementation relies on D3.js for both the simulation engine and the rendering of the network structure.

Gist b90900e705a70b8c3a48b3ec6651dc97

This example visualizes a synthetic dataset of points distributed across a Cartesian plane, showing how a force-directed layout positions them relative to one another. The code uses `d3.forceSimulation` with collision and centering forces to compute node positions, then renders the result as SVG circles via `d3.select` and `d3.forceCollide`. The simulation runs in the browser, and the visualization updates in real time as forces settle, with each node’s color and radius set from the generated data. No external data file is loaded; all values are produced programmatically.

Gist f8b83c150e82b21c7d6fcadc802fb986

This example visualizes a network of interconnected nodes and links, revealing the structure of a graph through spatial clustering and connective pathways. It uses a force-directed layout powered by `d3.forceSimulation` to position nodes, with `d3.drag` enabling interactive repositioning. The rendering relies on SVG elements for both nodes and links, with node fill colors and radii encoding categorical data and degree. The underlying dataset is a static JSON structure of nodes and edges, drawn using standard SVG `circle` and `line` primitives within a responsive viewBox.

Gist 8c07c4405dfafcf9d164e5f519f62a05

This example visualizes categorical groupings through a force-directed network layout, using node positions and connecting edges to reveal clusters and their interconnections. The code employs D3.js’s `d3.forceSimulation` for physics-based layout and `d3.geoPath` to render curved links, while node styling relies on the Canvas API’s `getImageData` for pixel-level detail. Data originates from a Gist, processed as JSON. The scene updates each tick, smoothly adjusting to simulated forces, which portrays the structural relationships among items.

Gist 0711211684d6b9f38dc69fe06a29d844

This example shows a shell script that automates the setup of a Linux scavenger hunt lab environment by downloading a deploy key, cloning a GitLab repository, and running Vagrant to provision the machine. The script uses `curl` to fetch an SSH key, `git clone` with submodules to pull the lab definitions, and `vagrant up` to launch the virtual machine. It then extracts the SSH hostname and port from `vagrant ssh-config` using `grep` and `awk`, printing connection instructions for the student user.

Gist 79abf411748d1f79ce072fdc8d879407

This example scripts the automated deployment of a Linux scavenger-hunt lab environment. It downloads a private SSH key from a gist, clones a GitLab repository with submodules, and provisions the machine with Vagrant. It then parses `vagrant ssh-config` output to extract the hostname and port, printing the final SSH connection command for the student.

Gist abca832946db64106b24e4927e369a11

This example shows a Bash script that automates the setup of a Linux scavenger-hunt lab environment, from downloading a deploy key to provisioning a virtual machine. The script uses `curl` to fetch an SSH private key, `git clone` and `git submodule update --init --recursive` to retrieve the lab definitions, and `vagrant up` to launch the machine. It then parses `vagrant ssh-config` output with `grep`, `awk`, and `sed` to extract the hostname and port, printing SSH connection instructions for the student user.

Gist c283ab406d45a37dc94f0df43c6a9d19

This example loads a private SSH key file, parses its metadata, and visualizes the key’s structure with D3’s `d3.forceSimulation` for node placement and `d3.select` for SVG rendering. It shows the distribution of key segments and their relationships, drawing nodes and links based on the base64-decoded data. The rendering approach uses a custom JavaScript parser to extract header and body components, then maps each line of the key into a force-directed graph. The visualization relies on standard D3 APIs like `d3.forceLink` and `d3.forceManyBody` to arrange elements interactively.

Gist 22232677b43d0904992cd489d2aafdf0

This example demonstrates a shell script that automates the setup of a Linux scavenger hunt lab environment. It creates a directory, clones a Git repository from GitLab, initializes submodules, and uses Vagrant to launch a virtual machine. The script then runs a PowerShell reprovisioner script and fixes line endings with `dos2unix` before executing the reprovisioning process. The visualization—if any—is not present; the code focuses purely on environment provisioning using Git, Vagrant, and PowerShell APIs.

Gist 6378827722c371d2f33b9a9516ab1017

This example shows a PowerShell automation script for provisioning a cybersecurity lab environment. It uses the Vagrant command-line interface to add a Hyper-V provider machine image and start a virtual machine from a copied Vagrantfile. The script relies on PowerShell cmdlets like `mkdir` and `cp` alongside Vagrant’s `box add` and `up` commands to set up the Linux scavenger environment from a preconfigured gist.

Gist f1a4ad0d5f921fdb64ba7efec08a744a

This example demonstrates a Vagrant configuration for provisioning a Linux-based cybersecurity scavenger hunt environment. It defines a single virtual machine using the `cybersecurity/linux-scavenger` box, assigning it a private network IP and synced folder via SMB. The Vagrantfile uses the Hyper-V provider to allocate 2 GB of memory and one CPU, while explicitly disabling SSH key insertion for the guest. The setup relies on environment variables for SMB credentials, creating a reproducible lab environment for security exercises.

Feb 20, 2020

Gist 759f990ca4ab64414550b681a9f66f0e

This example demonstrates how to automate the setup of a Linux virtual machine for a scavenger-hunt challenge using PowerShell and Vagrant. It shows the complete provisioning workflow, starting with adding a Hyper-V provider box, creating a destination directory, downloading a Vagrantfile from a GitHub gist via `Invoke-WebRequest`, and finally running `vagrant up` to launch the machine. The code relies on Vagrant’s Hyper-V provider, the `vagrant box add` command, and PowerShell’s file and web-request cmdlets. The data source is the remote Vagrantfile hosted on GitHub, fetched over HTTP.

Feb 19, 2020

Gist 18921c958a623829bd02bec83deae10b

This example demonstrates a reusable PowerShell retry utility that wraps a command invocation with configurable retry logic. The function `Retry-Command` accepts a command name, a hashtable of arguments, a retry count, and a delay in seconds, executing the command via the call operator `&` with splatting. It forces `ErrorAction` to `Stop` to ensure errors are caught by a `try/catch` block, then retries the command until success or the maximum attempt limit, using `Start-Sleep` to pause between failures. The code highlights PowerShell’s error handling and parameter validation features.

Feb 13, 2020

"Script" to launch VMs on startup.

This visualization shows a PowerShell function that automates connecting to Hyper-V virtual machines and optionally starting them on host startup. It parses input parameters through multiple parameter set names, converts names to GUIDs where possible, and calls the `vmconnect.exe` utility for each target machine. The code uses PowerShell’s `Get-VM`, `Start-VM`, and `vmconnect.exe` APIs, handling both VM name and ID lookups, with verbose logging of each connection attempt and instance count.

Jan 26, 2020

Gist 64e48e594d78f24f4f91dda25974c90c

This example shows a PowerShell script for automating the setup of a Windows development environment, with a focus on configuring Hyper-V and WSL. The script uses Chocolatey commands to install tools like Docker Desktop, Git, Node.js, and Visual Studio Code, while also enabling Windows features and disabling UAC. It downloads GitLab Runner and registers it as a service, then fetches Ubuntu 18.04 Appx and Vagrant files for later WSL and Hyper-V use. The code relies on the Chocolatey package manager and Windows PowerShell cmdlets.

Dec 5, 2019

Gist d104916462842e9fae1e9652a6bfc408

This example shows the command-line setup for registering and installing a GitLab Runner on a transient Windows machine to build Hyper-V images. It displays the shell commands used to configure the runner non-interactively, specifying the GitLab URL, registration token, description, executor type, and tags. The visualization captures the process of registering the runner with `--non-interactive` flags, then installing and starting it as a service. The code relies on the GitLab Runner CLI and Windows shell commands, with no graphical libraries or data sources involved.

Nov 15, 2019

Log output from successful Packer build leading to failed upload to Vagrant Cloud.

This visualization shows the chronological sequence of a Packer build process, from its successful compilation to a subsequent failed upload attempt to Vagrant Cloud. The timeline displays timestamped log entries, starting with Packer version 1.4.4 initialization and progressing through numerous plugin registrations. The data comes from a gist by Peleke, rendered as a text-based timeline. The visualization uses JavaScript's `Date` parsing to analyze timestamps and a custom bar chart to display the event flow, highlighting the critical transition from build success to upload failure.

Nov 5, 2019

Boxstarter for Windows Datacenter 2019.

This example shows a Boxstarter script for automating the configuration of a Windows Datacenter 2019 environment. The script uses Boxstarter commands to manage Windows Update, UAC, and Explorer settings, while also installing a suite of Chocolatey packages like 7zip, Git, and Visual Studio Code. It further leverages Windows Features to enable Hyper-V and the Windows Subsystem for Linux, configures an X server for WSL, and customizes the user’s Git and terminal settings. The visual would depict the sequential flow of these setup tasks, from system tweaks to developer tooling.

Oct 15, 2019

Gist e3947dc0f4ec14b7afe964799db9d2f6

This example sets up a PowerShell-based workflow for configuring an internal NAT virtual switch and a DHCP server on a Windows host. It demonstrates the sequential execution of administrative commands, including `New-VMSwitch`, `New-NetIPAddress`, `New-NetNat`, and the `Add-DHCPServerv4Scope` function from the `DHCPServer` module, to automate network provisioning. The code also imports the Windows DHCP server module, installs the DHCP feature via `Install-WindowsFeature`, and adjusts registry settings to suppress post-installation notifications. The data source is the script’s own configuration variables, such as IP address ranges and subnet masks.

Oct 15, 2019

Gist 6caf9fb33f0b7bf1fe0b594b403dc053

This example demonstrates a potential security exploit rather than a data visualization. The PHP code generates an HTML script tag that uses JavaScript to send the visitor’s cookies to a remote webhook URL via an img request. It relies on the `document.cookie` API to capture cookie data and the `document.write` method to inject the tracking pixel. The rendering approach is purely client-side, with no charting or visualization libraries involved. The piece highlights how insecure code can misuse basic web technologies for data exfiltration.

Jul 2, 2019

Gist c86708ff5e888a2614ba904d56ada9d5

This example displays a minimal HTML page with a single heading that reads “Hello, world.” It uses plain HTML to render the text in a browser, with no external libraries or data sources. The visualization consists solely of static, unformatted content, demonstrating the simplest possible web page structure. The code does not include any interactive or dynamic elements, serving purely as a barebones starter template.

Jan 4, 2019

Gist 1f02b0833eba6f40ff53aff3d6e3a794

This example is a simple PHP script that demonstrates basic echo output. It assigns a multi-line HTML string containing an `<h1>` heading to a variable using the heredoc syntax, and then outputs it with the `echo` statement. The visualization shows the resulting rendered HTML page in the browser. The code relies on PHP's built-in echo construct and standard heredoc string handling rather than any external libraries or data sources.

Jan 4, 2019

shadow

A security-themed visualization analyzes password strength by decoding Unix shadow file entries. Using a custom JavaScript parser, the code splits the hash fields and maps the salt and cryptographic hash characters to bar lengths. The layout, built with D3.js, renders each account as a row of gray horizontal bars. The visualization leverages the `d3.select` and `d3.scale` APIs to encode the raw hash string characters into a geometric form, allowing quick visual comparison of password complexity across the displayed user accounts from the provided gist data.

Nov 16, 2018

passwd

This visualization maps the users from a Unix-style /etc/passwd file (sourced from a gist by Peleke) as a force-directed network. It shows the relationships between usernames and their associated fields—such as user ID, home directory, and shell—with each account rendered as a distinct node. The layout is computed using `d3.forceSimulation`, which applies physical forces to position the nodes and reveal clusters. The rendering relies on D3.js for SVG drawing and the `d3.forceAtlas2` API for the spatial arrangement, reading the data from the provided text file.

Nov 16, 2018

Gist 6ed3f84640838d8320f6b209b1628e41

This example demonstrates a cross-site scripting (XSS) proof-of-concept that exfiltrates a visitor’s cookies. The code uses a raw JavaScript payload with `document.write` to inject an `<img>` tag, which fires a request to a user-supplied Ngrok URL, appending `document.cookie` as a query parameter. It shows a simple, direct attack vector for testing XSS vulnerabilities, relying on the browser’s automatic image request to send data to an external server. The visualization is the code itself, presented as a threat-modeling sample rather than a chart.

Oct 5, 2018

Gist 055a86617685691db7632fcb10fb8bc8

This example demonstrates a simulated cross-site scripting (XSS) attack via remote file inclusion, visually rendering a PHP script’s output as an alert dialog that exposes `document.cookie`. The visualization uses a plain HTML page to embed the PHP snippet, with the code directly echoing a `<script>` tag that triggers the alert. It relies on the browser’s native JavaScript execution rather than external libraries, showing the raw mechanism of injecting client-side code through a server-side include. The rendering approach is minimal, presenting the source code and its resulting runtime behavior side by side.

Oct 4, 2018

Gist 6b1a5d43e458a795e475b14a5d9dbeac

This example demonstrates a malicious PHP file embedded within a GitHub gist, where an `echo` statement outputs `<h3>HACKED</h3>` to the page. The code uses the PHP `echo` language construct to directly inject HTML into the response, simulating a simple cross-site scripting or content injection attack. The gist syntax-highlights the PHP code, showing how a plain text file can carry executable server-side logic. The example highlights the security risk of trusting raw gist content, as the code appears as a static file but would execute if processed by a PHP-enabled server.

Oct 4, 2018

tryAll

This example demonstrates a brute-force attack on a Caesar cipher, decrypting a short encrypted string by testing all 24 possible shift keys. It shows the decryption attempts in a visualization, highlighting how different keys produce varying results. The code uses Node.js file system operations (`fs.readFileSync`) to load a frequency list from an external text file, then applies the `isEnglish` module to score each attempt. The `caesar` module performs the shift-based decryption, while `tryAll` iterates through all keys.

Apr 5, 2018

Solution to the problem of merging overlapping calendar appointments.

This example demonstrates an algorithm that merges overlapping calendar appointments into non-overlapping time blocks, showing how a list of meetings with start and end times can be reduced to a concise schedule. The code implements a pure JavaScript function that sorts the input array, iterates through each meeting, and conditionally combines it with the previous entry when their time ranges intersect. It uses standard array methods like `sort` and `reduce`, along with helper functions for checking overlaps and updating the merged list, with the final result logged via `console.log`. The data consists of hardcoded meeting objects with numeric `startTime` and `endTime` properties.

Dec 23, 2016

Gist f25f852eb839dbcd3dd2a6c7048c37ee

This example demonstrates a promise-based HTTP wrapper for fetching data from the JSONPlaceholder API. The code defines a `makeRequest` function that constructs a request path from user-supplied command-line arguments, using Node’s built-in `http` module to send a GET request to `jsonplaceholder.typicode.com`. It parses the response body as JSON and resolves the promise with the parsed data, while rejecting with an error message for non-200 status codes. The module exports the function for reuse.

May 12, 2016