Condividi tramite

Guida introduttiva: Caricare immagini del firmware nell'analisi del firmware con Python

Questo articolo illustra come usare uno script Python per caricare immagini del firmware nell'analisi del firmware.

L'analisi del firmware è uno strumento che analizza le immagini del firmware e fornisce informazioni sulle vulnerabilità di sicurezza nelle immagini del firmware.

Prerequisiti

Questa guida introduttiva presuppone una conoscenza di base dell'analisi del firmware. Per altre informazioni, vedere Analisi del firmware per i costruttori di dispositivi Per un elenco dei file system supportati, vedere Domande frequenti sull'analisi del firmware.

Predisporre l'ambiente

  1. Python versione 3.8+ è necessario per usare questo pacchetto. Eseguire il comando python --version per controllare la versione di Python.
  2. Prendere nota dell'ID sottoscrizione di Azure, del nome del gruppo di risorse in cui si vogliono caricare le immagini, il nome dell'area di lavoro e il nome dell'immagine del firmware da caricare.
  3. Assicurarsi che l'account Azure disponga delle autorizzazioni necessarie per caricare immagini del firmware nell'analisi del firmware per la sottoscrizione di Azure. Per caricare immagini firmware, è necessario essere proprietario, collaboratore, amministratore della sicurezza o amministratore dell'analisi del firmware a livello di sottoscrizione o gruppo di risorse. Per altre informazioni, vedere Ruoli di analisi del firmware, ambiti e funzionalità.
  4. Assicurarsi che l'immagine del firmware sia archiviata nella stessa directory dello script Python.
  5. Installare i pacchetti necessari per eseguire questo script: 
    pip install azure.storage.blob
pip install halo
pip install tabulate
  6. Accedere all'account Azure eseguendo il comando az login.

Eseguire lo script Python seguente

Copiare lo script Python seguente in un .py file e salvarlo nella stessa directory dell'immagine del firmware. Sostituire la subscription_id variabile con l'ID sottoscrizione di Azure, resource_group_name con il nome del gruppo di risorse in cui si vuole caricare l'immagine del firmware e firmware_file con il nome dell'immagine del firmware, che viene salvata nella stessa directory dello 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, {"firmwareId": firmware_id})
    fw_client.firmwares.create(resource_group_name, workspace_name, firmware_id, {"properties": {"fileName": 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_type=SummaryType.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())
  • Last updated on