有人想加密自己的perl脚本，有人想加密自己的php，有人认为bash编程并不是真正的编程，因为它们的源代码都是可见的，不像c程序那样，一旦经过编译就再也不可读了...其实这是一种误区，其一就是c语言编译而成的平台相关的elf或者pe文件并不是完全不可读，只是对于应用者不可读，对于黑客还是可以进行良好反汇编的，其二既然应用者不是专业人士，那么bash，perl等代码对于他们也是不可读的，我老婆就曾经完全看不懂echo abc的含义，其三就是perl也好，php也好，为何要隐藏代码呢？它们本身就是开源的，为何要隐藏用它们写成的代码呢？这也许是受了windows的影响...
不管怎样，linux上提供了一个工具，那就是shc，它表面上看来是可以将bash编译成二进制的形式，让很多人更放心，可是用心的人仔细看过shc生成的代码后就不会这么想了。事实上，如果shc真的能将一个bash脚本转化为平台相关的比如elf文件，那说明shc一定要理解bash的语法和关键字，而bash脚本中除了使用bash内置的命令外还可以调用任意的别的bash脚本和elf文件或者perl程序，或者其它的诸如python程序，复杂无比的gcc也不过是理解了c的语法和关键字，指望一个shc理解上述的所有是不可能的，比如一个bash脚本中调用一个名字是a的程序，那么shc是将a链接进来呢还是试图理解程序a的意义然后用一个等价的c语言函数来代替呢，即使shc完全理解并可以处理了bash，也不能指望它能完全理解并能处理其它的程序或者命令，这完全需要一种人工智能的方式来完成，及其复杂。
下面我们用一个例子来说明shc真正做了些什么，在分析代码之前先说明答案，那就是shc将一个脚本用一段密钥加密，算法是rc4，然后将加密后的数据和密钥一起保存成一些数组，将解密，执行的程序代码以及上述的加密后的脚本以及密钥保存在一个c文件中，然后编译这个c文件成一个可执行的elf文件(linux平台上)，当执行这个elf文件的时候，它会将加密的脚本数组数据解压后然后执行之。下面代码为证：
首先看一个简单的脚本文件
#########--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算法是一个流算法而不是诸如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)
{
...//这个函数主要用于混淆，使用一个环境变量控制该程序被执行两次，其实是用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是序列流加密算法，如果密钥相同，那么同一段明文将得到同样的密文，这样就一破皆破，因此每次密钥都随机生成。
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)) //到此为止验证一下解密是否正确，由于我们事先不知道明文，因此密文解密后的结果也就无从比对从而证明其解密后明文是正确的，由于事先安排一个随机的字符串序列常量，shc中将其按照加密的顺序加密并保存，如果按照相反的顺序解密到此后的数据和保存的字符串相等，就说明解密到此为止是争取的，注意，流算法对加解密顺序有着严格的要求，决不能乱序。
return "location has changed!";
ret = chkenv(argc);
if (ret < 0)
return "abnormal behavior!";
varg = (char **)calloc(argc + 10, sizeof(char *));
if (ret) { //这个ret判断纯粹是为了混淆，为了让该程序再执行一次...
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);
...
}
不管怎样，linux上提供了一个工具，那就是shc，它表面上看来是可以将bash编译成二进制的形式，让很多人更放心，可是用心的人仔细看过shc生成的代码后就不会这么想了。事实上，如果shc真的能将一个bash脚本转化为平台相关的比如elf文件，那说明shc一定要理解bash的语法和关键字，而bash脚本中除了使用bash内置的命令外还可以调用任意的别的bash脚本和elf文件或者perl程序，或者其它的诸如python程序，复杂无比的gcc也不过是理解了c的语法和关键字，指望一个shc理解上述的所有是不可能的，比如一个bash脚本中调用一个名字是a的程序，那么shc是将a链接进来呢还是试图理解程序a的意义然后用一个等价的c语言函数来代替呢，即使shc完全理解并可以处理了bash，也不能指望它能完全理解并能处理其它的程序或者命令，这完全需要一种人工智能的方式来完成，及其复杂。
下面我们用一个例子来说明shc真正做了些什么，在分析代码之前先说明答案，那就是shc将一个脚本用一段密钥加密，算法是rc4，然后将加密后的数据和密钥一起保存成一些数组，将解密，执行的程序代码以及上述的加密后的脚本以及密钥保存在一个c文件中，然后编译这个c文件成一个可执行的elf文件(linux平台上)，当执行这个elf文件的时候，它会将加密的脚本数组数据解压后然后执行之。下面代码为证：
首先看一个简单的脚本文件
#########--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算法是一个流算法而不是诸如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)
{
...//这个函数主要用于混淆，使用一个环境变量控制该程序被执行两次，其实是用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是序列流加密算法，如果密钥相同，那么同一段明文将得到同样的密文，这样就一破皆破，因此每次密钥都随机生成。
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)) //到此为止验证一下解密是否正确，由于我们事先不知道明文，因此密文解密后的结果也就无从比对从而证明其解密后明文是正确的，由于事先安排一个随机的字符串序列常量，shc中将其按照加密的顺序加密并保存，如果按照相反的顺序解密到此后的数据和保存的字符串相等，就说明解密到此为止是争取的，注意，流算法对加解密顺序有着严格的要求，决不能乱序。
return "location has changed!";
ret = chkenv(argc);
if (ret < 0)
return "abnormal behavior!";
varg = (char **)calloc(argc + 10, sizeof(char *));
if (ret) { //这个ret判断纯粹是为了混淆，为了让该程序再执行一次...
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脚本编译成二进制，而仅仅是加密了它，保存了加密后的它，然后在执行的时候解密之，执行之。
本文转自 dog250 51CTO博客，原文链接:http://blog.51cto.com/dog250/1271780
