Rail Fence Cipher: The Zigzag That Hid the Message

Most beginner ciphers change letters. Caesar turns A into D, Atbash turns A into Z, Vigenere changes letters according to a keyword, and Affine turns letters into numbers before sending them through a formula. The Rail Fence cipher does something different: it does not replace letters with other letters. It rearranges them.

The message is written diagonally down and up across a set of imaginary rails, like a zigzag fence. Once the letters have been placed, the ciphertext is read row by row. The letters themselves are the same, but their order has changed. That makes Rail Fence a transposition cipher, not a substitution cipher.

A Caesar cipher hides by changing the alphabet. A Rail Fence cipher hides by changing the route.

Rail Fence cipher at a glance

The Rail Fence cipher is often called a zigzag cipher because the message is written diagonally down and up across imaginary rails before being read off horizontally. It is one of the cleanest ways to teach a very important cryptographic distinction:

Substitution changes symbols.

Transposition changes positions.

What is the Rail Fence cipher?

The Rail Fence cipher is a classical transposition cipher.

It takes the plaintext and writes it in a zigzag pattern across a chosen number of rows. These rows are called rails.

For example, with 3 rails, the writing path looks like this:

Rail 1: 1       5       9
Rail 2:   2   4   6   8
Rail 3:     3       7

The path moves down from the top rail, down again to the bottom rail, then back upward until it reaches the top rail again.

For 3 rails, the repeating movement is:

1 -> 2 -> 3 -> 2 -> 1 -> 2 -> 3 -> 2 -> 1 ...

That movement is the cipher's structure.

The key is simply the number of rails. A 2-rail Rail Fence cipher is very simple. A 3-rail version gives a more recognisable zigzag. A 4-rail or 5-rail version spreads the letters out further. The principle is always the same:

1. Write the plaintext along the zigzag path.
2. Read the rails from top to bottom.

The message is not transformed letter by letter. It is redistributed. That is why Rail Fence is a good first transposition cipher: it lets the reader see that encryption can be about where information is placed, not only what each symbol becomes.

How does the Rail Fence cipher work?

Suppose we want to encrypt:

WEAREDISCOVEREDFLEEATONCE

using:

3 rails

First, write the message along a zigzag path.

Rail 1: W . . . E . . . C . . . R . . . L . . . T . . . E
Rail 2: . E . R . D . S . O . E . E . F . E . A . O . C .
Rail 3: . . A . . . I . . . V . . . D . . . E . . . N . .

The dots are only placeholders. They show the empty spaces in the zigzag.

Now read each rail from left to right.

Now join the rails together:

WECRLTEERDSOEEFEAOCAIVDEN

So:

WEAREDISCOVEREDFLEEATONCE -> WECRLTEERDSOEEFEAOCAIVDEN

The important thing to notice is that the ciphertext contains the same letters as the plaintext. No letter has changed identity. The W is still a W. The E is still an E. The A is still an A. Only the order has been disturbed.

That is transposition.

Key and rules

The Rail Fence cipher is simpler than many classical ciphers because its key is usually just a number: the number of rails.

The main rules are:

There are also variants. Some versions preserve spaces and punctuation. Some remove whitespace. Some group the output into blocks of five letters. Some allow an offset, meaning the zigzag starts partway through its cycle.

But the basic educational version is:

start at the top, move down, bounce, read rows

That is the version most learners mean by Rail Fence cipher.

Worked example: WE ARE DISCOVERED FLEE AT ONCE

Now encrypt the message:

WE ARE DISCOVERED FLEE AT ONCE

First remove spaces:

WEAREDISCOVEREDFLEEATONCE

Use:

3 rails

The rail pattern for 3 rails repeats like this:

1, 2, 3, 2, 1, 2, 3, 2, ...

So the letters are assigned to rails like this:

Now collect each rail.

That gives:

WECRLTE + ERDSOEEFEAOC + AIVDEN

Join the rails:

WECRLTEERDSOEEFEAOCAIVDEN

So the full encryption is:

This is the Rail Fence cipher doing exactly what it promises. It takes a straight line of text and turns it into a zigzag. Then it hides the zigzag by reading the rails separately.

A smaller example with 2 rails

A 2-rail example is even easier to see.

Encrypt:

HELLOWORLD

using:

2 rails

Write the letters alternately across two rails:

Rail 1: H . L . O . O . L .
Rail 2: . E . L . W . R . D

Rail 1 gives:

HLOOL

Rail 2 gives:

ELWRD

Join them:

HLOOLELWRD

So:

HELLOWORLD -> HLOOLELWRD

With 2 rails, the cipher is almost just separating odd and even positions. Rail 1 gets positions 1, 3, 5, 7, and 9. Rail 2 gets positions 2, 4, 6, 8, and 10.

That makes it very easy to break, but excellent for learning the basic idea. The Rail Fence cipher is not about replacing letters. It is about changing their order.

Decrypting the Rail Fence cipher

Decryption is less obvious than encryption.

To encrypt, you write the message along the zigzag and read the rows. To decrypt, you must reconstruct the zigzag positions, fill them with ciphertext letters row by row, and then read along the zigzag path.

Suppose the ciphertext is:

WECRLTEERDSOEEFEAOCAIVDEN

and the key is:

3 rails

You do not immediately know which ciphertext letters belong to which original positions, but you do know the zigzag pattern.

For 25 letters and 3 rails, the rail pattern is:

1, 2, 3, 2, 1, 2, 3, 2, ...

This tells you how many letters belong to each rail.

Now split the ciphertext according to those rail lengths.

Place those letters back into the zigzag positions:

Rail 1: W . . . E . . . C . . . R . . . L . . . T . . . E
Rail 2: . E . R . D . S . O . E . E . F . E . A . O . C .
Rail 3: . . A . . . I . . . V . . . D . . . E . . . N . .

Finally, read along the zigzag path:

W E A R E D I S C O V E R E D F L E E A T O N C E

That gives:

WEAREDISCOVEREDFLEEATONCE

Decryption is really a reconstruction problem. The receiver knows the fence shape. The ciphertext provides the row contents. The plaintext is recovered by walking the original zigzag route.

The pattern behind the zigzag

The Rail Fence cipher can be described visually, but there is also a simple mathematical pattern underneath it.

For 3 rails, the rail numbers repeat:

1, 2, 3, 2, 1, 2, 3, 2, ...

For 4 rails, the pattern is:

1, 2, 3, 4, 3, 2, 1, 2, 3, 4, 3, 2, ...

For 5 rails, the pattern is:

1, 2, 3, 4, 5, 4, 3, 2, 1, 2, 3, 4, 5, 4, 3, 2, ...

The cycle length is:

2 x rails - 2

This matters because the cipher is periodic. With 3 rails, the path repeats every 4 positions. With 4 rails, it repeats every 6 positions. With 5 rails, it repeats every 8 positions.

That periodic structure makes the cipher easy to analyse. It looks like a zigzag, but to a codebreaker it is also a repeating positional pattern.

History and origin

The Rail Fence cipher is best understood as a simple classical transposition cipher rather than as a historically dramatic military system.

It does not have the grand origin story of Caesar, the named mathematical identity of Hill, or the diplomatic history of Playfair. Its importance is educational. It is a clear example of transposition: hiding a message by rearranging its characters according to a pattern.

That does not make it worthless. It means its role is different.

Rail Fence is not remembered because it was unbreakable. It is remembered because it explains a basic cryptographic category with unusual clarity. A learner who understands Caesar has seen substitution. A learner who understands Rail Fence has seen transposition.

That is an important step.

Why the Rail Fence cipher was useful

The Rail Fence cipher is weak, but it is not pointless.

For hand puzzles, school exercises, programming tasks, and introductory cryptography, it has several useful qualities.

It also teaches a useful general programming idea:

1. Create a set of rows.
2. Move through them according to a direction.
3. Append characters to the current row.
4. Reverse direction at boundaries.
5. Join the rows.

The Rail Fence cipher is not only a cryptography lesson. It is also a lesson in pattern generation.

Weaknesses and limitations

The Rail Fence cipher is very weak.

Its biggest weakness is that it only rearranges letters. It does not change the letters themselves.

That means the ciphertext has exactly the same letter frequencies as the plaintext. If the plaintext contains many Es, the ciphertext still contains many Es. If the plaintext contains no Zs, the ciphertext still contains no Zs.

Only the order changes.

A 3-rail cipher looks interesting to a beginner. To a computer, it is barely a lock. Even by hand, it is usually not hard to test likely rail counts and look for readable output.

How the Rail Fence cipher is broken

A practical attack begins with one simple observation:

The letters have not changed.

If the ciphertext has normal-looking English letter frequencies but the order is strange, then a transposition cipher is a reasonable guess.

From there, Rail Fence is especially vulnerable because the key is small. The attacker can try 2 rails, 3 rails, 4 rails, 5 rails, 6 rails, and so on. Most ordinary Rail Fence messages use only a small number of rails.

Once the rail count is guessed, decryption is mechanical:

1. Mark the zigzag pattern.
2. Count how many letters belong to each rail.
3. Split the ciphertext into rail-sized chunks.
4. Fill the rails.
5. Read along the zigzag.

That is why Rail Fence is educational but insecure. The same regularity that makes it easy to learn also makes it easy to undo.

Rail Fence vs substitution ciphers

Rail Fence is useful because it contrasts strongly with substitution ciphers.

This is the key distinction:

Substitution changes identity.

Transposition changes order.

For example, the plaintext:

HELLO

might become:

KHOOR

under Caesar. The letters have changed.

Under a simple transposition, it might become:

HLOEL

The letters are the same, but rearranged.

This is why transposition ciphers preserve letter frequency. They can scramble readability, but they do not disguise which letters are present.

Related ciphers and comparisons

The Rail Fence cipher belongs to the family of transposition ciphers.

Rail Fence is usually simpler than columnar transposition. Columnar transposition uses a rectangular grid and a keyword to decide the order of columns. Rail Fence uses only a zigzag path and a rail count.

That makes Rail Fence easier to teach but weaker as a cipher.

The broader lesson is important. A single transposition step is usually not enough. Modern cryptographic systems use much more sophisticated forms of permutation and substitution, repeated many times and combined with strong key schedules.

Rail Fence is only the seed of that idea.

Where the Rail Fence cipher appears today

The Rail Fence cipher is common in beginner cryptography because it is visual, easy to draw, and easy to program.

You are likely to see it in:

• school cryptography lessons
• beginner programming exercises
• puzzle books
• escape-room style puzzles
• online cipher tools
• recreational cryptography
• geocaching clues
• CTF warm-up tasks
• simple demonstrations of transposition

It is also well suited to website tools because users can immediately see the pattern. A good Rail Fence tool can show the plaintext, the rail count, the zigzag grid, the rail rows, the final ciphertext, and the decryption reconstruction.

That visual quality is the cipher's main strength today. It is not secure, but it is extremely teachable.

It lets the reader see encryption as movement.

A simple Python Rail Fence cipher

The Rail Fence cipher is a good programming example because the encryption follows a clear path:

1. Create one string for each rail.
2. Start at rail 0.
3. Move down until the bottom rail.
4. Move up until the top rail.
5. Repeat until the message is finished.
6. Join the rails.

The code below implements Rail Fence encryption, Rail Fence decryption, and the classic 3-rail example.

def rail_fence_encrypt(text, rails):
    """
    Encrypt text using the Rail Fence cipher.

    The text is written in a zigzag over the chosen number of rails.
    The ciphertext is created by reading each rail from left to right.
    """
    if rails < 2:
        raise ValueError("Rail Fence cipher needs at least 2 rails.")

    fence = []

    for _ in range(rails):
        fence.append([])

    current_rail = 0
    direction = 1

    for char in text:
        fence[current_rail].append(char)

        if current_rail == 0:
            direction = 1
        elif current_rail == rails - 1:
            direction = -1

        current_rail += direction

    ciphertext = ""

    for rail in fence:
        ciphertext += "".join(rail)

    return ciphertext


def rail_pattern(length, rails):
    """
    Return the rail number used for each character position.
    For example, with 3 rails:
        0, 1, 2, 1, 0, 1, 2, 1, ...
    """
    pattern = []
    current_rail = 0
    direction = 1

    for _ in range(length):
        pattern.append(current_rail)

        if current_rail == 0:
            direction = 1
        elif current_rail == rails - 1:
            direction = -1

        current_rail += direction

    return pattern


def rail_fence_decrypt(ciphertext, rails):
    """
    Decrypt text encrypted with the Rail Fence cipher.

    Decryption works by:
    - reconstructing the rail pattern
    - counting how many letters belong to each rail
    - splitting the ciphertext into rail chunks
    - reading letters back along the zigzag path
    """
    if rails < 2:
        raise ValueError("Rail Fence cipher needs at least 2 rails.")

    length = len(ciphertext)
    pattern = rail_pattern(length, rails)

    rail_lengths = []

    for rail in range(rails):
        rail_lengths.append(pattern.count(rail))

    rails_text = []
    index = 0

    for count in rail_lengths:
        rail_chunk = list(ciphertext[index:index + count])
        rails_text.append(rail_chunk)
        index += count

    plaintext = ""

    for rail in pattern:
        plaintext += rails_text[rail].pop(0)

    return plaintext


plaintext = "WEAREDISCOVEREDFLEEATONCE"
rails = 3

ciphertext = rail_fence_encrypt(plaintext, rails)
decrypted = rail_fence_decrypt(ciphertext, rails)

print("Plaintext :", plaintext)
print("Rails     :", rails)
print("Encrypted :", ciphertext)
print("Decrypted :", decrypted)

Expected output:

Plaintext : WEAREDISCOVEREDFLEEATONCE
Rails     : 3
Encrypted : WECRLTEERDSOEEFEAOCAIVDEN
Decrypted : WEAREDISCOVEREDFLEEATONCE

The encryption logic is centred on this movement:

if current_rail == 0:
    direction = 1
elif current_rail == rails - 1:
    direction = -1

current_rail += direction

That is the zigzag.

When the path reaches the top rail, it starts moving downward. When it reaches the bottom rail, it starts moving upward. The cipher is just that motion applied to text.

Reading the code like the cipher

The encryption function begins by creating the rails:

fence = []

for _ in range(rails):
    fence.append([])

If the key is 3, this creates:

Rail 0: []
Rail 1: []
Rail 2: []

Then each character is placed onto the current rail:

fence[current_rail].append(char)

The variable:

direction

controls whether the path is moving down or up.

When the current rail is the top rail, the direction becomes downward. When the current rail is the bottom rail, the direction becomes upward. This reproduces the fence shape.

Decryption is more interesting. The function:

rail_pattern(length, rails)

recreates the path of the zigzag.

For a 3-rail message, it produces:

0, 1, 2, 1, 0, 1, 2, 1, ...

That tells the program which rail each plaintext position originally belonged to.

Then the ciphertext is split into rail chunks. For the classic example:

Finally, the program follows the zigzag pattern and pulls one character from the correct rail each time. That recreates the original message.

Encryption writes the zigzag. Decryption reconstructs the zigzag.

Common questions about the Rail Fence cipher

Is the Rail Fence cipher secure?

No. The Rail Fence cipher is not secure by modern standards. It has a very small keyspace, preserves letter frequencies, and can usually be brute-forced by trying plausible rail counts.

It is suitable for learning, puzzles, and historical interest only.

Is Rail Fence a substitution cipher?

No. Rail Fence is a transposition cipher. It does not replace letters with other letters. It rearranges the order of the original letters.

What is the key in the Rail Fence cipher?

The key is usually the number of rails. For example, a key of 3 means the message is written across 3 rails in a zigzag.

Why is it called Rail Fence?

It is called Rail Fence because the letters are written diagonally across imaginary horizontal rails, like a fence pattern. The message moves down and up across those rails before being read row by row.

What is another name for the Rail Fence cipher?

It is also called the zigzag cipher. That name comes from the path the letters follow during encryption.

Does Rail Fence preserve letter frequency?

Yes. Because it only rearranges letters, the ciphertext contains exactly the same letters as the plaintext. That means letter frequencies are unchanged, which is one reason it is weak.

What is a good Rail Fence example?

A classic example is:

The plaintext is written in a 3-rail zigzag, then read row by row.

Can spaces and punctuation be preserved?

Yes, a tool can preserve spaces and punctuation, but classical examples often remove them before encryption. Removing spaces usually makes the ciphertext less revealing. Preserving spaces makes the output easier to read but leaks structure.

Can the Rail Fence cipher use more than 3 rails?

Yes. The number of rails can be 2, 3, 4, 5, or higher. However, using more rails does not make it secure by modern standards. It only changes the transposition pattern.

Why the Rail Fence cipher still matters

The Rail Fence cipher should not be used to protect anything serious.

Not passwords.

Not private messages.

Not personal information.

Not financial data.

Not API keys.

Not recovery phrases.

Modern encryption depends on carefully analysed algorithms, large keys, randomness, authentication, and resistance to many forms of attack. Rail Fence has none of that.

But it still earns its place.

It shows that encryption does not have to mean replacing letters. It shows how a message can be hidden by rearranging its order. It shows why preserving letter frequency is dangerous. It shows how a simple key can generate a regular pattern. It shows why regular patterns are easy to attack.

And most importantly, it gives the learner a visible cipher.

You can see the encryption happen.

The line becomes a fence.

The fence becomes rows.

The rows become ciphertext.

That is why the Rail Fence cipher still matters. Not because it is strong, but because it teaches that sometimes the secret is not in the letters themselves. It is in the path they took.