Объясните в чём ошибка (файловый ввод/вывод - не открывается файл)

/**\file*********************************************************************
 *                                                                     \brief
 *  AES CBC mode implementation
 *
 *  Обеспечивает (де)шифрацию файлов по алгоритму AES
 *  (возможные ключи: 128, 192 и 256 бит)
 *  в режиме Cipher Block Chaining (CBC).
 *
 *  @author Serge Trusov
 *  mailto: [email]serge.trusov@gmail.com[/email]
 *
 *  @date   02 April 2005
 *
 *  @note   Возможные параметры командной строки:
 *          /e      - режим шифрования;
 *          /d      - режим расшифровывания;
 *          2 и более имен файлов;
 *          ключ выбирается автоматически из первого бинарного файла
 *          длиной 16, 24 или 32 байт.
 *          Длина зашифрованного файла округляется вверх до 16 байт.
 *
 *  @warning    Как следует не тестировалось, но вроде бы работает :-)
 *
 ****************************************************************************
 */ 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "aes.cpp"
 
 
int main( int arg_count, char * argument[])
{
    static char
    help[] =    "\nusage: aest option keyfile filename"
                "\noptions:" 
                "\n/e   encrypt"
                "\n/d   decrypt\n"
                "\n warning! filesize will be rounded up by 16 bytes.";
 
    printf("\nAES (CBC mode) crypto tool v0.1\n");
 
    if( arg_count <= 2 )
    {
            printf(help);
            return ~0;
    }
    
    aes         crypto;     int i;
 
    const int   max_key = 256/8;
    byte        key[max_key+1]; // Резервируем лишний байт для чтения.
                                // Нужно для определения длины ключевого файла.
 
    void (aes:: * whats_to_do)(
                    const byte  [aes::block_size], 
                    byte        [aes::block_size]
                    ) = 0;
 
    // Исходя из опций командной строки, определяем, что делать.
    // Допустима только ОДНА опция.
    // Иначе - ошибка! Выводим help.
    for( i = 1; i < arg_count; i++ )
    {
        if( * argument[i] != '-' && * argument[i] != '/' )
            continue;
 
        switch( *(argument[i]+1) | 0x20 )   // любой регистр.
        {
        case 'd':
            if( whats_to_do )
            {
                printf(help);
                return ~0;
            }
            printf("\ndecrypt mode");
            whats_to_do = &aes::decrypt;
            break;
         case 'e':
            if( whats_to_do )
            {
                printf(help);
                return ~0;
            }
            printf("\nencrypt mode");
            whats_to_do = &aes::encrypt;
            break;
        }
         
        // "Убираем" опцию из списка аргументов командной строки
        // что бы не обрабатывать её как имя файла позже.
        if( whats_to_do )
        {
            // Имя ключевого файла может быть сразу за опцией
            // без пробелов!
            // В таком случае, сдвигаем указатель.
            if( *(argument[i]+2) > ' ')
                argument[i] += 2;
            else
                argument[i]  = 0;
        }
    }
 
    // Если опция не указана, выходим.
    if( ! whats_to_do )
    {
        printf(help);
        return ~0;
    }
 
    // Простматриваем файлы указанные в командной строке.
    // Превый файл длиной 128, 192 или 256 байт 
    // содержит ключ (де)шифровки.
    for( i = 1; i < arg_count; i++ )
    {
        if( ! argument[i] ) continue;
 
        FILE * f = fopen( argument[i], "rb" );
        if( ! f )
        {
            printf("\nerror: can't read file `%s'", argument[i]);
            return ~0;
        }
 
        // Попытаемся считатьт больше, чем максимальная длина ключа.
        int key_size = 8 * fread( key, sizeof(byte), max_key+1, f );
        fclose( f );
 
        switch( key_size )
        {
        case 128:
        case 192:
        case 256:
            printf("\nusing %d bit keyfile `%s'...", key_size, argument[i]);
            crypto.expand_key( key, key_size );
            argument[i] = 0;    // Файл обработан.
            goto key_Ok;
        }
    }
    printf("\nno keyfile found.");
    return ~0;
 
key_Ok:
    for( i = 1; i < arg_count; i++ )
    {
        if( ! argument[i] ) continue;
 
        printf("\nprocessing file `%s'...", argument[i]);
        FILE * in  = fopen( argument[i], "rb" );
        FILE * out = fopen( argument[i], "r+b" );
        if( ! in || ! out )
        {
            printf(" can't open.");
            continue;
        }
 
        byte    buf[crypto.block_size];
        byte    feedback[crypto.block_size] = {0};
 
        while( unsigned chunk = fread(buf, sizeof(byte), crypto.block_size, in) )
        {
            // CBC mode.
            // Обратная cвязь по шифротексту.
            
            if( whats_to_do == &aes::encrypt)
            {
                // Если считано меньше, чем минимально допустимый блок,
                // дополняем буфер нулями.
                for( int pos = 0; pos < crypto.block_size; pos++ )
                    buf[pos] = pos < chunk ? buf[pos] ^ feedback[pos] : 0;
                (crypto.*whats_to_do)(buf, buf);
                memcpy(feedback, buf, crypto.block_size);
            }
 
            if( whats_to_do == &aes::decrypt)
            {
                byte    plain[crypto.block_size];
                (crypto.*whats_to_do)(buf, plain);
                for( int pos = 0; pos < crypto.block_size; pos++ )
                {
                    byte tmp = buf[pos];
                    buf[pos] = plain[pos] ^ feedback[pos];
                    feedback[pos] = tmp;
                }
            }
 
            if( fwrite(buf, sizeof(byte), crypto.block_size, out) 
                < crypto.block_size )
            {
                printf("error: can't write to file `%s'.", argument[i]);
                break;
            }
        }
        if( feof (in) ) printf(" Ok.");
 
        fclose( in );
        fclose( out );
    }
    return 0;
}
 
 
//=========================================================================//
// EOF