Пример #1
0
	int GenerateXbitKey( unsigned int key_bit_length )
	{
		OAES_RET ret = OAES_RET_ERROR;

		switch( key_bit_length )
		{
		case 128: ret = oaes_key_gen_128(m_ctx); break;
		case 192: ret = oaes_key_gen_192(m_ctx); break;
		case 256: ret = oaes_key_gen_256(m_ctx); break;
		default:
			return -1;
			break;
		}

		LOG_PRINTF_ERROR(( "oaes_key_gen_%u() failed: %d, ", key_bit_length, (int)ret ));

		return (ret == OAES_RET_SUCCESS) ? 0 : -1;
	}
Пример #2
0
int main(int argc, char** argv)
{
  size_t _i;
  OAES_CTX * ctx = NULL;
  uint8_t *_encbuf, *_decbuf, *_key_data = NULL, *_bin_data = NULL;
  size_t _encbuf_len, _decbuf_len, _buf_len;
  size_t _key_data_len = 0, _bin_data_len = 0;
  char *_buf;
  short _is_ecb = 0, _is_bin = 0;
  char * _text = NULL, * _key_text = NULL;
  int _key_len = 128;
  uint8_t _iv[OAES_BLOCK_SIZE] = "";
  uint8_t _pad = 0;
  
  if( argc < 2 )
  {
    usage( argv[0] );
    return EXIT_FAILURE;
  }

  for( _i = 1; _i < argc; _i++ )
  {
    int _found = 0;

    if( 0 == strcmp( argv[_i], "-nostep" ) )
    {
      _found = 1;
      _is_step = 0;
    }

    if( 0 == strcmp( argv[_i], "-ecb" ) )
    {
      _found = 1;
      _is_ecb = 1;
    }
    
    if( 0 == strcmp( argv[_i], "-bin" ) )
    {
      _found = 1;
      _is_bin = 1;
    }
    
    if( 0 == strcmp( argv[_i], "-key" ) )
    {
      _found = 1;
      _i++; // len
      if( _i >= argc )
      {
        printf("Error: No value specified for '-%s'.\n",
            "key");
        usage( argv[0] );
        return EXIT_FAILURE;
      }
      _key_len = atoi( argv[_i] );
      switch( _key_len )
      {
        case 128:
        case 192:
        case 256:
          break;
        default:
          _key_text = argv[_i];
          if( to_binary( NULL, &_key_data_len, _key_text ) )
          {
            printf( "Error: Invalid value [%s] specified for '-%s'.\n",
                argv[_i], "key" );
            return EXIT_FAILURE;
          }
          switch( _key_data_len )
          {
            case 16:
            case 24:
            case 32:
              break;
            default:
              printf("Error: key_data [%s] specified for '-%s' has an invalid "
                  "size.\n", argv[_i], "key");
              usage( argv[0] );
              return EXIT_FAILURE;
          }
      }
    }
    
    if( 0 == _found )
    {
      if( _text )
      {
        printf("Error: Invalid option '%s'.\n", argv[_i]);
        usage( argv[0] );
        return EXIT_FAILURE;
      }
      else
      {
        _text = argv[_i];
        if( _is_bin && to_binary( NULL, &_bin_data_len, _text ) )
        {
          printf( "Error: Invalid value [%s] specified for '-%s'.\n",
              argv[_i], "bin" );
          return EXIT_FAILURE;
        }
      }
    }      
  }

  if( NULL == _text )
  {
    usage( argv[0] );
    return EXIT_FAILURE;
  }

  if( _is_step )
    printf( "\nEnabling step mode, press Return to step.\n\n" );

  if( _is_bin )
  {
    _bin_data = (uint8_t *) calloc(_bin_data_len, sizeof(uint8_t));
    if( NULL == _bin_data )
    {
      printf( "Error: Failed to allocate memory.\n" );
      return EXIT_FAILURE;
    }
    if( to_binary( _bin_data, &_bin_data_len, _text ) )
    {
      printf( "Error: Could not load data [%s].\n", _text);
      free( _bin_data );
      return EXIT_FAILURE;
    }
  }
  else
  {
    oaes_sprintf( NULL, &_buf_len, (const uint8_t *)_text, strlen(_text));
    _buf = (char *) calloc(_buf_len, sizeof(char));
    printf( "\n***** plaintext  *****\n" );
    if( _buf )
    {
      oaes_sprintf( _buf, &_buf_len,
          (const uint8_t *)_text, strlen( _text ) );
      printf( "%s", _buf );
    }
    printf( "\n**********************\n" );
    free( _buf );
  }
  
  ctx = oaes_alloc();
  if( NULL == ctx )
  {
    printf("Error: Failed to initialize OAES.\n");
    if( _bin_data )
      free( _bin_data );
    return EXIT_FAILURE;
  }
  if( OAES_RET_SUCCESS != oaes_set_option( ctx, OAES_OPTION_STEP_ON, step_cb ) )
    printf("Error: Failed to set OAES options.\n");
  if( _is_ecb )
    if( OAES_RET_SUCCESS != oaes_set_option( ctx, OAES_OPTION_ECB, NULL ) )
      printf("Error: Failed to set OAES options.\n");

  if( _key_text )
  {
    _key_data = (uint8_t *) calloc(_key_data_len, sizeof(uint8_t));
    if( NULL == _key_data )
    {
      printf( "Error: Failed to allocate memory.\n" );
      if( _bin_data )
        free( _bin_data );
      return EXIT_FAILURE;
    }
    if( to_binary( _key_data, &_key_data_len, _key_text ) )
    {
      printf( "Error: Could not load key [%s].\n", _key_text);
      free( _key_data );
      return EXIT_FAILURE;
    }
    oaes_key_import_data( ctx, _key_data, _key_data_len );
  }
  else
    switch( _key_len )
    {
      case 128:
        if( OAES_RET_SUCCESS != oaes_key_gen_128(ctx) )
          printf("Error: Failed to generate OAES %d bit key.\n", _key_len);
        break;
      case 192:
        if( OAES_RET_SUCCESS != oaes_key_gen_192(ctx) )
          printf("Error: Failed to generate OAES %d bit key.\n", _key_len);
        break;
      case 256:
        if( OAES_RET_SUCCESS != oaes_key_gen_256(ctx) )
          printf("Error: Failed to generate OAES %d bit key.\n", _key_len);
        break;
      default:
        break;
    }

  if( _bin_data )
  {
    if( OAES_RET_SUCCESS != oaes_encrypt( ctx,
        _bin_data, _bin_data_len, NULL, &_encbuf_len, NULL, NULL ) )
      printf("Error: Failed to retrieve required buffer size for encryption.\n");
    _encbuf = (uint8_t *) calloc(_encbuf_len, sizeof(uint8_t));
    if( NULL == _encbuf )
    {
      printf( "Error: Failed to allocate memory.\n" );
      if( _key_data )
        free( _key_data );
      free( _bin_data );
      return EXIT_FAILURE;
    }
    printf( "\n" );
    if( OAES_RET_SUCCESS != oaes_encrypt( ctx,
        _bin_data, _bin_data_len, _encbuf, &_encbuf_len, _iv, &_pad ) )
      printf("Error: Encryption failed.\n");
    printf( "\n**********************\n\n" );
  }
  else
  {
    if( OAES_RET_SUCCESS != oaes_encrypt( ctx,
        (const uint8_t *)_text, strlen( _text ), NULL, &_encbuf_len,
        NULL, NULL ) )
      printf("Error: Failed to retrieve required buffer size for encryption.\n");
    _encbuf = (uint8_t *) calloc(_encbuf_len, sizeof(uint8_t));
    if( NULL == _encbuf )
    {
      printf( "Error: Failed to allocate memory.\n" );
      if( _key_data )
        free( _key_data );
      return EXIT_FAILURE;
    }
    printf( "\n" );
    if( OAES_RET_SUCCESS != oaes_encrypt( ctx,
        (const uint8_t *)_text, strlen( _text ), _encbuf, &_encbuf_len,
        _iv, &_pad ))
      printf("Error: Encryption failed.\n");
    printf( "\n**********************\n\n" );
  }

  if( OAES_RET_SUCCESS != oaes_decrypt( ctx,
      _encbuf, _encbuf_len, NULL, &_decbuf_len, NULL, NULL ) )
    printf("Error: Failed to retrieve required buffer size for encryption.\n");
  _decbuf = (uint8_t *) calloc(_decbuf_len, sizeof(uint8_t));
  if( NULL == _decbuf )
  {
    printf( "Error: Failed to allocate memory.\n" );
    if( _key_data )
      free( _key_data );
    if( _bin_data )
      free( _bin_data );
    free( _encbuf );
    return EXIT_FAILURE;
  }
  if( OAES_RET_SUCCESS != oaes_decrypt( ctx,
      _encbuf, _encbuf_len, _decbuf, &_decbuf_len, _iv, _pad ) )
    printf("Error: Decryption failed.\n");

  if( OAES_RET_SUCCESS !=  oaes_free( &ctx ) )
    printf("Error: Failed to uninitialize OAES.\n");
  
  oaes_sprintf( NULL, &_buf_len, _encbuf, _encbuf_len );
  _buf = (char *) calloc(_buf_len, sizeof(char));
  printf( "\n***** cyphertext *****\n" );
  if( _buf )
  {
    oaes_sprintf( _buf, &_buf_len, _encbuf, _encbuf_len );
    printf( "%s", _buf );
  }
  printf( "\n**********************\n" );
  free( _buf );
  
  oaes_sprintf( NULL, &_buf_len, _decbuf, _decbuf_len );
  _buf = (char *) calloc(_buf_len, sizeof(char));
  printf( "\n***** plaintext  *****\n" );
  if( _buf )
  {
    oaes_sprintf( _buf, &_buf_len, _decbuf, _decbuf_len );
    printf( "%s", _buf );
  }
  printf( "\n**********************\n\n" );
  free( _buf );
  
  free( _encbuf );
  free( _decbuf );
  if( _key_data )
    free( _key_data );
  if( _bin_data )
    free( _bin_data );

  return (EXIT_SUCCESS);
}
Пример #3
0
int main(int argc, char** argv)
{
	size_t _i = 0, _j = 0;
	size_t _read_len = 0;
	char *_file_in = NULL, *_file_out = NULL, *_file_k = NULL;
	int _op = 0;
	FILE *_f_in = stdin, *_f_out = stdout, *_f_k = NULL;
	do_block _b[OAES_THREADS];
	
	fprintf( stderr, "\n"
		"*******************************************************************************\n"
		"* OpenAES %-10s                                                          *\n"
		"* Copyright (c) 2013, Nabil S. Al Ramli, www.nalramli.com                     *\n"
		"*******************************************************************************\n\n",
		OAES_VERSION );

	// pad the key
	for( _j = 0; _j < 32; _j++ )
		_key_data[_j] = _j + 1;

	if( argc < 2 )
	{
		usage( argv[0] );
		return EXIT_FAILURE;
	}

	if( 0 == strcmp( argv[1], "gen-key" ) )
	{
		OAES_CTX *_oaes = NULL;
		uint8_t _buf[16384];
		size_t _buf_len = sizeof(_buf);
		OAES_RET _rc = OAES_RET_SUCCESS;

		_i++;
		_i++; // key_length
		_i++; // key_file
		if( _i >= argc )
		{
			fprintf( stderr, "Error: No value specified for '%s'.\n",
					argv[1] );
			usage( argv[0] );
			return EXIT_FAILURE;
		}
		_key_data_len = atoi( argv[_i - 1] );
		_file_k = argv[_i];
		_oaes = oaes_alloc();
		if( NULL == _oaes )
		{
			fprintf(stderr, "Error: Failed to initialize OAES.\n");
			return OAES_RET_MEM;
		}
		switch( _key_data_len )
		{
			case 128:
				_rc = oaes_key_gen_128(_oaes);
				break;
			case 192:
				_rc = oaes_key_gen_192(_oaes);
				break;
			case 256:
				_rc = oaes_key_gen_256(_oaes);
				break;
			default:
				fprintf( stderr, "Error: Invalid value [%s] specified for '%s'.\n",
						argv[_i - 1], argv[_i - 2] );
				oaes_free(&_oaes);
				return EXIT_FAILURE;
		}
		if( OAES_RET_SUCCESS != _rc )
		{
			fprintf( stderr, "Error: Failed to generate OAES %lu bit key.\n",
				_key_data_len );
			oaes_free(&_oaes);
			return EXIT_FAILURE;
		}
		if( OAES_RET_SUCCESS != oaes_key_export(_oaes, _buf, &_buf_len) )
		{
			fprintf( stderr, "Error: Failed to retrieve key length %lu.\n",
				_key_data_len );
			oaes_free(&_oaes);
			return EXIT_FAILURE;
		}
		oaes_free(&_oaes);
		if( 0 == access(_file_k, 00) )
		{
			fprintf(stderr,
				"Error: '%s' already exists.\n", _file_k);
			return EXIT_FAILURE;
		}
		_f_k = fopen(_file_k, "wb");
		if( NULL == _f_k )
		{
			fprintf(stderr,
				"Error: Failed to open '%s' for writing.\n", _file_k);
			return EXIT_FAILURE;
		}
		fwrite(_buf, sizeof(uint8_t), _buf_len, _f_k);
		fclose(_f_k);
		return EXIT_SUCCESS;
	}
	else if( 0 == strcmp( argv[1], "base64-enc" ) )
	{
		_op = 0;
		_read_len = OAES_BASE64_LEN_ENC;
	}
	else if( 0 == strcmp( argv[1], "base64-dec" ) )
	{
		_op = 1;
		_read_len = OAES_BASE64_LEN_DEC;
	}
	else if( 0 == strcmp( argv[1], "aes-enc" ) )
	{
		_op = 2;
		_read_len = OAES_AES_LEN_ENC;
	}
	else if( 0 == strcmp( argv[1], "aes-dec" ) )
	{
		_op = 3;
		_read_len = OAES_AES_LEN_DEC;
	}
	else
	{
		fprintf(stderr, "Error: Unknown command '%s'.", argv[1]);
		usage( argv[0] );
		return EXIT_FAILURE;
	}

	for( _i = 2; _i < argc; _i++ )
	{
		int _found = 0;

		if( 0 == strcmp( argv[_i], "--ecb" ) )
		{
			_found = 1;
			_is_ecb = 1;
		}
		
		if( 0 == strcmp( argv[_i], "--key" ) )
		{
			uint8_t *_buf = NULL;
			size_t _buf_len = 0;
			_found = 1;
			_i++; // base64_encoded_key_data
			if( _i >= argc )
			{
				fprintf(stderr, "Error: No value specified for '%s'.\n",
						argv[_i - 1]);
				usage( argv[0] );
				return EXIT_FAILURE;
			}
			if( oaes_base64_decode(argv[_i], strlen(argv[_i]), NULL, &_buf_len) )
			{
				fprintf(stderr, "Error: Invalid value for '%s'.\n",
						argv[_i - 1]);
				usage( argv[0] );
				return EXIT_FAILURE;
			}
			_buf = (uint8_t *) calloc(_buf_len, sizeof(uint8_t));
			if( NULL == _buf )
			{
				fprintf(stderr, "Error: Failed to allocate memory.\n");
				return EXIT_FAILURE;
			}
			if( oaes_base64_decode(argv[_i], strlen(argv[_i]), _buf, &_buf_len) )
			{
				free(_buf);
				fprintf(stderr, "Error: Invalid value for '%s'.\n",
						argv[_i - 1]);
				usage( argv[0] );
				return EXIT_FAILURE;
			}
			_key_data_len = _buf_len;
			if( 16 >= _key_data_len )
				_key_data_len = 16;
			else if( 24 >= _key_data_len )
				_key_data_len = 24;
			else
				_key_data_len = 32;
			memcpy(_key_data, _buf, __min(32, _buf_len));
			for( _j = 0; _j < _buf_len; _j++ )
			{
				_key_data[_j % 32] ^= _buf[_j];
			}
			free(_buf);
		}
		
		if( 0 == strcmp( argv[_i], "--key-file" ) )
		{
			OAES_CTX *_ctx = NULL;
			uint8_t _buf[16384];
			size_t _read = 0;

			_found = 1;
			_i++; // key_file
			if( _i >= argc )
			{
				fprintf(stderr, "Error: No value specified for '%s'.\n",
						argv[_i - 1]);
				usage( argv[0] );
				return EXIT_FAILURE;
			}
			_file_k = argv[_i];
			_ctx = oaes_alloc();
			if( NULL == _ctx )
			{
				fprintf(stderr, "Error: Failed to initialize OAES.\n");
				return OAES_RET_MEM;
			}
			_f_k = fopen(_file_k, "rb");
			if( NULL == _f_k )
			{
				fprintf(stderr,
					"Error: Failed to open '%s' for reading.\n", _file_k);
				oaes_free(&_ctx);
				return EXIT_FAILURE;
			}
			_read = fread(_buf, sizeof(uint8_t), sizeof(_buf), _f_k);
			fclose(_f_k);
			if( OAES_RET_SUCCESS != oaes_key_import(_ctx, _buf, _read) )
			{
				fprintf(stderr,
					"Error: Failed to import '%s'.\n", _file_k);
				oaes_free(&_ctx);
				return EXIT_FAILURE;
			}
			_key_data_len = sizeof(_key_data);
			if( OAES_RET_SUCCESS != oaes_key_export_data(_ctx, _key_data, &_key_data_len) )
			{
				fprintf(stderr,
					"Error: Failed to export '%s' data.\n", _file_k);
				oaes_free(&_ctx);
				return EXIT_FAILURE;
			}
			oaes_free(&_ctx);
		}
		
		if( 0 == strcmp( argv[_i], "--in" ) )
		{
			_found = 1;
			_i++; // path_in
			if( _i >= argc )
			{
				fprintf(stderr, "Error: No value specified for '%s'.\n",
						argv[_i - 1]);
				usage( argv[0] );
				return EXIT_FAILURE;
			}
			_file_in = argv[_i];
		}
		
		if( 0 == strcmp( argv[_i], "--out" ) )
		{
			_found = 1;
			_i++; // path_out
			if( _i >= argc )
			{
				fprintf(stderr, "Error: No value specified for '%s'.\n",
						argv[_i - 1]);
				usage( argv[0] );
				return EXIT_FAILURE;
			}
			_file_out = argv[_i];
		}
		
		if( 0 == _found )
		{
			fprintf(stderr, "Error: Invalid option '%s'.\n", argv[_i]);
			usage( argv[0] );
			return EXIT_FAILURE;
		}			
	}

	switch(_op)
	{
	case 0:
	case 1:
		break;
	case 2:
	case 3:
		if( 0 == _key_data_len )
		{
			char _key_data_ent[8193] = "";
			uint8_t *_buf = NULL;
			size_t _buf_len = 0;

			fprintf(stderr, "Enter base64-encoded key: ");
			scanf("%8192s", _key_data_ent);
			if( oaes_base64_decode(
					_key_data_ent, strlen(_key_data_ent), NULL, &_buf_len ) )
			{
				fprintf(stderr, "Error: Invalid value for '%s'.\n",
						argv[_i - 1]);
				usage( argv[0] );
				return EXIT_FAILURE;
			}
			_buf = (uint8_t *) calloc(_buf_len, sizeof(uint8_t));
			if( NULL == _buf )
			{
				fprintf(stderr, "Error: Failed to allocate memory.\n");
				return EXIT_FAILURE;
			}
			if( oaes_base64_decode(
					_key_data_ent, strlen(_key_data_ent), _buf, &_buf_len ) )
			{
				free(_buf);
				fprintf(stderr, "Error: Invalid value for '%s'.\n",
						argv[_i - 1]);
				usage( argv[0] );
				return EXIT_FAILURE;
			}
			_key_data_len = _buf_len;
			if( 16 >= _key_data_len )
				_key_data_len = 16;
			else if( 24 >= _key_data_len )
				_key_data_len = 24;
			else
				_key_data_len = 32;
			memcpy(_key_data, _buf, __min(32, _buf_len));
			for( _j = 0; _j < _buf_len; _j++ )
			{
				_key_data[_j % 32] ^= _buf[_j];
			}
			free(_buf);
		}
		break;
	default:
		break;
	}

	if( _file_in )
	{
		_f_in = fopen(_file_in, "rb");
		if( NULL == _f_in )
		{
			fprintf(stderr,
				"Error: Failed to open '%s' for reading.\n", _file_in);
			return EXIT_FAILURE;
		}
	}
	else
	{
		if( setmode(fileno(stdin), 0x8000) < 0 )
			fprintf(stderr,"Error: Failed in setmode().\n");
		_f_in = stdin;
	}

	if( _file_out )
	{
		if( 0 == access(_file_out, 00) )
		{
			fprintf(stderr,
				"Error: '%s' already exists.\n", _file_out);
			return EXIT_FAILURE;
		}
		_f_out = fopen(_file_out, "wb");
		if( NULL == _f_out )
		{
			fprintf(stderr,
				"Error: Failed to open '%s' for writing.\n", _file_out);
			if( _file_in )
				fclose(_f_in);
			return EXIT_FAILURE;
		}
	}
	else
	{
		if( setmode(fileno(stdout), 0x8000) < 0 )
			fprintf(stderr, "Error: Failed in setmode().\n");
		_f_out = stdout;
	}

	_i = 0;
	while( _b[_i].in_len =
		fread(_b[_i].in, sizeof(uint8_t), _read_len, _f_in) )
	{
		switch(_op)
		{
		case 0:
			_b[_i].id = start_thread(_do_base64_encode, &(_b[_i]));
			if( NULL == _b[_i].id )
				fprintf(stderr, "Error: Failed to start encryption.\n");
			break;
		case 1:
			_b[_i].id = start_thread(_do_base64_decode, &(_b[_i]));
			if( NULL == _b[_i].id )
				fprintf(stderr, "Error: Failed to start decryption.\n");
			break;
		case 2:
			_b[_i].id = start_thread(_do_aes_encrypt, &(_b[_i]));
			if( NULL == _b[_i].id )
				fprintf(stderr, "Error: Failed to start encryption.\n");
			break;
		case 3:
			_b[_i].id = start_thread(_do_aes_decrypt, &(_b[_i]));
			if( NULL == _b[_i].id )
				fprintf(stderr, "Error: Failed to start decryption.\n");
			break;
		default:
			break;
		}
		if( OAES_THREADS == _i + 1 )
		{
			for( _j = 0; _j < OAES_THREADS; _j++ )
			{
				if( _b[_j].id )
				{
					join_thread(_b[_j].id);
					_b[_j].id = 0;
					if( _b[_j].out )
					{
						fwrite(_b[_j].out, sizeof(uint8_t), _b[_j].out_len, _f_out);
						free(_b[_j].out);
						_b[_j].out = NULL;
					}
				}
			}
		}
		_i = (_i + 1) % OAES_THREADS;
	}
	for( _j = 0; _j < _i; _j++ )
	{
		if( _b[_j].id )
		{
			join_thread(_b[_j].id);
			_b[_j].id = 0;
			if( _b[_j].out )
			{
				fwrite(_b[_j].out, sizeof(uint8_t), _b[_j].out_len, _f_out);
				free(_b[_j].out);
				_b[_j].out = NULL;
			}
		}
	}


	if( _file_in )
		fclose(_f_in);
	if( _file_out )
		fclose(_f_out);

	fprintf(stderr, "done.\n");
	return (EXIT_SUCCESS);
}
int main(int argc, char** argv)
{
	size_t _i;
	OAES_CTX * ctx = NULL;
	uint8_t *_encbuf, *_decbuf;
	size_t _encbuf_len, _decbuf_len, _buf_len;
	char *_buf;
	short _is_ecb = 0;
	char * _text = NULL;
	int _key_len = 128;
	
	if( argc < 2 )
	{
		usage( argv[0] );
		return EXIT_FAILURE;
	}

	for( _i = 1; _i < argc; _i++ )
	{
		int _found = 0;
		
		if( 0 == strcmp( argv[_i], "-ecb" ) )
		{
			_found = 1;
			_is_ecb = 1;
		}
		
		if( 0 == strcmp( argv[_i], "-key" ) )
		{
			_found = 1;
			_i++; // len
			if( _i >= argc )
			{
				printf("Error: No value specified for '-%s'.\n",
						"key");
				usage( argv[0] );
				return EXIT_FAILURE;
			}
			_key_len = atoi( argv[_i] );
			switch( _key_len )
			{
				case 128:
				case 192:
				case 256:
					break;
				default:
					printf("Error: Invalid value [%d] specified for '-%s'.\n",
							_key_len, "key");
					usage( argv[0] );
					return EXIT_FAILURE;
			}
		}
		
		if( 0 == _found )
		{
			if( _text )
			{
				printf("Error: Invalid option '%s'.\n", argv[_i]);
				usage( argv[0] );
				return EXIT_FAILURE;
			}
			else
			{
				_text = (char *) calloc(strlen( argv[_i] ) + 1, sizeof(char));
				if( NULL == _text )
				{
					printf("Error: Failed to allocate memory.\n", argv[_i]);
					return EXIT_FAILURE;
				}
				strcpy( _text, argv[_i] );
			}
		}			
	}

	if( NULL == _text )
	{
		usage( argv[0] );
		return EXIT_FAILURE;
	}

	oaes_sprintf( NULL, &_buf_len,
			(const uint8_t *)_text, strlen( _text ) );
	_buf = (char *) calloc(_buf_len, sizeof(char));
	printf( "\n***** plaintext  *****\n" );
	if( _buf )
	{
		oaes_sprintf( _buf, &_buf_len,
				(const uint8_t *)_text, strlen( _text ) );
		printf( "%s", _buf );
	}
	printf( "\n**********************\n" );
	free( _buf );
	
	ctx = oaes_alloc();
	if( NULL == ctx )
	{
		printf("Error: Failed to initialize OAES.\n");
		free( _text );
		return EXIT_FAILURE;
	}
	if( _is_ecb )
		if( OAES_RET_SUCCESS != oaes_set_option( ctx, OAES_OPTION_ECB, NULL ) )
			printf("Error: Failed to set OAES options.\n");
	switch( _key_len )
	{
		case 128:
			if( OAES_RET_SUCCESS != oaes_key_gen_128(ctx) )
				printf("Error: Failed to generate OAES %d bit key.\n", _key_len);
			break;
		case 192:
			if( OAES_RET_SUCCESS != oaes_key_gen_192(ctx) )
				printf("Error: Failed to generate OAES %d bit key.\n", _key_len);
			break;
		case 256:
			if( OAES_RET_SUCCESS != oaes_key_gen_256(ctx) )
				printf("Error: Failed to generate OAES %d bit key.\n", _key_len);
			break;
		default:
			break;
	}

	if( OAES_RET_SUCCESS != oaes_encrypt( ctx,
			(const uint8_t *)_text, strlen( _text ), NULL, &_encbuf_len ) )
		printf("Error: Failed to retrieve required buffer size for encryption.\n");
	_encbuf = (uint8_t *) calloc( _encbuf_len, sizeof(uint8_t) );
	if( NULL == _encbuf )
	{
		printf( "Error: Failed to allocate memory.\n" );
		free( _text );
		return EXIT_FAILURE;
	}
	if( OAES_RET_SUCCESS != oaes_encrypt( ctx,
			(const uint8_t *)_text, strlen( _text ), _encbuf, &_encbuf_len ) )
		printf("Error: Encryption failed.\n");

	if( OAES_RET_SUCCESS != oaes_decrypt( ctx,
			_encbuf, _encbuf_len, NULL, &_decbuf_len ) )
		printf("Error: Failed to retrieve required buffer size for encryption.\n");
	_decbuf = (uint8_t *) calloc( _decbuf_len, sizeof(uint8_t) );
	if( NULL == _decbuf )
	{
		printf( "Error: Failed to allocate memory.\n" );
		free( _text );
		free( _encbuf );
		return EXIT_FAILURE;
	}
	if( OAES_RET_SUCCESS != oaes_decrypt( ctx,
			_encbuf, _encbuf_len, _decbuf, &_decbuf_len ) )
		printf("Error: Decryption failed.\n");

	if( OAES_RET_SUCCESS !=  oaes_free( &ctx ) )
		printf("Error: Failed to uninitialize OAES.\n");
	
	oaes_sprintf( NULL, &_buf_len, _encbuf, _encbuf_len );
	_buf = (char *) calloc(_buf_len, sizeof(char));
	printf( "\n***** cyphertext *****\n" );
	if( _buf )
	{
		oaes_sprintf( _buf, &_buf_len, _encbuf, _encbuf_len );
		printf( "%s", _buf );
	}
	printf( "\n**********************\n" );
	free( _buf );
	
	oaes_sprintf( NULL, &_buf_len, _decbuf, _decbuf_len );
	_buf = (char *) calloc(_buf_len, sizeof( char));
	printf( "\n***** plaintext  *****\n" );
	if( _buf )
	{
		oaes_sprintf( _buf, &_buf_len, _decbuf, _decbuf_len );
		printf( "%s", _buf );
	}
	printf( "\n**********************\n\n" );
	free( _buf );
	
	free( _encbuf );
	free( _decbuf );
	free( _text );

	return (EXIT_SUCCESS);
}