python 检测白名单外的非法进程的进程树和链接信息

本文链接：https://blog.csdn.net/u011085172/article/details/77478524

之前服务器被hacker留下后门，会在服务器起脚本与hacker的机器进行连接发送信息，后面在处理完后加防时写了个检测非法进程的脚本

一般来说，自己的服务器上的进程是固定的，而且在这里只是检查有网络活动的进程

1、进程白名单

首先拟定了针对自己服务器上进程的白名单文件pro_white，内容如下：

sshd
mysqld
zabbix_agentd
/usr/sbin/sshd
cupsd
dhclient
rpcbind
rpc.statd
/usr/libexec/postfix
/usr/sbin/dnsmasq
secu-tcs-agent
ssh

将服务器上有进行网络活动的合法进程写到这份白名单文件中

2、获取当前有网络活动的进程，返回进程列表

本文章是通过lsof这个命令来获取进行网络活动的进程信息： /usr/sbin/lsof -i -nP ，将获取到的信息处理成自己想要的：

结果如下：

这行命令执行结果有三列，第一列为进程号，第二列为父进程号，后面的为进程的shell命令

用python将结果处理为这样的数据格式：{进程号：{‘ppid’:父进程号,'shellcommand':shell命令}}

###获取当前有网络活动的进程，返回进程字典
        def getCurProcDict(self):
                n = runCmd(real=1)
                cmd = '/usr/sbin/lsof -i -nP |/usr/bin/tr -s [:space:] |/bin/cut -d " " -f 2 |/usr/bin/tail -n +2 |/bin/sort |/usr/bin/uniq|/usr/bin/xargs /bin/ps -fp |/usr/bin/tr -s [:space:] |/bin/cut -d " " -f 2,3,9- | /bin/sed "1d"'
                execute = n.run(cmd) 
                if not execute[0]:
                        sa.error(u"执行lsof失败: %s" % execute[2])                                                 
                else:                
                        curAllProcList = execute[2].strip().split('\n')
                        curAllProcDict = {}
                        for proc in curAllProcList:
                                procinfo = proc.split(' ')
                                tempDict = {}
                                tempDict['ppid'] = procinfo[1]
                                tempDict['shellditail'] = ' '.join(procinfo[2:])
                                curAllProcDict[procinfo[0]] = tempDict
                        return curAllProcDict

3、获取链接信息

执行命令：/usr/sbin/lsof -i -nP |/usr/bin/tr -s [:space:] |/bin/cut -d " " -f 2,9 | /bin/sed "1d" | /bin/sed -e "s/*://g"

结果如下：

第一列为进程号，后面的为进程的连接信息

用python处理成这样的数据格式：{进程号:连接信息}

##获取链接信息              
        def getConnDict(self):
                n = runCmd(real=1)
                cmd = '/usr/sbin/lsof -i -nP |/usr/bin/tr -s [:space:] |/bin/cut -d " " -f 2,9 | /bin/sed "1d" | /bin/sed -e "s/*://g"'
                execute = n.run(cmd)
                if not execute[0]:
                        sa.error(u"执行lsof失败: %s" % execute[2])                                                 
                else:                
                        connList = execute[2].strip().split('\n')
                        connDict = {}              
                        for item in connList:
                                connDict[item.split(' ')[0]] = ' '.join(item.split(' ')[1:])

                        return connDict

4、获取所有进程信息

执行命令：/bin/ps -ef | /usr/bin/tr -s [:space:] | /bin/cut -d " " -f 2,3,8-

结果如下：

用python处理成这样的数据格式： {进程号：{‘ppid’:父进程号,'shellcommand':shell命令}}

#获取所有进程信息
	def getAllPs(self):
                n = runCmd(real=1)
                cmd = '/bin/ps -ef | /usr/bin/tr -s [:space:] | /bin/cut -d " " -f 2,3,8-'
                execute = n.run(cmd)
                if not execute[0]:
                        sa.error(u"执行lsof失败: %s" % execute[2])                                                 
                else:                
                        AllPsList = execute[2].strip().split('\n')
                        AllPsDict = {}
                        for proc in AllPsList:
                                procinfo = proc.split(' ')
                                tempDict = {}
                                tempDict['ppid'] = procinfo[1]
                                tempDict['shellditail'] = ' '.join(procinfo[2:])
                                AllPsDict[procinfo[0]] = tempDict   
                        return AllPsDict

5、解析白名单文件

        def getWhiteProcList(self):
                with open("%s/proc_white" % self.path,"r") as f:
                        x = f.readlines()
                return x

以上几个函数，都是用于获取数据并进行格式化的函数

6、通过进程号获取父进程

这是个递归函数，函数返回的字典结构：{进程号:连接信息}

##获取父进程
       def getPProc(self,ppid,procdict1,allpsdict):
                if ppid != '0' and ppid != '1':
                        procdict1[ppid] = allpsdict[ppid]['shellditail']
                        self.getPProc(allpsdict[ppid]['ppid'],procdict1,allpsdict)
                return procdict1

这个函数会在父进程号为0或1（init进程）时停止递归

7、检测主函数

接下来的代码，会用到以上的所有函数，对每个有网络活动的进程进行检查，与白名单进行对比，确定是否为非法进程：

def checkMain(self):
                invalidproc = []
                curprocdict = self.getCurProcDict()
                whiteproclist = self.getWhiteProcList()
                conndict = self.getConnDict()
                for pid,curproc in curprocdict.items():
                        isnormalproc = False
                        #sa.info(curproc['shellditail'])
			#每个进程与白名单比对
                        for whiteproc in whiteproclist:
                                for item in whiteproc.strip().split(' '):
                                        isre = True #是否匹配到
                                        
                                        if curproc['shellditail'].find(item) == -1:
                                                #没有匹配到
                                                isre = False
                                                break
                                #匹配到
                                if isre:
                                        isnormalproc = True
                                        break
                        if not isnormalproc:
                                
                                procdict1 = {pid:curproc['shellditail']}
                                procdict1 = self.getPProc(curproc['ppid'],procdict1,allpsdict)
                                procdict1 = sorted(procdict1.items(),key=lambda item:item[0])
				#去掉本地连接
                                m = re.search('(.*)->(.*)', conndict[pid])
                                if m:
                                        ip1 = m.group(1).split(':')[0]
                                        ip2 = m.group(2).split(':')[0]
                                        if ip1 and ip2 in ['127.0.0.1']:
                                                continue

                                if curproc['shellditail'].strip() not in self.totallist.values():
                                        #if not self.totallist.has_key(pid):
                                        #if curproc['shellditail'] not in self.totallist:
                                        sa.error(u"检测到非法进程：进程ID： %s 具体进程: %s" % (pid,curproc['shellditail']))
                                        sa.error(u"pstree: %s" % str(procdict1))
                                        #self.totallist.append(curproc['shellditail'])
                                        
                                        self.totallist[pid] = curproc['shellditail'].strip()
                                        invalidproc.append(u'连接信息：%s' % conndict[pid])
        				sa.error(u'连接信息：%s' % conndict[pid])
                                        for item in procdict1:
                                                invalidproc.append(item[0]+" "+json.dumps(item[1]))
                                        #else:
                                        #        self.totallist[pid]
                                                
                                        
                if len(invalidproc)>2:
                        sa.error('检测到的非法进程列表: %s' % str(self.totallist))
                        
                        p = PostReport('\n'.join(invalidproc).replace(">","-"),u'非法进程检测')
                        sendMsg = p.postRes()
                        if int(sendMsg['state']) == 1:
                                sa.info(u"检测非法进程发送告警接口成功")                       
                        else:
                                sa.error(u"检测非法进程发送告警接口异常")

整个过程如上，文章省略了日志函数sa和执行命令函数runcmd的代码，这个大家可以按照自己的方式来就行，重点是逻辑

哈哈