Inicio rápido: carga de imágenes de firmware en Análisis de firmware de Defender para IoT con Python

En este artículo se explica cómo usar un script de Python para cargar imágenes de firmware en el Análisis de firmware de Defender para IoT.

El Análisis de firmware de Defender para IoT es una herramienta que analiza las imágenes de firmware y proporciona una comprensión de las vulnerabilidades de seguridad en las imágenes de firmware.

Requisitos previos

En esta guía de inicio rápido se da por supuesto un conocimiento básico del Análisis de firmware de Defender para IoT. Para más información, consulte el Análisis de firmware para generadores de dispositivos. Para obtener una lista de los sistemas de archivos compatibles, consulte Preguntas más frecuentes sobre el Análisis de firmware de Defender para IoT.

Preparación del entorno

• Se requiere una versión de Python 3.8 o posterior para usar este paquete. Ejecute el comando python --version para comprobar la versión de Python.
• Anote el identificador de la suscripción de Azure, el nombre del grupo de recursos donde desee cargar las imágenes, el nombre del área de trabajo y el nombre de la imagen de firmware que desee cargar.
• Asegúrese de que la cuenta de Azure tenga los permisos necesarios para cargar imágenes de firmware en el análisis de firmware de Defender para IoT para su suscripción de Azure. Es necesario ser Propietario, Colaborador, Administrador de seguridad o Administrador de análisis de firmware en el nivel de suscripción o grupo de recursos para cargar imágenes de firmware. Para obtener más información, visite Capacidades, ámbitos y roles de análisis de firmware de Defender para IoT.
• Asegúrese de que la imagen de firmware se almacene en el mismo directorio que el script de Python.
• Instale los paquetes necesarios para ejecutar este script:

  pip install azure-mgmt-iotfirmwaredefense
  pip install azure-identity
  

• Inicie sesión en la cuenta de Azure con el comando az login.

Ejecute el siguiente script de Python

Copie el siguiente script de Python en un archivo .py y guárdelo en el mismo directorio que la imagen de firmware. Reemplace la variable subscription_id por el identificador de suscripción de Azure, resource_group_name por el nombre del grupo de recursos donde desee cargar la imagen de firmware y firmware_file por el nombre de la imagen de firmware, que se guarda en el mismo directorio que el script de Python.

from azure.identity import AzureCliCredential
from azure.mgmt.iotfirmwaredefense import *
from azure.mgmt.iotfirmwaredefense.models import *
from azure.core.exceptions import *
from azure.storage.blob import BlobClient
import uuid
from time import sleep
from halo import Halo
from tabulate import tabulate

subscription_id = "subscription-id"
resource_group_name = "resource-group-name"
workspace_name = "default"
firmware_file = "firmware-image-name"

def main():
    firmware_id = str(uuid.uuid4())
    fw_client = init_connections(firmware_id)
    upload_firmware(fw_client, firmware_id)
    get_results(fw_client, firmware_id)

def init_connections(firmware_id):
    spinner = Halo(text=f"Creating client for firmware {firmware_id}")
    cli_credential = AzureCliCredential()
    client = IoTFirmwareDefenseMgmtClient(cli_credential, subscription_id, 'https://management.azure.com')
    spinner.succeed()
    return client

def upload_firmware(fw_client, firmware_id):
    spinner = Halo(text="Uploading firmware to Azure...", spinner="dots")
    spinner.start()
    token = fw_client.workspaces.generate_upload_url(resource_group_name, workspace_name, {"firmware_id": firmware_id})
    fw_client.firmwares.create(resource_group_name, workspace_name, firmware_id, {"properties": {"file_name": firmware_file, "vendor": "Contoso Ltd.", "model": "Wifi Router", "version": "1.0.1", "status": "Pending"}})
    bl_client = BlobClient.from_blob_url(token.url)
    with open(file=firmware_file, mode="rb") as data:
        bl_client.upload_blob(data=data)
    spinner.succeed()

def get_results(fw_client, firmware_id):
    fw = fw_client.firmwares.get(resource_group_name, workspace_name, firmware_id)

    spinner = Halo("Waiting for analysis to finish...", spinner="dots")
    spinner.start()
    while fw.properties.status != "Ready":
        sleep(5)
        fw = fw_client.firmwares.get(resource_group_name, workspace_name, firmware_id)
    spinner.succeed()

    print("-"*107)

    summary = fw_client.summaries.get(resource_group_name, workspace_name, firmware_id, summary_name=SummaryName.FIRMWARE)
    print_summary(summary.properties)
    print()

    components = fw_client.sbom_components.list_by_firmware(resource_group_name, workspace_name, firmware_id)
    if components is not None:
        print_components(components)
    else:
        print("No components found")

def print_summary(summary):
    table = [[summary.extracted_size, summary.file_size, summary.extracted_file_count, summary.component_count, summary.binary_count, summary.analysis_time_seconds, summary.root_file_systems]]
    header = ["Extracted Size", "File Size", "Extracted Files", "Components", "Binaries", "Analysis Time", "File Systems"]
    print(tabulate(table, header))

def print_components(components):
    table = []
    header = ["Component", "Version", "License", "Paths"]
    for com in components:
        table.append([com.properties.component_name, com.properties.version, com.properties.license, com.properties.file_paths])
    print(tabulate(table, header, maxcolwidths=[None, None, None, 57]))

if __name__ == "__main__":
    exit(main())