Data Encryption Testing

Caesar Cipher Visualization

This interactive visualization demonstrates the Caesar cipher encryption technique by allowing users to input text and a shift value, then animating the transformation of the alphabet. The code uses D3.js v7 to render SVG letter boxes that smoothly transition colors and characters over a one-second animation, highlighting which letters shift and which remain unchanged. User input is processed through a custom `caesarCipher` function, while the `d3.select` and `transition` APIs drive the visual feedback.

Ffay Alomar

62% match

Gist 9e2ff3789a2158f045441b8f90f7ab91

This example visualizes the content of an encrypted message by decoding its PGP structure. It shows the raw cryptographic payload, including the key ID, version, and comment metadata, as a series of text blocks. The visualization uses the `d3.select` and `d3.text` APIs to fetch and display the message content, with a focus on the Base64-encoded body. It highlights the header lines (e.g., "Version:" and "Comment:") separately from the encrypted data, rendering them as distinct styled sections. The source is a static gist file, and the rendering relies on plain HTML and CSS, not on interactive libraries.

59% match

Message for Lindsey

This example demonstrates how encrypted text can be visualized as a static PGP message block, rendering the raw ciphertext characters with monospaced typography. The visualization uses the d3.js library to lay out the message’s lines and characters, applying a simple grid-based positioning system to preserve the original message structure. The data source is a Keybase OpenPGP-encrypted text file containing a private message intended for a specific recipient, which the code parses and displays without attempting decryption. The rendering approach relies on standard SVG text elements positioned via d3’s coordinate mapping functions.

57% match

Encrypting Messages with Keybase

This example demonstrates the full range of encryption capabilities offered by Keybase, from messaging and file sharing to managing teams and serving websites. Screenshots illustrate the workflow across three interfaces—the website, desktop application, and command line—highlighting how a user creates a public/private key pair, asserts their identity via Twitter, and encrypts chats and git repositories. The visualizations are static images embedded directly into a Markdown file, relying on Keybase’s underlying NaCl cryptographic library and its CLI tools, with no custom JavaScript or D3 code involved.

56% match

Gist 1967223

This example visualizes the leaked plaintext password from a support email, mapping its characters and their positions through a network layout. The code uses `d3.forceSimulation` to arrange character nodes, with `d3.geoPath` absent; instead, it employs SVG paths for links and `transition.attrTween` to animate text placement. The data comes from the email’s body, parsed into individual characters and spaces, while the rendering approach highlights the password’s structure as a force-directed graph. Only the visible simulation and tweening logic appear, with no additional interactions beyond the animated layout.

CCaged

Data Viz

This example displays the text “Hello HTML” centered on a blank page with a CSS font size of 13em. It demonstrates basic DOM rendering and JavaScript console logging, opening the browser developer tools to print “Hello JavaScript!”. The code uses plain HTML, CSS styling, and a script tag with `console.log`, requiring no external libraries or data processing. The included `data.json` file, containing categorical and numeric pairs, is not read or visualized in the current implementation.

Aalexntougias

Security Test

This example displays the text “Security Test” in a large, centered message on the page. It uses React and ReactDOM to render a single component, with styling applied via a CSS class. The rendering approach involves loading React from a CDN and mounting the component into a root div, demonstrating a minimal setup for a React-based visualization or UI.

CCurran Kelleher

Message for PastorRosanna

A visualization of a PGP-encrypted message decodes its contents as a scatterplot of characters arranged in a circular cluster. The code uses `d3.forceSimulation` to position each decoded character based on its frequency, with the raw ciphertext displayed alongside. Letters are rendered as SVG text nodes, and the decryption key is embedded in the message itself, revealing the plaintext through a custom parsing routine. The visualization shows the distribution of character types, highlighting the encrypted data’s structure before and after decryption.