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进制，而仅仅是加密了它，保存了加密后的它，然后在履行的时候解密之，履行之。

生活不易，码农辛苦
如果您觉得本网站对您的学习有所帮助,可以手机扫描二维码进行捐赠