Automatiza el análisis de software malicioso para archivos subidos a Cloud Storage

Configura tu entorno

En esta sección, debes asignar parámetros de configuración a los valores que se usan en el instructivo, como la región y la zona. En este instructivo, debes usar us-central1 como la región para el servicio de Cloud Run y us como la ubicación para el activador de Eventarc y los buckets de Cloud Storage.

1. En Cloud Shell, configura las variables de shell comunes, incluidas la región y la ubicación:

   REGION=us-central1
   LOCATION=us
   PROJECT_ID=PROJECT_ID
   SERVICE_NAME="malware-scanner"
   SERVICE_ACCOUNT="${SERVICE_NAME}@${PROJECT_ID}.iam.gserviceaccount.com"

   PROJECT_ID: Establece el ID del proyecto.

2. Inicializa el entorno gcloud con el ID de tu proyecto:

   gcloud config set project "${PROJECT_ID}"
   

3. Crea tres depósitos de Cloud Storage con nombres únicos:

   gsutil mb -l "${LOCATION}" "gs://unscanned-${PROJECT_ID}"
   gsutil mb -l "${LOCATION}" "gs://quarantined-${PROJECT_ID}"
   gsutil mb -l "${LOCATION}" "gs://clean-${PROJECT_ID}"
   

   ${PROJECT_ID} se usa para garantizar que los nombres de los buckets sean únicos.

   Estos tres buckets contienen los archivos subidos en varias etapas durante la canalización de análisis de archivos:

   • unscanned-PROJECT_ID: Contiene los archivos antes de que se analicen. Tus usuarios suben sus archivos a este bucket.

   • quarantined-PROJECT_ID: Contiene los archivos que el servicio de análisis de software malicioso analizó y considera que contienen software malicioso.

   • clean-PROJECT_ID: Contiene los archivos que el servicio de análisis de software malicioso analizó y descubrió que no están infectados.

4. Crea un cuarto bucket de Cloud Storage:

   gsutil mb -l "${LOCATION}" "gs://cvd-mirror-${PROJECT_ID}"
   

   ${PROJECT_ID} se usa para garantizar que el nombre del bucket sea único.

   Este bucket cvd-mirror-PROJECT_ID se usa para mantener una duplicación local de la base de datos de definiciones de software malicioso, que evita que la CDN de ClamAV active el límite de frecuencia.

Crea una cuenta de servicio para el servicio de análisis de software malicioso y otorga permisos

En esta sección, crearás una cuenta de servicio para usar en el servicio de análisis de software malicioso y otorgarás las funciones correspondientes a la cuenta de servicio a fin de que tenga permisos de lectura y escritura en los buckets de Cloud Storage. Esto garantiza que la cuenta tenga permisos mínimos y solo tenga acceso a los recursos que necesita.

1. Crea la cuenta de servicio malware-scanner:

   gcloud iam service-accounts create ${SERVICE_NAME}
   

2. Otorga la función de administrador de objetos a los buckets, lo que permite que el servicio lea y borre archivos del bucket no analizado y escriba archivos en los buckets en cuarentena y limpios.

   gsutil iam ch \
       "serviceAccount:${SERVICE_ACCOUNT}:objectAdmin" \
       "gs://unscanned-${PROJECT_ID}"
   gsutil iam ch \
       "serviceAccount:${SERVICE_ACCOUNT}:objectAdmin" \
       "gs://clean-${PROJECT_ID}"
   gsutil iam ch \
       "serviceAccount:${SERVICE_ACCOUNT}:objectAdmin" \
       "gs://quarantined-${PROJECT_ID}"
   gsutil iam ch \
       "serviceAccount:${SERVICE_ACCOUNT}:objectAdmin" \
       "gs://cvd-mirror-${PROJECT_ID}"
   

3. Otorga la función de escritor de métricas, que permite que el servicio escriba métricas en Monitoring:

   gcloud projects add-iam-policy-binding \
         "${PROJECT_ID}" \
         --member="serviceAccount:${SERVICE_ACCOUNT}" \
         --role=roles/monitoring.metricWriter
   

Crea el servicio de análisis de software malicioso en Cloud Run

En esta sección, implementarás el servicio de análisis de software malicioso en Cloud Run. El servicio se ejecuta en un contenedor de Docker y contiene lo siguiente:

• Un Dockerfile para compilar una imagen de contenedor con el servicio, el entorno de ejecución de Node.js, el SDK de gcloud y los objetos binarios de ClaamAV.
• Los archivos Node.js para el servicio de análisis de software malicioso de Cloud Run.
• config.json para especificar los nombres de tus buckets de Cloud Storage.
• updateCvdMirror.sh para actualizar la duplicación de la base de datos de definiciones de software malicioso de ClamAV en Cloud Storage.
• Servicio cloud-run-proxy para usar un proxy en las solicitudes HTTP freshclam, que proporcionan acceso autenticado a las APIs de Cloud Storage
• bootstrap.sh para ejecutar los servicios necesarios cuando se inicia la instancia.

1. En Cloud Shell, clona el repositorio de GitHub que contiene los archivos de código:

   git clone https://github.com/GoogleCloudPlatform/docker-clamav-malware-scanner.git
   

2. Cambia al directorio cloudrun-malware-scanner:

   cd docker-clamav-malware-scanner/cloudrun-malware-scanner
   

3. Edita el archivo de configuración config.json para especificar los buckets de Cloud Storage que acabas de crear. Como se basan en el ID del proyecto, se puede usar una búsqueda y un reemplazo simples:

   sed "s/-bucket-name/-${PROJECT_ID}/" config.json.tmpl > config.json
   

   Puedes ver el archivo de configuración actualizado:

   cat config.json
   

4. Realiza una propagación inicial de la duplicación de la base de datos de software malicioso de ClamAV en Cloud Storage:

   python3 -m venv pyenv
   . pyenv/bin/activate
   pip3 install crcmod cvdupdate
   ./updateCvdMirror.sh "cvd-mirror-${PROJECT_ID}"
   deactivate
   

   Esto realiza una instalación local de la herramienta de CVDUpdate, la usa para descargar la base de datos de software malicioso y, luego, la sube al bucket cvd-mirror de Cloud Storage que creaste antes.

   Puedes verificar el contenido de la duplicación:

   gsutil ls "gs://cvd-mirror-${PROJECT_ID}/cvds"
   

   El bucket debe contener varios archivos CVD, que contengan la base de datos completa de software malicioso, varios archivos .cdiff que contengan las actualizaciones diferenciales diarias y dos archivos .json con información de configuración y estado.

5. Crea e implementa el servicio de Cloud Run mediante la cuenta de servicio creada antes:

   gcloud beta run deploy "${SERVICE_NAME}" \
     --source . \
     --region "${REGION}" \
     --no-allow-unauthenticated \
     --memory 4Gi \
     --cpu 1 \
     --concurrency 20 \
     --min-instances 1 \
     --max-instances 5 \
     --no-cpu-throttling \
     --cpu-boost \
     --service-account="${SERVICE_ACCOUNT}"
   

   Esto crea una instancia de Cloud Run que tiene 1 CPU virtual y usa 4 GiB de RAM. Si bien este es un tamaño aceptable para este instructivo, en un entorno de producción, es posible que desees elegir un tamaño de CPU y memoria mayor para la instancia, y un parámetro --max-instances más grande según la cantidad de tráfico que el servicio necesita controlar.

   El parámetro --concurrency especifica la cantidad de solicitudes simultáneas que puede procesar cada instancia.

   El parámetro --no-cpu-throttling permite que la instancia realice operaciones en segundo plano, como la actualización de definiciones de software malicioso.

   El parámetro --cpu-boost duplica la cantidad de CPU virtuales en el inicio de la instancia para reducir la latencia de inicio.

   El parámetro --min-instances 1 mantiene al menos una instancia activa, ya que el tiempo de inicio de cada instancia es relativamente alto.

   El parámetro --max-instances 5 evita que el servicio escale demasiado verticalmente.

6. Cuando se te solicite, ingresa Y.

La compilación y la implementación tardan unos 10 minutos. Una vez completada, verás el siguiente mensaje:

Service [malware-scanner] revision [malware-scanner-NNNNN-XXX] has been deployed and is serving 100 percent of traffic.
Service URL: https://malware-scanner-XXXXXXXX-XX.a.run.app

Almacena el valor Service URL del resultado del comando de implementación en una variable de shell. Se usará más adelante cuando crees un trabajo de Cloud Scheduler:

SERVICE_URL="SERVICE_URL"

El servicio de Cloud Run requiere que todas las invocaciones se autentiquen, y las identidades en autenticación deben tener el permiso run.routes.invoke en el servicio.

Para verificar el servicio en ejecución y la versión de ClamAV, ejecuta el siguiente comando:

curl -D - -H "Authorization: Bearer $(gcloud auth print-identity-token)"  \
     ${SERVICE_URL}

Crea un activador de Eventarc en Cloud Storage

En esta sección, agregarás permisos para permitir que Eventarc capture eventos de Cloud Storage y un activador a fin de enviar estos eventos al servicio malware-scanner de Cloud Run.

1. Si usas un proyecto existente que se creó antes del 8 de abril de 2021, configura Pub/Sub para las notificaciones push.

2. En Cloud Shell, otorga el rol roles/pubsub.publisher a la cuenta de servicio de Cloud Storage:

   STORAGE_SERVICE_ACCOUNT=$(gsutil kms serviceaccount -p "${PROJECT_ID}")
   
   gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
     --member "serviceAccount:${STORAGE_SERVICE_ACCOUNT}" \
     --role "roles/pubsub.publisher"
   

3. Permite que la cuenta de servicio malware-scanner invoque el servicio de Cloud Run y actúe como un receptor de eventos de Eventarc:

   gcloud run services add-iam-policy-binding "${SERVICE_NAME}" \
     --region="${REGION}" \
     --member "serviceAccount:${SERVICE_ACCOUNT}" \
     --role roles/run.invoker
   gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
     --member "serviceAccount:${SERVICE_ACCOUNT}" \
     --role "roles/eventarc.eventReceiver"
   

4. Crea un activador de Eventarc para capturar el evento de objeto final en el bucket no analizado de Cloud Storage y envíalo a tu servicio de Cloud Run. El activador usará la cuenta de servicio malware-scanner para la autenticación:

   BUCKET_NAME="unscanned-${PROJECT_ID}"
   gcloud eventarc triggers create "trigger-${BUCKET_NAME}-${SERVICE_NAME}" \
     --destination-run-service="${SERVICE_NAME}" \
     --destination-run-region="${REGION}" \
     --location="${LOCATION}" \
     --event-filters="type=google.cloud.storage.object.v1.finalized" \
     --event-filters="bucket=${BUCKET_NAME}" \
     --service-account="${SERVICE_ACCOUNT}"
   

   Si recibes uno de los siguientes dos errores, espera un minuto y vuelve a ejecutar el comando:

   ERROR: (gcloud.eventarc.triggers.create) INVALID_ARGUMENT: The request was invalid: Bucket "unscanned-PROJECT_ID" was not found. Please verify that the bucket exists.

   ERROR: (gcloud.eventarc.triggers.create) FAILED_PRECONDITION: Invalid resource state for "": Permission denied while using the Eventarc Service Agent. If you recently started to use Eventarc, it may take a few minutes before all necessary permissions are propagated to the Service Agent. Otherwise, verify that it has Eventarc Service Agent role.

5. Cambia el plazo de confirmación del mensaje a dos minutos en la suscripción de Pub/Sub subyacente que usa el activador de Eventarc:

   SUBSCRIPTION_NAME=$(gcloud eventarc triggers describe \
       "trigger-${BUCKET_NAME}-${SERVICE_NAME}" \
       --location="${LOCATION}" \
       --format="get(transport.pubsub.subscription)")
   gcloud pubsub subscriptions update "${SUBSCRIPTION_NAME}" --ack-deadline=120
   

   El valor predeterminado de diez segundos es demasiado corto para archivos grandes o cargas altas.

Crea un trabajo de Cloud Scheduler para activar las actualizaciones de la duplicación de la base de datos de ClamAV

Crea un trabajo de Cloud Scheduler que ejecute una solicitud HTTP POST en el servicio de Cloud Run con un comando para actualizar la duplicación de la base de datos de definiciones de software malicioso. Para evitar que demasiados clientes usen la misma ranura de tiempo, ClamAV requiere que programes el trabajo en un minuto aleatorio entre 3 y 57, evitando múltiplos de 10.

while : ; do
  # set MINUTE to a random number between 3 and 57
  MINUTE="$((RANDOM%55 + 3))"
  # exit loop if MINUTE is not a multiple of 10
  [[ $((MINUTE % 10)) != 0 ]] && break
done

gcloud scheduler jobs create http \
    "${SERVICE_NAME}-mirror-update" \
    --location="${REGION}" \
    --schedule="${MINUTE} */2 * * *" \
    --oidc-service-account-email="${SERVICE_ACCOUNT}" \
    --uri="${SERVICE_URL}" \
    --http-method=post \
    --message-body='{"kind":"schedule#cvd_update"}' \
    --headers="Content-Type=application/json"

El argumento de línea de comandos --schedule define cuándo se ejecutará el trabajo con el formato de string unix-cron. El valor proporcionado indica que debe ejecutarse en el minuto específico generado de forma aleatoria cada 2 horas.

Este trabajo solo actualizará la duplicación de ClamAV en Cloud Storage. El daemon de freshclam de ClamAV en cada instancia de Cloud Run verificará la duplicación cada treinta minutos para obtener definiciones nuevas y actualizará el daemon de ClamAV.

Sube archivos para probar la canalización

Sube un archivo limpio (libre de software malicioso) y un archivo infectado para probar la canalización.

1. Crea un archivo de texto de muestra o usa un archivo limpio existente para probar los procesos de canalización.

2. Copia el archivo de datos de muestra en el bucket no analizado:

   gsutil cp filename "gs://unscanned-${PROJECT_ID}"
   

   Reemplaza filename con el nombre del archivo de texto limpio. El servicio de análisis de software malicioso inspecciona cada archivo y lo mueve a un bucket adecuado. Este archivo se mueve al bucket limpio.

3. Espera unos segundos mientras la canalización procesa el archivo y, luego, verifica el bucket limpio para ver si el archivo procesado está allí:

   gsutil ls -r "gs://clean-${PROJECT_ID}"
   

4. El archivo se quitó del bucket no analizado:

   gsutil ls -r "gs://unscanned-${PROJECT_ID}"
   

5. En Cloud Shell, sube un archivo llamado eicar-infected.txt que contenga la firma de prueba de software malicioso estándar de EICAR en el bucket no analizado:

   echo -e 'X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*' \
       | gsutil cp - "gs://unscanned-${PROJECT_ID}/eicar-infected.txt"
   

6. Espera unos segundos y, luego, verifica el bucket en cuarentena para ver si el archivo pasó por la canalización de forma correcta. El servicio también registra una entrada de registro de Logging cuando se detecta un archivo infectado con software malicioso.

   gsutil ls -r "gs://quarantined-${PROJECT_ID}"
   

7. El archivo se quitó del bucket no analizado:

   gsutil ls -r "gs://unscanned-${PROJECT_ID}"
   

Prueba el mecanismo de actualización de la base de datos de definiciones de software malicioso

• En Cloud Shell, puedes activar la verificación de actualizaciones si fuerzas la ejecución del trabajo de Cloud Scheduler:

  gcloud scheduler jobs run "${SERVICE_NAME}-mirror-update" --location="${REGION}"
  

  Los resultados de este comando solo se mostrarán en los registros detallados.

Supervisa el servicio

El servicio se puede supervisar mediante Cloud Logging y Cloud Monitoring.

Ve registros detallados

1. En la consola de Google Cloud, ve a la página Explorador de registros de Cloud Logging.

   Ir al Explorador de registros

2. Si el filtro Campos de registro no se muestra, haz clic en el botón Campos de registro.

3. En el filtro Campos de registro, haz clic en Revisión de Cloud Run.

4. En la sección Nombre del servicio del filtro Campos de registro, haz clic en malware-scanner

Los resultados de la consulta de registros mostrarán los registros del servicio, incluidas varias líneas que muestran las solicitudes de análisis y el estado de los 2 archivos que subiste, por ejemplo:

Scan request for gs://unscanned-PROJECT_ID/filename, (##### bytes) scanning with clam ClamAV CLAMAV_VERSION_STRING
Scan status for gs://unscanned-PROJECT_ID/filename: CLEAN (##### bytes in #### ms)
...
Scan request for gs://unscanned-PROJECT_ID/eicar-infected.txt, (69 bytes) scanning with clam ClamAV CLAMAV_VERSION_STRING
Scan status for gs://unscanned-PROJECT_ID/eicar-infected.txt: INFECTED stream: Eicar-Signature FOUND (69 bytes in ### ms)

Puedes ver que se informan la versión de ClamAV y la revisión de la firma de la base de datos de software malicioso, junto con el nombre del software malicioso del archivo de prueba infectado.

Puedes usar estos mensajes de registro a fin de configurar alertas para cuando se haya encontrado software malicioso o cuando se hayan producido errores durante el análisis.

También se muestran los registros de actualización de la duplicación de definiciones de software malicioso y se verán de la siguiente manera:

Starting CVD Mirror update
CVD Mirror update check complete. output: ...

Si se actualizó la duplicación, habrá una línea adicional:

CVD Mirror updated: DATE_TIME - INFO: Downloaded daily.cvd. Version: VERSION_INFO

Los registros de actualización de freshclam se mostrarán cada 30 minutos y se mostrarán de la siguiente manera:

DATE_TIME -> Received signal: wake up
DATE_TIME -> ClamAV update process started at DATE_TIME
DATE_TIME -> daily.cvd database is up-to-date (version: VERSION_INFO)
DATE_TIME -> main.cvd database is up-to-date (version: VERSION_INFO)
DATE_TIME -> bytecode.cvd database is up-to-date (version: VERSION_INFO)

Si se actualizó la base de datos, las líneas de registro de freshclam se mostrarán de la siguiente manera:

DATE_TIME -> daily.cld updated (version: VERSION_INFO)

Visualiza métricas

El servicio genera las siguientes métricas para fines de supervisión y alertas:

• Cantidad de archivos limpios procesados:
  custom.googleapis.com/opencensus/malware-scanning/clean_files
• Cantidad de archivos infectados procesados:
  custom.googleapis.com/opencensus/malware-scanning/infected_files
• Tiempo de análisis de archivos:
  custom.googleapis.com/opencensus/malware-scanning/scan_duration
• Cantidad total de bytes analizados:
  custom.googleapis.com/opencensus/malware-scanning/bytes_scanned
• Cantidad de análisis de software malicioso con errores:
  custom.googleapis.com/opencensus/malware-scanning/scans_failed
• Cantidad de verificaciones de actualización de la duplicación de CVD:
  custom.googleapis.com/opencensus/malware-scanning/cvd-mirror-updates

Estas métricas se pueden ver en el Explorador de métricas de Cloud Monitoring.

1. En la consola de Google Cloud, ve a la página Explorador de métricas de Cloud Monitoring.

   Ir al Explorador de métricas

2. Haz clic en el campo Seleccionar una métrica y, luego, ingresa la string de filtro malware.

3. Selecciona la métrica OpenCensus/malware-scanning/clean_files. El gráfico mostrará un dato que indica cuándo se analizó el archivo limpio.

Las métricas se pueden usar para supervisar la canalización y crear alertas cuando se detecte software malicioso o cuando el procesamiento de archivos falle.

Para obtener más detalles, las métricas se pueden desglosar en varias etiquetas:

• source_bucket
• destination_bucket
• clam_version
• cloud_run_revision

Administra varios buckets

El servicio de análisis de software malicioso puede analizar archivos de varios buckets de origen y enviarlos a buckets limpios y en cuarentena.

Si bien esta configuración avanzada está fuera del alcance de este instructivo, los pasos involucrados se resumen de la siguiente manera:

1. Crea los distintos buckets de Cloud Storage no analizados, limpios y en cuarentena con nombres únicos.

2. Otorga las funciones correspondientes a la cuenta de servicio malware-scanner en los distintos buckets.

3. Edita el archivo de configuración config.json para especificar los nombres de los buckets de cada configuración:

   {
     "buckets": [
       {
         "unscanned": "unscanned-bucket-1-name",
         "clean": "clean-bucket-1-name",
         "quarantined": "quarantined-bucket-1-name"
       },
       {
         "unscanned": "unscanned-bucket-2-name",
         "clean": "clean-bucket-2-name",
         "quarantined": "quarantined-bucket-2-name"
       }
     ]
     "ClamCvdMirrorBucket": "cvd-mirror-bucket-name"
   }
   

4. Para cada uno de los buckets no analizados, crea un activador de Eventarc que garantice un nombre de activador único para cada bucket.