void
tvhcsa_destroy ( tvhcsa_t *csa )
{
#if ENABLE_DVBCSA
if (csa->csa_key_odd)
dvbcsa_bs_key_free(csa->csa_key_odd);
if (csa->csa_key_even)
dvbcsa_bs_key_free(csa->csa_key_even);
if (csa->csa_tsbbatch_odd)
free(csa->csa_tsbbatch_odd);
if (csa->csa_tsbbatch_even)
free(csa->csa_tsbbatch_even);
#endif
if (csa->csa_tsbcluster)
free(csa->csa_tsbcluster);
if (csa->csa_priv) {
switch (csa->csa_type) {
case DESCRAMBLER_CSA_CBC:
break;
case DESCRAMBLER_DES_NCB:
des_free_priv_struct(csa->csa_priv);
break;
case DESCRAMBLER_AES_ECB:
aes_free_priv_struct(csa->csa_priv);
break;
case DESCRAMBLER_AES128_ECB:
aes128_free_priv_struct(csa->csa_priv);
break;
default:
assert(0);
}
}
memset(csa, 0, sizeof(*csa));
}
cDeCSA::~cDeCSA()
{
for(int i=0; i<MAX_CSA_IDX; i++) {
if(csa_bs_key_even[i])
dvbcsa_bs_key_free(csa_bs_key_even[i]);
if(csa_bs_key_odd[i])
dvbcsa_bs_key_free(csa_bs_key_odd[i]);
}
}
void csa_key_free(csakey_t **pcsakey) {
struct csakey *key = *((struct csakey **)pcsakey);
if (key) {
dvbcsa_key_free(key->s_csakey[0]);
dvbcsa_key_free(key->s_csakey[1]);
dvbcsa_bs_key_free(key->bs_csakey[0]);
dvbcsa_bs_key_free(key->bs_csakey[1]);
ffdecsa_key_free(key->ff_csakey);
FREE(*pcsakey);
}
}
void ffdecsa_benchmark(void) {
struct timeval t0, t1;
ffdecsa_key_t *key = ffdecsa_key_alloc();
unsigned int n, i, d, npackets = 0;
unsigned int batch_size = ffdecsa_get_suggested_cluster_size() / 2;
uint8_t data[batch_size + 1][188];
uint8_t *pcks[batch_size * 2 + 1];
uint8_t ecw[8] = { 0x12, 0x34, 0x56, 0x78, 0x89, 0xab, 0xcd, 0xef, };
uint8_t ocw[8] = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, };
ffdecsa_set_even_cw(key, ecw);
ffdecsa_set_odd_cw (key, ocw);
printf("Batch size %d packets.\n\n", batch_size);
for (i = 0; i < batch_size; i++) {
memset(data[i], rand(), 188);
data[i][0] = 0x47;
data[i][1] = 0x01;
data[i][2] = 0x02;
data[i][3] = i & 0x0f;
}
gettimeofday(&t0, NULL);
for (n = (1 << 12) / batch_size; n < (1 << 18) / batch_size; n *= 2) {
static unsigned int key_idx = 0;
printf(" Decrypting %6u mpegts packets\r", n * batch_size);
fflush(stdout);
for (i = 0; i < n; i++) {
// ffdecsa_decrypt function modifies data and pcks
for (d = 0; d < batch_size; d++) {
pcks[d * 2] = data[d];
pcks[d * 2 + 1] = data[d] + 188;
data[d][3] |= (key_idx == 0) ? (2 << 6) : (3 << 6);
}
pcks[d * 2] = NULL;
key_idx = !!key_idx;
ffdecsa_decrypt_packets(key, pcks);
}
npackets += n * batch_size;
}
gettimeofday(&t1, NULL);
unsigned long long usec = timeval_diff_usec(&t0, &t1);
printf("DONE: %u packets (%u bytes) decrypted in %llu ms = %.1f Mbits/s\n\n",
npackets,
npackets * 188,
usec / 1000,
(double)(npackets * 188 * 8) / (double)usec
);
dvbcsa_bs_key_free(key);
}
/* The following routine is taken from benchbitslice in libdvbcsa */
void dvbcsa_benchmark(void) {
struct timeval t0, t1;
struct dvbcsa_bs_key_s *key = dvbcsa_bs_key_alloc();
unsigned int n, i, npackets = 0;
unsigned int batch_size = dvbcsa_bs_batch_size();
uint8_t data[batch_size + 1][188];
struct dvbcsa_bs_batch_s pcks[batch_size + 1];
uint8_t cw[8] = { 0x12, 0x34, 0x56, 0x78, 0x89, 0xab, 0xcd, 0xef, };
dvbcsa_bs_key_set (cw, key);
printf("Batch size %d packets.\n\n", batch_size);
for (i = 0; i < batch_size; i++) {
pcks[i].data = data[i];
pcks[i].len = 184;
memset(data[i], rand(), pcks[i].len);
}
pcks[i].data = NULL;
gettimeofday(&t0, NULL);
for (n = (1 << 12) / batch_size; n < (1 << 19) / batch_size; n *= 2) {
printf(" Decrypting %6u mpegts packets\r", n * batch_size);
fflush(stdout);
for (i = 0; i < n; i++) {
dvbcsa_bs_decrypt(key, pcks, 184);
}
npackets += n * batch_size;
}
gettimeofday(&t1, NULL);
unsigned long long usec = timeval_diff_usec(&t0, &t1);
printf("DONE: %u packets (%u bytes) decrypted in %llu ms = %.1f Mbits/s\n\n",
npackets,
npackets * 188,
usec / 1000,
(double)(npackets * 188 * 8) / (double)usec
);
dvbcsa_bs_key_free(key);
}
