srccmospwd.cpp

这是一个远程控制程序

//---------------------------------------------------------------------------
#pragma hdrstop
#include "srcCmosPwd.h"
//---------------------------------------------------------------------------

#pragma package(smart_init)
char TCmos::InPortb(Bit16u Port)
{
        char Val;
        asm{
                mov     dx,Port
                in      al,dx
                mov     Val,al
        };
        return Val;
}
void TCmos::OutPortb(Bit16u Port, char Value)
{
        asm{
                mov     dx,Port
                mov     al,Value
                out     dx,al
        };
}
Bit8u TCmos::ReadCmos(const int cell)
{
	OutPortb(PORT_CMOS_0,cell);
	return InPortb(PORT_CMOS_1);
}
void TCmos::WriteCmos(const int cell, const byte value)
{
	OutPortb(PORT_CMOS_0,cell);
	OutPortb(PORT_CMOS_1,value);
}
bool TCmos::LoadCmos(void)
{
	SetPermissions();
        for(register i = 0; i < TAILLE_CMOS; i ++)
        {
                CmosBuf[ i ] = ReadCmos( i );
        }
	UnSetPermissions();
        return TRUE;
}
Bit16u  TCmos::Get32(int position)
{
	return ((CmosBuf[position+1] <<8) | CmosBuf[position]);
}
Bit16u TCmos::Rol(Bit16u n)
{
        return (n<<2)| ((n & 0xC000) >> 14);
}
void TCmos::GenericBasic(const int position, const int lng, const int meth_parcourt,const int algo,const int val_stop,const int mode_aff)
{
	int table[1024];
	BuildTable(position,lng,meth_parcourt,table);
	GenericTable(table,lng,algo,val_stop,mode_aff);
}
void TCmos::GenericTable(const int *table, const int lng, const int algo,const int val_stop,const int mode_aff)
{
}
bool TCmos::CheckCRCAdd(int position, int size, int pos_crc)
{
	int CRC = 0;
	for(register i = position; i < position + size; i++)
		CRC += CmosBuf[ i ];
	return ((CRC & 0xFF) == CmosBuf[pos_crc]);
}
bool TCmos::CheckFilled(const unsigned char* value, const int lng, const unsigned char filled_value)
{
	int etat=0;
	for(register i=0; i < lng; i++)
	{
		switch(etat)
		{
			case 0:	if(value[i]==filled_value)
					etat++;
				break;
			case 1:	if(value[i]!=filled_value) return TRUE;
		}
	}
	return TRUE;

}
bool TCmos::BuildTable(const int position, const int lng, const int meth_parcourt, int *table)
{
	register i;
	switch(meth_parcourt)
	{
		case METH_PARC_NORMAL:
                {
			for(i=0;i<lng;i++)
				table[i]=position+i;
			return FALSE;
                }
		case METH_PARC_SWAP:
                {
			for(i=0;i<lng;i+=2)
			{
				table[i]=position+i+1;
				if(i+1<lng)
					table[i+1]=position+i;
			}
			return FALSE;
                }
	}
	return TRUE;
}

//*********************Aaward*********************
bool TAward::BruteAward(Bit16u but)
{
	bool res;
	AwardPos = 0;
        memset(AwardPasswd,0,9);
	for (register i = 1; i <= 8; i++)
	{
		res = BruteAward(but, 0,i);
		if (res) break;
	}
        return res;
}
bool TAward::BruteAward(Bit16u but, Bit16u somme, BYTE lng)
{
	static Bit8u const tbl_car[]={'0','1','2','3','4','5','6'};

	if (lng==0)
        {
		return (but == somme);
        }
	else
	{
		for( BYTE p = 0; p < 4; p++)
		{
			if (BruteAward(but, Rol(somme) + tbl_car[p], lng-1))
			{
				AwardPasswd[AwardPos++] = tbl_car[p];
				return TRUE;
			}
		}
	}
	return FALSE;
}

void TAward::GenericCRC(int algo, int position)
{
        char PwdTmp[ 9 ];

        switch( algo )
        {
                case ALGO_AWARD:BruteAward(Get32(position));
                default:        break;
        }
        memcpy( PwdTmp,AwardPasswd,9);
        for(register i = 0; i < AwardPos ; i ++)
        {
                AwardPasswd[ i ] = PwdTmp[ AwardPos - i - 1];
        }

}

char* TAward::Password(int Index)
{
        static const BYTE Tbl[] = {0x1C,0x60,0x4D,0x43};

        GenericCRC(ALGO_AWARD,Tbl[Index]);

        return AwardPasswd;
}