Detecção de vírus por meio de python baseada em "ClamAv" (2) - explicação detalhada do controle pyClamd clamd

Apresente o uso geral e os métodos comuns do módulo pyClamd.

Podemos usar python para o controle clamde, assim, controlar ClamAv, a necessidade de introduzir módulos de terceiros: pyClamd.

O uso de pyClamdcontrole clamdantes, deve ser instalado corretamente com clamdo clamav. Você pode consultar o artigo anterior:

• Detecção de vírus por meio de python com base em "ClamAv" (0) - Visão geral da tecnologia básica

• Detecção de vírus via python baseada em "ClamAv" (1) - compilação e instalação do código-fonte ClamAv

1. Introdução ao pyClamd

PyClamdSim clamdinterface python. clamdÉ ClamAvo processo daemon das ferramentas antivírus.

Ao usar pyClamd, podemos adicionar a função de detecção de vírus ao programa python de uma forma simples e eficiente.

Dois, instale o pyClamd

Use a pipinstalação expressa:

pip install pyClamd

Documentação oficial do módulo:

http://xael.org/pages/pyclamd-en.html

tip1: Amigos que falam inglês podem ler os documentos oficiais diretamente. Claro, você também pode ler os documentos oficiais rapidamente após ler este artigo.

Dica2: pypiNa pyClamdúltima atualização em 2017, o autor pode não continuar a manter este projeto, e 且行且珍惜 ele ~

Três, use

3.1 Exemplos de métodos comuns

pyClamdFornece alguns métodos comuns, incluindo teste simples clamdse está disponível, verificação de fluxo de bytes, verificação de arquivo / pasta, etc. A seguir, testaremos esses métodos no terminal Python.

A primeira etapa: Abra o terminal de linha de comando python3:

[root@程序员的一天 home]# python3
Python 3.7.4 (default, Sep 18 2020, 14:36:11) 
[GCC 4.8.5 20150623 (Red Hat 4.8.5-39)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 
>>> 

Etapa 2: Importar pyClamd:

>>> import pyclamd
>>> 

A terceira etapa: instanciar um clamdobjeto de controle:

>>> cd = pyclamd.ClamdAgnostic()
>>> 

dica: este é o primeiro método de instanciação e os outros dois métodos serão introduzidos posteriormente, incluindo a conexão por meio da rede clamd.

Etapa 4: teste clamdse ele pode ser conectado:

Se a conexão for bem-sucedida, retorne True.

>>> cd = pyclamd.ClamdAgnostic()
>>> cd.ping()
True
>>> 

Etapa 5: verifique a ClamAvversão:

>>> cd.version()
'ClamAV 0.103.0/25929/Sun Sep 13 21:53:46 2020'
>>> 

Etapa 6: Gerar amostras de vírus de teste:

pyClamdFornece um EICAR()método que pode gerar rapidamente amostras de vírus para teste. Vamos primeiro dar uma olhada no conteúdo específico da amostra:

>>> cd.EICAR()
b'X5O!P%@AP[4\\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*'
>>> 

dica: você pode ver que a saída é uma string de bytes python. Embora seja uma amostra de vírus, não o executamos, por isso é inofensivo. Não se preocupe com o envenenamento da máquina! !

Etapa 7: Fluxo de scan_stream()detecção do método bytes:

scan_stream()O método é usado para detectar o bytesfluxo.

Incluindo fluxos de bytes da rede, ele também pode ser detectado. Por exemplo, na frente do sistema de caixa de correio, todos os fluxos de bytes de email são detectados para detectar e eliminar emails maliciosos.

Podemos usar EICAR()métodos para gerar fluxos de bytes para testar:

>>> cd.scan_stream(cd.EICAR())
{'stream': ('FOUND', 'Win.Test.EICAR_HDB-1')}
>>> 
>>> cd.scan_stream(b'pythonbytes')
>>> 
>>> cd.scan_stream(b'pythonbytes') is None
True
>>> 

dica: se um vírus for detectado, retorne ao dicionário, caso contrário, retorne Nenhum.

Etapa 8: scan_file()Verificação de arquivo / pasta:

scan_file()Método para detectar arquivos ou pastas.

scan_file()Método, assim que um vírus for detectado, a varredura terminará e o primeiro resultado de vírus será retornado imediatamente.

Se você ClamAvusar o método de compilação do código-fonte para instalar, ClamAVhaverá uma testpasta no pacote de descompactação do código-fonte , que contém todas ClamAvas amostras de teste de vírus fornecidas:

[root@程序员的一天 clamAv]# ls
clamav-0.103.0  clamav-0.103.0.tar.gz
[root@程序员的一天 clamAv]# 
[root@程序员的一天 clamAv]# ls clamav-0.103.0/test
clam.7z           clam_cache_emax.tgz  clam.exe.bz2          clam.impl.zip       clam.mail       clam-pespin.exe  clam-upx.exe     Makefile.am
clam.arj          clam.chm             clam.exe.html         clam_IScab_ext.exe  clam-mew.exe    clam-petite.exe  clam-v2.rar      Makefile.in
clam-aspack.exe   clam.d64.zip         clam.exe.mbox.base64  clam_IScab_int.exe  clam.newc.cpio  clam.ppt         clam-v3.rar      README
clam.bin-be.cpio  clam.ea05.exe        clam.exe.mbox.uu      clam_ISmsi_ext.exe  clam-nsis.exe   clam.sis         clam-wwpack.exe
clam.bin-le.cpio  clam.ea06.exe        clam.exe.rtf          clam_ISmsi_int.exe  clam.odc.cpio   clam.tar.gz      clam-yc.exe
clam.bz2.zip      clam.exe             clam.exe.szdd         clam.iso            clam.ole.doc    clam.tnef        clam.zip
clam.cab          clam.exe.binhex      clam-fsg.exe          clamjol.iso         clam.pdf        clam-upack.exe   Makefile
[root@程序员的一天 clamAv]# 

dica: Não examine levemente a pasta continuamentetest , porque todas são amostras de vírus, a varredura será muito lenta (talvez possa ser usada para testar o desempenho de varredura do ClamAv). Você pode especificar um teste de arquivo específico entre eles ou gerar um novo teste de arquivo de amostra.

Podemos usar esses arquivos para teste ou podemos usar EICAR()métodos para gravar strings de bytes de vírus em arquivos para gerar novos arquivos de amostra para teste. Aqui eu uso para gerar um novo arquivo para teste.

tmpGere EICARe NO_EICARarquive no diretório :

>>> void = open('/tmp/EICAR','w').write(cd.EICAR().decode())
>>> void = open('/tmp/NO_EICAR','w').write('no virus in this file')
>>> 

dica: aqui, os arquivos e são /tmpgerados no diretório , que representam arquivos de amostra de vírus e arquivos normais, respectivamente.EICARNO_EICAR

Passe o caminho do arquivo específico para o scan_file()método de verificação do arquivo :

>>> cd.scan_file('/tmp/EICAR')
{'/tmp/EICAR': ('FOUND', 'Win.Test.EICAR_HDB-1')}
>>> 
>>> cd.scan_file('/tmp/NO_EICAR') is None
True
>>> 

dica: Assim que o vírus for detectado, retorne imediatamente ao dicionário, que keyé o arquivo específico e valueo resultado da detecção. Caso contrário, ele retorna None.

Da mesma forma, você também pode passar um caminho de pasta como um scan_file()parâmetro de método para verificação de pasta :

>>> cd.scan_file('/tmp')      
{'/tmp/EICAR': ('FOUND', 'Win.Test.EICAR_HDB-1')}
>>> 

dica: Depois que o primeiro arquivo de vírus é verificado, a verificação termina e o resultado é retornado.

Etapa 9: contscan_file()Verificação de arquivos / pastas:

contscan_file()Método, também usado para verificação de arquivo / pasta.

Diferente da scan_file()verificação do método, o contscan_file()método retornará todos os arquivos de vírus detectados depois que toda a pasta for verificada.

Para facilitar o teste, /tmpgeramos outro EICAR_1arquivo de amostra no diretório . Em seguida, verifique o /tmpdiretório:

>>> void = open('/tmp/EICAR_1','w').write(cd.EICAR().decode())
>>> 
>>> cd.contscan_file('/tmp/')
{'/tmp/EICAR': ('FOUND', 'Win.Test.EICAR_HDB-1'),  '/tmp/EICAR_1': ('FOUND', 'Win.Test.EICAR_HDB-1')}
>>> 
>>> cd.scan_file('/tmp') 
{'/tmp/EICAR': ('FOUND', 'Win.Test.EICAR_HDB-1')}
>>> 

dica: você pode ver que o scan_file()método retorna apenas um resultado e contscan_file()irá verificar todo o diretório de arquivos e retornar todos os arquivos de ameaças detectados.

O mesmo contscan_file()também pode ser usado para verificação de arquivo único:

>>> cd.contscan_file('/tmp/EICAR_1')
{'/tmp/EICAR_1': ('FOUND', 'Win.Test.EICAR_HDB-1')}
>>> 
>>> cd.contscan_file('/tmp/EICAR')  
{'/tmp/EICAR': ('FOUND', 'Win.Test.EICAR_HDB-1')}
>>> 

3.2 Resumo dos métodos de pyClamdconexãoclamd

Ao compilar, instalar ClamAve configurar o código-fonte clamd, apresentamos: Se você deseja permitir a clamdcomunicação com outros aplicativos, ative pelo menos uma das seguintes opções:

# 本地套接字通信
LocalSocket
# 网络套接字通信
TCPSocket

Por exemplo, configure assim:

# LocalSocket /tmp/clamd.socket
TCPSocket 3310

dica: comunique-se na porta 3310 via soquete TCP.

Da mesma forma, pyClamdcom a clamdcomunicação, esses dois métodos também são correspondentes.

Em pyClamd, duas classes são fornecidas para conexão clamd. Eles são:

ClamdUnixSocket()
ClamdNetworkSocket()

Acima, usamos ClamdAgnostic()um método de embalagem selecionado automaticamente.

Dica: Deve-se notar que não importa qual método está conectado, todos os métodos comuns são os mesmos após a criação de um objeto instanciado.

A seguir, iremos apresentá-los separadamente.

3.2.1. ClamdAgnostic()Método

ClamdAgnostic()Método, o método de conexão é selecionado automaticamente.

ClamdAgnostic()Método, primeiro tente se ClamdUnixSocketconectar clamd. Se falhar, tente
se ClamdNetworkSocketconectar. Finalmente, o objeto instanciado correspondente é retornado.

O ClamdAgnostic()método em pyclamd.py é definido como:

dica: É o módulo principal pyclamd.pyda pyClamdbiblioteca, podemos até colocar esse arquivo diretamente no programa sem usar a pipinstalação pyClamd.

############################################################################

def ClamdAgnostic():
    """
    Tries to connect to clamd using ClamdUnixSocket or if it fails, tries
    with ClamdNetworkSocket and return the corresponding object.
    Of course, it tries to connect with default settings...
    """
    try:
        # Create object for using unix socket
        cd = ClamdUnixSocket()
    except ConnectionError:
        # if failed, test for network socket
        try:
            cd = ClamdNetworkSocket()
        except ConnectionError:
            raise ValueError("could not connect to clamd server either by unix or network socket")
    return cd

############################################################################

Se estivermos na mesma máquina e controlados por pythonclamd , esse método será suficiente. Os exemplos de instanciação específicos são os seguintes:

>>> cd = pyclamd.ClamdAgnostic()
>>> 

3.2.2, ClamdUnixSocket()classe

ClamdUnixSocket()Use soquetes locais para comunicação de processo no mesmo computador.

Precisa clamd.confconfigurar LocalSocketopções:

# 指定本地套接字路径
LocalSocket /tmp/clamd.socket

ClamdUnixSocket()Parte do código-fonte é o seguinte:

class ClamdUnixSocket(_ClamdGeneric):
    """
    Class for using clamd with an unix socket
    """
    def __init__(self, filename=None, timeout=None):
        """
        Unix Socket Class initialisation

        filename (string) : unix socket filename or None to get the socket from /etc/clamav/clamd.conf or /etc/clamd.conf
        timeout (float or None) : socket timeout
        """

        # try to get unix socket from clamd.conf
        if filename is None:
            for clamdpath in ['/etc/clamav/clamd.conf', '/etc/clamd.conf']:
                if os.path.isfile(clamdpath):
                    break
            else:
                raise ConnectionError('Could not find clamd unix socket from /etc/clamav/clamd.conf or /etc/clamd.conf')

Como você pode ver, ClamdUnixSocket()ele pode receber dois parâmetros de entrada:

# 指定本地套接字
filename
# 设置连接超时
timeout

Se, no mesmo computador, quisermos especificar um soquete local para controlar clamd, podemos instanciar a ClamdUnixSocket()classe:

>>> cd = pyclamd.ClamdUnixSocket(filename='/tmp/clamd.socket', timeout=10)
>>> 

dica: O soquete local correspondente precisa existir.

3.2.3, ClamdNetworkSocket()classe

ClamdNetworkSocket()Classe, permitindo controle via sockets de rede clamd.

Precisa clamd.confconfigurar TCPSocketopções:

# 配置监听端口
TCPSocket 3310
# 配置监听地址，默认为0.0.0.0
TCPAddr 127.0.0.1

ClamdNetworkSocket()Parte do código-fonte é o seguinte:

class ClamdNetworkSocket(_ClamdGeneric):
    """
    Class for using clamd with a network socket
    """
    def __init__(self, host='127.0.0.1', port=3310, timeout=None):
        """
        Network Class initialisation
        host (string) : hostname or ip address
        port (int) : TCP port
        timeout (float or None) : socket timeout
        """

Como você pode ver, ClamdNetworkSocket()três parâmetros de entrada podem ser recebidos:

# 指定clamd监听地址
host
# 指定clamd监听端口
port
# 设置连接超时
timeout

Através ClamdNetworkSocket(), podemos controlar remotamente através de máquinas e através de sockets de rede clamd. Instancie a ClamdNetworkSocket()classe:

>>> cd = pyclamd.ClamdNetworkSocket(host='127.0.0.1', port=3310, timeout=10)
>>> 

Neste ponto, a pyClamdintrodução acabou!
FIM.

Alguns dos meus artigos serão publicados na conta pública pela primeira vez. Os leitores do Wechat podem pesquisar por: [ Dia do Programador ], amigos interessados ​​podem seguir e apoiar, obrigado!

Cada atenção e elogio são um grande apoio e incentivo. Por fim, muito obrigado pela leitura.