Learn RCEA

What Is Encryption?

Imagine you want to send a secret note to your friend across the room, but other people can see the note as it passes between you. You need a way to scramble the message so that only your friend can read it. That's what encryption does.

Three key terms

What is a block cipher?

There are different ways to do encryption. A block cipher works by chopping your message into fixed-size chunks called blocks, then encrypting each block separately.

RCEA is a block cipher. What makes it unique is how it scrambles each block — it maps the bytes onto the faces of a virtual Rubik's Cube and uses cube rotations as the scrambling mechanism. The block size depends on the cube size: a 3×3 cube has 6 faces × 9 cells = 54 bytes per block.

The Rubik's Cube Idea

A real Rubik's Cube has 6 faces, each covered in a grid of colored squares. A standard 3×3 cube has 9 squares per face, for a total of 54 squares. Now imagine replacing each colored square with a byte of data (a number from 0 to 255).

Mapping data to the cube

To encrypt a message, RCEA takes a chunk of bytes and lays them out across the 6 faces of the cube. Here's what it looks like for the string "Hello World!" on a 3×3 cube:

Block size formula

The cube size N determines how many bytes fit in one block:

Why a cube?

When you twist a Rubik's Cube, pieces move from one face to another. This creates positional diffusion — a byte that was on the Front face might end up on the Right face. In traditional ciphers like AES, this is done with simple row shifts. RCEA uses the much richer structure of a Rubik's Cube, where a single rotation moves 2N+1 bytes across multiple faces simultaneously.

How RCEA Works

RCEA encrypts one block at a time. Each block passes through a pipeline of four operations, and this pipeline repeats for a configurable number of rounds (4 to 20). More rounds = more scrambling = harder to break.

Step by step

The mixing analogy

Think of it like mixing paint. One stir blends the colors a little — you can still see streaks. Ten stirs and the colors are uniformly blended. Each round is a stir. With 4 rounds, the data is reasonably mixed. With 10+ rounds, every output byte depends on every input byte and every bit of the key.

The actual code

Here's what the encrypt function looks like in pseudocode. This is the exact logic used by RCEA:

// 1. Start with the plaintext block
state = plaintextBlock

// 2. Mix in the key-derived initial state
state = XOR(state, keyedState)

// 3. Run R rounds of transformation
for round = 0 to R-1:
  state = SubBytes(state)          // confusion: S-box lookup
  state = CubeRotate(state, rots)  // diffusion: cube face rotations
  state = FaceMix(state)           // diffusion: row & column XOR scan
  state = XOR(state, roundKey[r])  // key mixing: round key addition

// 4. Output
ciphertextBlock = state

Why these four operations?

Good encryption needs two properties, identified by Claude Shannon in 1949:

The Four Operations

Each round applies four operations in sequence. Let's look at each one in detail — what it does, why it's needed, and exactly how it transforms the data.

CBC Mode & Authentication

So far we've talked about encrypting a single block. But real messages are usually longer than one block (54 bytes for a 3×3 cube). How do we encrypt a 10KB file? We need a mode of operation — a strategy for handling multiple blocks.

The problem with encrypting blocks independently

The simplest approach (called ECB mode) encrypts each block separately. But this has a fatal flaw: identical plaintext blocks produce identical ciphertext blocks. An attacker can spot patterns — for example, if you encrypt an image, the shape of the image is still visible in the ciphertext!

CBC: Cipher Block Chaining

RCEA uses CBC mode. Before encrypting each block, it XORs the plaintext with the previous ciphertext block. This creates a chain — each block's encryption depends on all the blocks before it. Identical plaintext blocks now produce different ciphertext because each is mixed with different previous data.

The IV (Initialization Vector)

The first block has no previous ciphertext to chain with. So we generate a random IV (Initialization Vector) — a block-sized random value. This means encrypting the same message with the same key produces completely different ciphertext each time (because the IV is different).

PKCS#7 Padding

Messages don't always divide evenly into blocks. If your message is 100 bytes and your block size is 54, you need to pad the last block to fill it up. RCEA uses PKCS#7 padding:

HMAC Authentication (Encrypt-then-MAC)

Encryption alone protects confidentiality (nobody can read the message), but not integrity (nobody has tampered with it). An attacker could flip bits in the ciphertext, and decryption would succeed — producing garbage that looks like a valid message.

RCEA uses Encrypt-then-MAC: after encrypting, it computes an HMAC-SHA256 tag over the entire ciphertext (IV + encrypted blocks). This tag is a 32-byte fingerprint. When decrypting, the tag is verified first. If it doesn't match, decryption is refused — the data has been tampered with.

Key Schedule

The key schedule is the process of taking your secret key (just 16 or 32 bytes) and expanding it into all the material the cipher needs: a keyed initial state, one round key per round, rotation sequences for CubeRotate, and an HMAC key for authentication. Without this expansion, the short key couldn't fill all these roles.

The expansion process

RCEA uses a KDF (Key Derivation Function) based on SHA-256. It works like a deterministic random number generator — given the same key and label, it always produces the same output, but different labels produce completely independent outputs.

KDF(key, label, length):
  output = empty
  counter = 0
  while output.length < length:
    chunk = SHA-256(key || label || counter)
    output = output + chunk
    counter++
  return output[0..length]

What gets derived

Why label-based derivation?

Security Notes

What RCEA does well

• Demonstrates core block cipher concepts (confusion, diffusion, key scheduling)
• Uses the well-studied AES S-Box for non-linearity
• Includes proper CBC mode with random IVs
• Uses HMAC-SHA256 for ciphertext authentication (Encrypt-then-MAC)
• Key derivation via Web Crypto HKDF

Why you shouldn't use it for real security

• Not peer-reviewed or cryptanalyzed by experts
• No formal security proofs
• Side-channel attacks not considered (timing, cache)
• Novel cipher design — proven algorithms are always safer

RCEA vs. Established Algorithms

Step-by-Step: RCEA vs. AES Round Comparison

RCEA's round structure is directly inspired by AES. Each step has an analogous operation:

Key Differences