DOCUMENTATION
Encryption System / Documentation

Built on randomness.
Designed to resist.

Enkripto is a randomized encryption system built around individually generated encryption configurations, transferable seed data, and its own command language.

Get Started Command Reference
01 / Core Concept

Every setup is different.

Enkripto is designed around the idea that encryption should not rely on one shared configuration. During initialization, Enkripto can generate an individual seed and library for a setup. The resulting configuration can then be used for encryption and decoding.

Configuration Space
A 1 followed by 149 zeros.
The number of encryption configurations Enkripto can generate. That's roughly 10⁵⁹ times more than the number of grains of sand in a universe made entirely of sand.

Randomized configurations

Instead of everyone working with the same configuration, Enkripto can generate a different one for each setup. The large configuration space makes identical configurations highly unlikely.

Reproducible with a seed

The seed is a compact representation that lets Enkripto recreate the required configuration later. The configuration itself does not need to be transferred directly.

Note: This page explains the public concept and workflow. Internal generation and reconstruction details are intentionally not documented here.

02 / Quick Start

Ready for the Unreadable.

The basic workflow is simple: initialize a configuration, use it to process a message, and save the seed data when you need to reproduce or transfer the setup. Because createNew defaults to True, a new setup can be started with just init.

01

Initialize

Use init or initiate to start the library and seed creation/import process.

02

Encrypt

Pass a message to encrypt or encode.

03

Decipher

Use decipher or decode with the same configuration.

04

Save

Use save or write to store the current seed data in an .enk file.

ENKRIPTO TERMINAL 
> init
[+] initialization complete

> encrypt msg=Hello World
[+] message encrypted

> decipher msg=<encrypted-message>
[+] message decoded
03 / Security Experiment

Even with the clues.

As an informal experiment, an AI model was given an Enkripto seed in both its raw and packed forms, together with an encrypted message. The model was explicitly told that the data was a seed, which version was packed, and which piece of data was the message.

Even with that information — far more context than an ordinary third party would have — the model could not determine how to reconstruct the required configuration or decipher the message.

What this demonstrates: The experiment illustrates how difficult the data can be to interpret without the Enkripto system itself. It is an informal demonstration, not a mathematical proof of security or an independent cryptographic audit.

04 / Preferences

Remember the way you work.

Enkripto can store a small set of startup preferences in preferences.json. These preferences control how initialization behaves the next time you use the program.

Stored preferences

The current persistent preferences are createNew, readFromENK, and fileLocation.

Default values

If no saved preference overrides them, Enkripto starts with createNew=True, readFromENK=False, and fileLocation=Default.enk.

PREFERENCES.JSON 
# Example preferences
{
  "createNew" : True,
  "readFromENK": False,
  "fileLocation": "Default.txt"
}

# Because createNew defaults to True:
> init

Important: Preferences and seed data are separate. preferences.json stores startup settings; seed data is handled separately through the save/import workflow.

Use restoredefaults, defaults, or default to restore the default parameter values.

05 / Seeds & Libraries

Small data. Reproducible configuration.

A seed is a set of numeric values that allows Enkripto to recreate a library without directly transferring that library. This makes seed data compact and convenient to store or transfer.

Raw seeds

Raw seeds are compact numeric data. They are convenient when copying a seed directly and have a recognizable structure.

Packed seeds

A packed seed uses an additional packing step, producing a less immediately recognizable representation. Packed data is longer but can be convenient for sharing through an .enk file.

ENkripto uses it's own Filetype: .enk
This ensures even safer transfer because the structure of .enk files distinguishes itself from any traditional form.

Libraries

A library represents the generated encryption configuration used by Enkripto for its processing operations. Users generally work with the seed rather than manually transferring the library.

Save & restore

Enkripto can save seed data and the required packing information into an .enk file. That data can later be used to restore the setup.

SEED EXAMPLE 
# raw seed — illustrative format only
123.4567.890

# packed seed — illustrative format only
dfsizt2u673598$&
06 / NHH

Native Handling Hub.

Enkripto uses its own mini parsing language called NHH. It provides a consistent way to enter commands and parameters directly in the terminal.

Case insensitive

Capitalization does not matter when entering commands or parameters.

Flexible parameter order

Parameters do not need to be entered in a specific order.

Optional underscores

Parameter names can omit underscores, such as seed_ispacked and seedispacked.

Defaults

If a parameter is not provided, Enkripto falls back to its default value.

NHH SYNTAX 
> setparams createnew=True, encryptionamount=999

> encrypt target=hi.txt

# parameter order does not matter
> setparams encryptionamount=3, createnew=True

Strings: Avoid quotation marks around parameter values. Enkripto interprets strings by default, so added quotation marks become part of the value.

07 / Command Reference

Commands at a glance.

These commands are exposed through the current help system. Aliases can be used interchangeably.

help

Shows the main help menu and explains how to access detailed help.

explain

Starts the Enkripto tutorial.

resetfile

Resets the text file to default values.

init / initiate

Starts the library creation or import process.

(function).params

Shows a function's relevant parameters and their current values.

all.params

Shows all available parameters and their current values.

save / write

Packs and saves the current seed to an .enk file.

display / displayseed

Displays the current seed, packed or raw depending on the parameter.

scan / list / ls

Scans and lists the current directory.

currentpath / cwd / currentdir

Displays the work directory path.

restoredefaults / defaults / default

Restores all parameters to their default values.

setparams / setparam

Changes selected parameters without executing another function.

encrypt / encode

Encrypts the provided target message or text file using the current library.

decipher / decode

Decodes the provided target message or text file using the current library.

exit

Closes the program.

08 / Parameters

Control the process.

Parameters use name=value. Multiple parameters are separated by commas. Their order does not matter, and omitted values use defaults.

createnew bool Whether a new seed and library should be generated.
readfromENK bool Whether values should be read from an .enk file during initialization.
filelocation str Path to the .enk file used for seed data. Default: Default.enk.
custom_packerlibrary str Packing-library data for manually imported packed seed data.
importseed str Manually supplied seed data for import.
seed_ispacked bool Whether manually imported seed data is packed.
encryptionamount int Defines the number of encryption layers used during library creation. The layer count adds another source of variability to the generated result; a different layer count can produce a different library even under otherwise similar conditions. More layers should not be interpreted as automatically meaning more security.
packmyseed bool Controls packed seed display/save behavior where supported.
debug bool Developer-oriented extra information; not recommended for normal use.
msg / target str The message or target file supplied to encryption/decoding commands. Use msg to directly provide text and target to provide a file path
09 / Typical Workflow

A practical session.

A simplified example of how the pieces fit together without exposing the internal encryption implementation.

SESSION 
# 1. Initialize a new configuration — defaults are enough
> init

# 2. Encrypt a message
> encrypt msg=Meet me at 8

# 3. Save the seed data
> save filelocation=save.enk

# 4. Later, restore/import the seed data
> init readfromtxt=True, filelocation=save.txt

# 5. Decode using the restored configuration
> decipher msg=<encrypted-message>
# you can also directly en/ decode files using the target parameter (e.g encode target = test.txt)

Tip: Use scan, list, or ls to locate files. Use currentpath, cwd, or currentdir to see where you are working.