TamaGo - Go su metallo nudo

tamago | https://github.com/usbarmory/tamago

Copyright (c) Gli autori di TamaGo. Tutti i diritti riservati.

Introduzione

TamaGo è un framework che consente la compilazione e l'esecuzione di applicazioni Go libere su processori bare metal (AMD64, ARM, ARM64, RISCV64).

Il progetto nasce dal desiderio di ridurre la superficie di attacco del firmware dei sistemi embedded rimuovendo qualsiasi dipendenza runtime dal codice C e dai sistemi operativi.

Il framework TamaGo consiste nei seguenti componenti:

• Una distribuzione Go modificata che estende il supporto di GOOS al target tamago, consentendo l'esecuzione bare metal attraverso un overlay runtime/goos impostato da GOOSPKG.

• Pacchetti Go per il supporto di processori/SoC.

• Pacchetti Go per il supporto di schede.

Le modifiche sono minime rispetto al compilatore Go originale, al runtime e all'applicazione target (è richiesta una import), con una netta separazione dalle altre architetture.

Viene posta una forte enfasi sul riutilizzo del codice dalle architetture esistenti già incluse nel runtime Go standard, vedi Interni.

Le modifiche mantengono il supporto completo della libreria standard.

Tali aspetti sono motivati dal desiderio di fornire un framework che consenta lo sviluppo sicuro di firmware Go su sistemi embedded.

Versioni correnti

I seguenti link sono le ultime versioni per la distribuzione Go modificata di TamaGo, che aggiunge il supporto GOOS=tamago alla corrispondente versione di Go, e la libreria TamaGo:

Documentazione

La documentazione principale si trova sul wiki del progetto.

La documentazione dell'API del pacchetto si trova su pkg.go.dev.

Target AMD64 supportati

La tabella seguente riassume i target x86-64 attualmente supportati (GOOS=tamago GOARCH=amd64).

Target ARM supportati

La tabella seguente riassume i SoC e le schede ARM attualmente supportati (GOOS=tamago GOARCH=arm).

Target ARM64 supportati

La tabella seguente riassume i SoC e le schede ARM64 attualmente supportati (GOOS=tamago GOARCH=arm64).

Target RISC-V supportati

La tabella seguente riassume i SoC e le schede RISC-V attualmente supportati (GOOS=tamago GOARCH=riscv64).

Target in spazio utente

L'esecuzione di programmi compilati con GOOS=tamago può avvenire anche nello spazio utente importando qualsiasi pacchetto che implementi l'overlay runtime/goos richiesto con la supervisione del sistema operativo invece dei driver bare metal.

Compilare ed eseguire programmi Go nello spazio utente come GOOS=tamago offre il vantaggio dell'isolamento delle chiamate di sistema poiché l'eseguibile non può sfruttare il runtime Go per accedere direttamente alle risorse del sistema operativo, ciò si traduce in:

• isolamento dal filesystem del sistema operativo, tramite disco emulato in memoria
• isolamento dalla rete del sistema operativo, vedi net.SocketFunc
• API per gestori personalizzati di rete, rng, tempo

La tabella seguente riassume il supporto attualmente disponibile per lo spazio utente:

¹ Usato per eseguire test di distribuzione standard e go test -tags user_linux

Compilazione

Distribuzione Go con supporto GOOS=tamago

Il comando tamago scarica, compila ed esegue il comando go dalla distribuzione TamaGo che corrisponde alla versione del modulo tamago dal go.mod dell'applicazione.

Le applicazioni possono aggiungere github.com/usbarmory/tamago a go.mod, e quindi sostituire il comando go con:

go run github.com/usbarmory/tamago/cmd/tamago

oppure aggiungere la seguente riga a go.mod per usare go tool tamago come comando go:

tool github.com/usbarmory/tamago/cmd/tamago

In alternativa l'ultima distribuzione TamaGo può essere compilata manualmente o si può usare l'ultima release binaria:

wget https://github.com/usbarmory/tamago-go/archive/refs/tags/latest.zip
unzip latest.zip
cd tamago-go-latest/src && ./all.bash
cd ../bin && export TAMAGO=`pwd`/go

Compilazione di applicazioni

Durante la compilazione, la variabile d'ambiente Go GOOSPKG deve essere impostata per abilitare questa libreria come overlay a supporto di GOOS=tamago.

export GOOSPKG=github.com/usbarmory/tamago

Le applicazioni Go devono importare il pacchetto scheda pertinente per garantire che l'inizializzazione dell'hardware e il supporto runtime avvengano:

import (
	// Esempio per USB armory Mk II
	_ "github.com/usbarmory/tamago/board/usbarmory/mk2"
)

Le applicazioni Go possono essere compilate con il compilatore costruito nel passaggio precedente, con l'aggiunta di alcuni flag/variabili:

# imposta questa libreria come overlay `runtime/goos`
export GOOSPKG=github.com/usbarmory/tamago

# Esempio per Cloud Hypervisor, QEMU e Firecracker KVM
GOOS=tamago GOARCH=amd64 ${TAMAGO} build -ldflags "-T 0x10010000 -R 0x1000" main.go

# Esempio per NXP i.MX6UL
GOOS=tamago GOARM=7 GOARCH=arm ${TAMAGO} build -ldflags "-T 0x80010000 -R 0x1000" main.go

# Esempio per NXP 8MPLUSLPD4-EVK
GOOS=tamago GOARCH=arm64 ${TAMAGO} build -ldflags "-T 0x40010000 -R 0x1000" main.go

# Esempio per SiFive FU540
GOOS=tamago GOARCH=riscv64 ${TAMAGO} build -ldflags "-T 0x80010000 -R 0x1000" main.go

# Esempio per AI Foundry Erbium
GOOS=tamago GOARCH=riscv64 GOSOFT=1 ${TAMAGO} build -ldflags "-T 0x40010000 -R 0x1000" main.go

# Esempio per spazio utente Linux
GOOS=tamago ${TAMAGO} build main.go

Vedi il file README del rispettivo pacchetto scheda per le informazioni di compilazione per ogni target specifico.

Tag di compilazione

I seguenti tag di compilazione consentono alle applicazioni di sovrascrivere la definizione del pacchetto per l'overlay runtime/goos:

• linkramstart: sovrascrive ramStart
• linkramsize: sovrascrive ramSize
• linkprintk: sovrascrive printk
• linkcpuinit: sovrascrive cpuinit
• tiny: riduce i requisiti di allocazione heap

Esecuzione e debug

Vedi il file README del rispettivo pacchetto scheda per le informazioni di esecuzione e debug per ogni target specifico (reale o emulato).

L'applicazione di esempio fornisce esempi di utilizzo dei driver e istruzioni per l'esecuzione nativa ed emulata.

Un'esecuzione emulata dell'applicazione di esempio può essere lanciata come segue:

git clone https://github.com/usbarmory/tamago-example
cd tamago-example && make qemu

Applicazioni che utilizzano TamaGo

• go-boot - il gestore di avvio UEFI Go su bare metal
• GoKey - la smartcard Go su bare metal
• GoTEE - ambiente di esecuzione fidato Go
• ArmoredWitness - rete di testimoni cross-ecosistema
• armory-drive - unità USB crittata
• armory-ums - firmware USB Mass Storage
• armory-boot - boot loader USB armory
• tamago-example - applicazione di esempio TamaGo
• tamago-sev-example - esempio di VM confidenziale (AMD SEV-SNP)
• kotama - dimostratore di target RISC-V miniaturizzato
• kanzashi - agente bare metal

Driver esterni che utilizzano TamaGo

• go-net - Driver di rete generico
• go-net/imx-usb - Driver i.MX Ethernet over USB
• go-net/virtio - Driver di rete VirtIO
• imx-usbserial - Driver i.MX Serial over USB

Risorse aggiuntive

• API del pacchetto
• API di runtime
• Compatibilità
• Interni
• FAQ
• Presentazioni: TamaGo, ArmoredWitness

Manutentori

Andrea Barisani
[email protected]

Andrej Rosano
[email protected]

Licenza

tamago | https://github.com/usbarmory/tamago
Copyright (c) Gli autori di TamaGo. Tutti i diritti riservati.

Questo progetto è distribuito sotto la licenza BSD-style presente nel file LICENSE.

Il logo TamaGo è adattato dal gopher Go progettato da Renee French e concesso in licenza sotto la licenza Creative Commons 3.0 Attribuzione. Illustrazione vettoriale del gopher Go di Hugo Arganda.