shc加密shell原理

        有人想加密自己的perl腳本，有人想加密自己的php，有人認(rèn)為bash編程其實(shí)不是真實(shí)的編程，由于它們的源代碼都是可見的，不像c程序那樣，1旦經(jīng)過編譯就不再可讀了...其實(shí)這是1種誤區(qū)，其1就是c語言編譯而成的平臺(tái)相干的elf或pe文件其實(shí)不是完全不可讀，只是對(duì)利用者不可讀，對(duì)黑客還是可以進(jìn)行良好反匯編的，其2既然利用者不是專業(yè)人士，那末bash，perl等代碼對(duì)他們也是不可讀的，我就曾完全看不懂echo abc的含義，其3就是perl也好，php也好，為什么要隱藏代碼呢？它們本身就是開源的，為什么要隱藏用它們寫成的代碼呢？這或許是受了windows的影響...
     不管怎樣，linux上提供了1個(gè)工具，那就是shc，它表面上看來是可以將bash編譯成2進(jìn)制的情勢(shì)，讓很多人更放心，可是用心的人仔細(xì)看過shc生成的代碼后就不會(huì)這么想了。事實(shí)上，如果shc真的能將1個(gè)bash腳本轉(zhuǎn)化為平臺(tái)相干的比如elf文件，那說明shc1定要理解bash的語法和關(guān)鍵字，而bash腳本中除使用bash內(nèi)置的命令外還可以調(diào)用任意的別的bash腳本和elf文件或perl程序，或其它的諸如Python程序，復(fù)雜非常的gcc也不過是理解了c的語法和關(guān)鍵字，期望1個(gè)shc理解上述的所有是不可能的，比如1個(gè)bash腳本中調(diào)用1個(gè)名字是a的程序，那末shc是將a鏈接進(jìn)來呢還是試圖理解程序a的意義然后用1個(gè)等價(jià)的c語言函數(shù)來代替呢，即便shc完全理解并可以處理了bash，也不能期望它能完全理解并能處理其它的程序或命令，這完全需要1種人工智能的方式來完成，及其復(fù)雜。
     下面我們用1個(gè)例子來講明shc真正做了些甚么，在分析代碼之前先說明答案，那就是shc將1個(gè)腳本用1段密鑰加密，算法是rc4，然后將加密后的數(shù)據(jù)和密鑰1起保存成1些數(shù)組，將解密，履行的程序代碼和上述的加密后的腳本和密鑰保存在1個(gè)c文件中，然后編譯這個(gè)c文件成1個(gè)可履行的elf文件(linux平臺(tái)上)，當(dāng)履行這個(gè)elf文件的時(shí)候，它會(huì)將加密的腳本數(shù)組數(shù)據(jù)解壓后然后履行之。下面代碼為證：
首先看1個(gè)簡(jiǎn)單的腳本文件
#########--simple.sh--#########
#!/bin/bash
echo 1
#########--end--#########
然后下面這個(gè)是通過shc -f simple.sh生成的c文件
#########--simple.sh.x.c--#########

static  long date = 0;
static  char mail[] = "Please contact your provider";
static  int  relax = 0;
typedef char pswd_t[474];
static  char pswd[] = //這里是密鑰
    "/367/026/340/141/333/034/344/067/103/155/241/324/354/345/056/253"
    ...
    "/125/300/045/273/061/114";
typedef char shll_t[10]; 
static  char shll[] = 
    "/142/255/213/016/240/111/146/224/304/270/321/256/255/314/174/025";
typedef char inlo_t[3];
static  char inlo[] = 
    "/325/233/105/366/212/116/244/207/272/345/242/161/132/177/134/253"
    "/125";
typedef char xecc_t[15];
static  char xecc[] = //這個(gè)數(shù)組用于混淆代碼，使得反匯編更難
    "/134/317/165/125/034/257/377/004/136/110/115/262/262/061/027/301"
    "/364/157/201/032/052/262/146/240/203";
typedef char lsto_t[1];
static  char lsto[] = 
    "/226/115/117/220/142";
#define TEXT_chk1    "ksjWFsdVl0EsE"
typedef char chk1_t[14];
static  char chk1[] = 
    "/204/245/141/023/147/245/253/366/274/130/145/064/011/134/043/213"
    "/011/226/037/345/232/026/336/045/371/102/333";
typedef char opts_t[1];
static  char opts[] = 
    "/237/314/241/274/355/321/275/002/027/251/044/063/164/302/246/070";
typedef char text_t[20];
static  char text[] = 
    "/150/207/154/160/250/073/136/042/050/230/310/252/236/366/061/372"
    "/300/123/332/054/043/133/223/055/362/262/022";
#define TEXT_chk2    "24JoASCmvuaP"
typedef char chk2_t[13];
static  char chk2[] = 
    "/272/250/101/200/054/030/146/004/003/063/006/172/157/110";
typedef char hide_t[4096];
...
static unsigned char state[256], indx, jndx;
...
void key(char * str, int len) //設(shè)置密鑰，rc4算法是1個(gè)流算法而不是諸如des之類的分組算法
{
    unsigned char tmp, * ptr = (unsigned char *)str;
    while (len > 0) {
        do {
            tmp = state[indx];
            jndx += tmp;
            jndx += ptr[(int)indx % len];
            state[indx] = state[jndx];
            state[jndx] = tmp;
        } while (++indx);
        ptr += 256;
        len -= 256;
    }
}
void rc4(char * str, int len) //rc4函數(shù)解密了數(shù)據(jù)，這些數(shù)據(jù)是在shc中被加密的
{
    unsigned char tmp, * ptr = (unsigned char *)str;
    jndx = 0;
    while (len > 0) {
        indx++;
        tmp = state[indx];
        jndx += tmp;
        state[indx] = state[jndx];
        state[jndx] = tmp;
        tmp += state[indx];
        *ptr ^= state[tmp];
        ptr++;
        len--;
    }
}
...
int chkenv(int argc)
{
...//這個(gè)函數(shù)主要用于混淆，使用1個(gè)環(huán)境變量控制該程序被履行兩次，實(shí)際上是用exec的方式被履行的。
}
char * xsh(int argc, char ** argv)  //解密相干數(shù)據(jù)，終究履行解密的腳本
{
    char buff[512];
    char * scrpt;
    int ret, i, j;
    char ** varg;
    state_0();
    key(pswd, sizeof(pswd_t));  //設(shè)置密鑰，注意，shc每次履行的時(shí)候生成的密鑰都是不同的，由于rc4是序列流加密算法，如果密鑰相同，那末同1段明文將得到一樣的密文，這樣就1破皆破，因此每次密鑰都隨機(jī)生成。
    rc4(shll, sizeof(shll_t));  //解密結(jié)果為命令解釋器：/bin/bash
    rc4(inlo, sizeof(inlo_t));  //解密結(jié)果為bash選項(xiàng)：-c，提示腳本在后續(xù)的字符串中而不是在文件中
    ...
    rc4(lsto, sizeof(lsto_t));
    rc4(chk1, sizeof(chk1_t));
    if (strcmp(TEXT_chk1, chk1))  //到此為止驗(yàn)證1下解密是不是正確，由于我們事前不知道明文，因此密文解密后的結(jié)果也就無從比對(duì)從而證明其解密后明文是正確的，由于事前安排1個(gè)隨機(jī)的字符串序列常量，shc中將其依照加密的順序加密并保存，如果依照相反的順序解密到爾后的數(shù)據(jù)和保存的字符串相等，就說明解密到此為止是爭(zhēng)取的，注意，流算法對(duì)加解密順序有著嚴(yán)格的要求，決不能亂序。
        return "location has changed!";
    ret = chkenv(argc);
    if (ret < 0)
        return "abnormal behavior!";
    varg = (char **)calloc(argc + 10, sizeof(char *));
    if (ret) {  //這個(gè)ret判斷純潔是為了混淆，為了讓該程序再履行1次...
        if (!relax && key_with_file(shll))
            return shll;
        rc4(opts, sizeof(opts_t));
        rc4(text, sizeof(text_t));
        rc4(chk2, sizeof(chk2_t));  //依照流算法，如果前面的text，即腳本本身解密出錯(cuò)，此處的chk2是正確的可能性也不大，不過個(gè)人認(rèn)為此處使用帶有初始化向量的分組算法更好。
        if (strcmp(TEXT_chk2, chk2))
            return "shell has changed!";
        if (sizeof(text_t) < sizeof(hide_t)) {
            scrpt = malloc(sizeof(hide_t));
            memset(scrpt, (int) ' ', sizeof(hide_t));
            memcpy(&scrpt[sizeof(hide_t) - sizeof(text_t)], text, sizeof(text_t));
        } else {
            scrpt = text;    /* Script text */
        }
    }
    ...  //省略處理命令行參數(shù)的混淆進(jìn)程
    j = 0;
    varg[j++] = argv[0];        
    if (ret && *opts)
        varg[j++] = opts;    
    if (*inlo)
        varg[j++] = inlo;    
    varg[j++] = scrpt;        
    if (*lsto)
        varg[j++] = lsto;    
    i = (ret > 1) ? ret : 0;    
    while (i < argc)
        varg[j++] = argv[i++];    
    varg[j] = 0;            
    execvp(shll, varg); //履行解密后腳本
    return shll;
}

int main(int argc, char ** argv)
{
    xsh(argc, argv);
    ...
}
終究證明，shc并未將bash腳本編譯成2進(jìn)制，而僅僅是加密了它，保存了加密后的它，然后在履行的時(shí)候解密之，履行之。

生活不易，碼農(nóng)辛苦
如果您覺得本網(wǎng)站對(duì)您的學(xué)習(xí)有所幫助,可以手機(jī)掃描二維碼進(jìn)行捐贈(zèng)