كمك در رابطه با كامپايل كردن C++ به Binary file !!!

[Peyman2003]

با سلام خدمت همه دوستان گرامي بنده سوالي داشتم در مورد كامپايل C++ به Binary File (.bin)
بنده تا جايي كه ميدانم اين كار به وسيله يك برنامه به اسم ST20CC.exe انجام مي شود كه در مجموعه نرم افزار ST20 ToolSet هستش بنده مي خواهم اين كار را انجام دهم اما زياد وارد نيستم به اين كار اگر مي شود بنده رو راهنمايي كنيد يا اگر لينك فايل آموزشي در اين رابطه داريد از بنده دريغ نفرماييد ممنون ميشوم كمكم كنيد

با تشكر

[someone]

سلام.
شما برای چه کاری چنین فایلی رو نیاز دارید؟ تمامی فایل های تحت windows باینری هستند.
مثل exe,dll,sys,obj و .... ممکنه بیشتر توضیح بدید؟

[Peyman2003]

سلام.
شما برای چه کاری چنین فایلی رو نیاز دارید؟ تمامی فایل های تحت windows باینری هستند.
مثل exe,dll,sys,obj و .... ممکنه بیشتر توضیح بدید؟

والا راستش رو بگم براي گيرنده ماهواره مي خوامش البته به خود گيرنده ماهواره ربط نداره بنده Emu source دارم هموني كه به دستگاه شما اجازه ميده بعضي كانالهاي كارتي رو مشاهده كنيد بنده سورس دارم كه بايد توسط اون برنامه ايي كه گفتم به .bin تبديل بشه و بعدا روي برنامه گيرنده لحاظ بشه به طور مثال:
// compilation
// st20cc -cpp -c2 -O2 -fspace -D DSX6071 -e do_ecm -rcu emu16.c system_seca.c system_conax.c system_viaccess.c system_irdeto.c system_nagra.c st7.c crypto.c string.lib -M map
با اين فرمان به طور مثال به .bin بايد تبديلش كرد البته اين فرمانش خوب سورسش نيستش
ممنون ميشم اگه لينك فايل آموزشي در اين مورد يا راهنمايي مي تونيد بكنيد به بنده دريق نفرماييد

ممنون

[someone]

دوباره سلام.
فایلی که شما میخواید یه فایل باینری هست با ساختاری مشخص.
البته این فایل Header نداره چون در سطح پردازنده استفاده میشه. این فرمت جزو فرمت های آزاد هست.
میدونید برنامه از چه آدرسی باید شروع بشه؟
به نظرم بهتره شما سوالتون رو در این فروم مطرح کنید.
[ برای مشاهده لینک ، با نام کاربری خود وارد شوید یا ثبت نام کنید ]

[Peyman2003]

والا من فكر مي كنم اين زبان C خالي باشه به طور مثال:

//---------------------------------------------------------------------------
// This software is for educational purposes only. It should not be used
// to ilegally watch TV channels.
//---------------------------------------------------------------------------

#include "system_irdeto.h"
#include "emu.h"
#include <string.h>

const unsigned char table0[32] = {
0,1,2,3,4,5,6,7, 0,1,2,3,4,5,6,7,
0,1,2,3,4,5,6,7, 0,3,6,1,4,7,2,5
};

const unsigned char table1[256] = {
0xDA,0x26,0xE8,0x72,0x11,0x52,0x3E,0x46, 0x32,0xFF,0x8C,0x1E,0xA7,0xBE,0x2C,0x29,
0x5F,0x86,0x7E,0x75,0x0A,0x08,0xA5,0x21, 0x61,0xFB,0x7A,0x58,0x60,0xF7,0x81,0x4F,
0xE4,0xFC,0xDF,0xB1,0xBB,0x6A,0x02,0xB3, 0x0B,0x6E,0x5D,0x5C,0xD5,0xCF,0xCA,0x2A,
0x14,0xB7,0x90,0xF3,0xD9,0x37,0x3A,0x59, 0x44,0x69,0xC9,0x78,0x30,0x16,0x39,0x9A,
0x0D,0x05,0x1F,0x8B,0x5E,0xEE,0x1B,0xC4, 0x76,0x43,0xBD,0xEB,0x42,0xEF,0xF9,0xD0,
0x4D,0xE3,0xF4,0x57,0x56,0xA3,0x0F,0xA6, 0x50,0xFD,0xDE,0xD2,0x80,0x4C,0xD3,0xCB,
0xF8,0x49,0x8F,0x22,0x71,0x84,0x33,0xE0, 0x47,0xC2,0x93,0xBC,0x7C,0x3B,0x9C,0x7D,
0xEC,0xC3,0xF1,0x89,0xCE,0x98,0xA2,0xE1, 0xC1,0xF2,0x27,0x12,0x01,0xEA,0xE5,0x9B,
0x25,0x87,0x96,0x7B,0x34,0x45,0xAD,0xD1, 0xB5,0xDB,0x83,0x55,0xB0,0x9E,0x19,0xD7,
0x17,0xC6,0x35,0xD8,0xF0,0xAE,0xD4,0x2B, 0x1D,0xA0,0x99,0x8A,0x15,0x00,0xAF,0x2D,
0x09,0xA8,0xF5,0x6C,0xA1,0x63,0x67,0x51, 0x3C,0xB2,0xC0,0xED,0x94,0x03,0x6F,0xBA,
0x3F,0x4E,0x62,0x92,0x85,0xDD,0xAB,0xFE, 0x10,0x2E,0x68,0x65,0xE7,0x04,0xF6,0x0C,
0x20,0x1C,0xA9,0x53,0x40,0x77,0x2F,0xA4, 0xFA,0x6D,0x73,0x28,0xE2,0xCD,0x79,0xC8,
0x97,0x66,0x8E,0x82,0x74,0x06,0xC7,0x88, 0x1A,0x4A,0x6B,0xCC,0x41,0xE9,0x9D,0xB8,
0x23,0x9F,0x3D,0xBF,0x8D,0x95,0xC5,0x13, 0xB9,0x24,0x5A,0xDC,0x64,0x18,0x38,0x91,
0x7F,0x5B,0x70,0x54,0x07,0xB6,0x4B,0x0E, 0x36,0xAC,0x31,0xE6,0xD6,0x48,0xAA,0xB4
};

const unsigned char table2[256] = {
0x8E,0xD5,0x32,0x53,0x4B,0x18,0x7F,0x95, 0xBE,0x30,0xF3,0xE0,0x22,0xE1,0x68,0x90,
0x82,0xC8,0xA8,0x57,0x21,0xC5,0x38,0x73, 0x61,0x5D,0x5A,0xD6,0x60,0xB7,0x48,0x70,
0x2B,0x7A,0x1D,0xD1,0xB1,0xEC,0x7C,0xAA, 0x2F,0x1F,0x37,0x58,0x72,0x88,0xFF,0x87,
0x1C,0xCB,0x00,0xE6,0x4E,0xAB,0xEB,0xB3, 0xF7,0x59,0x71,0x6A,0x64,0x2A,0x55,0x4D,
0xFC,0xC0,0x51,0x01,0x2D,0xC4,0x54,0xE2, 0x9F,0x26,0x16,0x27,0xF2,0x9C,0x86,0x11,
0x05,0x29,0xA2,0x78,0x49,0xB2,0xA6,0xCA, 0x96,0xE5,0x33,0x3F,0x46,0xBA,0xD0,0xBB,
0x5F,0x84,0x98,0xE4,0xF9,0x0A,0x62,0xEE, 0xF6,0xCF,0x94,0xF0,0xEA,0x1E,0xBF,0x07,
0x9B,0xD9,0xE9,0x74,0xC6,0xA4,0xB9,0x56, 0x3E,0xDB,0xC7,0x15,0xE3,0x80,0xD7,0xED,
0xEF,0x13,0xAC,0xA1,0x91,0xC2,0x89,0x5B, 0x08,0x0B,0x4C,0x02,0x3A,0x5C,0xA9,0x3B,
0xCE,0x6B,0xA7,0xE7,0xCD,0x7B,0xA0,0x47, 0x09,0x6D,0xF8,0xF1,0x8B,0xB0,0x12,0x42,
0x4A,0x9A,0x17,0xB4,0x7E,0xAD,0xFE,0xFD, 0x2C,0xD3,0xF4,0xB6,0xA3,0xFA,0xDF,0xB8,
0xD4,0xDA,0x0F,0x50,0x93,0x66,0x6C,0x20, 0xD8,0x8A,0xDD,0x31,0x1A,0x8C,0x06,0xD2,
0x44,0xE8,0x23,0x43,0x6E,0x10,0x69,0x36, 0xBC,0x19,0x8D,0x24,0x81,0x14,0x40,0xC9,
0x6F,0x2E,0x45,0x52,0x41,0x92,0x34,0xFB, 0x5E,0x0D,0xF5,0x76,0x25,0x77,0x63,0x65,
0xAF,0x4F,0xCC,0x03,0x9D,0x0C,0x28,0x39, 0x85,0xDE,0xB5,0x7D,0x67,0x83,0xBD,0xC3,
0xDC,0x3C,0xAE,0x99,0x04,0x75,0x8F,0x97, 0xC1,0xA5,0x9E,0x35,0x0E,0x3D,0x1B,0x79
};

// -- cSystemIrd ---------------------------------------------------------------

int irdeto_ecm (const byte *source, byte *dw, byte *emu_buf){
byte *keys;
int keyIdx, key_end, retval=0;

keyIdx=*(source+9);
key_end= ((*(emu_buf+OPKEY_END))<<8)|(*(emu_buf+OPKEY_END+1 ));
keys=emu_buf+OPKEY_OFFSET;
while (keys <(emu_buf+key_end))
{
if((*keys==0x40)&&(*(keys+2)==keyIdx)) retval = irdeto_decode(source+6,keys+3,dw);
if(retval) break;
keys += OPKEY_LEN;
}
return retval;
}

int irdeto_EMM (const byte *source, byte *emu_buf) {
int length=source[5]+6-5; // 6 header bytes - 5 signature bytes
int data_pos=0, data_ind=0, j;
int provN=0, ident,ident_len, isPMKupdate=0;
byte date[2];
int len, param, index;
byte data[36], tmp[128], mkey[8], provid[IRD_PG_LEN+1];

/* begin decrypt */
provid[0]=0;
memset(data,0,sizeof(data));
for(index=6 ; index<length {
param=source[index++];
len =source[index++] & 0x3f;

switch(param) {
case 0x10: /* OP keys update */
case 0x50:
case 0x28: /* PMK update */
case 0x48:
case 0x68:
data_pos = index;
break;
case 0x00:
case 0x40:
memcpy(date,&source[index],2);
break;
}
index+=len;
}
if((!data_pos)) return 1; /* no key update in current EMM */
if (source[0]==0xC3) /* addressing by HexSerial */
{
ident=IRD_HSN_OFFSET;
ident_len=IRD_HSN_LEN;
isPMKupdate=1;
}
else
{
ident=IRD_PG_OFFSET;
ident_len=IRD_PG_LEN;
}

/* search provNum in the list of irdeto providers */
for(; provN < 9; provN++){
j=0;
for (;j<ident_len;j++)
{
if(*(emu_buf+ident+ident_len*provN+j) != *(source+1+j)) break;
}
if(j==ident_len) break; /* ident found */
if((j==2) && (!isPMKupdate)) break; /* ident for opkeys update - 2 bytes */
}
if (provN == 9) return 0; /* provider or hex serial not found in list */
if (source[0]==0xC3) /* addressing by HexSerial */
{

memcpy(mkey,emu_buf+IRD_HMK_OFFSET+IRD_HMK_LEN*pro vN,8); /* 0..7 bytes of HMK */
memcpy(date,emu_buf+IRD_HMK_OFFSET+IRD_HMK_LEN*pro vN+8,2); /* 8..9 bytes of HMK */
/* prepare PreXORed HMK */
date[0]=date[0]^mkey[0];
date[1]=date[1]^mkey[1];

}
else
memcpy(mkey,emu_buf+IRD_PMK_OFFSET+IRD_PMK_LEN*pro vN,8);
j=0;
/* chk for void master key */
for(;j<8;j++)
if(mkey[j]) break;
if(j==8) return false; /* key is null */

memcpy(tmp,source,length); /* Make a copy we can work on */
for(index=6 ; index<length {
param=tmp[index++];
len =source[index++] & 0x3f;

switch(param) {
case 0x10:
case 0x50:
for (j=0;j<len;j+=9) {
cIrdeto_SessionKeyCrypt(tmp+index+j+1,mkey,date);
memcpy(data+data_ind,tmp+index+j,9);
data_ind += 9;
}
break;
case 0x28: // pmk & provid update
case 0x48:
case 0x68:
cIrdeto_SessionKeyCrypt(tmp+index+2,mkey,date);
memcpy(data+data_ind,tmp+index+2,9);
if(len==0xD) {/* Prov ID update */
provid[0]=1;
memcpy(provid+1,tmp+index+10,3);
}
data_ind += 9;
}
index+=len;
}
if(!(cIrdeto_SignatureCheck(tmp,length,mkey,date,s ource+length))) return false;
if(isPMKupdate) {
j=0;
for (;j<8 ;j++)
{
if(emu_buf[provN*IRD_PMK_LEN+IRD_PMK_OFFSET+j] != data[j]) break;
}
if (j==8) return true; /* old key == new key */

/* insert new PMK */
memcpy(emu_buf+provN*IRD_PMK_LEN+IRD_PMK_OFFSET,da ta,8);
/* update prov ID */
if (provid[0])
memcpy(emu_buf+provN*IRD_PG_LEN+IRD_PG_OFFSET, provid+1,IRD_PG_LEN);
/* signal to MHW about update happend */
if(!emu_buf[SIG_UPD_OFFSET]){
emu_buf[SIG_UPD_OFFSET]=1;
emu_buf[KEY_IDX_OFFSET]=0x14;
}
return true;
}
/* else update opkeys */
j=0; /* number of new keys */
index=0;
while (data_ind)
{
if(update_keys(emu_buf,data+data_ind-9,(byte)(provN+1),IRDETO))
{
mkey[j]=data[data_ind-9]; /* index of new key */
j++;
}
data_ind -= 9;
index++;
}
/* signal to MHW about update happend */
if(!emu_buf[SIG_UPD_OFFSET]){
if((emu_buf[UPD_FLAG_OFFSET]==2)){
/* display only new keys */
emu_buf[SIG_UPD_OFFSET]=(byte)j;
while(j) {
j--;
switch (j)
{
case 0: emu_buf[KEY_IDX_OFFSET]=mkey[j];
break;
case 1: emu_buf[KEY_IDX2_OFFSET]=mkey[j];
break;
case 2: emu_buf[KEY_IDX3_OFFSET]=mkey[j];
break;
default: ;
}
}
}
else { /* all keys will be displayed */
emu_buf[SIG_UPD_OFFSET]=(byte)index;
emu_buf[KEY_IDX_OFFSET]=data[0];
index--;
if(index) {
emu_buf[KEY_IDX2_OFFSET]=data[9]; /* 2nd key */
index--;
if(index) emu_buf[KEY_IDX3_OFFSET]=data[18]; /* 3rd key */
}
}
}
return true;
}

// -- cIrdeto ------------------------------------------------------------------

void cIrdeto_Rotate( byte *p) {
byte temp,i;

temp = p[9];
for (i=9; i>0; i--) p[i] = (p[i] >> 1) | (p[i-1] << 7);
p[0] = (p[0] >> 1) | (temp << 7);
}

int irdeto_decode (const byte *source, const byte *key, byte *cw) {
int length=source[5]+6-5; // 6 header bytes - 5 signature bytes
int data_pos=0;
byte date[2];
int len, param, index;
byte data[16], tmp[256];
for(index=6 ; index<length {
param=source[index++];
len =source[index++] & 0x3f;

switch(param) {
case 0x78:
data_pos = index+2;
break;
case 0x00:
case 0x40:
memcpy(date,&source[index],2);
break;
}
index+=len;
}
if((!data_pos)) return -1;
memcpy(data,source+data_pos,16); /* copy the encrypted data*/

cIrdeto_SessionKeyCrypt(data,key,date);
cIrdeto_SessionKeyCrypt(data+8,key,date);
memcpy(tmp,source,length);
memcpy(tmp+data_pos, data, 16);
if(!(cIrdeto_SignatureCheck(tmp,length,key,date,&s ource[length]))) return false;

memcpy(cw,data,16); /* put the decrypted data to output buffer */
return true;
}

void cIrdeto_DecryptIrd (byte *data, byte *key, int rounds, int offset) {
int count,index;
byte d,k;

for (count=0; count<rounds; count++) {
#ifdef BCT1330
__asm { ldc 0xff; gintdis; };
#endif
index = count % 10;
#ifdef BCT1330
__asm { ldc 0xff; gintenb; };
#endif

if (index == 0) cIrdeto_Rotate(key);
k = key[index];

d = data[table0[(count & 0x0f) + offset]] ^ k;

if (k & 1) d = table1[d];
else d = table2[d];

data[table0[((count+1) & 0x0f) + offset]] ^= d;
}
}

void cIrdeto_SessionKeyCrypt (byte *data, const byte *key, byte *date) {
byte temp[10];

memcpy(temp,key,8);
temp[8]=((date[0])^(key[0]))&0xff;
temp[9]=((date[1])^(key[1]))&0xff;
cIrdeto_DecryptIrd(data,temp,128,16);
}

int cIrdeto_SignatureCheck (const byte *data,int length, const byte *key, byte *date,const byte *signature) {
byte temp[10], hash[8];
int rounds;
int i,j,k, tail;
for (i=0;i<8 ;i++)
hash[i]=0;
/* prepare key */
memcpy(temp,key,8);
temp[8]=date[0]^key[0];
temp[9]=date[1]^key[1];
k = 0x61; /* pad char */
i = 0;
while (length > 0)
{
tail = 0;
rounds = 40;
if(length < 8){
tail= 8 - length;
rounds = 104;
}
for (j=0; j<(8-tail); j++)
hash[j] ^= data[i+j]; /* xor hash with current block */
while (tail){
hash[8-tail] ^= k++;
tail--;
}
cIrdeto_DecryptIrd(hash,temp,rounds,0); /* decrypt hash */
i+= 8;
length -= 8;
cIrdeto_Rotate(temp); /* cIrdeto_Rotate key */
}
/*return memcmp(hash,signature,5)==0;*/
for(i=0;i<5;i++) if(hash[i] != signature[i]) return false;
return true;
}

اين يكي از اون فايل هاي سورس هستش در ضمن اون بخشي كه شما معرفي كردين گفتم مربوط به اين كار نميشه و مربوط به بخش C هستش

ممنون ميشم راهنمايي كنيد

[someone]

دوباره سلام.
منظور من این نبود که کد برنلمه رو بذارید.
ببینید دستگاه شما دارای یه microcontroller هست که باید program بشه. (معمولا AVR هست)
شما کافی مدل این micro رو بدونید و به دنبال programer اون بگردید.
اگه مدل micro رو داشته باشید به راحتی programer اون پیدا میشه و مطمئنا مشکلتون حل میشه.

[Peyman2003]

يعني واسه كامپايل امو سورس بايد اونو بدونيم بنده بعيد مي دونم اينطور باشه بازم از شما ممنونم بنده فقط مي خواستم اينو كامپايل به باينري فايل فقط همين