Aes256::Aes256(BinData key):
key_( std::move(key) ),
iv_( generateRandomData( ivSize() ) ),
td_(MCRYPT_RIJNDAEL_256, MCRYPT_CFB)
{
if( key_.size()!=iv_.size() )
throw std::runtime_error("key and IV size differ");
assert( static_cast<size_t>(mcrypt_enc_get_key_size(td_.get()))==keySize() );
assert( static_cast<size_t>(mcrypt_enc_get_iv_size(td_.get())) ==ivSize() );
int ret;
if( (ret = mcrypt_generic_init(td_.get(), key_.data(), key_.size(), iv_.data())) < 0 )
throw std::runtime_error( (Util::ErrStrm{}<<"mcrypt_generic_init(): "<<mcrypt_strerror(ret)).str().c_str() );
}
static int
cipher_decrypt(PX_Cipher * c, const uint8 *data, unsigned dlen, uint8 *res)
{
int err;
MCRYPT ctx = (MCRYPT) c->ptr;
memcpy(res, data, dlen);
err = mdecrypt_generic(ctx, res, dlen);
if (err < 0)
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_INVOCATION_EXCEPTION),
errmsg("mdecrypt_generic error"),
errdetail("%s", mcrypt_strerror(err))));
return 0;
}
static int
cipher_init(PX_Cipher * c, const uint8 *key, unsigned klen, const uint8 *iv)
{
int err;
MCRYPT ctx = (MCRYPT) c->ptr;
err = mcrypt_generic_init(ctx, (char *) key, klen, (char *) iv);
if (err < 0)
ereport(ERROR,
(errcode(ERRCODE_EXTERNAL_ROUTINE_INVOCATION_EXCEPTION),
errmsg("mcrypt_generic_init error"),
errdetail("%s", mcrypt_strerror(err))));
c->pstat = 1;
return 0;
}
int descrypt_decrypt(void * dataptr, unsigned char * block, size_t cryptlen,
const unsigned char * fragkey, struct himderrinfo * status)
{
unsigned char finalfragkey[8];
unsigned char mainkey[8];
struct descrypt_data * data = dataptr;
int err;
xor_keys(finalfragkey, data->masterkey, fragkey);
if((err = cached_cipher_prepare(&data->master, finalfragkey, NULL)) < 0)
{
set_status_printf(status, HIMD_ERROR_ENCRYPTION_FAILURE, _("Can't setup track key: %s"), mcrypt_strerror(err));
return -1;
}
memcpy(mainkey, block+16, 8);
if((err = mcrypt_generic(data->master.cipher, mainkey, 8)) < 0)
{
set_status_printf(status, HIMD_ERROR_ENCRYPTION_FAILURE, _("Can't calc block key: %s"), mcrypt_strerror(err));
return -1;
}
if((err = cached_cipher_prepare(&data->block, mainkey, block + 24)) < 0)
{
set_status_printf(status, HIMD_ERROR_ENCRYPTION_FAILURE, _("Can't setup block key: %s"), mcrypt_strerror(err));
return -1;
}
if((err = mdecrypt_generic(data->block.cipher, block+32, cryptlen)) < 0)
{
set_status_printf(status, HIMD_ERROR_ENCRYPTION_FAILURE, _("Can't decrypt: %s"), mcrypt_strerror(err));
return -1;
}
return 0;
}
void Aes256::decryptImpl(uint8_t* data, size_t size)
{
int ret;
if( (ret = mdecrypt_generic( td_.get(), data, size )) < 0 )
throw std::runtime_error( (Util::ErrStrm{}<<"mdecrypt_generic(): "<<mcrypt_strerror(ret)).str().c_str() );
}
