Baillehache Pascal's personal website

Encrypting data using Feistel cipher and LibCapy

After seeing this video from Computerphile, I've got interested in implementing the Feistel cipher in LibCapy and play with it a bit. In this article I'll show you how to create a CLI application to encrypt data using LibCapy's CapyFeistelCipher object.

The Feistel cipher network is a framework to implement data encryption. It doesn't define completely the encryption algorithm by itself, but works in collaboration with an encryption function called a round function. It is a widely used network, for example in the DES or twofish algorithms.

In addition to the round function, it is wrapped in an operation mode, which improves its security. LibCapy implements the Feistel cipher in ECB, CBC and CTR modes, and a dummy round function for test purpose. A new private round function can easily be implemented thanks to class inheritance. Now, lets see how to implement your encryption app ! (the complete code is available at the end of the article)

Beware: the example below is just for didactic purpose. It uses the ECB operation mode and a very simple round function, hence doesn't provide much security. If you wish to modify it to make a really secured app out of it, by changing the round function and choosing the appropriate operation mode, refer to a data encryption expert, which I am not.

(The complete code is available at the end of the article)

First, lets define a structure to hold all the needed data.

struct App {

  // Return code at the end of execution
  int ret;

  // Parser to process the command line arguments
  CapyArgParser* parser;

  // Path to the keys, input and output files
  char* pathKeys;
  char* pathInput;
  char* pathOutput;

  // Streams to read/write the files
  CapyStreamIo* streamKeys;
  CapyStreamIo* streamInput;
  CapyStreamIo* streamOutput;

  // Variables to memorise the list of keys, the input and output data
  CapyListArrChar* keys;
  CapyArrChar* input;
  CapyArrChar* output;

  // FeistelCipher and RoundFun objects to perform the ciphering
  CapyFeistelCipher* cipher;
  CapyFeistelRoundFun roundFun;

};

Performing the encryption is as simple as creating the Feistel cipher instance (here in ECB operation mode for example):

    app.cipher = CapyFeistelCipherAlloc(capyFeistelCipher_ECB);

and ciphering:

      app.output =
        $(app.cipher, cipher)(
          (CapyFeistelRoundFun*)&(app.roundFun),
          app.keys,
          app.input);

or deciphering:

      app.output =
        $(app.cipher, decipher)(
          (CapyFeistelRoundFun*)&(app.roundFun),
          app.keys,
          app.input);

If you want to use an operating mode needing a initialisation vector, you can set it with CapyArrChar* initVector = ...; $(cipher, setInitVector)(initVector); before ciphering/deciphering.

Here, I simply process the whole input/output as one single block. Another option is to split them into fixed size blocks and process them sequentially or in parallel.

The keys can be loaded from a text file, one per line, as follow:

    $(app.streamKeys, open)(app.pathKeys, "r");
    app.keys = $(app.streamKeys, readLines)();

The round function is defined and used as follow:

void Run(
  cipherData_t const* const key,
  cipherData_t const* const block,
        cipherData_t* const output) {

  // Encrypt the block byte by byte using the key.
  // Modif the code below to the implementation of your own round function.
  loop (i, (size_t)(block->size))
    output->data[i] = block->data[i] ^ key->data[i % key->size];

}

...

    // Create the round function object and set its implementation to our
    // private one
    app.roundFun = CapyFeistelRoundFunCreate();
    app.roundFun.run = Run;

I'm using the modulo operator on the key index to leave the user free to use keys of any size. It is generally defined by the encryption algorithm.

To retrieve the paths to the keys and data from the command line, we'll use the command line parser provided by LibCapy. The argument definition looks as follow:

    CapyArg args[] = {
      {.lbl=argv[0], .nbVal=capyArg_noVal,
       .help="Encrypt/decrypt data using the Feistel cipher network."},

      {.shortLbl="-k", .lbl="--keys", .nbVal=1,
       .help="Path to the text file containing the keys used to "
             "encrypt/decrypt, one key per line)"},

      {.shortLbl="-i", .lbl="--input", .nbVal=1,
       .help="Path to the file containing the data to encrypt/decrypt"},

      {.shortLbl="-o", .lbl="--output", .nbVal=1,
       .help="Path to the file containing the encrypted/decrypted "
             "(overwritten if already exists)"},

      {.shortLbl="-e", .lbl="--encrypt", .nbVal=0,
       .help="Encrypt the data"},

      {.shortLbl="-d", .lbl="--decrypt", .nbVal=0,
       .help="Decrypt the data"},
    };

and the actual parsing is done with:

    app.parser = CapyArgParserAlloc(argc, argv, args);

Of course we'll want to check the arguments passed by the user, and to process any problem cleanly, we'll use some purpose made exceptions:

enum AppExceptions {
  excInvalidMode = CapyExc_LastID,
  excMissingKeys,
  excMissingInput,
  excMissingOutput,
  excNotEnoughKeys,
  lastAppException
};

char* exceptionStr[] = {
  "Invalid mode, you must choose either --encrypt or --decrypt",
  "Missing path to the file containing keys",
  "Missing path to the file to encrypt/decrypt",
  "Missing path to the result file",
  "There must be at least one key",
};

char const* ExcToStr(int16_t exc) {

  // If the exception ID is one of AppExceptions,
  // return the exception's explanation
  if (exc >= excInvalidMode && exc < lastAppException)
    return exceptionStr[exc - excInvalidMode];

  // Else, the exception ID is not one of AppExceptions, return NULL
  else return NULL;

}

The ExcToStr conversion function is set with:

  CapyAddExcToStrFun(ExcToStr);

and the arguments checking looks like this:

    if ($(app.parser, isSet)("-k") == false) raiseExc(excMissingKeys);
    if ($(app.parser, isSet)("-i") == false) raiseExc(excMissingInput);
    if ($(app.parser, isSet)("-o") == false) raiseExc(excMissingOutput);
    if ($(app.parser, isSet)("-e") == false &&
        $(app.parser, isSet)("-d") == false) raiseExc(excInvalidMode);

After the arguments have been checked, we can use them as follow:

    // Load the keys
    app.streamKeys = CapyStreamIoAlloc();
    app.pathKeys = $(app.parser, getAsStr)("-k", 0);
    $(app.streamKeys, open)(app.pathKeys, "r");
    app.keys = $(app.streamKeys, readLines)();

    // Check there is at least 1 keys
    if ($(app.keys, getSize)() == 0) raiseExc(excNotEnoughKeys);

    // Load the input data
    app.streamInput = CapyStreamIoAlloc();
    app.pathInput = $(app.parser, getAsStr)("-i", 0);
    $(app.streamInput, open)(app.pathInput, "rb");
    app.input = $(app.streamInput, read)();

...

    // Encrypt or decrypt the data according to the command line arguments
    if ($(app.parser, isSet)("-e"))
      app.output =
        $(app.cipher, cipher)(...);
    else if ($(app.parser, isSet)("-d"))
      app.output =
        $(app.cipher, decipher)(...);

    // Save the output data
    app.streamOutput = CapyStreamIoAlloc();
    app.pathOutput = $(app.parser, getAsStr)("-o", 0);
    $(app.streamOutput, open)(app.pathOutput, "wb");
    $(app.streamOutput, write)(app.output);

I skip intentionally releasing memory and closing streams. This is done automatically at the end of the program, which is so small and simple that there is nothing to fear here. Everything put together, it becomes:

/*
    Cryptic - A simple ciphering application
    Copyright (C) 2021  Pascal Baillehache baillehache.pascal@gmail.com
    https://baillehachepascal.dev
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <LibCapy/capy.h>

// App exceptions
enum AppExceptions {
  excInvalidMode = CapyExc_LastID,
  excMissingKeys,
  excMissingInput,
  excMissingOutput,
  excNotEnoughKeys,
  lastAppException
};

// Label for the AppExceptions
char* exceptionStr[] = {
  "Invalid mode, you must choose either --encrypt or --decrypt",
  "Missing path to the file containing keys",
  "Missing path to the file to encrypt/decrypt",
  "Missing path to the result file",
  "There must be at least one key",
};

char const* ExcToStr(int16_t exc) {

  // If the exception ID is one of AppExceptions,
  // return the exception's explanation
  if (exc >= excInvalidMode && exc < lastAppException)
    return exceptionStr[exc - excInvalidMode];

  // Else, the exception ID is not one of AppExceptions, return NULL
  else return NULL;

}

// Private implementation of the round function
void Run(
  cipherData_t const* const key,
  cipherData_t const* const block,
        cipherData_t* const output) {

  // Encrypt the block byte by byte using the key.
  // Modif the code below to the implementation of your own round function.
  loop (i, (size_t)(block->size))
    output->data[i] = block->data[i] ^ key->data[i % key->size];

}

// Structure to memorise the appli variables
struct App {

  // Return code at the end of execution
  int ret;

  // Parser to process the command line arguments
  CapyArgParser* parser;

  // Path to the keys, input and output files
  char* pathKeys;
  char* pathInput;
  char* pathOutput;

  // Streams to read/write the files
  CapyStreamIo* streamKeys;
  CapyStreamIo* streamInput;
  CapyStreamIo* streamOutput;

  // Variables to memorise the list of keys, the input and output data
  CapyListArrChar* keys;
  CapyArrChar* input;
  CapyArrChar* output;

  // FeistelCipher and RoundFun objects to perform the ciphering
  CapyFeistelCipher* cipher;
  CapyFeistelRoundFun roundFun;

};

// Main function
int main(
     int argc,
  char** argv) {

  // Set the conversion function for raised exceptions
  CapyAddExcToStrFun(ExcToStr); 

  // Instance of the application
  struct App app;

  // Initialise the return code
  app.ret = EXIT_SUCCESS;

  try {

    // Definition of the arguments from the command line
    CapyArg args[] = {
      {.lbl=argv[0], .nbVal=capyArg_noVal,
       .help="Encrypt/decrypt data using the Feistel cipher network."},

      {.shortLbl="-k", .lbl="--keys", .nbVal=1,
       .help="Path to the text file containing the keys used to "
             "encrypt/decrypt, one key per line)"},

      {.shortLbl="-i", .lbl="--input", .nbVal=1,
       .help="Path to the file containing the data to encrypt/decrypt"},

      {.shortLbl="-o", .lbl="--output", .nbVal=1,
       .help="Path to the file containing the encrypted/decrypted "
             "(overwritten if already exists)"},

      {.shortLbl="-e", .lbl="--encrypt", .nbVal=0,
       .help="Encrypt the data"},

      {.shortLbl="-d", .lbl="--decrypt", .nbVal=0,
       .help="Decrypt the data"},
    };

    // Create the argument parser and parse the arguments
    app.parser = CapyArgParserAlloc(argc, argv, args);

    // Check the arguments
    if ($(app.parser, isSet)("-k") == false) raiseExc(excMissingKeys);
    if ($(app.parser, isSet)("-i") == false) raiseExc(excMissingInput);
    if ($(app.parser, isSet)("-o") == false) raiseExc(excMissingOutput);
    if ($(app.parser, isSet)("-e") == false &&
        $(app.parser, isSet)("-d") == false) raiseExc(excInvalidMode);

    // Load the keys
    app.streamKeys = CapyStreamIoAlloc();
    app.pathKeys = $(app.parser, getAsStr)("-k", 0);
    $(app.streamKeys, open)(app.pathKeys, "r");
    app.keys = $(app.streamKeys, readLines)();

    // Check there is at least 1 keys
    if ($(app.keys, getSize)() == 0) raiseExc(excNotEnoughKeys);

    // Load the input data
    app.streamInput = CapyStreamIoAlloc();
    app.pathInput = $(app.parser, getAsStr)("-i", 0);
    $(app.streamInput, open)(app.pathInput, "rb");
    app.input = $(app.streamInput, read)();

    // Create the Feistel ciphering with operation mode ECB. If you use another
    // mode, don't forget to set the initialisation vector if necessary.
    app.cipher = CapyFeistelCipherAlloc(capyFeistelCipher_ECB);

    // Create the round function object and set its implementation to our
    // private one
    app.roundFun = CapyFeistelRoundFunCreate();
    app.roundFun.run = Run;

    // Encrypt or decrypt the data according to the command line arguments
    if ($(app.parser, isSet)("-e"))
      app.output =
        $(app.cipher, cipher)(
          (CapyFeistelRoundFun*)&(app.roundFun),
          app.keys,
          app.input);
    else if ($(app.parser, isSet)("-d"))
      app.output =
        $(app.cipher, decipher)(
          (CapyFeistelRoundFun*)&(app.roundFun),
          app.keys,
          app.input);

    // Save the output data
    app.streamOutput = CapyStreamIoAlloc();
    app.pathOutput = $(app.parser, getAsStr)("-o", 0);
    $(app.streamOutput, open)(app.pathOutput, "wb");
    $(app.streamOutput, write)(app.output);

  } catchDefault {

    // Inform the user about the raised exception
    CapyStrDecorator decorator = CapyStrDecoratorCreate();
    $(&decorator, setFgColor)(&capyColorRGBRed);
    $(&decorator, activate)(capyStrDecoratorFgColor);
    $(&decorator, fprintf)(
      stdout, "Sorry, an exception occured. Exiting.\n");
    $(&decorator, fprintf)(
      stdout, "%s\n", CapyExcToStr(CapyGetLastExcId()));
    CapyStrDecoratorDestruct(&decorator);
    app.ret = EXIT_FAILURE;

  } endCatch;

  return app.ret;

}

Compile with the following Makefile:

CAPY_PARAM=-std=c18 -I./ -Wall -Wextra -Wshadow -Wno-format-truncation -Werror -Wfatal-errors -O3 -ggdb -DPNG_SKIP_SETJMP_CHECK -DWITH_GUI=0
CAPY_LINK=-lcapy -lm

cryptic: main.o Makefile
	gcc -o cryptic main.o $(CAPY_LINK)

main.o: main.c Makefile
	gcc $(CAPY_PARAM) -c main.c

Example of use:

> cat input.txt 
After seeing this video from Computerphile, I've got interested in implementing the Feistel cipher in LibCapy and play with it a bit. In this article I'll show you how to create a CLI application to encrypt data using LibCapy's CapyFeistelCipher object.

> cat keys.txt
123
456
789
> cryptic -e -k keys.txt -i input.txt -o encrypted.secret
> cat encrypted.secret 
#oft.#Da tkd| aqyfclf-F'lo-|hot-vou#e`w wb/crfl{e b-LLI#lpljnntilc/to#hacrz}{ dbyn updag OdmCast(s @lyFfd|teoNfphf/obihlt.	Daqer%t`eik`%thlt%viabj fwhh Cjjuut`uuhiib) I"q` gjs%inqbwesqba ik'lmpibhenqnkg qo` F`nvtei'fipmbw ik'IibFfuy dia pif| wlsm iq'd> 
> cryptic -d -k keys.txt -i encrypted.secret -o decrypted.txt
> cat decrypted.txt 
After seeing this video from Computerphile, I've got interested in implementing the Feistel cipher in LibCapy and play with it a bit. In this article I'll show you how to create a CLI application to encrypt data using LibCapy's CapyFeistelCipher object.

>

2021-11-08
in All, C programming, LibCapy examples,
148 views