HDL / MHW reference guide

[Böllke]

Heeft er iemand een reference guide voor de HDL en/of MHW programmering van canal digitaal? Ik bedoel dus een beschrijving van alle functie's/variabelen voor programmeurs.

 

Gr

Böllke

 

[Gast exduckfan]

Deze nog gevonden.

Niet in NL.

 

Groeten

Faq MHW.pdf

MHW_9.pdf

[Böllke]

Hoi ExduckFan

 

Deze bestanden had ik idd ook al gevonden. Met name de faqMHW zou ik graag in het engels, duits of nederlands willen zien. Mja de vertaalcomputers bakken er meestal niets van. Dus als er iemand goed is in italiaans en deze faq wil en kan vertalen. GRAAG.

 

Greetz

Böllke

 

[Gast exduckfan]

Tja in het Nederlands? dat kun je wel vergeten...

Iets anders als je geinteresseerd bent in C source HDL programming heb ik wel broncode bestanden voor studie klaarliggen. Moet je met het volgende voorbeeld wel overweg kunnen.

 

example:

/**************************************

//wt embedded seca2 algo into our system

//06-20-2004

//20-01-2004: T1[2] and T2[2] are empty, if it is point them, then make the pointer to T1[3] and T2[3]

***************************************/

#include <stdio.h>

#include <string.h>

#include "appldef.h"

#include "fcas.h"

#include "nn.h"

#include "nagra_.h"

#include "sha1.h"

 

/*#define DEBUG*/

/*#define BCT1330*/

#define SECA_DATA_IN_FLASH

 

#define PROV_COUNT 8

#define ISSU_COUNT 3

 

int decrypt_seca_ecm(unsigned char *source, unsigned char *dw, unsigned char *key);

void RSA_nano51(unsigned char *msg);

/************************************************************************/

#define SN_SECA( b ) (((b&0xf0)>>4)+((b&0xf)<<4))

static unsigned char TD[4] = {1,3,0,2};

static unsigned char t1[ ]=

 

#include "nn.h"

#ifdef DEBUG

#include <stdio.h>

#endif

 

// perform XORing of 8 bytes encrypted block

#define maskblock(buf) { if((provi->ident & 0xF0) == 0x60) \

for(i=0;i<8;i++) buf ^= issuer->masktable[j+i]; \

else \

for(i=0;i<8;i++) buf ^= (issuer->masktable[j+i*2]^issuer->masktable[j+i*2+1]); \

}

/*

#define maskblock(buf) {for(i=0;i<8;i++) buf ^= issuer->masktable[j+i]; }

*/

 

void add_algo (unsigned char* d, unsigned char *k, int crypt)

{

unsigned short k1 = k[1]<< 8 | k[0];

unsigned short k2 = k[3]<< 8 | k[2];

unsigned short k3 = k[5]<< 8 | k[4];

unsigned short k4 = k[7]<< 8 | k[6];

unsigned short d1 = d[1]<< 8 | d[0];

unsigned short d2 = d[3]<< 8 | d[2];

unsigned short d3 = d[5]<< 8 | d[4];

unsigned short d4 = d[7]<< 8 | d[6];

unsigned short adder = 0;

unsigned short counter = 0;

int i;

if(crypt) {

counter = 120;

for (i = 0x0F; i >= 0; i--)

{

 

adder = 0xE555 * counter;

counter -= i;

 

d4 = (d4 << 5) | (d4 >> 11);

d4 -= (k3 + d1 + adder) ^ (k4 + d2 + adder);

d3 = (d3 >> 3) | (d3 << 13);

 

d3 -= (k1 + d1 + adder) ^ (k2 + d2 + adder);

d2 = (d2 >> 3) | (d2 << 13);

d2 -= (k3 + d3 + adder) ^ (k4 + d4 + adder);

d1 = (d1 >> 11) | (d1 << 5);

d1 -= (k1 + d3 + adder) ^ (k2 + d4 + adder);

}

}

else {

for (i = 0; i < 0x10; i++)

{

counter += i;

adder = 0xE555 * counter;

d1 += (k1 + d3 + adder) ^ (k2 + d4 + adder);

d1 = (d1 << 11) | (d1 >> 5);

d2 += (k3 + d3 + adder) ^ (k4 + d4 + adder);

d2 = (d2 << 3) | (d2 >> 13);

d3 += (k1 + d1 + adder) ^ (k2 + d2 + adder);

d3 = (d3 << 3) | (d3 >> 13);

d4 += (k3 + d1 + adder) ^ (k4 + d2 + adder);

d4 = (d4 >> 5) | (d4 << 11);

}

}

d[0] = d1 & 0xff;

d[1] = d1 >> 8;

d[2] = d2 & 0xff;

d[3] = d2 >> 8;

d[4] = d3 & 0xff;

d[5] = d3 >> 8;

d[6] = d4 & 0xff;

d[7] = d4 >> 8;

}

 

static unsigned char PC1_seca[][8] =

{

{42, 57, 29, 34, 41, 53, 30, 15},

{19, 36, 23, 14, 43, 61, 12, 3},

{51, 49, 5, 6, 45, 54, 52, 47},

{63, 38, 58, 22, 60, 33, 10, 26},

{37, 35, 44, 1, 20, 62, 28, 18},

{46, 9, 39, 4, 27, 11, 21, 50},

{31, 25, 2, 7, 13, 55, 59, 17}

};

 

void doPC1_seca(unsigned char data[])

{

unsigned char buf[8];

unsigned char i, j;

memset(buf, 0, 8);

for(j=0; j<7; j++)

{

for(i=0; i<8; i++)

{

unsigned char lookup = PC1_seca[j];

 

buf[j] |= ((data[(lookup>>3)]>>(8-(lookup & 7))) & 1) << (7-i);

}

}

memcpy(data, buf, 8);

}

 

void core_51(unsigned char *key, unsigned char *data, s2issuer *issuer, int mode, int decrypt)

{

int i;

if(!mode)

{

// XOR

/*

Funzione 0 (00): Xor

a) Xor dei primi 8 bytes dei dati con i primi 8 bytes della k*y

Xor dei secondi 8 bytes dei dati con i primi 8 bytes della k*y

*/

for(i=0; i<8; i++) {

data ^= key;

data[i+8] ^= key;

}

}

else if(mode==1) { //seca with tab 9x

/*

Funzione 1 (01): (De)Cipher S**a

Se e' settato il bit BIT:

a) Decipher dei primi 8 bytes dei dati, con k*y fornita dai 16 bytes della k*y e con hash table in ROM

Decipher dei secondi 8 bytes dei dati, con k*y fornita dai 16 bytes della k*y e con hash table in ROM

Altrimenti:

a) Cipher dei primi 8 bytes dei dati, con k*y fornita dai 16 bytes della k*y e con hash table in ROM

Cipher dei secondi 8 bytes dei dati, con k*y fornita dai 16 bytes della k*y e con hash table in ROM

*/

memcpy(key+8, key, 8);

if(decrypt) {

decrypt_seca(key,data,(unsigned char *)&issuer->t1[0], (unsigned char *)&issuer->t2[0]);

decrypt_seca(key,data+8,(unsigned char *)&issuer->t1[0], (unsigned char *)&issuer->t2[0]);

}

else {

encrypt_seca(key, data,(unsigned char *)&issuer->t1[0], (unsigned char *)&issuer->t2[0]);

encrypt_seca(key, data+8,(unsigned char *)&issuer->t1[0], (unsigned char *)&issuer->t2[0]);

}

 

}

else if(mode==2)

{

//DES

doPC1_seca(key);

if(decrypt)

i = DES_ECS2_DECRYPT;

else

i = DES_ECS2_CRYPT;

i |= SECA2;

des(key, i, data);

des(key, i, data+8);

}

else if(mode==3){ // additional algo

add_algo(data, key, decrypt);

add_algo(data+8, key, decrypt);

}

}