FugitiveAI Deep Research: Challenge Design and Puzzle System

Full report

On this page

Executive Summary

The intersection of cognitive psychology, educational game design, and steganography provides a rich theoretical foundation for evolving the FugitiveAI challenge ecosystem. FugitiveAI operates within a highly constrained product boundary: a harmless, self-contained, deterministic hidden-message platform devoid of offensive security risks. The objective of this exhaustive research is to architect a methodology that deepens the intellectual satisfaction, educational value, and replayability of these challenges without violating the platform's core philosophy. Through a rigorous synthesis of Representational Change Theory, instructional scaffolding, and modern Capture The Flag (CTF) dynamic scoring mechanics, this report establishes a comprehensive framework for puzzle design. It defines a multi-axis difficulty model that isolates cognitive variables, proposes a progressive hint and penalty architecture to manage cognitive load, and provides a strict mathematical evaluation rubric for challenge fairness. Furthermore, an audit of existing challenge families reveals significant opportunities for vertical expansion, while a backlog of 30 novel steganographic mechanisms and 10 fully developed challenge concepts establishes a robust blueprint for a 50-challenge curriculum. The resulting architecture ensures that FugitiveAI scales gracefully, transforming users from novices who rely on visual anomalies into advanced analysts capable of navigating multi-layered, machine-level data structures.

1. Research Methodology

This research applies a multi-disciplinary analytical framework to the domain of self-contained hidden-message puzzles. The core psychological framework relies on Representational Change Theory (RCT), which posits that insight problem-solving difficulty stems not from a lack of logic, but from an initially flawed mental representation that over-constrains the solver's search space1. To reach a solution, the solver must encounter an "impasse" and subsequently achieve "constraint relaxation" or "chunk decomposition," shifting their perspective of the artifact from a semantic text to a structural data carrier3. This cognitive framework is paired with principles of instructional design, specifically Cognitive Load Theory (CLT) and the Zone of Proximal Development (ZPD). Effective educational game design minimizes extraneous cognitive load—such as confusing user interfaces or arbitrary logic—so that the learner's mental resources are exclusively allocated to the generative processing required for problem-solving5. Furthermore, the research integrates technical steganographic methodologies, including format-based, linguistic, and zero-width techniques, evaluating their viability within static, browser-rendered artifacts6. Finally, the analysis incorporates competitive cybersecurity frameworks, specifically examining dynamic scoring algorithms used in standard CTFd deployments to align reward systems with actual empirical difficulty9.

2. What Makes a FugitiveAI Puzzle Good?

A high-quality FugitiveAI puzzle operates as an elegant test of observation, hypothesis generation, and precise data extraction. To align with the platform's constraints, a puzzle must satisfy four definitional pillars. First, it must be rigorously deterministic. The puzzle must rely on formal, deductive logic rather than inductive or abductive guessing11. Once the correct channel is identified, the extraction rule must yield a single, mathematically unambiguous result. Second, the artifact must exhibit high semantic cohesion12. The covertext or carrier must appear perfectly natural; if linguistic steganography produces syntactically flawless but semantically disjointed sentences, the anomaly broadcasts itself too loudly, ruining the cognitive satisfaction of discovery13. Third, a good puzzle forces a representational shift. The solver must be induced to look at a standard HTML file and transition from reading it semantically to analyzing it structurally—for instance, examining the factorial permutations of HTML attributes rather than their rendering effects1. Finally, the puzzle must provide internal confirmation. The solver should recognize that they have achieved the correct answer prior to server submission, typically through the emergence of a recognizable flag format, legible plaintext, or a mathematically sound checksum, thus eliminating the frustration of pareidolia.

3. Puzzle Fairness Model

Fairness in puzzle design is the delicate equilibrium between cognitive challenge and logical consistency. A fair puzzle assures the solver that all necessary information is embedded within the self-contained artifact. A fair puzzle ensures optimal discoverability and clue sufficiency. The artifact must contain internal clues—subtle structural anomalies or recurring patterns—that gently guide the solver toward the correct hypothesis. Unfair puzzles often manifest as "beta-tester puzzles," where the solver is forced to attempt random permutations simply to account for undocumented edge cases or the author's idiosyncratic logic15. Fairness dictates that the artifact contains sufficient structural redundancy to point strictly toward the intended extraction method16. Ambiguity and arbitrary transforms are the antithesis of fairness. If a puzzle relies on synonymous substitution, the rules governing substitution must be absolute and universally verifiable18. If a puzzle requires translating extracted bits into ASCII, the endianness and bit boundaries must be standardized or explicitly signaled. A puzzle becomes unfair when multiple plausible interpretations exist, but only one arbitrary, untelegraphed path is accepted by the validation server19. Therefore, the FugitiveAI fairness definition requires that the hidden channel avoids obscure trivia, the extraction rule applies without exception, and the output provides unmistakable confirmation of success.

4. Multi-Axis Difficulty Model

Difficulty in hidden-message puzzles is frequently misunderstood as a linear continuum. In reality, difficulty arises from the manipulation of multiple independent cognitive and technical axes. The following multi-axis difficulty model replaces the binary "easy/hard" label, allowing for precise engineering of challenge progression.

By isolating these dimensions, designers can escalate difficulty along a single axis at a time, preventing cognitive overload and maintaining the solver's state of flow5.

5. Hint-System Research

An effective hint system functions as an external instructional scaffold, guiding the solver through the phases of representational change and moving them past cognitive impasses2. Hints should be systematically progressive, mapping directly to the solver's internal problem-solving journey. The recommended hint progression for FugitiveAI operates in five stages. First, Attention Direction narrows the solver's focus without revealing the mechanism (e.g., "The visible text tells a story, but observe the punctuation"). Second, a Representation Clue prompts the necessary constraint relaxation (e.g., "Read the text not for its meaning, but for its grammatical structure"). Third, an Extraction Clue identifies the specific channel (e.g., "Analyze the use of the Oxford comma in lists"). Fourth, the Exact Rule provides the deterministic mechanism (e.g., "An Oxford comma represents a binary 1, its absence represents a 0"). Finally, Partial Validation offers a tool to check intermediate steps (e.g., an automated bit-counter) without revealing the final flag. Hint penalties must be dynamically linked to the scoring system to disincentivize over-reliance while preserving motivation. Requesting an Attention Direction hint should incur a minimal penalty (e.g., 5% of the current challenge value). However, requesting the Exact Rule bypasses the generative processing essential for learning, and should severely penalize the score (e.g., a 75% deduction)5. Partial Validation tools should carry zero penalty, as they reward hypothesis generation and merely aid in mechanical execution.

6. Solution-Explanation Standard

The core educational value of FugitiveAI lies in the post-solve explanation. Constructivist learning theory dictates that knowledge is permanently solidified when learners can reflect on the mechanics of a solution and understand its broader applicability25.

7. Learning and Skill Transfer

To prepare users for advanced challenges without rendering them trivial, FugitiveAI must leverage the concepts of scaffolding, fading, and interleaving24. When a solver completes an introductory challenge involving zero-width spaces, they acquire a mental model of non-printable character manipulation6. To facilitate learning transfer, the subsequent challenge should utilize interleaving—mixing this known concept with a novel one. For instance, the solver encounters a text where zero-width spaces are present, but instead of containing the payload, they act as a synchronization layer (noise cancellation) that dictates which visible words should be evaluated for length parity. The instructional concept of fading involves gradually removing explicit structural clues25. An introductory HTML attribute steganography challenge might feature wildly abnormal indentation or obviously strange tag casing to signal its presence27. Subsequent challenges within that family should feature increasingly naturalistic formatting, fading the visual cue and forcing the solver to rely on their analytical tools (e.g., DOM inspectors) rather than immediate visual inspection.

8. Challenge Family Architecture

A challenge family explores a single steganographic technique across multiple axes of difficulty, preventing puzzles from devolving into repetitive, cosmetic variants. An analysis of HTML Attribute Steganography demonstrates this architecture14. The introductory variant focuses solely on boolean states, such as tag capitalization (\<DIV\> vs \<div\>), requiring simple binary mapping28. The intermediate variant shifts the focus to attribute ordering (e.g., \<img src="a.jpg" alt="b"\> vs \<img alt="b" src="a.jpg"\>), which introduces the mathematical concept of permutations and factorial capacities14. The advanced variant manipulates the spacing between attributes, combining multiple HTML tags and requiring script-based extraction and noise filtering to ignore tags without attributes27. By systematically altering the channel discovery method, the handling of distractor noise, and the extraction transformation, a single core concept yields a rich, intellectually distinct family of puzzles.

9. Multi-Layer Challenge Design

Multi-layer puzzles combine disparate techniques to create deep, engaging scenarios. However, if layered irresponsibly, they devolve into arbitrary guesswork15. The guiding principle of responsible layering dictates that Layer N must provide deterministic instructions, structural clues, or cryptographic keys for Layer N+1. To avoid arbitrary chains, layers should rely on modality shifts—combining a structural layer with a linguistic layer to force a complete representational change. For example, a webpage features a short essay. Inspection of the HTML canonical metadata tags reveals a custom attribute containing a Hexadecimal string. This Hex string, when decoded, yields the word "PUNCTUATION". The solver is now explicitly instructed to evaluate the essay's commas and periods as a deterministic binary channel. Alternatively, format can dictate extraction order. A JSON file contains an array of objects where keys are ordered non-alphabetically. Extracting the first letter of every key yields a Base64 string. Decoding this string produces an array of integers. These integers serve as the exact word indices to extract from a seemingly benign paragraph in the JSON's "description" field. In both cases, the puzzle remains entirely self-contained and logically unassailable.

10. False-Positive and Verification Design

In deterministic puzzles, the solver must be mathematically certain they possess the correct hypothesis before attempting server validation. Without internal verification, players succumb to pareidolia—seeing patterns in noise—which destroys the puzzle's fairness16. FugitiveAI must implement robust verification mechanisms. The strongest approach is the use of Known Prefixes (Magic Bytes). The extracted payload should always begin with a recognizable flag format, such as FUGITIVE{. If the solver extracts FUG..., they know their hypothesis is correct and merely need to refine their script's offset or endianness. Secondly, puzzles must utilize Exact Carrier Counts. If a payload requires 64 bits (8 ASCII characters), the artifact should contain exactly 64 manipulatable instances. If a text has 65 sentences, the solver immediately knows sentence-length parity is a false positive. Finally, challenges must enforce Valid Encoding Output. If a binary extraction results in non-printable ASCII characters (e.g., ASCII 04 or 19), the solver is provided immediate, deterministic feedback that their extraction logic is flawed.

11. Machine View / Inspection UX Research

To solve structural and format-based puzzles, solvers must inspect artifacts without the browser's rendering engine normalizing or obscuring the data24. FugitiveAI must provide safe, repository-owned inspection interfaces that minimize extraneous cognitive load, ensuring that deciphering the UI does not consume the cognitive capacity required for the puzzle itself24. The UX should include a Raw Artifact View, providing a strictly monospaced, copy-safe plaintext interface that prevents the browser from sanitizing whitespaces or normalizing line endings. A Hexadecimal / Byte Viewer is critical for identifying zero-width characters (e.g., U+200B) and exact whitespace counting, showing the hex values side-by-side with their ASCII representations6. A DOM Tree View should visualize HTML or JSON artifacts as nested nodes, allowing users to analyze element ordering and attribute arrangements without visual rendering interference31. Finally, a Whitespace Visibility Toggle should replace spaces with ·, tabs with →, and carriage returns with ¶. Crucially, to maintain the product boundary, these views must execute entirely client-side on the static text or be pre-rendered server-side, preventing arbitrary URL fetching or cross-site scripting risks.

12. Scoring System Analysis

A stagnant, static scoring system fails to reflect the empirical difficulty of a puzzle. FugitiveAI should adopt a dynamic scoring system based on standard CTF mechanics, where a challenge's value decays based on the number of successful solves it receives9. The widely adopted CTFd parabolic decay function is highly recommended over linear or logarithmic models, as it ensures higher-valued challenges experience a slower initial drop, rewarding early solvers appropriately while creating a larger standard deviation in scores to differentiate skill levels9. The formula is mathematically defined as: [Figure omitted from source export] Hint penalties should be deducted as a fixed percentage of the current dynamic value rather than the base points, ensuring penalties scale fairly as the challenge decays. Additionally, a minor, flat-point completion bonus for "First-Attempt Solves" (solving without any incorrect server submissions) heavily encourages players to verify their work locally rather than brute-forcing the validation server.

13. Achievement and Progression Analysis

Achievement systems within an intellectual puzzle platform must target mastery, methodological rigor, and educational absorption rather than manipulative engagement mechanics (e.g., grinding or daily login streaks). Appropriate achievements include "The Purist" (solving multiple challenges without utilizing the hint system), "Polyglot" (completing challenges across five distinct technique families), and "Deep Inspector" (successfully extracting a flag from a multi-layer challenge on the first server submission). Furthermore, a "Post-Mortem" achievement, awarded for spending sustained time reviewing a solution explanation, directly incentivizes pedagogical absorption. Progression should be managed via a structured Skill Tree. A user must complete an introductory HTML casing puzzle before unlocking intermediate HTML attribute ordering. This design operationalizes the Zone of Proximal Development, enforcing prerequisites and ensuring foundational concepts are mastered before complex interleaving occurs25.

14. Accessibility Considerations for Hidden-Message Puzzles

Puzzles that rely on visual perception—such as identifying subtle typographic differences or color shifts—inherently alienate users with visual impairments or those relying on screen readers. Accessibility in steganography puzzles is achieved through data representation. By providing raw text, DOM, and Hex views, users relying on screen readers can analyze the underlying data structure (bytes and syntax) rather than relying on visual rendering. Challenges must maintain strict Color Independence; if CSS hex colors (\#FF0000) hide data, the challenge must rest on the textual representation of the code, not the visual display of the color23. Because screen readers typically ignore zero-width spaces6, the platform's "machine view" must translate non-printable characters into explicit, readable tokens (e.g., \[ZWSP\]), ensuring that visually impaired users have equal access to the steganographic payload. Finally, clean, distraction-free UI design manages cognitive load, fulfilling cognitive accessibility requirements5.

15. Complete Challenge Quality Rubric

Every proposed FugitiveAI challenge must be evaluated against this strict out-of-100 scoring rubric. A minimum score of 85 is required for deployment.

16. Existing Challenge-Family Audit

An evaluation of FugitiveAI's current linguistic steganography techniques reveals foundational strengths, but significant opportunities for vertical deepening to prevent repetitive binary puzzles. Word Length Parity: Currently mapping even/odd lengths to 0/1, this serves as a strong introductory mechanism but is highly susceptible to noise (e.g., hyphenated words). To deepen this family, challenges should shift from binary parity to modulo operations (e.g., Word Length % 3), grouping lengths into trinary digits to encode data and increase payload density. Sentence Length Parity: This requires broader structural analysis but suffers from punctuation ambiguity (e.g., abbreviations like "Dr."). To deepen, introduce a syntactic synchronization challenge: only count sentences that begin with a specific part of speech (e.g., prepositions), testing natural language processing alongside steganography. Synonym Choice: While conceptually elegant7, natural language is ambiguous, making "correct" synonyms subjective. Deepening requires replacing arbitrary synonyms with strict regional variants (American vs. British spelling, e.g., color/colour), which offer mathematically strict, indisputable binary choices. Punctuation Choice: Utilizing the Oxford comma is subtle and highly natural, though it suffers from low payload capacity. This can be deepened by combining it with HTML structures—for example, requiring solvers to analyze punctuation strictly within \<li\> elements while ignoring standard paragraph text. Contractions: Choosing between "Do not" and "Don't" occurs with high frequency in natural text. To deepen this, make the choice stateful: the first contraction determines the endianness or the bit-offset of the ensuing bitstream, requiring programmatic state-tracking rather than simple counting. Active/Passive Voice: This demands advanced linguistic analysis22, though writing long covertexts naturally is exceptionally difficult. Deepen this by using it as a secondary filter mask: the active/passive status of a clause dictates whether the word count of that clause should be evaluated or discarded as noise. Sentence Order: This offers high capacity using factorial permutations22. Deepen this by requiring the user to reconstruct the original chronological story to discover the permutation index, which is then mapped to a lexicographical hash, combining reading comprehension with combinatorial math. Spelling Variants: Currently an absolute binary mapping. This can be deepened by creating a multi-pass challenge where spelling variants in paragraph one yield the decryption key (XOR) for spelling variants in paragraph two, introducing basic cryptography to linguistic steganography.

17. Future Challenge Research Backlog

The following 30 mechanisms adhere to FugitiveAI's philosophy, relying on formal constraints and deterministic rules across linguistic, web, and encoding layers.

18. Ten Fully Developed Challenge Concepts

19. 50-Challenge Progression Blueprint

To architect a 50-challenge catalog, FugitiveAI must abandon linear progression in favor of a Skill Tree. This operationalizes instructional interleaving and ensures players master foundational formats before confronting multi-layer capstones25.

20. Highest-Leverage Improvements

To substantially elevate FugitiveAI's current system, the following ten systemic improvements are ranked by their leverage, feasibility, and immediate impact on pedagogical quality and user satisfaction:

1. Implement the Dynamic Scoring Model (CTFd Parabolic Decay): Replace static scoring to allow point values to mathematically self-calibrate based on empirical solver difficulty, differentiating skill levels without penalizing early adopters9.

2. Deploy Safe "Machine Views": Build client-side DOM, Hex, and explicit whitespace viewers directly into the platform to prevent browser rendering normalization from destroying format-based clues27.

3. Establish the Strict Fairness Rubric: Enforce the 100-point rubric for all new challenges to permanently eliminate arbitrary "beta-tester" logic, ensuring deterministic verification15.

4. Adopt the Progressive Hint/Penalty System: Tie cognitive scaffolding directly to dynamic score penalties, encouraging users to push through psychological impasses rather than relying on exact rules2.

5. Standardize Solution Explanations: Mandate the 8-part worked-example template to guarantee that mechanical solving translates into genuine learning transfer and conceptual understanding25.

6. Introduce Multi-Layer Synchronization: Move beyond basic binary mappings by deliberately injecting "noise" (distractor data) and requiring programmatic synchronization markers, thereby deepening existing linguistic challenge families.

7. Implement Exact-Count and Checksum Verification: Mathematically eliminate false positives by embedding magic bytes and bit-limits, ensuring solvers never submit an answer they cannot verify locally16.

8. Transition to a Skill-Tree Progression: Require completion of fundamental format/linguistic challenges before unlocking multi-layer capstones, utilizing instructional interleaving and prerequisite gating24.

9. Expand into HTML/CSS Steganography: Capitalize on the repository-owned nature of web artifacts by manipulating attribute order, tag casing, and CSS rules, which offer vast, untapped deterministic channels14.

10. Incorporate Unicode Steganography: Integrate zero-width character challenges to teach modern, real-world data obfuscation techniques while testing solver reliance on hex-level tooling over visual inspection6.

Works cited

1. Search and representational change 1 Insight and search in Katona's Five-Square problem \- NTU \> IRep, https://irep.ntu.ac.uk/id/eprint/22777/1/22777\_Jones.pdf

2. Heuristics and representational change in two-move matchstick arithmetic tasks \- Advances in Cognitive Psychology, https://ac-psych.org/en/download-pdf/volume/2/issue/4/id/22

3. A generalization of the representational change theory from insight to non-insight problems: The case of arithmetic word problems \- ResearchGate, https://www.researchgate.net/publication/23299488\_A\_generalization\_of\_the\_representational\_change\_theory\_from\_insight\_to\_non-insight\_problems\_The\_case\_of\_arithmetic\_word\_problems

4. Cognitive Mechanisms of Insight : Journal of Experimental Psychology \- Ovid, https://www.ovid.com/journals/jeplm/fulltext/10.1037/a0029194\~cognitive-mechanisms-of-insight-the-role-of-heuristics-and

5. To add or not to add game elements? Exploring the effects of different cognitive task designs using eye tracking \- Figshare, https://figshare.com/articles/journal\_contribution/To\_add\_or\_not\_to\_add\_game\_elements\_Exploring\_the\_effects\_of\_different\_cognitive\_task\_designs\_using\_eye\_tracking/13318214/1/files/25661483.pdf

6. A Review on Text Steganography Techniques \- MDPI, https://www.mdpi.com/2227-7390/9/21/2829

7. A Survey on Semantic Steganography Systems \- arXiv, https://arxiv.org/pdf/2203.12425

8. CERIAS Tech Report 2004-13 LINGUISTIC STEGANOGRAPHY: SURVEY, ANALYSIS, AND ROBUSTNESS CONCERNS FOR HIDING INFORMATION IN TEXT by, https://www.cerias.purdue.edu/tools\_and\_resources/bibtex\_archive/archive/2004-13.pdf

9. Dynamic Value \- CTFd Docs, https://docs.ctfd.io/docs/custom-challenges/dynamic-value/

10. A comparative study of dynamic scoring formulas for capture-the-flag competitions \- Journal of Emerging Investigators, https://emerginginvestigators.org/articles/23-173/pdf

11. The Quest for Knowledge in The Witness | SUPERJUMP, https://www.superjumpmagazine.com/the-quest-for-knowledge-in-the-witness/

12. AN OVERVIEW OFVARIOUS FORMS OF LINGUISTIC STEGANOGRAPHYAND THEIRAPPLICATIONS IN PROTECTING DATA \- Research and Reviews, https://www.rroij.com/open-access/an-overview-of-various-forms-of-linguistic-steganography-and-their-applications-in-protecting-data-33-37.pdf

13. Linguistic Steganography via Self-Adjusting Asymmetric Number System \- MIT Press Direct, https://direct.mit.edu/coli/article/52/1/113/132854/Linguistic-Steganography-via-Self-Adjusting

14. Deogol \- HTML Steganography Tool, https://hord.ca/projects/deogol/intro.html

15. IF Theory Reader \- Inform 6, https://www.inform-fiction.org/manual/if\_theory\_reader.pdf

16. Logic Puzzles Explained: How to Think Like a Problem-Solving Pro, https://puzzlestreets.com/logic-puzzles-explained-how-to-think-like-a-problem-solving-pro/

17. LLMs as Puzzle Generators for The New York Times' Connections Word Game \- arXiv, https://arxiv.org/html/2407.11240v1

18. MTS-Stega: Linguistic Steganography Based on Multi-Time-Step \- PMC, https://pmc.ncbi.nlm.nih.gov/articles/PMC9140853/

19. Journey \- The Digital Antiquarian, https://www.filfre.net/2016/07/journey/

20. Steganography in HTML Based on Substitution of Script ... \- NADIA, http://article.nadiapub.com/IJSIA/vol7\_no4/33.pdf

21. (PDF) Steganography in HTML Files Using ROT-N Algorithm \- ResearchGate, https://www.researchgate.net/publication/327073978\_Steganography\_in\_HTML\_Files\_Using\_ROT-N\_Algorithm

22. The Secrets in the Word Order: Text-to-Text Generation for Linguistic Steganography \- ACL Anthology, https://aclanthology.org/C12-1032.pdf

23. Stego Html source after embedding the secret message \- ResearchGate, https://www.researchgate.net/figure/Stego-Html-source-after-embedding-the-secret-message\_fig2\_45909979

24. Design and Development of Learning Tools Through Web-Based Puzzle Games \- ICoBITS, https://icobits.ubhinus.ac.id/index.php/ICoBITS/article/download/126/214

25. (PDF) Elements of Educational Game Design: A Comprehensive Examination for Modern Educators \- ResearchGate, https://www.researchgate.net/publication/394112456\_Elements\_of\_Educational\_Game\_Design\_A\_Comprehensive\_Examination\_for\_Modern\_Educators

26. Hashing, Pooling and Coding: Towards Optimal Embedding in Linguistic Steganography, https://www.cs.ox.ac.uk/people/andrew.ker/docs/wilson-linguistic-steganography.pdf

27. ONLINE WEB PAGES STEGANOGRAPHY \- Informatika, https://informatika.stei.itb.ac.id/\~rinaldi.munir/Kriptografi/2007-2008/Makalah1/MakalahIF5054-2007-A-035.pdf

28. Data Hiding in Web Pages \- International Journal of Engineering Research & Technology, https://www.ijert.org/research/data-hiding-in-web-pages-IJERTCONV5IS10009.pdf

29. Steganography using web documents as a carrier: A Survey \- RJ Wave, https://rjwave.org/ijedr/papers/IJEDR1303036.pdf

30. D\&D Dungeon Puzzle Design: Creative Ideas & Examples \- LitRPG Reads, https://litrpgreads.com/blog/rpg/dnd-dungeon-puzzle-design-creative-ideas-amp-examples

31. 13.2 Parsing HTML documents \- HTML Standard, https://html.spec.whatwg.org/multipage/parsing.html

32. Educational Board Game Design and Implementation for Complex Secondary Student Skills: A Rapid Review \- Preprints.org, https://www.preprints.org/manuscript/202508.2159

33. Steganography, http://ashgillman.github.io/2015/05/04/Steganography.html

34. Swati-Rathi/Steganography-SNOW-AVariation \- GitHub, https://github.com/Swati-Rathi/Steganography-SNOW-AVariation