linux s prot scan

[c]/
TCP Syn port scanner
By:sincoder
Blog:[url]www.sincoder.com[/url]
*/

#include <stdio.h> //printf
#include <string.h> //memset
#include <stdlib.h> //for exit(0);
#include <sys/socket.h>
#include <errno.h> //For errno – the error number
#include <pthread.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <netdb.h>    //hostend
#include <arpa/inet.h>
#include <netinet/tcp.h>    //Provides declarations for tcp header
#include <netinet/ip.h>    //Provides declarations for ip header
#define  msg(fmt,arg…) printf(fmt,##arg);fflush(stdout)

const char *logFileName = "Result.txt";
int log_fd = 0;  // for log
int bIsLogRet = 0 ;//is log scan result
uint32_t g_bind_ip = 0; // 绑定的本地ip
uint8_t g_port_list[0xFFFF] = {0}; //要扫描的端口相应的位会被置1
volatile int g_IsTimeToShutDown = 0;

enum IpSingType
{
    IP_TYPE_RANGE,
    IP_TYPE_SINGLE
};

typedef struct _IPSting
{
    enum IpSingType type;
    uint32_t start_ip;
    uint32_t end_ip;
}IPString;

IPString *g_ScanIpList = NULL;
uint32_t  g_IpCount = 0;

#pragma pack(push,1)

typedef struct _ip_header
{
    unsigned char  h_lenver; //4位首部长度+4位IP版本号
    unsigned char  tos; //8位服务类型TOS
    unsigned short total_len; //16位总长度(字节)
    unsigned short ident; //16位标识
    unsigned short frag_and_flags; //3位标志位
    unsigned char  ttl; //8位生存时间 TTL
    unsigned char  proto; //8位协议 (TCP, UDP 或其他)
    unsigned short checksum; //16位IP首部校验和
    uint32_t   sourceIP; //32位源IP地址
    uint32_t   destIP; //32位目的IP地址
}IP_HEADER;

typedef struct _tcp_header //定义TCP首部
{
    unsigned short th_sport; //16位源端口
    unsigned short th_dport; //16位目的端口
    uint32_t   th_seq; //32位序列号
    uint32_t   th_ack; //32位确认号
    unsigned char  th_lenres; //4位首部长度/6位保留字
    unsigned char  th_flag; //6位标志位
    unsigned short th_win; //16位窗口大小
    unsigned short th_sum; //16位校验和
    unsigned short th_urp; //16位紧急数据偏移量
}TCP_HEADER;

typedef struct _psd_header //定义TCP伪首部
{
    unsigned long saddr; //源地址
    unsigned long daddr; //目的地址
    char mbz;
    char ptcl; //协议类型
    unsigned short tcpl; //TCP长度
}PSD_HEADER;

#pragma pack(pop)

/*
Get ip from domain name
*/
uint32_t hostname_to_ip(char * hostname)
{
    struct hostent *he;
    struct in_addr **addr_list;
    int i;
    //msg("%s:%s\n",__func__,hostname);
    if ( (he = gethostbyname( hostname ) ) == NULL)
    {
        // get the host info
        //herror("gethostbyname");
        //use inet_ntoa
        return inet_addr(hostname);
    }

addr_list = (struct in_addr **) he->h_addr_list;

for(i = 0; addr_list[i] != NULL; i++)
    {
        //Return the first one;
        return (*addr_list[i]).s_addr;
        //return inet_ntoa(*addr_list[i]) ;
    }
    return 0;
}

unsigned short checkSum(void * buffer, int size)
{
    unsigned long cksum=0;
    while (size >1) {
        cksum += *(unsigned short *)buffer;
        size -= sizeof(unsigned short);
        buffer = (char *)buffer + sizeof(unsigned short);
    }
    if (size) cksum += *(unsigned char*) buffer;
    cksum = (cksum >> 16) + (cksum&0xffff);
    cksum += (cksum >> 16);
    return (unsigned short) (~cksum);
}

int    buildSynPacket(char * buf, u_long saddr, u_long sport, u_long daddr, u_long dport)
{
    int    len = 0;
    IP_HEADER ip_header;
    TCP_HEADER tcp_header;
    PSD_HEADER psd_header;
    //填充IP首部
    ip_header.h_lenver=(4<<4 | sizeof(ip_header)/sizeof(unsigned long));
    //高四位IP版本号,低四位首部长度
    ip_header.total_len=htons(sizeof(IP_HEADER)+sizeof(TCP_HEADER)); //16位总长度(字节)
    ip_header.ident=1; //16位标识
    ip_header.frag_and_flags = 0; //3位标志位
    ip_header.ttl = 128; //8位生存时间TTL
    ip_header.proto = IPPROTO_TCP; //8位协议(TCP,UDP…)
    ip_header.checksum = 0; //16位IP首部校验和
    ip_header.sourceIP = saddr; //32位源IP地址
    ip_header.destIP = daddr; //32位目的IP地址

//填充TCP首部
    tcp_header.th_sport = sport; //源端口号
    tcp_header.th_lenres=(sizeof(TCP_HEADER)/4<<4|0); //TCP长度和保留位
    tcp_header.th_win = htons(0x4000);

//填充TCP伪首部(用于计算校验和,并不真正发送)
    psd_header.saddr=ip_header.sourceIP;
    psd_header.daddr=ip_header.destIP;
    psd_header.mbz=0;
    psd_header.ptcl=IPPROTO_TCP;
    psd_header.tcpl=htons(sizeof(tcp_header));

tcp_header.th_dport = dport; //目的端口号
    tcp_header.th_ack=0; //ACK序列号置为0
    tcp_header.th_flag=2; //SYN 标志
    tcp_header.th_seq = sport -1; //SYN序列号随机
    tcp_header.th_urp=0; //偏移
    tcp_header.th_sum=0; //校验和
    //计算TCP校验和,计算校验和时需要包括TCP pseudo header
    memcpy(buf,&psd_header,sizeof(psd_header));
    memcpy(buf+sizeof(psd_header),&tcp_header,sizeof(tcp_header));
    tcp_header.th_sum=checkSum(buf,sizeof(psd_header)+sizeof(tcp_header));

//计算IP校验和
    memcpy(buf,&ip_header,sizeof(ip_header));
    memcpy(buf+sizeof(ip_header),&tcp_header,sizeof(tcp_header));
    memset(buf+sizeof(ip_header)+sizeof(tcp_header),0,4);
    len=sizeof(ip_header)+sizeof(tcp_header);
    ip_header.checksum=checkSum(buf,len);

//填充发送缓冲区
    memcpy(buf,&ip_header,sizeof(ip_header));

return len;
}

const char *TakeOutStringByChar(const char *Source,char *Dest, int buflen, char ch)
{
    int i;

if(Source == NULL)
        return NULL;

const char *p = strchr(Source, ch);
    while(*Source == ‘ ‘)
        Source++;
    for(i=0; i<buflen && *(Source+i) && *(Source+i) != ch; i++)
    {
        Dest[i] = *(Source+i);
    }
    if(i == 0)
        return NULL;
    else
        Dest[i] = ‘\0’;

const char *lpret = p ? p+1 : Source+i;

while(Dest[i-1] == ‘ ‘ && i>0)
        Dest[i—1] = ‘\0’;

return lpret;
}

void InsertIntoIpList(enum IpSingType type,uint32_t start_ip,uint32_t end_ip)
{
//    msg("%s:%x %x\n",__func__,start_ip,end_ip);
    if(!g_ScanIpList)
    {
        g_ScanIpList = (IPString *)malloc(sizeof(IPString));
        g_ScanIpList->end_ip = end_ip;
        g_ScanIpList->start_ip = start_ip;
        g_ScanIpList->type = type;
        ++g_IpCount ;
        return ;
    }
    else
    {
        IPString *pTmp = (IPString *)malloc((g_IpCount + 1) * sizeof(IPString));
        memcpy(pTmp,g_ScanIpList,g_IpCount * sizeof(IPString));
        free(g_ScanIpList);
        g_ScanIpList = pTmp;
        g_ScanIpList[g_IpCount].end_ip = end_ip;
        g_ScanIpList[g_IpCount].start_ip = start_ip;
        g_ScanIpList[g_IpCount].type = type;
        ++g_IpCount;
        return;
    }
};

void DestoryIpList()
{
    free(g_ScanIpList);
    g_ScanIpList = NULL;
}

/*
典型的用法

uint32_t start = inet_addr("192.168.122.1");
  uint32_t end = inet_addr("192.168.123.122");
  uint32_t ip = start;
  do
  {
        msg("%s\n",inet_ntoa(*(struct in_addr *)&ip));

} while ((ip = GetNextIpInRange(ip,end)));
*/
uint32_t GetNextIpInRange(uint32_t start,uint32_t end)
{
    uint32_t pos = start;
    pos = htonl(start )+1;
    if(pos > htonl(end))
    {
        return 0;
    }
    pos = htonl(pos);
    return pos;
}

int  ParseIpString(const char *IpString)
{
    const char *p = IpString;
    char *slash = NULL;
    char buff[256];
    struct hostent * hostInfo ;

while((p = TakeOutStringByChar(p,buff,256,’,’)))
    {
        char startIpStr[256]={0};
        uint32_t start,end,range,submask;
        start = end = range = submask = 0;
        enum IpSingType type;
        //msg("%s  \n",buff);
        if((slash = strchr(buff,’/’))) //12.12.12.12/24
        {
            strncpy(startIpStr, buff, slash – buff );
            int bit = atoi(slash+1);
            range = 0xFFFFFFFF >> bit;
            submask = 0xFFFFFFFF << (32 – bit);
            uint32_t ip = hostname_to_ip(startIpStr);
            if(!ip)
                continue;
            start = (ip & ntohl(submask)) + ntohl(1);
            end = (ip & ntohl(submask)) + ntohl(range-1);
            type = IP_TYPE_RANGE;
        }
        else if((slash = strchr(buff,’-‘)))  //12.12.12.12 – 12.12.12.122
        {
            strncpy(startIpStr, buff, slash – buff );
            start = hostname_to_ip(startIpStr);
            end = hostname_to_ip(slash+1);
            type = IP_TYPE_RANGE;

}else //12.12.12.12
        {
            start = hostname_to_ip(buff);
            end = 0xFFFFFFFF;
            type = IP_TYPE_SINGLE;
        }
        if ((start || end) && (htonl(start) < htonl(end)))
        {
            InsertIntoIpList(type,start,end);
            //char endIpStr[256];
            //strcpy(endIpStr, inet_ntoa(*(struct in_addr *)&end));
            //strcpy(startIpStr, inet_ntoa(*(struct in_addr*)&start));
            //msg("start : %s end :%s \n",startIpStr,endIpStr);
        }
    }
}

void  GetNextScanIp(int (*callback)(uint32_t,void *),void *lparam)
{
    uint32_t idx;
    if(!g_ScanIpList)
    {
        msg("%s Ip list not init\n",__func__);
        return ;
    }
    for (idx = 0 ;idx < g_IpCount;idx ++)
    {
        switch(g_ScanIpList[idx].type)
        {
        case IP_TYPE_RANGE:
            {
                //msg("%s:%x %x\n",__func__,g_ScanIpList[idx].start_ip,g_ScanIpList[idx].end_ip);
                uint32_t ip = g_ScanIpList[idx].start_ip;
                do
                {
                    callback(ip,lparam);
                } while ((ip = GetNextIpInRange(ip,g_ScanIpList[idx].end_ip)));
            }
            break;
        case IP_TYPE_SINGLE:
            {
                callback(g_ScanIpList[idx].start_ip,lparam);
            }
            break;
        default:
            msg("%s:%s",__func__,"unknow ip type \n");
            break;
        }
    }
}

void ParsePortString(const char *ScanPortString)
{
    const char *p = ScanPortString;
    char buff[256];
    int idx;
    while((p = TakeOutStringByChar(p,buff,256,’,’)))
    {
        uint16_t start,end;
        char *slash = NULL;
        char port[64] = {0};
        if((slash = strchr(buff,’-‘)))  //122-1111
        {
            strncpy(port,buff, slash – buff );
            start = atoi(port);
            end = atoi(slash + 1);
            if(end < start)
            {
                continue;
            }
            for (idx = start;idx<=end;idx++)
            {
                g_port_list[idx] = 1;
            }
        }else
        {
            start = atoi(buff);
            g_port_list[start] = 1;
        }
    }
}

uint32_t  GetScanPortCount()
{
    int idx = 0 ;
    uint32_t count = 0 ;
    for (idx = 0 ;idx < 0xFFFF;idx++)
    {
        if(g_port_list[idx])
            ++count;
    }
    return count;
}

int help(char * app) //argc 3 4
{
    printf("Usage:   %s [Ip String] Ports [/Save]\n", app);
    printf("Example: %s 12.12.12.12-12.12.12.254 80\n", app);
    printf("Example: %s 12.12.12.12 1-65535\n", app);
    printf("Example: %s 12.12.12.12/24 1-65535\n", app);
    printf("Example: %s 12.12.12.12-12.12.12.254 21,80,3389\n", app);
    return printf("Example: %s 12.12.12.12,12.12.12.122 21,80,3389-22233  /Save\n", app);
}

/*
Method to sniff incoming packets and look for Ack replies
*/
void * receive_ack( void *ptr )
{
    //Start the sniffer thing
    start_sniffer();
}

void process_packet(unsigned char* buffer, int size)
{
    //Get the IP Header part of this packet
    char log_buff[256];
    int len = 0;
    IP_HEADER *iphdr = (IP_HEADER *)buffer;
    TCP_HEADER *tcphdr = NULL;
    struct sockaddr_in source,dest;

if(iphdr->proto = IPPROTO_TCP)
    {
        /* retireve the position of the tcp header */
        int ip_len = (iphdr->h_lenver & 0xf) * 4;
        tcphdr = (TCP_HEADER *) (buffer + ip_len);
        if(tcphdr->th_flag == 18)  //ACK+SYN
        {
            len = sprintf(log_buff,"%-16s%-8uOPEN                                           \n",inet_ntoa(*(struct in_addr *)&iphdr->sourceIP),ntohs(tcphdr->th_sport));
            if(bIsLogRet)
            {
                write(log_fd,log_buff,len);
            }
            msg("%s",log_buff);
        }
    }
}

int start_sniffer()
{
    int sock_raw = 0; // raw socket for sniff
    int saddr_size , data_size;
    struct sockaddr saddr;

unsigned char buffer[65536];// = (unsigned char *)malloc(65536); //Its Big!

//Create a raw socket that shall sniff
    sock_raw = socket(AF_INET , SOCK_RAW , IPPROTO_TCP);

if(sock_raw < 0)
    {
        printf("Socket Error\n");
        fflush(stdout);
        return 1;
    }

saddr_size = sizeof saddr;
    while(!g_IsTimeToShutDown)
    {
        //Receive a packet
        data_size = recvfrom(sock_raw , buffer , 65536 , 0 , &saddr , &saddr_size);
        if(data_size <0 )
        {
            msg("%s","Recvfrom error , failed to get packets\n");
            return 1;
        }
        //Now process the packet
        process_packet(buffer , data_size);
    }
    close(sock_raw);
//    msg("%s","Sniffer finished.");
    return 0;
}

uint32_t get_local_ip (uint32_t ip)
{
    char buffer[100];
    int sock = socket ( AF_INET, SOCK_DGRAM, 0);
    int dns_port = 53;
    int err;
    struct sockaddr_in serv;
    struct sockaddr_in name;
    socklen_t namelen = sizeof(name);
    //msg("%s:%s  \n",__func__,inet_ntoa(*(struct in_addr *)&ip));
    memset( &serv, 0, sizeof(serv));
    memset( &name, 0, sizeof(name));
    serv.sin_family = AF_INET;
    serv.sin_addr.s_addr = ip;//inet_addr(HostName);
    //memcpy(&serv.sin_addr.s_addr,&ip,4);
    serv.sin_port = htons( dns_port );
    err = connect( sock , (const struct sockaddr*) &serv , sizeof(serv) );
    err = getsockname(sock, (struct sockaddr*) &name, &namelen);
    //const char *p = inet_ntop(AF_INET, &name.sin_addr, buffer, 100);
    if(-1 == err)
    {
        msg("%s:%s",__func__,"getsockname failed\n");
    }
    close(sock);
    return name.sin_addr.s_addr;
}

int ip_callback(uint32_t ip,void *lparam)
{
    static uint32_t seed = 0x2b;
    uint32_t idx = 0;
    int len = 0;
    int s  = (int)lparam;
    struct sockaddr_in addr;
    char buff[0x100];
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = ip;
    if(!g_bind_ip)
    {
        g_bind_ip = get_local_ip(ip);
        msg("bind on ip : %s \n",inet_ntoa(*(struct in_addr *)&g_bind_ip));
    }
    for (idx = 0 ; idx < 0xFFFF;idx ++)
    {
        if(g_port_list[idx])
        {
            addr.sin_port = htons(idx);
            msg("scanning %16s:%u\r",inet_ntoa(*(struct in_addr *)&ip),idx);
            srandom(seed++);
            len = buildSynPacket(buff,g_bind_ip,htons(random() % 0xFFFF),ip,addr.sin_port);
            if ( sendto (s,buff,len, 0 , (struct sockaddr *) &addr, sizeof (addr)) < 0)
            {
                 printf ("Error sending syn packet. Error number : %d . Error message : %s \n" , errno , strerror(errno));
                return 0;
            }
        }
    }
    return 1;
}

int main(int argc, char *argv[])
{
    int s;
    uint32_t ScanPortCount = 0;
    msg("%s","s syn port scanner\nBY:sincoder\nBlog:[url]www.sincoder.com[/url]\n");
    if(argc < 3 )
    {
        help(argv[0]);
        return -1;
    }
    ParseIpString(argv[1]);
    ParsePortString(argv[2]);
    ScanPortCount = GetScanPortCount();
    if(!ScanPortCount)
    {
        msg("%s","No Ports !!\n");
        return -1;
    }else
    {
        msg("About to scan %u ports\n",ScanPortCount);
    }
    if(argc == 4)
    {
        bIsLogRet = 1;
        log_fd = open(logFileName,O_RDWR|O_APPEND|O_CREAT,S_IRUSR|S_IWUSR);
        if(log_fd == -1)
        {
            msg("Can not create log file .\n");
        }
    }
    //Create a raw socket
    s = socket (AF_INET, SOCK_RAW , IPPROTO_TCP);
    if(s < 0)
    {
        msg("%s","Error creating socket. Error number : %d . Error message : %s \n" , errno , strerror(errno));
        return -1;
    }
    //IP_HDRINCL to tell the kernel that headers are included in the packet
    int one = 1;
    const int *val = &one;
    if (setsockopt (s, IPPROTO_IP, IP_HDRINCL, val, sizeof (one)) < 0)
    {
        printf ("Error setting IP_HDRINCL. Error number : %d . Error message : %s \n" , errno , strerror(errno));
        exit(0);
    }
    msg("%s","Starting sniffer thread…\n");
    pthread_t sniffer_thread;
    g_IsTimeToShutDown = 0;
    if( pthread_create( &sniffer_thread , NULL ,  receive_ack , NULL) < 0)
    {
        msg("%s","Could not create sniffer thread. Error number : %d . Error message : %s \n" , errno , strerror(errno));
        goto clean;
    }
    GetNextScanIp(ip_callback,(void *)s);
    sleep(2);
    g_IsTimeToShutDown = 1;
    ip_callback(g_bind_ip,(void *)s); //send a packet to myself ,let me exit ^_^
    msg("%s","scan over!!                             \n");
    pthread_join( sniffer_thread , NULL);
clean:
    DestoryIpList();
    if(bIsLogRet)
        close(log_fd);
    close(s);
    return 0;
}[/c]

服务器被罗马尼亚黑客入侵

今天头告诉我有一台服务器有 大量的sshscan进程 有个叫test的用户问我怎么回事

我上去服务器一看果然有好几十个进程 首先将进程关掉 pkill sshscan

su test 看有一下日志记录没有 history后 果然还有

 1  w
2  uname -a
3  cat /proc/cpuinfo
4  passwd
5  w
6  php -v
7  perl -v
8  ifconfig
9  cat /proc/cpuinfo
10  wget http://download.microsoft.com/download/win2000platform/SP/SP3/NT5/EN-US/W2Ksp3.exe
11  rm -rf W2Ksp3.exe
12  uname -a
13  cd /tmp
14  ls -a
15  cd .ICE-unix/
16  ls -a
17  cd ..
18  ls -a
19  cd ar/tmp
20  ls -a
21  cd /usr/games
22  ls -a
23  cd ar/spool
24  ls -a
25  cd /dev/shm
26  ls -a
27  cd /tmp
28  ls -a
29  cd /test
30  wget http://download.microsoft.com/download/win2000platform/SP/SP3/NT5/EN-US/W2Ksp3.exe
31  rm -rf W2Ksp3.exe
32  wget http://download.microsoft.com/download/win2000platform/SP/SP3/NT5/EN-US/W2Ksp3.exe
33  rm -rf W2Ksp3.exe
34  ls -a
35  php -v
36  perl -v
37  ps -x
38  w
39  uname -a
40  cat /proc/cpuinfo
41  pkill scanssh
42  top
43  ls
44  ls
45  pwd
46  exit
47  cd
48  ls
49  top
50  ls
51  exit
52  history
百度了一个 W2Ksp3.exe 结果发现好多人都被这家伙搞过 下载这个EXE文件 应该是用来测试网速的 怎么能在LINUX上运行呢
上面这段记录不完整不知道为什么
这家伙应该共登陆了三次
找一下 这个sshscan是什么吧 find / -name sshscan 竟然藏的挺严实的
看了一下里面都是些什么东西
my.zip是我刚才将这些目录打包的
a是一个脚本
#!/bin/bash
if [ $# != 1 ]; then
echo ” usage: $0 <b class>”
exit;
fi
rm -rf bios.txt
echo -e “fly with me :X”
././pscan2 $1 22
echo “continue…”
sleep 2
mv scan.log bios.txt
./scanssh
passfile里面是几万条弱口令密码
sshscan就是攻击程序了
trueusers.txt 应该是扫描的结果我试了两个结果没上去 不知道为什么
这个IP来自罗马尼亚
经常百度的资料来看
这个黑客确实来自这里 他应该扫描了好多的服务器
http://www.hengha.me/blog/2010/08/07/intrude-by-accident.xhtml
上面也有这个人的详细分析
杯具呀 竟然被人入侵了 郁闷心情无以言表
这些入侵主要是因为我用了test和密码test的用户 全测试邮件接收情况  结果没有删除 网络真是不安全啊

说说我的博客近况

这些天一直没有怎么更新博客 一来 人都是比较懒 刚开始做的时候心头比较足 后面就会松懈 不过也比较忙 一直在写一个采集的程序 终于到现在也把网站给弄好 www.lovemm.org 期待百度的收录吧

前些天博客 中了PHPDDOS 真是郁闷  其实这个情况应该很久了 因为以前有时候打开网站偶尔会出现 HTTP  500 错误  我以为是 主机自己的问题 不以为然 终于有一天 网站死活打不开了 只要联系优易主机的客服  经过漫长的等待 确定我的空间中毒了 大量发包 我在我VPS上下载本空间的文件搭建WORDPRESS 结果折腾了一大晚上装不上 后来也知道是这个原因  还好 vps 刚整 我又把vps 重装了系统 恢复了 本机的空间杂七杂八的 换血重装的 基本上算是恢复原来的面貌了病毒直接都进入了数据库中了 优易主机的客服终于给搞好了 但是现在主机不能使用打开http的函数  所以空间现在不能更新 我比较懒不想手动呵呵 Akimet 插件也无法使用 垃圾留言一大堆 终于今天找了个小插件验证一下 留言 手动删除一堆堆的 累死人不说 还误删 希望优易主机把这个功能打开

http://anfirst.cn/wp-content/uploads/2009/10/wp-validcode.zip 这是我现在用的留言小插件 先暂时观察一下 不行的话再换掉呵呵

 

谈一下食品安全网

今日看到新闻 有关 掷出窗外的 报道 是一个 民间有关搜集几年来有关不安全食品的网站  心中一想完了 我自己有这个想法应该从去年也就有了 一直在忙于考试而不得 就在前几天准备搜集一些有关安全食品的报道放在wordpress中 但是考虑到食品安全的报道网上都是大量重复的而不利于SEO,而暂时搁浅  目前的网址在这 http://www.rootsir.com/food/  只能说有想法就赶快做 不然别人会很快做起来的  也不得不说别人网站12年就上线了 期间想了几个域名也迟迟没下手注册

eatingsafty
eatsafety
myfoodsafe
thesafefood.com
mysafefood.cn
foodslife.net
foodhome.org
thesafefood.com

不知道现在还在不呀 呵呵

我是 四月份才有时间去考虑这个问题  总体上还是落后了 仅以此纪念夭折中的一个想法吧  有想法一定要去做呀 不要瞻前顾后 ~~~

360开机提速砖家

在QQ图看到一张这样的图片   很久没有笑了 看到了 还是忍不住的笑了

您这次开机共用了1年6个月 您 的电脑此次开机速度前无古人,后无来者!360安全卫士已经彻底对您的电脑失去贪心,请立即将360相关软件从您的电脑卸载,以免有损我们的名誉。

在这里随便说一下我对360的看法,3Q大战过几次了,作为一个2B网民,我是静观其战。我本人使用的电脑是不喜欢有360相关的软件的,以前上大学的时候经常装360可谓是不太懂啊,上大学好像也用了四年IE内核的浏览器,360就一流氓,360浏览器我使用过几次用的让我崩溃,360一贯使用吓唬电脑小白的手段,采取偷,默认,强,强制安装不少软件,流氓的出身的保安仍然难改其本色。

第一次面试

毕业快两年了,第一次面试?好像听起来有点假的感觉,怎么会没有面试过,除非没有找过工作那种。今天是我第一次面试别人,这地方一共两个C语言程序员,上级就是老大,老大看了一个人的简历过来面试估计不理想,于是扔给我让我面试,于是不得已经我就装B上阵了。
这兄弟08级今年毕业的,沈阳航空航天大学的,虽然这学院没听过但是有个航空航天觉的很NB啊,看看人家北航。看了看简历,写的比我的还烂了,怪不得老大扔给我让我面试。说来这兄弟就来了,开场让他做个自我介绍,他说过来应聘C语言的,他说他会JAVA ,ANDORID ..etc 哥就郁闷啦……  这位仁兄还参加了 X同科技的培训 说了问做过啥项目吧 说LINUX 一个项目 好你就是一个一个增删改查 问也没问出来东西。还做过一个新浪微博的登陆接口(好像是JAVA做的)没问。问下线程和进程,回答给答反了,问下数据结构,什么是AVL,给答成图的最小生成树了,让写个二分查找算法,我等了十分钟写的啥都不是杯具浪费哥时间啊,你说你不会啊,我还在那给媳妇聊QQ等。看人家不容易的,都参加了培训怎么也得一万块钱啊,问C语言问题吧,内存中堆和栈的区别,答成数据结构的队列和栈了,栈举出可能会有哪些原因,不知道,问用过LINUX gcc没,会写makefile么 答用 A.C文件链接一个B.A库 命令应该怎么写 答不会 问独立将A.C生成一个可执行文件怎么写 这个会 问用过VIM没 熟悉么 答熟悉 问在VI命令中如何将本行复制到下一行 不会 问如何删除一行 答不会 时间不知不觉过的如此之快 时间没掌握好 老大在QQ上十分钟前已经催我了(当时没看到,面完后看到的),再问个吧 给你一个P指针变量指向一个字符串 如何求得这个字符串的长度 提示用哪个库函数 答不知道 我真晕了 再问个 字符串COPY用哪个函数 答用STR copy函数 好吧就这样吧 我让他出去等等 我给老大说太差了 然后直接给人事说让他回去了
这位兄弟基本实在不咋的,我觉得进来也干不了活啊,不知道怎么过的简历那观,估计那个90年的HR MM一点不懂技术吧。面试了好长时间,我觉得已经给他很多机会了,刚毕业找个工作也不容易,可惜很多都不会,我发现他基本会那些网上流行的C语言面试题,估计这兄弟背了背也是一知半解,会背但是不知道什么意思。算是从C语言 基本数据结构 LINUX开发环境都了解了一下,本来想问C++的 基本什么都不会也就不问了。还是希望这位兄弟把基础打牢固,就算参加了培训也没好好把握机会,一路走好吧。仅以此记我的第一次面试别人经历。

2010-01-01 削发明志(Hair cut for my firm determination )

公元后201011日星期五的下午,今天元旦么,不就是新的一年么,刚刚理发去了O(_)O哈哈~~不是去做道士OR和尚去了,我的广大海内外女粉丝们就不用伤心AND失望了啊。

一直嫌头发长的快,过个一个月多点又要去一次理发店,纽结啊。

­新的一年,新的开始,又寄寓了新的希望,从做起,努力是关键!

2010元旦写于西南大学

送给自己

我们都过于缈小,我们慢慢地走进现实的社会,社会的阶梯曲折又过于陡峭,儿时的梦想,我们还能记住多少,还有多大的勇气去面对去实现,在为梦想前进的路上,梦想好像离我们越来越远!
离校不过两个月而已,但是真的是很怀念以前简简单单的生活,十多年来,自己只需要读书学习,没有更多的想法,什么都不用想。现如今,自己面临的选择 太多太多,需要放弃的要放弃,需要坚持的要坚持。有人说,聪明的人不“幸福”,年轻的我们面对愚蠢和聪明两者,后者只能是我们不二的选择。
我想我是应该慢慢长大了,以前小时候认为只要你努力的付出,就会实现你所想要的。后来,愈来发现很多时候付出和收获,也是经常不成正比的。现在发现,自 己的力量是那么的有限,我把握不了这个世界趋势,把握不了别人的思维和行为,把握不住自己的未来。我唯一能把握的就是自己信念,我就是自己的全部,不求凡 事但所愿,但求全身心的付出过程,加油!
此刻写给自己,给未来的自己留下一些痕迹,如果有一天走的迷路了,迷茫了,希望通过以前留下的痕迹找回真实的自我,希望自己保持一颗纯真的心。

写于 重庆 2010.9.8 晚