RC6 Class Reference

Class implementing the RC6 cipher algorithm. More...

#include <rc6.hpp>

Public Member Functions
	RC6 (const std::vector< uint8_t > &key)
	Constructor for RC6 class. More...
std::vector< uint8_t >	encrypt (const std::vector< uint8_t > &plaintext)
	Encrypts plaintext using RC6 algorithm. More...
std::vector< uint8_t >	decrypt (const std::vector< uint8_t > &ciphertext)
	Decrypts ciphertext using RC6 algorithm. More...

Private Member Functions
void	key_schedule (const std::vector< uint8_t > &key)
	Generates the key schedule from the given key. More...
std::vector< uint32_t >	expand (const std::vector< uint8_t > &key)
	Performs key expansion. More...
uint32_t	rotl (uint32_t val, int shift)
	Performs left rotation. More...
uint32_t	rotr (uint32_t val, int shift)
	Performs right rotation. More...
void	encrypt_block (const uint32_t plaintext[2], uint32_t ciphertext[2])
	Encrypts a single block of plaintext. More...
void	decrypt_block (const uint32_t ciphertext[2], uint32_t plaintext[2])
	Decrypts a single block of ciphertext. More...

Private Attributes
const int	w = 32
const int	r = 20
const int	b = 16
std::vector< uint32_t >	S

Detailed Description

Class implementing the RC6 cipher algorithm.

Definition at line 44 of file rc6.hpp.

Constructor & Destructor Documentation

RC6()

RC6::RC6

(

const std::vector< uint8_t > &

key

)

Constructor for RC6 class.

Parameters

key	The encryption key

Definition at line 37 of file rc6.cpp.

                                      {
    key_schedule(key);
}

References key_schedule().

Member Function Documentation

decrypt()

std::vector< uint8_t > RC6::decrypt

(

const std::vector< uint8_t > &

ciphertext

)

Decrypts ciphertext using RC6 algorithm.

Parameters

ciphertext

The ciphertext to decrypt

Returns

The decrypted plaintext

Definition at line 125 of file rc6.cpp.

                                                                    {
    if (ciphertext.size() % 8 != 0) {
        throw std::invalid_argument(
            "Ciphertext length must be a multiple of 8 bytes");
    }
    std::vector<uint8_t> plaintext;
    plaintext.reserve(ciphertext.size());
    for (size_t i = 0; i < ciphertext.size(); i += 8) {
        uint32_t block[2];
        uint32_t decrypted_block[2];
        for (int j = 0; j < 2; ++j) {
            block[j] =
                (static_cast<uint32_t>(ciphertext[i + 4 * j]) << 24) |
                (static_cast<uint32_t>(ciphertext[i + 4 * j + 1]) << 16) |
                (static_cast<uint32_t>(ciphertext[i + 4 * j + 2]) << 8) |
                static_cast<uint32_t>(ciphertext[i + 4 * j + 3]);
        }
        decrypt_block(block, decrypted_block);
        for (int j = 0; j < 8; ++j) {
            plaintext.push_back((decrypted_block[j / 4] >> (8 * (j % 4))) &
                                0xFF);
        }
    }
    return plaintext;
}

References decrypt_block().

decrypt_block()

void RC6::decrypt_block ( const uint32_t  ciphertext[2], uint32_t  plaintext[2]  )

private

Decrypts a single block of ciphertext.

Parameters

ciphertext	The ciphertext block to decrypt
plaintext	The resulting plaintext block

Definition at line 88 of file rc6.cpp.

                                                                           {
    uint32_t A = ciphertext[0], B = ciphertext[1];
    for (int i = r; i >= 1; --i) {
        B = rotr(B - S[2 * i + 1], A) ^ A;
        A = rotr(A - S[2 * i], B) ^ B;
    }
    B -= S[1];
    A -= S[0];
    plaintext[0] = A;
    plaintext[1] = B;
}

References python.linalg::A, python.linalg::B, r, rotr(), and S.

Referenced by decrypt().

encrypt()

std::vector< uint8_t > RC6::encrypt

(

const std::vector< uint8_t > &

plaintext

)

Encrypts plaintext using RC6 algorithm.

Parameters

plaintext

The plaintext to encrypt

Returns

The encrypted ciphertext

Definition at line 100 of file rc6.cpp.

                                                                   {
    if (plaintext.size() % 8 != 0) {
        throw std::invalid_argument(
            "Plaintext length must be a multiple of 8 bytes");
    }
    std::vector<uint8_t> ciphertext;
    ciphertext.reserve(plaintext.size());
    for (size_t i = 0; i < plaintext.size(); i += 8) {
        uint32_t block[2];
        uint32_t encrypted_block[2];
        for (int j = 0; j < 8; ++j) {
            block[j / 4] |=
                (static_cast<uint32_t>(plaintext[i + j]) << (8 * (j % 4)));
        }
        encrypt_block(block, encrypted_block);
        for (int j = 0; j < 2; ++j) {
            ciphertext.push_back((encrypted_block[j] >> 24) & 0xFF);
            ciphertext.push_back((encrypted_block[j] >> 16) & 0xFF);
            ciphertext.push_back((encrypted_block[j] >> 8) & 0xFF);
            ciphertext.push_back(encrypted_block[j] & 0xFF);
        }
    }
    return ciphertext;
}

References encrypt_block().

encrypt_block()

void RC6::encrypt_block ( const uint32_t  plaintext[2], uint32_t  ciphertext[2]  )

private

Encrypts a single block of plaintext.

Parameters

plaintext	The plaintext block to encrypt
ciphertext	The resulting ciphertext block

Definition at line 76 of file rc6.cpp.

                                                                           {
    uint32_t A = plaintext[0], B = plaintext[1];
    A += S[0];
    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];
    }
    ciphertext[0] = A;
    ciphertext[1] = B;
}

References python.linalg::A, python.linalg::B, r, rotl(), and S.

Referenced by encrypt().

expand()

std::vector< uint32_t > RC6::expand ( const std::vector< uint8_t > &  key )

private

Performs key expansion.

Parameters

key	The encryption key

Returns

The expanded key schedule

Definition at line 60 of file rc6.cpp.

                                                             {
    std::vector<uint32_t> L(b / 4);
    for (size_t i = 0; i < key.size(); i++) {
        L[i / 4] |= (static_cast<uint32_t>(key[i]) << (8 * (i % 4)));
    }
    return L;
}

References b.

Referenced by key_schedule().

key_schedule()

void RC6::key_schedule ( const std::vector< uint8_t > &  key )

private

Generates the key schedule from the given key.

Parameters

key	The encryption key

Definition at line 41 of file rc6.cpp.

                                                    {
    std::vector<uint32_t> L = expand(key);
    S.resize(2 * (r + 1));
    const uint32_t P = 0xB7E15163;
    const uint32_t Q = 0x9E3779B9;
    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(b, 2 * (r + 1)); ++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) % b;
    }
}

References python.linalg::A, b, python.linalg::B, expand(), r, rotl(), and S.

Referenced by RC6().

rotl()

uint32_t RC6::rotl ( uint32_t  val, int  shift  )

private

Performs left rotation.

Parameters

val	The value to rotate
shift	The number of bits to rotate by

Returns

The rotated value

Definition at line 68 of file rc6.cpp.

                                          {
    return (val << shift) | (val >> (w - shift));
}

References w.

Referenced by encrypt_block(), and key_schedule().

rotr()

uint32_t RC6::rotr ( uint32_t  val, int  shift  )

private

Performs right rotation.

Parameters

val	The value to rotate
shift	The number of bits to rotate by

Returns

The rotated value

Definition at line 72 of file rc6.cpp.

                                          {
    return (val >> shift) | (val << (w - shift));
}

References w.

Referenced by decrypt_block().

Member Data Documentation

b

const int RC6::b = 16

private

Number of bytes in key

Definition at line 69 of file rc6.hpp.

Referenced by expand(), and key_schedule().

r

const int RC6::r = 20

private

Number of rounds

Definition at line 68 of file rc6.hpp.

Referenced by decrypt_block(), encrypt_block(), and key_schedule().

S

std::vector<uint32_t> RC6::S

private

Internal state array

Definition at line 71 of file rc6.hpp.

Referenced by decrypt_block(), encrypt_block(), and key_schedule().

w

const int RC6::w = 32

private

Word size

Definition at line 67 of file rc6.hpp.

Referenced by rotl(), and rotr().

---

The documentation for this class was generated from the following files:

• include/openGPMP/nt/rc6.hpp
• modules/nt/rc6.cpp