El primer error que me da es: Undefined identifier DKEY
fastdecc.c
//-------------------------------------------------------------------------
// Keeloq Decryption Algorithm
//
// optimized for CCS PIC C compiler v. 2.535
//
// version 1.00 08/07/2000 Lucio Di Jasio
//
//=========================================================================
#include "decccs.h"
byte aux;
void Decrypt()
{
byte i, j, key;
sbyte p;
p = 1;
for (j=66; j>0; j--)
{
key = DKEY[p--];
ERROR !!! if (p<0)
p+=8;
for (i=8; i>0; i--)
{
// NLF
if ( BIT_TEST( Buffer[3],6))
{
if ( !BIT_TEST( Buffer[3],1))
aux = 0b00111010; // 10
else
aux = 0b01011100; // 11
}
else
{
if ( !BIT_TEST( Buffer[3],1))
aux = 0b01110100; // 00
else
aux = 0b00101110; // 01
}
// move bit in position 7
if ( BIT_TEST( Buffer[2],3))
#asm
swapf aux,f
#endasm
if ( BIT_TEST( Buffer[1],0))
aux<<=2;
if (BIT_TEST( Buffer[0],0))
aux<<=1;
// xor with Buffer and Dkey
aux ^= Buffer[1] ^ Buffer[3] ^ key;
// shift in buffer
shift_left( Buffer, 4, BIT_TEST( aux,7));
key<<=1;
} // for i
} // for j
} // decrypt
En cambio esta declarada en
//-------------------------------------------------------------------------
//
// Keeloq Normal Key Generation and Decryption
// Compiled using CCS PIC C compiler v. 2.535
//
// version 1.00 08/07/2000 Lucio Di Jasio
//
//=========================================================================
#include "fastdecc.c" // for CCS optimized version
byte DKEY[8]; // Decryption key
DECLARACION byte SEED[4]; // seed value = serial number
word NextHop; // resync value for 2 Chance
//----------------------------------------------------------------------
void LoadManufCode()
{
DKEY[0]=0xef; // DKEY=0123456789ABCDEF
DKEY[1]=0xcd;
DKEY[2]=0xAB;
DKEY[3]=0x89;
DKEY[4]=0x67;
DKEY[5]=0x45;
DKEY[6]=0x23;
DKEY[7]=0x01;
}
//----------------------------------------------------------------------
//
// Key Generation routine
//
// Normal Learn algorithm
//
// INPUT: Serial Number (Buffer[4..7])
// Manufacturer code
// OUTPUT: DKEY[0..7] computed decryption key
//
void NormalKeyGen()
{
byte HOPtemp[4]; // HOP temp buffer
byte SKEYtemp[4]; // temp decryption key
// check if same Serial Number as last time while output active
// it was stored in Seed
if (( SEED[0] != Buffer[4]) ||
( SEED[1] != Buffer[5]) ||
( SEED[2] != Buffer[6]) ||
( SEED[3] != (Buffer[7] & 0x0f)) ||
(COut == 0))
{
// no new KeyGen is needed
memcpy( HOPtemp, Buffer, 4); // save hopping code to temp
memcpy( SEED, &Buffer[4], 4); // make seed = Serial Number
SEED[3] &= 0x0f; // mask out function codes
// compute LSb of decryption key first
memcpy( Buffer, SEED, 4); // get SEED in
Buffer[3] |= 0x20; // add constant 0x20
LoadManufCode();
Decrypt();
memcpy( SKEYtemp, Buffer, 4); // save result for later
// compute MSb of decryption key
memcpy( Buffer, SEED, 4); // get SEED in
Buffer[3] |= 0x60; // add constant 0x60
LoadManufCode();
Decrypt();
memcpy( &DKEY[4], Buffer, 4); // move it into DKEY MSb
memcpy( DKEY, SKEYtemp, 4); // add LSb
// ready for Decrypt
memcpy( Buffer, HOPtemp, 4); // restore hopping code
}
else // same Serial Number as last time...
{ // just keep on using same Decription Key
}
} // Normal KeyGen
//----------------------------------------------------------------------
//
// Valid Decryption Check
//
// INPUT: Serial Number (Buffer[4..7])
// Hopping Code (Buffer[0..3])
// OUTPUT: TRUE if discrimination bits == lsb Serial Number
// and decrypted function code == plain text function code
byte DecCHK()
{
// verify discrimination bits
if ( DisLo != IDLo) // compare low 8bit of Serial Number
return FALSE;
if ( ( (Buffer[3] ^ IDMi) & 0x3)!= 0) // compare 9th and 10th bit of SN
return FALSE;
// verify function code
if ( ((Buffer[3] ^ Buffer[7]) & 0xf0)!= 0)
return FALSE;
return TRUE;
} // DecCHK
//----------------------------------------------------------------------
//
// Hopping Code Verification
//
// INPUT: Hopping Code (Buffer[0..3])
// and previous value stored in EEPROM EHop
// OUTPUT: TRUE if hopping code is incrementing and inside a safe window (16)
//
byte ReqResync()
{
F2Chance= TRUE; // flag that a second (sequential) transmission
NextHop = Hop+1; // is needed to resynchronize receiver
return FALSE; // cannot accept for now
}
byte HopCHK()
{
FHopOK = FALSE; // Hopping Code is not verified yet
FSame = FALSE; // Hopping Code is not the same as previous
// make it a 16 bit signed integer
Hop = ((word)HopHi <<
+ HopLo;
if ( F2Chance)
if ( NextHop == Hop)
{
F2Chance = FALSE; // resync success
FHopOK = TRUE;
return TRUE;
}
// verify EEPROM integrity
if ( EHop != ETemp)
return ReqResync(); // memory corrupted need a resync
// main comparison
ETemp = Hop - EHop; // subtract last value from new one
if ( ETemp < 0) // locked region
return FALSE; // fail
else if ( ETemp > 16) // resync region
return ReqResync();
else // 0>= ETemp >16 ; open window
{
if ( ETemp == 0) // same code (ETemp == 0)
FSame = TRUE; // rise a flag
FHopOK = TRUE;
return TRUE;
}
} // HopCHK
Creo que conpila los .c por orden alfabetico y no coje primero el main y compila a partir de ahí, alguien sabe una solucion mas "elegante" que el extern ?
Gracias por vuestra respusto, es el AN744, no me lo deja subir por que dice que no hay suficiente espacio (134K"s en un rar ¿?)
Gracias otra vez.
