Partager via

Démarrage rapide : Charger des images de microprogramme dans Analyse du microprogramme en utilisant Python

  • Article

Cet article explique comment utiliser un script Python pour charger des images de microprogramme dans Analyse du microprogramme.

Analyse du microprogramme est un outil qui analyse les images de microprogramme et qui permet de comprendre les vulnérabilités de sécurité dans les images de microprogramme.

Prérequis

Ce guide de démarrage rapide part du principe que vous connaissez les bases d’Analyse du microprogramme. Pour obtenir plus d’informations, consultez Analyse de microprogramme pour les fabricants d’appareils. Pour obtenir la liste des systèmes de fichiers pris en charge, consultez Questions fréquentes (FAQ) sur Analyse du microprogramme.

Préparation de votre environnement

  1. Python version 3.8+ est nécessaire pour utiliser ce package. Exécutez la commande python --version pour vérifier la version de Python que vous utilisez.
  2. Notez votre ID d’abonnement Azure, le nom de votre groupe de ressources dans lequel vous souhaitez charger vos images, le nom de votre espace de travail et le nom de l’image du microprogramme que vous souhaitez charger.
  3. Vérifiez que votre compte Azure dispose des autorisations nécessaires pour charger des images de microprogramme dans Analyse du microprogramme pour votre abonnement Azure. Vous devez être propriétaire, contributeur, administrateur de sécurité ou administrateur d’analyse du microprogramme au niveau de l’abonnement ou du groupe de ressources pour charger des images de microprogramme. Pour plus d’informations, consultez Rôles, étendues et fonctionnalités d’Analyse du microprogramme.
  4. Vérifiez que votre image de microprogramme est stockée dans le même répertoire que le script Python.
  5. Installez les packages nécessaires pour exécuter ce script : 
    pip install azure-mgmt-iotfirmwaredefense
pip install azure-identity
  6. Connectez-vous à votre compte Azure en exécutant la commande az login.

Exécutez le script Python suivant

Copiez le script Python suivant dans un fichier .py et enregistrez-le dans le même répertoire que votre image de microprogramme. Remplacez la variable subscription_id par votre ID d’abonnement Azure, resource_group_name par le nom de votre groupe de ressources dans lequel vous souhaitez charger votre image de microprogramme et firmware_file par le nom de votre image de microprogramme, qui est enregistré dans le même répertoire que le script 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())