Guia de início rápido: carregue imagens de firmware para o Defender for IoT Firmware Analysis usando Python

Este artigo explica como usar um script Python para carregar imagens de firmware para o Defender for IoT Firmware Analysis.

O Defender for IoT Firmware Analysis é uma ferramenta que analisa imagens de firmware e fornece uma compreensão das vulnerabilidades de segurança nas imagens de firmware.

Pré-requisitos

Este guia de início rápido pressupõe uma compreensão básica da Análise de Firmware do Defender for IoT. Para obter mais informações, consulte Análise de firmware para construtores de dispositivos. Para obter uma lista dos sistemas de arquivos suportados, consulte Perguntas freqüentes sobre a análise de firmware do Defender for IoT.

Preparar o ambiente

• Python versão 3.8+ é necessária para usar este pacote. Execute o comando python --version para verificar sua versão do Python.
• Anote a sua ID de subscrição do Azure, o nome do seu Grupo de Recursos onde pretende carregar as imagens, o nome da área de trabalho e o nome da imagem de firmware que pretende carregar.
• Certifique-se de que sua conta do Azure tenha as permissões necessárias para carregar imagens de firmware no Defender for IoT Firmware Analysis para sua assinatura do Azure. Tem de ser Proprietário, Colaborador, Administrador de Segurança ou Administrador de Análise de Firmware ao nível da Subscrição ou do Grupo de Recursos para carregar imagens de firmware. Para obter mais informações, visite Funções, escopos e recursos de análise de firmware do Defender for IoT.
• Certifique-se de que a imagem do firmware está armazenada no mesmo diretório que o script Python.
• Instale os pacotes necessários para executar este script:

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

• Faça logon na sua conta do Azure executando o comando az login.

Execute o seguinte script Python

Copie o seguinte script Python em um .py arquivo e salve-o no mesmo diretório da imagem do firmware. Substitua a subscription_id variável pela ID da assinatura do Azure, resource_group_name pelo nome do Grupo de Recursos onde você deseja carregar a imagem do firmware e firmware_file pelo nome da imagem do firmware, que é salva no mesmo diretório do 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())