RC5 Encryption Algorithm

RC5 is a symmetric key block encryption algorithm designed by Ron Rivest in 1994. It is notable for being simple, fast (on account of using only primitive computer operations like XOR, shift, etc.) and consumes less memory. Example:

Key : 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
Plain Text : 00000000 00000000
Cipher Text : EEDBA521 6D8F4B15

RC5 is a block cipher and addresses two word blocks at a time. Depending on input plain text block size, number of rounds and key size, various instances of RC5 can be defined and each instance is denoted as RC5-w/r/b where w=word size in bits, r=number of rounds and b=key size in bytes. Allowed values are:

Note - Since at a time, RC5 uses 2 word blocks, the plain text block size can be 32, 64 or 128 bits. Notation used in the algorithm:

Step-1: Initialization of constants P and Q. RC5 makes use of 2 magic constants P and Q whose value is defined by the word size w.

For any other word size, P and Q can be determined as:

P = Odd((e-2)2^w) Q = Odd((\phi-2)2^w)

Here, Odd(x) is the odd integer nearest to x, e is the base of natural logarithms and \phi  is the golden ratio. Step-2: Converting secret key K from bytes to words. Secret key K of size b bytes is used to initialize array L consisting of c words where c = b/u, u = w/8 and w = word size used for that particular instance of RC5. For example, if we choose w=32 bits and Key k is of size 96 bytes then, u=32/8=4, c=b/u=96/4=24. L is pre initialized to 0 value before adding secret key K to it.

for i=b-1 to 0
    L[i/u] = (L[u/i] <<< 8) + K[i]

Step-3: Initializing sub-key S. Sub-key S of size t=2(r+1) is initialized using magic constants P and Q.

S[0] = P
for i = 1 to 2(r+1)-1
    S[i] = S[i-1] + Q)

Step-4: Sub-key mixing. The RC5 encryption algorithm uses Sub key S. L is merely, a temporary array formed on the basis of user entered secret key. Mix in user's secret key with S and L.

i = j = 0
A = B = 0
do 3 * max(t, c) times:
    A = S[i] = (S[i] + A + B) <<< 3
    B = L[j] = (L[j] + A + B) <<< (A + B)
    i = (i + 1) % t
    j = (j + 1) % c

Step-5: Encryption. We divide the input plain text block into two registers A and B each of size w bits. After undergoing the encryption process the result of A and B together forms the cipher text block. RC5 Encryption Algorithm:

1. One time initialization of plain text blocks A and B by adding S[0] and S[1] to A and B respectively. These operations are mod2^w  .
2. XOR A and B. A=A^B
3. Cyclic left shift new value of A by B bits.
4. Add S[2*i] to the output of previous step. This is the new value of A.
5. XOR B with new value of A and store in B.
6. Cyclic left shift new value of B by A bits.
7. Add S[2*i+1] to the output of previous step. This is the new value of B.
8. Repeat entire procedure (except one time initialization) r times.

A = A + S[0] 
B = B + S[1]
for i = 1 to r do:
    A = ((A ^ B) <<< B) + S[2 * i]
    B = ((B ^ A) <<< A) + S[2 * i + 1]
return A, B

Alternatively, RC5 Decryption can be defined as:

for i = r down to 1 do:
    B = ((B - S[2 * i + 1]) >>> A) ^ A
    A = ((A - S[2 * i]) >>> B) ^ B
B = B - S[1]
A = A - S[0]
return A, B

Below is the implementation of above approach:

#include <cstdint>
#include <iostream>
#include <vector>

// Constants for RC5-32/12/16
const int W = 32; // Word size in bits
const int R = 12; // Number of rounds
const int B = 16; // Key size in bytes
const int C = 4; // Number of words in key

// Magic constants
const uint32_t P = 0xB7E15163;
const uint32_t Q = 0x9E3779B9;

// Rotate left function
uint32_t rotl(uint32_t x, int y)
{
    return (x << y) | (x >> (W - y));
}

// RC5 key expansion
void rc5_key_setup(const std::vector<uint8_t>& key,
                   std::vector<uint32_t>& S)
{
    std::vector<uint32_t> L(C, 0);

    for (int i = B - 1; i >= 0; --i) {
        L[i / 4] = (L[i / 4] << 8) + key[i];
    }

    S[0] = P;
    for (int i = 1; i < 2 * (R + 1); ++i) {
        S[i] = S[i - 1] + Q;
    }

    uint32_t A = 0, B = 0;
    int i = 0, j = 0;

    for (int k = 0; k < 3 * std::max(2 * (R + 1), C); ++k) {
        A = S[i] = rotl(S[i] + A + B, 3);
        B = L[j] = rotl(L[j] + A + B, A + B);
        i = (i + 1) % (2 * (R + 1));
        j = (j + 1) % C;
    }
}

// RC5 encryption
void rc5_encrypt(const std::vector<uint32_t>& S,
                 uint32_t& A, uint32_t& B)
{
    A = (A + S[0])
        & ((1 << W) - 1); // Adjusted modulo operation
    B = (B + S[1])
        & ((1 << W) - 1); // Adjusted modulo operation

    for (int i = 1; i <= R; ++i) {
        A = (rotl(A ^ B, B) + S[2 * i])
            & ((1 << W) - 1); // Adjusted modulo operation
        B = (rotl(B ^ A, A) + S[2 * i + 1])
            & ((1 << W) - 1); // Adjusted modulo operation
    }
}

int main()
{
    std::vector<uint8_t> key = { 0x00, 0x00, 0x00, 0x00,
                                 0x00, 0x00, 0x00, 0x00,
                                 0x00, 0x00, 0x00, 0x00,
                                 0x00, 0x00, 0x00, 0x00 };
    std::vector<uint32_t> S(2 * (R + 1), 0);

    rc5_key_setup(key, S);

    uint32_t A = 0x00000000;
    uint32_t B = 0x00000000;

    rc5_encrypt(S, A, B);

    std::cout << "Cipher Text: " << std::hex << A << " "
              << B << std::endl;

    return 0;
}

import java.util.ArrayList;
import java.util.List;

public class RC5 {
    // Constants for RC5-32/12/16
    private static final int W = 32; // Word size in bits
    private static final int R = 12; // Number of rounds
    private static final int B = 16; // Key size in bytes
    private static final int C
        = 4; // Number of words in key

    // Magic constants
    private static final int P = 0xB7E15163;
    private static final int Q = 0x9E3779B9;

    // Rotate left function
    private static int rotl(int x, int y)
    {
        return (x << y) | (x >>> (W - y));
    }

    // RC5 key expansion
    private static void rc5KeySetup(byte[] key, int[] S)
    {
        int[] L = new int[C];
        for (int i = B - 1; i >= 0; --i) {
            L[i / 4] = (L[i / 4] << 8) + (key[i] & 0xFF);
        }

        S[0] = P;
        for (int i = 1; i < 2 * (R + 1); ++i) {
            S[i] = S[i - 1] + Q;
        }

        int A = 0, B = 0;
        int i = 0, j = 0;
        for (int k = 0; k < 3 * Math.max(2 * (R + 1), C);
             ++k) {
            A = S[i] = rotl(S[i] + A + B, 3);
            B = L[j] = rotl(L[j] + A + B, (A + B) % W);
            i = (i + 1) % (2 * (R + 1));
            j = (j + 1) % C;
        }
    }

    // RC5 encryption
    private static void rc5Encrypt(int[] S, int[] data)
    {
        int A = data[0];
        int B = data[1];

        A = (A + S[0]);
        B = (B + S[1]);

        for (int i = 1; i <= R; ++i) {
            A = rotl(A ^ B, B) + S[2 * i];
            B = rotl(B ^ A, A) + S[2 * i + 1];
        }

        data[0] = A;
        data[1] = B;
    }

    public static void main(String[] args)
    {
        byte[] key = new byte[B];
        int[] S = new int[2 * (R + 1)];

        rc5KeySetup(key, S);

        int[] data = { 0x00000000, 0x00000000 };
        rc5Encrypt(S, data);

        // Convert the integer values to lowercase hex
        // strings and format the output
        System.out.printf("Cipher Text: %08x %08x%n",
                          data[0], data[1]);
    }
}

// This code is contributed by Shivam Gupta

Cipher Text: eedba521 6d8f4b15

Advantages:

High level of security: RC5 is designed to provide a high level of security against attacks, including brute-force attacks and differential cryptanalysis. It uses a variable-length key and can operate on block sizes of up to 256 bits, making it difficult for attackers to break the encryption.

Fast encryption and decryption: RC5 is known for its fast encryption and decryption speeds. It uses simple mathematical operations such as modular arithmetic and bit shifting, which can be efficiently implemented on modern CPUs and hardware.

Flexible key length: RC5 allows for a variable-length key, which can range from 0 to 2040 bits. This flexibility allows users to choose a key length that suits their security needs and resources.

Disadvantages:

Vulnerable to side-channel attacks: RC5 is vulnerable to side-channel attacks, such as timing attacks and power analysis attacks. These attacks exploit information leaked through the implementation of the algorithm, rather than attacking the algorithm itself.

Limited adoption: RC5 is not widely adopted in practice compared to other encryption algorithms, such as AES. This means that there may be fewer resources and tools available to support RC5 in various applications and systems.

Patent issues: RC5 was subject to a patent held by RSA Security, which limited its adoption and use in commercial applications. Although the patent has since expired, it may have contributed to the limited adoption of RC5 compared to other encryption algorithms