shc加密shell原理

        有人想加密自己的perl腳本，有人想加密自己的php，有人認為bash編程其實不是真實的編程，由于它們的源代碼都是可見的，不像c程序那樣，1旦經過編譯就不再可讀了...其實這是1種誤區，其1就是c語言編譯而成的平臺相干的elf或pe文件其實不是完全不可讀，只是對利用者不可讀，對黑客還是可以進行良好反匯編的，其2既然利用者不是專業人士，那末bash，perl等代碼對他們也是不可讀的，我就曾完全看不懂echo abc的含義，其3就是perl也好，php也好，為什么要隱藏代碼呢？它們本身就是開源的，為什么要隱藏用它們寫成的代碼呢？這或許是受了windows的影響...
     不管怎樣，linux上提供了1個工具，那就是shc，它表面上看來是可以將bash編譯成2進制的情勢，讓很多人更放心，可是用心的人仔細看過shc生成的代碼后就不會這么想了。事實上，如果shc真的能將1個bash腳本轉化為平臺相干的比如elf文件，那說明shc1定要理解bash的語法和關鍵字，而bash腳本中除使用bash內置的命令外還可以調用任意的別的bash腳本和elf文件或perl程序，或其它的諸如Python程序，復雜非常的gcc也不過是理解了c的語法和關鍵字，期望1個shc理解上述的所有是不可能的，比如1個bash腳本中調用1個名字是a的程序，那末shc是將a鏈接進來呢還是試圖理解程序a的意義然后用1個等價的c語言函數來代替呢，即便shc完全理解并可以處理了bash，也不能期望它能完全理解并能處理其它的程序或命令，這完全需要1種人工智能的方式來完成，及其復雜。
     下面我們用1個例子來講明shc真正做了些甚么，在分析代碼之前先說明答案，那就是shc將1個腳本用1段密鑰加密，算法是rc4，然后將加密后的數據和密鑰1起保存成1些數組，將解密，履行的程序代碼和上述的加密后的腳本和密鑰保存在1個c文件中，然后編譯這個c文件成1個可履行的elf文件(linux平臺上)，當履行這個elf文件的時候，它會將加密的腳本數組數據解壓后然后履行之。下面代碼為證：
首先看1個簡單的腳本文件
#########--simple.sh--#########
#!/bin/bash
echo 1
#########--end--#########
然后下面這個是通過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[] = //這個數組用于混淆代碼，使得反匯編更難
    "/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) //設置密鑰，rc4算法是1個流算法而不是諸如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函數解密了數據，這些數據是在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)
{
...//這個函數主要用于混淆，使用1個環境變量控制該程序被履行兩次，實際上是用exec的方式被履行的。
}
char * xsh(int argc, char ** argv)  //解密相干數據，終究履行解密的腳本
{
    char buff[512];
    char * scrpt;
    int ret, i, j;
    char ** varg;
    state_0();
    key(pswd, sizeof(pswd_t));  //設置密鑰，注意，shc每次履行的時候生成的密鑰都是不同的，由于rc4是序列流加密算法，如果密鑰相同，那末同1段明文將得到一樣的密文，這樣就1破皆破，因此每次密鑰都隨機生成。
    rc4(shll, sizeof(shll_t));  //解密結果為命令解釋器：/bin/bash
    rc4(inlo, sizeof(inlo_t));  //解密結果為bash選項：-c，提示腳本在后續的字符串中而不是在文件中
    ...
    rc4(lsto, sizeof(lsto_t));
    rc4(chk1, sizeof(chk1_t));
    if (strcmp(TEXT_chk1, chk1))  //到此為止驗證1下解密是不是正確，由于我們事前不知道明文，因此密文解密后的結果也就無從比對從而證明其解密后明文是正確的，由于事前安排1個隨機的字符串序列常量，shc中將其依照加密的順序加密并保存，如果依照相反的順序解密到爾后的數據和保存的字符串相等，就說明解密到此為止是爭取的，注意，流算法對加解密順序有著嚴格的要求，決不能亂序。
        return "location has changed!";
    ret = chkenv(argc);
    if (ret < 0)
        return "abnormal behavior!";
    varg = (char **)calloc(argc + 10, sizeof(char *));
    if (ret) {  //這個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，即腳本本身解密出錯，此處的chk2是正確的可能性也不大，不過個人認為此處使用帶有初始化向量的分組算法更好。
        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 */
        }
    }
    ...  //省略處理命令行參數的混淆進程
    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進制，而僅僅是加密了它，保存了加密后的它，然后在履行的時候解密之，履行之。

生活不易，碼農辛苦
如果您覺得本網站對您的學習有所幫助,可以手機掃描二維碼進行捐贈