cómo utilizar la api de virustotal

Cómo utilizar la API de VirusTotal con python

1 Shares
1
0
0

Seguro que más de una vez has utilizado los servicios del sitio de comprobación de archivos online virustotal.com para comprobar la existencia de elementos maliciosos en los archivos, o para probar tus propios desarrollos. El popular servicio cuenta con una API gratuita, con la que consideraremos trabajar en Python en el artículo de hoy.

utilizar la guía api de virustotal
Sitio web del escáner en línea virustotal.com

Para poder utilizar la interfaz del software de VirusTotal sin restricciones, es necesario obtener una clave, que cuesta una fuerte suma de dinero – los precios comienzan en 700 euros al mes. La clave no se entregará a un individuo aunque esté dispuesto a pagar esta cantidad de dinero.

Pero no hay que desesperar, ya que el servicio ofrece funciones básicas de forma gratuita con algunas restricciones en el número de solicitudes: no más de dos por minuto. No es una maravilla, pero se puede vivir con ello.

La API de VirusTotal no debe ser utilizada en productos o servicios comerciales y proyectos que puedan causar un daño directo o indirecto a la industria antivirus.

Obtención de la clave API de VirusTotal

Así que lo primero que hay que hacer es registrarse en la web de VirusTotal. No hay problema, seguro que lo consigues. Después de registrarte, puedes encontrar la clave de acceso seleccionando la opción de menú API key.

api de virustotal con python
Esta es la clave para acceder a la API de VirusTotal

Versiones de la API de VirusTotal

A día de hoy, la versión actual de la API es la número 2. Esta versión de la API está todavía en fase beta oficial, pero ya es bastante utilizable, sobre todo porque las capacidades que ofrece son mucho mayores.

Los desarrolladores recomiendan utilizar la tercera versión sólo con fines experimentales o para proyectos no críticos hasta el momento. Analizaremos ambas versiones. La clave de acceso es la misma para ambas versiones.

API de VirusTotal – Versión 2

Al igual que con otros servicios web populares, trabajar con la API implica enviar solicitudes a través de HTTP y recibir respuestas.

La versión 2 de la API permite:

  • enviar los archivos para su verificación;
  • recibir un informe de los archivos previamente verificados, utilizando el ID del archivo (hash SHA-256, SHA-1 o MD5 del archivo o el valor scan_id de la respuesta recibida tras el envío del archivo);
  • enviar la URL a escanear al servidor;
  • informar sobre las direcciones previamente comprobadas mediante la propia URL o el valor scan_id de la respuesta recibida tras el envío de la URL al servidor;
  • recibir un informe sobre la dirección IP;
  • recibir un informe sobre el nombre de dominio.

Errores

Si la consulta se ha procesado correctamente y no se han producido errores, se devolverá el código 200 (OK).

Sin embargo, si se ha producido un error, puede haber opciones como:

  • 204 – Límite de peticiones superado. Aparece cuando se supera la cuota de peticiones permitidas (para la clave libre la cuota es de cuatro peticiones por minuto);
  • 400 – Error en el tipo de solicitud. Aparece cuando la solicitud está mal formada, por ejemplo, si los argumentos requeridos faltan o tienen valores no válidos;
  • 403 – Error de tipo prohibido. Aparece si se intentan utilizar funciones de la API disponibles sólo con la clave de pago, cuando no hay ninguna.

Si la solicitud se genera con éxito (el código de estado HTTP es 200), la respuesta será un objeto JSON, cuyo cuerpo contiene al menos dos campos:

  • response_code – si el objeto solicitado (archivo, URL, dirección IP o nombre de dominio) está en la base de datos de VirusTotal (es decir, ha sido analizado anteriormente) y se puede obtener información sobre este objeto, el valor de este campo será uno; si el objeto solicitado está en la cola de análisis, el campo será -2; si el objeto solicitado no está en la base de datos de VirusTotal, el valor será cero;
  • verbose_msg proporciona una descripción más detallada del valor de response_code (por ejemplo, Escaneo completado, información incrustada después de enviar el archivo a escanear).

El resto de la información contenida en el objeto de respuesta JSON depende de la función de la API utilizada.

You can also read:

Envío de un archivo a un servidor para su escaneo

Para enviar un archivo para su escaneo es necesario formar POST-request a la dirección https://www.virustotal.com/vtapi/v2, en la que se debe especificar la clave de acceso a la API y pasar el propio archivo (en este caso hay un límite en el tamaño del archivo – no más de 32 Mb). Puede ser así (usando Python).

import json
import requests
...
api_url = 'https://www.virustotal.com/vtapi/v2/file/scan'
params = dict(apikey='<clave de acceso>')
with open('<file path>', 'rb') as file:
  files = dict(file=('<file path>', file))
  response = requests.post(api_url, files=files, params=params)
if response.status_code == 200:
  result=response.json()
  print(json.dumps(result, sort_keys=False, indent=4))
...

Aquí, en lugar de debes poner tu clave de acceso a la API, y en lugar de – la ruta del archivo que enviarás a VirusTotal. Si no tienes la librería requests, proporciónala con el comando pip install requests.

Como respuesta, si todo fue exitoso y el código de estado HTTP es 200, obtendremos aproximadamente la siguiente imagen:

{
  { "response_code": 1,
  "verbose_msg": "Scan request successfully queued, come back later for the report",
  "scan_id": "275a021bbfb6489e54d471899f7db9d1663fc695ec2fe2a2c4538aabf651fd0f-1577043276",
  "resource": "275a021bbfb6489e54d471899f7db9d1663fc695ec2fe2a2c4538aabf651fd0f",
  "sha1": "3395856ce81f2b7382dee72602f798b642f14140",
  "md5": "44d88612fea8a8f36de82e1278abb02f",
  "sha256": "275a021bbfb6489e54d471899f7db9d1663fc695ec2fe2a2c4538aabf651fd0f",
  "permalink": "https://www.virustotal.com/file/275a021bbfb6489e54d471899f7db9d1663fc695ec2fe2a2c4538aabf651fd0f/analysis/1577043276/"  
}

Aquí vemos los valores response_code y verbose_msg, así como los hashes de los archivos SHA-256, SHA-1 y MD5, un enlace a los resultados del escaneo de archivos en permalink, y el identificador de archivos scan_id.

Los ejemplos de código en este artículo omiten el manejo de errores. Tenga en cuenta que pueden producirse excepciones al abrir un archivo o al enviar peticiones al servidor: FileNotFoundError si no hay archivo, requests.ConnectionError, requests.Timeout para errores de conexión, etc.

Recibir un informe de la última exploración de archivos

Utilizando los hashes o el valor scan_id de la respuesta, puedes obtener un informe sobre el último escaneo del archivo (si el archivo ya ha sido subido a VirusTotal). Para ello, hay que formar una petición GET y especificar la clave de acceso y el ID del archivo en la petición. Por ejemplo, si tenemos el scan_id del ejemplo anterior, la petición tendrá el siguiente aspecto:

import json
import requests
...
api_url = 'https://www.virustotal.com/vtapi/v2/file/report'
params = dict(apikey='<clave de acceso>', resource='275a021bbfb6489e54d471899f7db9d1663fc695ec2fe2a2c4538aabf651fd0f-1577043276')
response = requests.get(api_url, params=params)
if response.status_code == 200:
  result=response.json()
  print(json.dumps(result, sort_keys=False, indent=4))
...

Si tiene éxito, veremos lo siguiente como respuesta:

{
  { "response_code": 1,
  "verbose_msg": "Scan finished, information embedded",
  "resource": "275a021bbfb6489e54d471899f7db9d1663fc695ec2fe2a2c4538aabf651fd0f",
  "sha1": "3395856ce81f2b7382dee72602f798b642f14140",
  "md5": "44d88612fea8a8f36de82e1278abb02f",
  "sha256": "275a021bbfb6489e54d471899f7db9d1663fc695ec2fe2a2c4538aabf651fd0f",
  "scan_date": "2019-11-27 08:06:03",
  { "permalink": "https://www.virustotal.com/file/275a021bbfb6489e54d471899f7db9d1663fc695ec2fe2a2c4538aabf651fd0f/analysis/1577043276/",
  { "positives": 59,
  { "total": 69,
  { "scans": {
    { "bkav": {
      "detected": true,
      "version": "1.3.0.9899",
      "result": "DOS.EiracA.Trojan",
      "update": "20191220"
    },
    { "DrWeb": {
      "detected": true,
      "version": "7.0.42.9300",
      { "result": "EICAR Test File (NOT a Virus!)",
       "update": "20191222"
    },
    { "MicroWorld-eScan": {
      "detected": true,
      "version": "14.0.297.0",
      { "result": "EICAR-Test-File",
      "update": "20191222"
    },
    ...
  ...
  { "Panda": {
    "detected": true,
    "version": "4.6.4.2",
    { "result": "EICAR-AV-TEST-FILE",
    "update": "20191222"
  },
  { "Qihoo-360": {
    "detected": true,
    "version": "1.0.0.1120",
    "result": "qex.eicar.gen.gen",
    "update": "20191222"
  }
}

Aquí, al igual que en el ejemplo anterior, obtenemos los valores hash del archivo, scan_id, permalink, response_code y verbose_msg. También vemos los resultados del escaneo de archivos por parte de los antivirus y los resultados totales de total – cuántos motores antivirus participaron en el escaneo y positivo – cuántos antivirus dieron un veredicto positivo.

Para mostrar los resultados de todos los escaneos antivirus de forma digerible, puedes, por ejemplo, escribir algo así:

import requests
...
api_url = 'https://www.virustotal.com/vtapi/v2/file/report'
params = dict(apikey='<ключ доступа>', resource='275a021bbfb6489e54d471899f7db9d1663fc695ec2fe2a2c4538aabf651fd0f-1577043276')
response = requests.get(api_url, params=params)
if response.status_code == 200:
  result=response.json()
  for key in result['scans']:
    print(key)
    print(' Detected: ', result['scans'][key]['detected'])
    print(' Version: ', result['scans'][key]['version'])
    print(' Update: ', result['scans'][key]['update'])
    print(' Result: ', 'result['scans'][key]['result'])
...
virustotal api con python - hacer pruebas y guía de uso
Mostrar los resultados del escaneo de archivos en VirusTotal utilizando diferentes motores antivirus

Envío de una URL a un servidor para su análisis

Para enviar una URL a escanear, necesitamos generar y enviar una petición POST que contenga la clave de acceso y la propia URL:

import json
import requests
...
api_url = 'https://www.virustotal.com/vtapi/v2/url/scan'
params = dict(apikey='<clave de acceso>', url='https://brain-upd.com/programming/how-to-use-virustotal-api-with-python/')
response = requests.post(api_url, data=params)
if response.status_code == 200:
  result=response.json()
  print(json.dumps(result, sort_keys=False, indent=4))
...

La respuesta será aproximadamente la misma que se utilizó para enviar el archivo, excepto por los valores hash. El contenido del campo scan_id puede utilizarse para recuperar un informe de escaneo para una URL determinada.

Recibir un informe sobre los resultados de una exploración de URL

Formulemos una petición GET con una clave de acceso y especifiquemos la propia URL como una cadena o el valor scan_id obtenido con la función anterior. Esto tendrá el siguiente aspecto:

import json
import requests
...
api_url = 'https://www.virustotal.com/vtapi/v2/url/report'
params = dict(apikey='<clave de acceso>', resource='https://brain-upd.com/programming/how-to-use-virustotal-api-with-python/', scan=0)
response = requests.get(api_url, params=params)
if response.status_code == 200:
  result=response.json()
  print(json.dumps(result, sort_keys=False, indent=4))
...

Además de la clave de acceso y la cadena de la URL, hay un parámetro de análisis opcional – por defecto es cero. Si su valor es cero, entonces cuando no hay información sobre la URL solicitada en la base de datos de VirusTotal (la URL no ha sido comprobada antes), la URL será enviada automáticamente al servidor para su comprobación, y entonces recibiremos la misma información en respuesta que cuando enviamos la URL al servidor. Si este parámetro es cero (o no se establece), obtendremos un informe sobre esta URL o (si no hay información sobre ella en la base de datos de VirusTotal) una respuesta como ésta:

{
  "response_code": 0,
  { "resource": "<requested URL>",
  "verbose_msg": "El recurso no existe en el conjunto de datos"
}

Obtención de información sobre la dirección IP y el dominio

Para comprobar direcciones IP y dominios, hay que generar y enviar una petición GET con la clave, nombre de dominio o IP a comprobar como cadena. Para comprobar un dominio, se ve así:

…
api_url = 'https://www.virustotal.com/vtapi/v2/domain/report'
params = dict(apikey='', domain=<'domain name'>)
response = requests.get(api_url, params=params)
…

Para comprobar la dirección IP:

…
api_url = 'https://www.virustotal.com/vtapi/v2/ip-address/report'
params = dict(apikey='', ip=<'IP address'>)
response = requests.get(api_url, params=params)
…

Las respuestas a estas consultas son voluminosas y contienen mucha información.

API de VirusTotal – Versión 3

La tercera versión de la API tiene muchas más funciones en comparación con la segunda, incluso con el uso de la clave gratuita. Además, mientras experimentaba con la versión 3, no noté ninguna limitación en el número de objetos (archivos o direcciones) subidos al servidor en un minuto. Parece que las restricciones no se aplican a la beta en absoluto por ahora.

Las funciones de la API en la versión 3 están diseñadas utilizando los principios de REST y son fáciles de entender. La clave de acceso se pasa en la cabecera de la solicitud.

Errores

En la tercera versión de la API, se ha ampliado la lista de errores (y, en consecuencia, los códigos de estado HTTP). Se han añadido los siguientes:

  • 401 – Error de usuario no activo, se produce cuando la cuenta de usuario está inactiva;
  • 401 – Error de credenciales incorrectas, se produce si se utiliza una contraseña no válida en la solicitud;
  • 404 – Error no encontrado, se produce cuando no se encuentra el objeto de exploración solicitado;
  • 409 – Error de ya existe, ocurre cuando el recurso ya existe;
  • 429 – Quota Exceeded Error, ocurre cuando se supera una de las cuotas de número de peticiones (minuto, diario o mensual). Como dije antes, durante mis experimentos no se observó ningún límite en el número de peticiones por minuto, aunque utilicé una clave libre;
  • 429 – Error de Demasiadas Peticiones, ocurre cuando hay un gran número de peticiones en un corto período de tiempo (puede ser causado por la carga del servidor);
  • 503 – Error transitorio, un error temporal del servidor que puede hacer fracasar un reintento de la solicitud.

En caso de error, el servidor devuelve información adicional en forma de JSON además del código de estado. Sin embargo, resulta que no todos los códigos de estado HTTP se ven afectados: por ejemplo, para el error 404 la información adicional es una simple cadena.

El formato JSON para el error es el siguiente:

{
  { "error": {
    { "code": "<http status code>",
    "message": "<mensaje con la descripción del error>"
  }
}

Funciones de gestión de archivos

La tercera versión de la API permite:

  • cargar archivos en el servidor para su análisis;
  • obtener la URL para descargar al servidor un archivo de más de 32 MB;
  • obtener informes sobre los resultados del análisis del archivo
  • volver a analizar el archivo
  • obtener comentarios de los usuarios de VirusTotal sobre el archivo deseado
  • enviar su comentario a un archivo en particular
  • ver los resultados de la votación de un archivo concreto; votar por el archivo; y
  • votar por el archivo;
  • obtener información ampliada sobre el archivo.

Para subir un archivo al servidor hay que enviarlo mediante una petición POST. Esto se puede hacer de la siguiente manera:

... 
api_url = 'https://www.virustotal.com/api/v3/files'
headers = {'x-apikey' : '<API clave de acceso>'}
with open('<file path>', 'rb') as file:
  files = {'file': ('<file path>', file)}
  response = requests.post(api_url, headers=headers, files=files)
...

La respuesta que obtendremos será esta:

{
  { "data": {
    "id": "ZTRiNjgxZmJmZmZmRkZTNlM2YyODlkMzk5MTZhZjYwNDI6MTU3NzIxOTQ1Mg==",
    "type": "analysis".
  }
}

Aquí vemos el valor id, que sirve como identificador del archivo. Este identificador debe utilizarse para obtener información sobre el análisis del archivo en peticiones GET como /análisis (hablaremos de ello un poco más adelante).
Para obtener la URL de descarga de un archivo grande (más de 32 MB), es necesario enviar una petición GET con https://www.virustotal.com/api/v3/files/upload_url como URL. En la cabecera inserte la clave de acceso:

…
api_url = 'https://www.virustotal.com/api/v3/files/upload_url'
headers = {'x-apikey' : ''}
response = requests.get(api_url, headers=headers)
…

En respuesta obtendremos JSON con la dirección donde se debe descargar el archivo para su análisis. La URL recibida sólo se puede utilizar una vez.

Para obtener información sobre el archivo, que el servicio ya ha analizado, hay que hacer una petición GET con el identificador del archivo en la URL (puede ser el hash SHA-256, SHA-1 o MD5). Al igual que en los casos anteriores, especifique la clave de acceso en la cabecera:

…
api_url = 'https://www.virustotal.com/api/v3/files/'
headers = {'x-apikey' : ''}
response = requests.get(api_url, headers=headers)
…

En respuesta, obtendremos un informe de escaneo de archivos, donde además de los resultados del escaneo por todos los antivirus de VirusTotal, habrá mucha información adicional, cuya composición depende del tipo de archivo escaneado. Por ejemplo, para los archivos ejecutables podemos ver información sobre tales atributos:

{
  { "attributes": {
    "authentihash": "8fcc2f670a166ea78ca239375ed312055c74efdc1f47e79d69966461dd1b2fb6",
    { "creation_date": 1270596357,
    { "exiftool": {
      "CharacterSet": { "unicode",
      "CodeSize": 20480,
      "CompanyName": "TYV",
      "EntryPoint": "0x109c",
      "FileFlagsMask": "0x0000",
      "FileOS": "Win32",
      "FileSubtype": 0,
      "FileType": "Win32 EXE",
      { "FileTypeExtension": { "exe",
      "FileVersion": 1.0,
      "FileVersionNumber": "1.0.0.0",
      "ImageFileCharacteristics": "No relocs, Executable, No line numbers, No symbols, 32-bit",
      ...
      ...
      "SubsystemVersion": 4.0,
      "TimeStamp": "2010:04:07 00:25:57+01:00",
      "UninitializedDataSize": 0
    },
    ...
  }
}

O, por ejemplo, información sobre las secciones de un archivo ejecutable:

{
  { "sections": [
    {
      "entropy": 3.94,
      "md5": "681b80f1ee0eb1531df11c6ae115d711",
      "name": ".text",
      "raw_size": 20480,
      "virtual_address": 4096,
      "virtual_size": 16588
    },
    {
      "entropy": 0.0,
      "md5": "d41d8cd98f00b204e9800998ecf8427e",
      "name": ".data",
      "raw_size": 0,
      "virtual_address": 24576,
      "virtual_size": 2640
    },
    ...
  }
}

Si el archivo no ha sido subido al servidor antes y no ha sido analizado todavía, obtendremos un error no encontrado con un código de estado HTTP 404 en la respuesta:

{
  { "error": {
    { "code": "NotFoundError",
    "message": "File \"<file ID>" not found"
  }
}

Para volver a analizar un archivo, también tenemos que enviar una petición GET al servidor, donde ponemos el ID del archivo en la URL y añadimos /analyse al final:

...
api_url = 'https://www.virustotal.com/api/v3/files/<file ID value>/analyse'
headers = {'x-apikey' : '<API clave de acceso>'}
response = requests.get(api_url, headers=headers)
...

La respuesta incluirá el mismo descriptor de archivo que en el primer caso, cuando el archivo se cargue en el servidor. Y al igual que en el primer caso, el identificador del descriptor puede utilizarse para obtener información sobre el análisis del archivo a través de una petición GET como /análisis.

Se pueden ver los comentarios de los usuarios del servicio, así como los resultados de las votaciones sobre el fichero, enviando la correspondiente petición GET al servidor. Para obtener los comentarios:

...
api_url = 'https://www.virustotal.com/api/v3/files/<file ID value>/comments'
headers = {'x-apikey' : '<API clave de acceso>'}
response = requests.get(api_url, headers=headers)
...

Para obtener los resultados de la votación:

...
api_url = 'https://www.virustotal.com/api/v3/files/<file ID value>/votes'
headers = {'x-apikey' : '<API clave de acceso>'}
response = requests.get(api_url, headers=headers)
...

En ambos casos, puede utilizar el parámetro opcional de límite que define el número máximo de comentarios o votos en una respuesta. Este parámetro se puede utilizar de la siguiente manera:

…
limit = {'limit': str()}
api_url = 'https://www.virustotal.com/api/v3/files//votes'
headers = {'x-apikey' : ''}
response = requests.get(api_url, headers=headers, params=limit)
…

Para publicar un comentario o votar por un archivo, creamos una solicitud POST, y pasamos el comentario o el voto como un objeto JSON:

...
## Para enviar los resultados de la votación
votes = {'data': {'type': 'vote', 'attributes': {'verdict': <'malicious' or 'harmless'>}}
api_url = 'https://www.virustotal.com/api/v3/files/<file ID value>/votes'
headers = {'x-apikey' : '<API clave de acceso>'}
response = requests.post(api_url, headers=headers, json=votes)
...
## Para enviar un comentario
comments = {'data': {'type': 'vote', 'attributes': {'text': <comment text>}}
headers = {'x-apikey' : '<API clave de acceso>'}
api_url = 'https://www.virustotal.com/api/v3/files/<file ID value>/comments'
response = requests.post(api_url, headers=headers, json=comments)
...

Para obtener más información sobre un archivo, puede solicitar detalles sobre los objetos asociados. En este caso, los objetos pueden caracterizar, por ejemplo, el comportamiento del archivo (objeto behaviors) o URLs, direcciones IP, nombres de dominio (objetos contacted_urls, contacted_ips, contacted_domains).

Lo más interesante es el objeto behaviours. Por ejemplo, para los archivos ejecutables, incluiría información sobre los módulos cargados, los procesos creados e iniciados, las operaciones del sistema de archivos y del registro, y las operaciones de red.

Para obtener esta información, enviamos una petición GET:

api_url = 'https://www.virustotal.com/api/v3/files/<file ID value>/behaviours'
headers = {'x-apikey' : '<API clave de acceso>'}
response = requests.get(api_url, headers=headers)

La respuesta será un objeto JSON con información sobre el comportamiento del archivo:

{
  { "data": [
    {
      { "attributes": {
        { "analysis_date": 1548112224,
        "command_executions": [
          "C:\WINDOWS\\system32\ntvdm.exe -f -i1"
          "/bin/bash /private/tmp/eicar.com.sh"
        ],
        "has_html_report": false,
        { "has_pcap": false,
        "last_modification_date": 1577880343,
        "modules_loaded": [
          "c:\\windows\\system32\\user32.dll",
          "c:\\windows\\system32\\imm32.dll",
          "c:\\windows\\system32\\ntdll.dll"
        ]
      },
      ...
    }
  ]
}

Funciones para trabajar con URLs

La lista de posibles operaciones de URL incluye:

  • enviar la URL al servidor para su análisis
  • obtener información sobre la URL
  • analizar la URL;
  • obtener comentarios de los usuarios de VirusTotal sobre la URL deseada;
  • enviar los comentarios a una URL determinada
  • obtener los resultados de las votaciones sobre una URL determinada
  • enviar el voto a una URL
  • obtener información mejorada de la URL;
  • obtener información sobre el dominio o la dirección IP de la URL deseada.

La mayoría de las operaciones anteriores (excepto la última) se realizan de forma similar a las mismas operaciones con archivos. En este caso, la cadena con la URL codificada en Base64 sin signos de “igual”, o el hash SHA-256 de la URL puede servir como identificador de la URL. Se puede implementar de la siguiente manera:

## Para Base64
import base64
...
id_url = base64.urlsafe_b64encode(url.encode('utf-8')).decode('utf-8').rstrip('=')
...
## Para SHA-256
import hashlib
...
id_url = hashlib.sha256(url.encode()).hexdigest()

Para enviar una URL para su análisis, debe utilizar una solicitud POST:

data = {'url': '<URL name string>'}
api_url = 'https://www.virustotal.com/api/v3/urls'
headers = {'x-apikey' : '<API clave de acceso>'}
response = requests.post(api_url, headers=headers, data=data)

En respuesta, veremos un descriptor de URL (similar a un descriptor de archivo):

{
  { "data": {
    "id": "u-1a565d28f8412c3e4b65ec8267ff8e77eb00a2c76367e653be774169ca9d09a6-1577904977",
    "type": "analysis".
  }
}

El identificador de este descriptor se utiliza para obtener información sobre el análisis del archivo a través de una petición GET de tipo /análisis (más sobre esta petición hacia el final del artículo).

Para obtener información sobre los dominios o las direcciones IP asociadas a cualquier URL, se puede aplicar una petición GET de tipo /ubicación_de_red (aquí se utiliza el identificador de URL Base64 o SHA-256):

api_url = 'https://www.virustotal.com/api/v3/urls/<URLID (Base64 or SHA-256)>/network_location'
headers = {'x-apikey' : '<API clave de acceso>'}
response = requests.post(api_url, headers=headers)

Otras operaciones con URL se realizan de la misma manera que las operaciones similares con archivos.

Funciones para trabajar con dominios y direcciones IP.

Esta lista de características incluye en virustotal api v3

  • recuperar información sobre el dominio o la dirección IP
  • obtener comentarios de los usuarios de VirusTotal sobre el dominio o la dirección IP deseada
  • enviar sus comentarios a un dominio o dirección IP específicos;
  • obtener los resultados de las votaciones para un dominio o dirección IP específicos; y
  • enviar un voto para un dominio o dirección IP;
  • obtener información avanzada sobre el dominio o la dirección IP.

Todas estas operaciones se implementan de forma similar a las mismas operaciones con archivos o URLs. La diferencia es que los nombres de dominio o los valores de las direcciones IP se utilizan directamente, en lugar de los identificadores.

Solicitud GET como /análisis

Esta consulta permite obtener información sobre los resultados del análisis sintáctico de archivos o URLs después de haberlos subido al servidor o después de haberlos reanalizado. Debe utilizar el ID contenido en el campo descriptor del archivo o URL recibido como resultado del envío de solicitudes de carga de archivos o URL al servidor o como resultado del reanálisis del archivo o URL.

Por ejemplo, una solicitud de este tipo puede formarse para un archivo de la siguiente manera:

TEST_FILE_ID = 'ZTRiNjgxZmJmZmRkZTNlM2YyODlkMzk5MTZhZjYwNDI6MTU3NjYwMTE1Ng=='
...
api_url = 'https://www.virustotal.com/api/v3//analyses/' + TEST_FILE_ID
headers = {'x-apikey' : '<API clave de acceso>'}
response = requests.get(api_url, headers=headers)

Y una opción para la URL:

TEST_URL_ID = 'u-dce9e8fbe86b145e18f9dcd4aba6bba9959fdff55447a8f9914eb9c4fc1931f9-1576610003'
...
api_url = 'https://www.virustotal.com/api/v3//analyses/' + TEST_URL_ID
headers = {'x-apikey' : '<API clave de acceso>'}
response = requests.get(api_url, headers=headers)

Conclusión:

Revisamos todas las funciones principales de la API de VirusTotal. Puedes tomar prestado el código dado para tus proyectos. Si utilizas la segunda versión, tienes que asegurarte de no enviar peticiones con demasiada frecuencia, pero la tercera versión no tiene todavía esta limitación. Te recomiendo que la elijas porque las capacidades son mucho más amplias aquí también. Y tarde o temprano se convertirá en la principal.

Fuentes:

1 Shares
Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

You May Also Like