Trickle Cipher

Rules, tools and methods

Trickles are very intuitive, the idea is that knowing the rules anyone can read one. You will find the logic behind it all below, but first an example:

Example:

Imagine you have the following paragraph for a trickle of 50 characters per line:

Lorem ipsum dolor sit amet, consectetur

adipiscing elit. Duis purus lorem, dapibus eget

ullamcorper non, vulputate suscipit sem. Nullam

gravida est ex, eget gravida enim interdum

dapibus. Proin in elit odio. Nunc interdum

faucibus sagittis. Maecenas vehicula convallis

magna sed tincidunt. Cras vel pellentesque odio.

Morbi lacinia bibendum efficitur. In euismod

feugiat turpis. Quisque non orci convallis,

finibus neque vel, dignissim ipsum. Suspendisse

potenti.

Output:
```
Lsr otdt iuase ei.  
```
- Line 1
```
Lorem ipsum dolor sit amet, consectetur          
```
  T: The trickle falls on the first character "L" of the paragraph and flows over the letters of the first word and then falls to the next line through the space between Lorem and ipsum.
  
  Decoded:
```
"L"
```
- Line 2
```
adipiscing elit. Duis purus lorem, dapibus eget  
```
  T: The trickle falls on the "s" of "adipiscing" and spreads over the word but finds resistance against the "d" because it is taller than the rest, hence falling off the right of the word again.
  
  Decoded:
```
"Ls"
```
- Line 3
```
ullamcorper non, vulputate suscipit sem. Nullam  
```
  T: The stream contienues to fall on the "r" of "ullamcorper". The trickle bounces off the last "l" because it is higher than any other letter in the word.
  
  Decoded:
```
"Lsr"
```
- Line 4
```
gravida est ex, eget gravida enim interdum       
```
  T: Falls straight through the 4th line between "est ex" adding a space.
  
  Decoded:
```
"Lsr "
```
- Line 5
```
dapibus. Proin in elit odio. Nunc interdum       
```
  T: Continues on the "o" of "Proin" and falls off the right again because of the capital P.
  
  Decoded:
```
"Lsr o"
```
- Line 6
```
faucibus sagittis. Maecenas vehicula convallis   
```
  T: The trickle continues on to the "t" of "sagittis." and falls off both sides of the word splitting the trickle in to two, T1 (left) and T2 (right), because there are no tall letters after a short letter.
  
  Decoded:
```
"Lsr ot"
```
- Line 7
```
magna sed tincidunt. Cras vel pellentesque odio. 
```
  The trickle now has two streams adding two letters to our clear text from left to right. So the next two letters are:
  
  T1: "d" in "sed". And divides T1 into T1.1 (left side) and T1.2 (right side)
  
  T2: "t" of "tincidunt." (note that the dot counts as a lower case letter).
  
  Decoded:
```
"Lsr otdt"
```
- Line 8
```
Morbi lacinia bibendum efficitur. In euismod     
```
  T1.1: Adds a space because it falls between "Morbi" and "lacinnia".
  
  T1.2: Adds "i" from "lacinia" and continues right.
  
  T2: Adds "u" from "bibendum" and falls right because of the "d".
  
  Decoded:
```
"Lsr otdt iu"
```
- Line 9
```
feugiat turpis. Quisque non orci convallis,      
```
  T1.1: Adds "a" of "feugiat" and fills up the word because "f" and "t" are tall letters, subdividing the stream in to T1.1.1 (out of the block) and T1.1.2 (right side).
  
  T1.2 falls on the "s" of "turpis" and continues right.
  
  T2: Adds "e" of "Quisque" and continues right.
  
  Decoded:
```
"Lsr otdt iuase"
```
- Line 10
```
finibus neque vel, dignissim ipsum. Suspendisse  
```
  T1.1.2: Falls through "finibus" and "neque" adding a space.
  
  T1.2 Falls on the "e" of "vel" and turns left.
  
  T2: Adds the second "i" from "dignissim" and continues right, because of the d.
  
  Decoded:
```
"Lsr otdt iuase ei"
```
- Line 11
```
potenti.                                        
```
  T1.1.2 Falls on the dot of "potenti.", adding it.
  
  T1.2 Falls on a space.
  
  T2: Falls on a space ending the trickle.
  
  Decoded:
```
"Lsr otdt iuase ei.  "
```

The Rules

Like a grille cipher if formatted incorrectly, a trickle is very hard to read, but when a set width is applied it becomes very intuitive to the naked eye. This is why the following rules must be observed when any trickle is being assembled.

The text body must have a defined character length per line and must be monospaced.
A start position for the trickle must be chosen (usually the first letter) determining the first decoded letter.
There are only three types of characters in a trickle ciphertext, short, tall and space.

Short characters:
```
acegijmnopqrsuvwxyz.,;:=-_
```

Tall characters:

bdfhkltABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890!?"'\/$%&()[]{}*><+

Space:
```
 
```

The Method

Once a start letter is set a trickle can do four things:

fall through if the selected character is a space
go left or go right (like this ) if it encounters a "Tall" character in the word of the selected character.
Or Split if there is equal resistance on either side of the selected character.

In a way it overflows the word of the character it falls on, In these examples the selected letter is black, "Tall" characters are "X", and "short" characters are "x".

Continue right:

xXxXx  Xxx  Xxx  Xx

Continue left:

 xXxXx  xxX  xxX  xX

Split the trickle in two:

 xXxXx   XxX   xxx   XXx

Also split:

 xXX   xX   Xx   x   X

That works with one line, but when multiple lines are involved the following behavior is added.

If the trickle falls through a line, adding a space, it continues until it meets a character or falls out of the text block.
When a trickle splits in two, the next lines selected letters are added from left to right.
When a previously split trickle rejoins another trickle they become one.

Trickle tool:

Input:
- [?]Where the trickle will start on the first line, use commas for multiple starts. Start
- [?]The amount of characters per line. Line length
- [?]The size of the font in pixels. Font size
- [?]Monospaced font families available. Font
- [?]Change these to determine what characters are considered "short".Short characters:
- [?]The characters below determine which characters are considered "tall".Tall characters:
- [?]Choose what character will be considered the "fall through" character.Space:
Output:

Variations

There is a lot that can change from trickle to trickle. Turn it around, use a ternary ciphertext (because there is basically three kinds of characters), or hide something else in it, the beauty of obfuscation is that no one knows its there...

Another neat thing to do is use several starting trickles (comma separated in the tool above), this makes the message shorter.

Notes

If you want to know more, read about null ciphers and transposition ciphers, trickles have many things in common with them, all though a trickle does not "encode" a message, meaning that it does not qualify as a cipher.

A word of advice, this is just a toy, don't ever use this if you want your information to stay safe, use real state of the art encryption for that.

The trickle: