Cоздать программу шифрования и дешифрования

#include <stdio.h>
#include <string.h>
 
#define KEY_MAX_LINE_LENGTH 64
#define KEY_MAX_LINE_COUNT  64
 
char key[ KEY_MAX_LINE_COUNT ][ KEY_MAX_LINE_LENGTH ];
size_t key_lines_count = 0;
 
/**********************************************
 *  В buffer копирует текст первого аргумента *
 * комманды command. Аргумент с пробелами     *
 * должен быть взят в одинарные, двойные или  *
 * косые кавычки. Все кавычки равнозначны.    *
 *  Возвращает buffer                         *
 **********************************************/
char * getarg( const char * command, char * buffer )
{
   *buffer = 0;
   
   // найти конец команды
   char * end = strchr( command, ' ' );
   
   while( *end == ' ' )
      end++;
   
   // если затем нет символов
   if( !sscanf( end, "%c", buffer ) )
      *buffer = 0; // аргументов нет
   else if( *buffer == '\"' ) // если далее двойная кавычка
   {
      // если нет закрывающей кавычки
      if( !strchr( strchr( end, '\"' ) + 1, '\"' ) )
         *buffer = 0; // аргументов нет
      else
         sscanf( end, "\"%[^\"]", buffer ); // иначе считать всё от кавычки до кавычки
   }
   else if( *buffer == '\'' ) // если далее одинарная кавычка
   {
      // если нет закрывающей кавычки
      if( !strchr( strchr( end, '\'' ) + 1, '\'' ) )
         *buffer = 0; // аргументов нет
      else
         sscanf( end, "\'%[^\']", buffer ); // иначе считать всё от кавычки до кавычки
   }
   else if( *buffer == '`' ) // если далее косая кавычка
   {
      // если нет закрывающей кавычки
      if( !strchr( strchr( end, '`' ) + 1, '`' ) )
         *buffer = 0; // аргументов нет
      else
         sscanf( end, "`%[^`]", buffer ); // иначе считать всё от кавычки до кавычки
   }
   else // если затем какой-то другой символ
      sscanf( end, "%s", buffer ); // считать одно слово*/
 
   return buffer;
}
 
/****************************************
 *  Выводит текст на стандартный вывод. *
 * what - определяет, что выводить.     *
 *  key - вывести файл ключа            *
 *  иначе выводит значение what         *
 ****************************************/
void echo( const char * what )
{   
   if( !strcmp( what, "key" ) )
   {
      size_t i;
      for( i = 0; i < key_lines_count; i++ )
         printf( "%3d: %s\n", i, key[i] );
   }
   else
      puts( what );
}
 
/***************************
 * Загружает ключ из файла *
 ***************************/
void load_key( const char * file_name )
{
   if( !file_name || strlen( file_name ) == 0 )
   {
      puts( "Необходимо указать файл" );
      return;
   }
   
   FILE * fin = fopen( file_name, "r" );
   
   if( !fin )
   {
      puts( "Немогу открыть файл" );
      return;
   }
   
   // читаем файл
   for( key_lines_count == 0; key_lines_count < KEY_MAX_LINE_COUNT && !feof(fin); key_lines_count++ )
   {
      fgets( key[ key_lines_count ], KEY_MAX_LINE_LENGTH, fin );
      
      if( feof(fin) ) break;
      
      *strchr( key[ key_lines_count ], '\n' ) = 0;
   }
   
   // проверяем, есть ли в ключе пробел
   if( key_lines_count )
   {
      size_t i, u;
      char ok = 0;
      for( i = 0; i < key_lines_count && !ok; i++ )
      {
         for( u = 0; u < strlen( key[i] ); u++ )
         {
            if( key[i][u] == ' ' )
            {
               ok = 1;
               break;
            }
         }
      }
      
      if( !ok ) // если пробелов нет
      {
         puts( "Файл шифра должен собержать хотя бы один пробел!" );
         key_lines_count = 0; // удаляем все строки
      }
      
   }
   
   printf( "%d строк(и) загружено\n", key_lines_count );
   
   fclose( fin );
}
 
/**********************************************
 * Шифрует строку, выводит шифротекст в буфер *
 * возвращает буфер. В случае ошибки буфер    *
 * будет пустым                               *
 **********************************************/
char * encrypt_str( const char * str, char * buffer )
{
   *buffer = 0;
 
   if( !key_lines_count )
   {
      puts( "Используйте key [имя_файла] для загрузки таблицы шифрования" );
      return buffer;
   }
   
   // шифруем
   for( ; *str; str++ )
   {
      char encoded[16] = {0};
      // найти этот символ в таблице
      int line = -1, column = -1;
      int i, u;
      
      // ищем символ в таблице
      for( i = 0; i < key_lines_count; i++ )
      {
         for( u = 0; u < strlen( key[ i ] ); u++ )
         {
            if( key[ i ][ u ] == *str ) // если нашли
            {
               line = i;
               column = u;
               break; // выходим
            }
         }
         
         if( line >= 0 ) // если нашли
            break; // выходим
      }
      
      if( line >= 0 )
         sprintf( encoded, "%d %d ", line, column );
      else
         sprintf( encoded, "%c ", *str );
      
      strcat( buffer, encoded );
   }
 
   return buffer;
}
 
/*******************************************
 * Дешифрует строку, выводит текст в буфер *
 * возвращает буфер. В случае ошибки буфер *
 * будет пустым                            *
 *******************************************/
char * decrypt_str( const char * str, char * buffer )
{
   *buffer = 0;
 
   if( !key_lines_count )
   {
      puts( "Используйте key [имя_файла] для загрузки таблицы шифрования" );
      return buffer;
   }
   
   int values[2];
   char current_value = 0;
   
   do
   {
      char raw = 0;
      char segment[64];
      sscanf( str, "%64s ", segment );
      
      if( !sscanf( segment, "%d", &values[current_value++] ) )
         raw = 1;
      else if( current_value == 2 )
      {
         if( values[0] >= key_lines_count || values[1] >= strlen( key[ values[0] ] ) )
            raw = 1;
         else
         {
            char smb[2] = {0};
            smb[0] = key[ values[0] ][ values[1] ];
            strcat( buffer, smb );
         }
         
         current_value = 0;
      }
      
      if( raw )
      {
         current_value = 0;
         strcat( buffer, segment );
         strcat( buffer, " " );
      }
   }
   while( str = strchr( str + 1, ' ' ) );
 
   return buffer;
}
 
int main( void )
{
   #define INPUT_SIZE 256
   char input[ INPUT_SIZE ],
        cmd[ INPUT_SIZE ];
   
   putchar( '>' );
   while( fgets( input, INPUT_SIZE, stdin ) )
   {
      *(strchr( input, '\n' )) = ' ';
   
      sscanf( input, "%s", cmd );
      
      if( !strcmp( cmd, "exit" ) || !strcmp( cmd, "quit" ) )
         break;
      
      if( !strcmp( cmd, "key" ) )
         load_key( getarg( input, cmd ) );
      else if( !strcmp( cmd, "echo" ) )
         echo( getarg( input, cmd ) );
      else if( !strcmp( cmd, "encrypt" ) )
         echo( encrypt_str( getarg( input, cmd ), input ) );
      else if( !strcmp( cmd, "decrypt" ) )
         echo( decrypt_str( getarg( input, cmd ), input ) );
      
      putchar( '>' );
   } 
 
   return 0;
}