TamaGo - Go em bare metal

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

Copyright (c) The TamaGo Authors. Todos os direitos reservados.

Introdução

TamaGo é um framework que possibilita a compilação e execução de aplicações Go sem dependências em processadores bare metal (AMD64, ARM, ARM64, RISCV64).

O projeto surge do desejo de reduzir a superfície de ataque do firmware de sistemas embarcados, removendo qualquer dependência em tempo de execução de código C e sistemas operacionais.

O framework TamaGo consiste nos seguintes componentes:

• Uma distribuição Go modificada que estende o suporte a GOOS para o destino tamago, permitindo execução bare metal através de uma sobreposição runtime/goos definida por GOOSPKG.

• Pacotes Go para suporte a processadores/SoCs.

• Pacotes Go para suporte a placas.

As modificações são mínimas em relação ao compilador Go original, runtime e a aplicação alvo (uma importação necessária), com uma separação limpa de outras arquiteturas.

Uma forte ênfase é colocada na reutilização de código de arquiteturas existentes já incluídas no runtime Go padrão, veja Internos.

As modificações mantêm suporte completo à biblioteca padrão.

Tais aspectos são motivados pelo desejo de fornecer um framework que permita o desenvolvimento seguro de firmware Go em sistemas embarcados.

Lançamentos atuais

Os links a seguir são os lançamentos mais recentes da Distribuição Go modificada TamaGo, que adiciona suporte a GOOS=tamago à versão Go correspondente, e da Biblioteca TamaGo:

Documentação

A documentação principal pode ser encontrada no wiki do projeto.

A documentação da API dos pacotes pode ser encontrada em pkg.go.dev.

Destinos AMD64 suportados

A tabela a seguir resume os destinos x86-64 atualmente suportados (GOOS=tamago GOARCH=amd64).

Destinos ARM suportados

A tabela a seguir resume os SoCs e placas ARM atualmente suportados (GOOS=tamago GOARCH=arm).

Destinos ARM64 suportados

A tabela a seguir resume os SoCs e placas ARM64 atualmente suportados (GOOS=tamago GOARCH=arm64).

Destinos RISC-V suportados

A tabela a seguir resume os SoCs e placas RISC-V atualmente suportados (GOOS=tamago GOARCH=riscv64).

Destinos de espaço de usuário

A execução de programas compilados com GOOS=tamago também pode ocorrer em espaço de usuário, importando qualquer pacote que implemente a sobreposição runtime/goos necessária com supervisão do SO em vez de drivers bare metal.

Compilar e executar programas Go em espaço de usuário como GOOS=tamago fornece o benefício do isolamento de chamadas de sistema, pois o executável não pode aproveitar o runtime Go para acessar diretamente os recursos do SO, isso resulta em:

• isolamento do sistema de arquivos do SO, através de disco emulado em memória
• isolamento de rede do SO, veja net.SocketFunc
• API para rede, rng, manipuladores de tempo personalizados

A tabela a seguir resume o suporte atual para espaço de usuário:

¹ Usado para executar testes de distribuição padrão e go test -tags user_linux

Compilando

Distribuição Go com suporte a GOOS=tamago

O comando tamago baixa, compila e executa o comando go da Distribuição TamaGo correspondente à versão do módulo tamago no go.mod da aplicação.

As aplicações podem adicionar github.com/usbarmory/tamago ao go.mod e, em seguida, substituir o comando go por:

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

ou adicionar a seguinte linha ao go.mod para usar go tool tamago como comando go:

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

Alternativamente, a última distribuição TamaGo pode ser compilada manualmente ou o último lançamento binário pode ser usado:

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

Compilando aplicações

Durante a compilação, a variável de ambiente Go GOOSPKG deve ser definida para habilitar esta biblioteca como sobreposição para suportar GOOS=tamago.

export GOOSPKG=github.com/usbarmory/tamago

As aplicações Go são obrigadas a importar o pacote de placa relevante para garantir que a inicialização de hardware e o suporte de runtime ocorram:

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

As aplicações Go podem ser compiladas com o compilador construído na etapa anterior, com a adição de alguns flags/variáveis:

# define esta biblioteca como sobreposição `runtime/goos`
export GOOSPKG=github.com/usbarmory/tamago

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

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

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

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

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

# Exemplo para espaço de usuário Linux
GOOS=tamago ${TAMAGO} build main.go

Veja o arquivo README do respectivo pacote de placa para informações de compilação para cada destino específico.

Build tags

As seguintes build tags permitem que as aplicações substituam a definição do próprio pacote para a sobreposição runtime/goos:

• linkramstart: substitui ramStart
• linkramsize: substitui ramSize
• linkprintk: substitui printk
• linkcpuinit: substitui cpuinit
• tiny: reduz requisitos de alocação de heap

Executando e depurando

Veja o arquivo README do respectivo pacote de placa para informações de execução e depuração para cada destino específico (real ou emulado).

A aplicação de exemplo fornece uso de driver de exemplo e instruções para execução nativa, bem como emulada.

Uma execução emulada da aplicação de exemplo pode ser iniciada da seguinte forma:

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

Aplicações usando TamaGo

• go-boot - o gerenciador de boot UEFI bare metal Go
• GoKey - o smartcard bare metal Go
• GoTEE - Ambiente de Execução Confiável Go
• ArmoredWitness - rede de testemunhas entre ecossistemas
• armory-drive - unidade criptografada USB
• armory-ums - firmware de Armazenamento em Massa USB
• armory-boot - boot loader do USB armory
• tamago-example - aplicação de exemplo TamaGo
• tamago-sev-example - exemplo de VM confidencial (AMD SEV-SNP)
• kotama - demonstrador de destino RISC-V pequeno
• kanzashi - Agente Bare Metal

Drivers externos usando TamaGo

• go-net - Driver de Rede Genérico
• go-net/imx-usb - Driver i.MX Ethernet sobre USB
• go-net/virtio - Driver de Rede VirtIO
• imx-usbserial - Driver i.MX Serial sobre USB

Recursos adicionais

• API de Pacotes
• API de Runtime
• Compatibilidade
• Internos
• FAQ
• Apresentações: TamaGo, ArmoredWitness

Mantenedores

Andrea Barisani
[email protected]

Andrej Rosano
[email protected]

Licença

tamago | https://github.com/usbarmory/tamago
Copyright (c) The TamaGo Authors. Todos os direitos reservados.

Este projeto é distribuído sob a licença BSD encontrada no arquivo LICENSE.

O logotipo TamaGo é adaptado do gopher Go projetado por Renee French e licenciado sob a licença Creative Commons 3.0 Attributions. Ilustração vetorial do Go Gopher por Hugo Arganda.