Auf Englisch lesen

Freigeben über

Schnellstart: Hochladen von Firmwareimages in die Firmwareanalyse mit Python

  • Artikel

In diesem Artikel wird erläutert, wie Sie ein Python-Skript verwenden, um Firmwareimages in die Firmwareanalyse hochzuladen.

Die Firmwareanalyse ist ein Tool, das Firmwareimages analysiert und ein Verständnis von Sicherheitsrisiken in den Firmwareimages vermittelt.

Voraussetzungen

In diesem Schnellstart wird ein grundlegendes Verständnis der Firmwareanalyse vorausgesetzt. Weitere Informationen finden Sie unter Firmwareanalyse für Geräteentwickler. Eine Liste der unterstützten Dateisysteme finden Sie unter Häufig gestellte Fragen zur Firmwareanalyse.

Vorbereiten der Umgebung

  1. Für die Verwendung dieses Pakets ist die Python-Version 3.8 oder höher erforderlich. Führen Sie den Befehl python --version aus, um Ihre Python-Version zu überprüfen.
  2. Notieren Sie sich Ihre Azure-Abonnement-ID, den Namen Ihrer Ressourcengruppe, in die Sie Ihre Images hochladen möchten, Ihren Arbeitsbereichsnamen und den Namen des Firmwareimages, das Sie hochladen möchten.
  3. Stellen Sie sicher, dass Ihr Azure-Konto über die erforderlichen Berechtigungen zum Hochladen von Firmwareimages in die Firmwareanalyse für Ihr Azure-Abonnement verfügt. Sie müssen Besitzer*in, Mitwirkende*r, Sicherheitsadministrator*in oder Firmware-Aalyseadministrator*in auf Abonnement- oder Ressourcengruppenebene sein, um Firmwareimages hochzuladen. Weitere Informationen finden Sie unter Rollen, Bereiche und Funktionen für die Firmwareanalyse.
  4. Stellen Sie sicher, dass Ihr Firmwareimage im selben Verzeichnis wie das Python-Skript gespeichert ist.
  5. Installieren Sie die Pakete, die zum Ausführen dieses Skripts erforderlich sind:
    Python 
    pip install azure-mgmt-iotfirmwaredefense
pip install azure-identity
  6. Melden Sie sich bei Ihrem Azure-Konto an, indem Sie den Befehl az login ausführen.

Ausführen des folgenden Python-Skripts

Kopieren Sie das folgende Python-Skript in eine .py-Datei, und speichern Sie es im selben Verzeichnis wie Ihr Firmwareimage. Ersetzen Sie die subscription_id-Variable durch Ihre Azure-Abonnement-ID, resource_group_name durch den Namen Ihrer Ressourcengruppe, in die Sie Ihr Firmwareimage hochladen möchten, und firmware_file durch den Namen Ihres Firmwareimages, das im selben Verzeichnis wie das Python-Skript gespeichert wird.

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())