Snabbstart: Ladda upp avbildningar av inbyggd programvara till analys av inbyggd programvara med Python

Den här artikeln beskriver hur du använder ett Python-skript för att ladda upp avbildningar av inbyggd programvara till analys av inbyggd programvara.

Analys av inbyggd programvara är ett verktyg som analyserar bilder av inbyggd programvara och ger en förståelse för säkerhetsrisker i avbildningarna av inbyggd programvara.

Förutsättningar

Den här snabbstarten förutsätter en grundläggande förståelse för analys av inbyggd programvara. Mer information finns i Analys av inbyggd programvara för enhetsbyggare. En lista över de filsystem som stöds finns i Vanliga frågor och svar om analys av inbyggd programvara.

Förbered din miljö

1. Python version 3.8+ krävs för att använda det här paketet. Kör kommandot python --version för att kontrollera python-versionen.
2. Anteckna ditt Azure-prenumerations-ID, namnet på resursgruppen där du vill ladda upp dina bilder, arbetsytans namn och namnet på den avbildning av inbyggd programvara som du vill ladda upp.
3. Se till att ditt Azure-konto har de behörigheter som krävs för att ladda upp avbildningar av inbyggd programvara till analys av inbyggd programvara för din Azure-prenumeration. Du måste vara ägare, deltagare, säkerhetsadministratör eller analysadministratör för inbyggd programvara på prenumerations- eller resursgruppsnivå för att ladda upp bilder av inbyggd programvara. Mer information finns i Roller, omfattningar och funktioner för analys av inbyggd programvara.
4. Kontrollera att avbildningen av den inbyggda programvaran lagras i samma katalog som Python-skriptet.
5. Installera de paket som behövs för att köra det här skriptet:

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

6. Logga in på ditt Azure-konto genom att köra kommandot az login.

Kör följande Python-skript

Kopiera följande Python-skript till en .py fil och spara det i samma katalog som din avbildning av inbyggd programvara. Ersätt variabeln subscription_id med ditt Azure-prenumerations-ID med resource_group_name namnet på resursgruppen där du vill ladda upp avbildningen av den inbyggda programvaran och firmware_file med namnet på din avbildning av inbyggd programvara, som sparas i samma katalog som Python-skriptet.

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