gosmbios

README

gosmbios

Pure Go implementation for reading SMBIOS/DMI data across Windows, Linux, and macOS on both AMD64 and ARM64 architectures.

Implements DSP0134 SMBIOS Reference Specification Version 3.9.0 with 100% type coverage.

Features

• Pure Go - No external dependencies or tools required
• Cross-platform - Supports Windows, Linux, and macOS
• Multi-architecture - Works on AMD64 and ARM64
• Complete Coverage - Implements all 47 SMBIOS structure types (including obsolete)
• Modular - Each SMBIOS type is in its own package
• Type-safe - Full Go type definitions with constants and methods

Supported SMBIOS Types

Core System Information

Type	Package	Description
0	types/type0	BIOS Information
1	types/type1	System Information
2	types/type2	Baseboard (Motherboard) Information
3	types/type3	System Enclosure/Chassis

Processor & Cache

Type	Package	Description
4	types/type4	Processor Information
7	types/type7	Cache Information
44	types/type44	Processor Additional Information

Memory

Type	Package	Description
5	types/type5	Memory Controller Information (obsolete)
6	types/type6	Memory Module Information (obsolete)
16	types/type16	Physical Memory Array
17	types/type17	Memory Device
18	types/type18	32-Bit Memory Error Information
19	types/type19	Memory Array Mapped Address
20	types/type20	Memory Device Mapped Address
33	types/type33	64-Bit Memory Error Information
37	types/type37	Memory Channel

Ports & Slots

Type	Package	Description
8	types/type8	Port Connector Information
9	types/type9	System Slots

On-Board Devices

Type	Package	Description
10	types/type10	On Board Devices Information (obsolete)
41	types/type41	Onboard Devices Extended Information

System Configuration

Type	Package	Description
11	types/type11	OEM Strings
12	types/type12	System Configuration Options
13	types/type13	BIOS Language Information
14	types/type14	Group Associations
15	types/type15	System Event Log

Input Devices

Type	Package	Description
21	types/type21	Built-in Pointing Device

Power & Battery

Type	Package	Description
22	types/type22	Portable Battery
23	types/type23	System Reset
25	types/type25	System Power Controls
39	types/type39	System Power Supply

Security

Type	Package	Description
24	types/type24	Hardware Security
43	types/type43	TPM Device

Probes & Thermal

Type	Package	Description
26	types/type26	Voltage Probe
27	types/type27	Cooling Device
28	types/type28	Temperature Probe
29	types/type29	Electrical Current Probe

Management

Type	Package	Description
30	types/type30	Out-of-Band Remote Access
34	types/type34	Management Device
35	types/type35	Management Device Component
36	types/type36	Management Device Threshold Data
38	types/type38	IPMI Device Information
42	types/type42	Management Controller Host Interface

Boot & Firmware

Type	Package	Description
31	types/type31	Boot Integrity Services Entry Point
32	types/type32	System Boot Information
45	types/type45	Firmware Inventory Information

Miscellaneous

Type	Package	Description
40	types/type40	Additional Information
46	types/type46	String Property
127	types/type127	End-of-Table

Installation

go get github.com/earentir/gosmbios

Command Line Tools

The package includes several command-line tools in the cmd/ directory:

smbiosinfo (cmd/info)

Displays comprehensive SMBIOS information in human-readable format.

go run ./cmd/info

smbiosdebug (cmd/debug)

Debug tool showing raw structure information with hex dumps.

go run ./cmd/debug

smbiosdump (cmd/dump)

Dumps SMBIOS data to file in various formats (text, JSON, raw hex).

# Text format (default)
go run ./cmd/dump -o smbios.txt

# JSON format
go run ./cmd/dump -o smbios.json -f json

# Raw hex format
go run ./cmd/dump -f raw > smbios.hex

examples (cmd/examples)

Basic example demonstrating library usage.

go run ./cmd/examples

Quick Start

package main

import (
    "fmt"
    "github.com/earentir/gosmbios"
    "github.com/earentir/gosmbios/types/type0"
    "github.com/earentir/gosmbios/types/type1"
    "github.com/earentir/gosmbios/types/type17"
)

func main() {
    // Read SMBIOS data
    sm, err := gosmbios.Read()
    if err != nil {
        panic(err)
    }

    fmt.Printf("SMBIOS Version: %s\n", sm.EntryPoint.String())

    // Get BIOS Information
    bios, _ := type0.Get(sm)
    fmt.Printf("BIOS: %s %s\n", bios.Vendor, bios.Version)

    // Get System Information
    sys, _ := type1.Get(sm)
    fmt.Printf("System: %s %s\n", sys.Manufacturer, sys.ProductName)
    fmt.Printf("UUID: %s\n", sys.UUID.String())

    // Get Memory Information
    memory, _ := type17.GetPopulated(sm)
    for _, m := range memory {
        fmt.Printf("Memory: %s %s %s\n",
            m.DeviceLocator,
            m.SizeString(),
            m.MemoryType.String())
    }
}

Platform-Specific Behavior

Linux

Reads from /sys/firmware/dmi/tables/smbios_entry_point and /sys/firmware/dmi/tables/DMI. May require root privileges on some systems.

Windows

Uses GetSystemFirmwareTable API to read SMBIOS data. Works without administrative privileges.

macOS

Uses ioreg and system_profiler to gather system information. Some data may be synthesized as macOS doesn't expose raw SMBIOS tables directly.

Advanced Usage

Working with Raw Structures

sm, _ := gosmbios.Read()

// Get all structures of a specific type
for _, s := range sm.GetStructures(17) { // Type 17 = Memory Device
    fmt.Printf("Handle: 0x%04X\n", s.Header.Handle)
    fmt.Printf("Type: %d\n", s.Header.Type)
    fmt.Printf("Length: %d\n", s.Header.Length)

    // Access raw data
    fmt.Printf("Raw byte at 0x04: 0x%02X\n", s.GetByte(0x04))
    fmt.Printf("Raw word at 0x08: 0x%04X\n", s.GetWord(0x08))

    // Access strings
    for i, str := range s.Strings {
        fmt.Printf("String %d: %s\n", i+1, str)
    }
}

Getting All Processors

import "github.com/earentir/gosmbios/types/type4"

processors, _ := type4.GetAll(sm)
for _, proc := range processors {
    if proc.Status.IsPopulated() {
        fmt.Printf("%s: %d cores, %d threads @ %d MHz\n",
            proc.DisplayName(),
            proc.GetCoreCount(),
            proc.GetThreadCount(),
            proc.CurrentSpeed)
    }
}

Checking TPM Status

import "github.com/earentir/gosmbios/types/type43"

tpm, err := type43.Get(sm)
if err == nil && tpm.IsSupported() {
    fmt.Printf("TPM: %s (Spec %s)\n", tpm.Family(), tpm.SpecVersionString())
    fmt.Printf("TPM Vendor: %s\n", tpm.VendorIDString())
}

Getting Battery Information (Laptops)

import "github.com/earentir/gosmbios/types/type22"

batteries, _ := type22.GetAll(sm)
for _, bat := range batteries {
    fmt.Printf("Battery: %s\n", bat.DeviceName)
    fmt.Printf("  Chemistry: %s\n", bat.DeviceChemistry.String())
    fmt.Printf("  Capacity: %s\n", bat.DesignCapacityString())
    fmt.Printf("  Voltage: %s\n", bat.DesignVoltageString())
}

Reading Temperature Probes

import "github.com/earentir/gosmbios/types/type28"

probes, _ := type28.GetAll(sm)
for _, probe := range probes {
    fmt.Printf("Probe: %s\n", probe.Description)
    fmt.Printf("  Location: %s\n", probe.LocationAndStatus.Location().String())
    fmt.Printf("  Status: %s\n", probe.LocationAndStatus.Status().String())
    fmt.Printf("  Range: %s to %s\n", probe.MinimumValueString(), probe.MaximumValueString())
}

Checking if Virtual Machine

import "github.com/earentir/gosmbios/types/type0"

bios, _ := type0.Get(sm)
if bios.IsVirtualMachine() {
    fmt.Println("Running in a virtual machine")
}

Getting Total Memory

import "github.com/earentir/gosmbios/types/type17"

devices, _ := type17.GetPopulated(sm)
var totalMB uint64
for _, dev := range devices {
    totalMB += dev.Size
}
fmt.Printf("Total Memory: %d GB\n", totalMB/1024)

API Reference

Main Package

Function	Description
Read()	Reads and parses SMBIOS data from the system
GetStructure(type)	Returns first structure of given type
GetStructures(type)	Returns all structures of given type

Structure Methods

Method	Description
GetString(index)	Get string by 1-based index
GetByte(offset)	Get byte at offset
GetWord(offset)	Get 16-bit value at offset
GetDWord(offset)	Get 32-bit value at offset
GetQWord(offset)	Get 64-bit value at offset

Type Constants

The types package provides constants for all SMBIOS structure types:

import "github.com/earentir/gosmbios/types"

types.BIOSInformation          // 0
types.SystemInformation        // 1
types.BaseboardInformation     // 2
types.ProcessorInformation     // 4
types.MemoryDevice             // 17
types.TPMDevice                // 43
// ... and all others

Building

# Build all packages and tools
go build ./...

# Build specific tool
go build -o smbiosinfo ./cmd/info
go build -o smbiosdebug ./cmd/debug
go build -o smbiosdump ./cmd/dump

# Cross-compile
GOOS=linux GOARCH=amd64 go build -o smbiosinfo-linux-amd64 ./cmd/info
GOOS=linux GOARCH=arm64 go build -o smbiosinfo-linux-arm64 ./cmd/info
GOOS=windows GOARCH=amd64 go build -o smbiosinfo.exe ./cmd/info
GOOS=darwin GOARCH=amd64 go build -o smbiosinfo-darwin-amd64 ./cmd/info
GOOS=darwin GOARCH=arm64 go build -o smbiosinfo-darwin-arm64 ./cmd/info

Testing

go test ./...

Requirements

• Go 1.21 or later
• Linux: Read access to /sys/firmware/dmi/tables/ (may need root)
• Windows: No special requirements
• macOS: Command-line tools available (ioreg, system_profiler)

License

GNU General Public License v2.0

Contributing

Contributions are welcome! Please feel free to submit issues or pull requests.

References

• DMTF DSP0134 - SMBIOS Reference Specification
• SMBIOS on Wikipedia

Documentation

Overview

Package gosmbios provides pure Go implementation for reading SMBIOS/DMI data across Windows, Linux, and macOS on both AMD64 and ARM64 architectures. Implements DSP0134 SMBIOS Reference Specification Version 3.9.0

Index

• Constants
• Variables
• type EntryPoint
  • func ParseEntryPoint32(data []byte) (*EntryPoint, error)
  • func ParseEntryPoint64(data []byte) (*EntryPoint, error)
  • func (ep *EntryPoint) String() string
• type EntryPointType
• type Header
• type RawFileHeader
• type SMBIOS
  • func Read() (*SMBIOS, error)
  • func ReadFromFile(filename string) (*SMBIOS, error)
  • func (sm *SMBIOS) GetStructure(structType uint8) *Structure
  • func (sm *SMBIOS) GetStructures(structType uint8) []Structure
  • func (sm *SMBIOS) WriteToFile(filename string) error
• type Structure
  • func ParseStructures(tableData []byte, maxStructures int) ([]Structure, error)
  • func (s *Structure) GetByte(offset int) uint8
  • func (s *Structure) GetDWord(offset int) uint32
  • func (s *Structure) GetQWord(offset int) uint64
  • func (s *Structure) GetString(index uint8) string
  • func (s *Structure) GetWord(offset int) uint16

Constants

const Version = "3.9.0"

Version represents the SMBIOS specification version implemented

Variables

var (
	ErrNotFound         = errors.New("smbios: entry point not found")
	ErrInvalidChecksum  = errors.New("smbios: invalid checksum")
	ErrUnsupportedOS    = errors.New("smbios: unsupported operating system")
	ErrAccessDenied     = errors.New("smbios: access denied (try running as root/admin)")
	ErrInvalidStructure = errors.New("smbios: invalid structure format")
)

Common errors

Types

type EntryPoint

type EntryPoint struct {
	Type             EntryPointType
	MajorVersion     uint8
	MinorVersion     uint8
	Revision         uint8 // Only for 3.x
	TableAddress     uint64
	TableLength      uint32
	TableMaxSize     uint32 // Only for 3.x
	StructureCount   uint16 // Only for 2.x (not reliable for 3.x)
	BCDRevision      uint8  // Only for 2.x
	EntryPointLength uint8
}

EntryPoint contains SMBIOS entry point information

func ParseEntryPoint32

func ParseEntryPoint32(data []byte) (*EntryPoint, error)

ParseEntryPoint32 parses a 32-bit SMBIOS entry point (_SM_)

func ParseEntryPoint64

func ParseEntryPoint64(data []byte) (*EntryPoint, error)

ParseEntryPoint64 parses a 64-bit SMBIOS entry point (_SM3_)

func (*EntryPoint) String

func (ep *EntryPoint) String() string

String returns a human-readable version string

type EntryPointType

type EntryPointType int

EntryPointType indicates the SMBIOS entry point version

const (
	EntryPoint32Bit EntryPointType = iota // SMBIOS 2.x 32-bit entry point
	EntryPoint64Bit                       // SMBIOS 3.x 64-bit entry point
)

type Header

type Header struct {
	Type   uint8
	Length uint8
	Handle uint16
}

Header represents the common SMBIOS structure header (4 bytes)

type RawFileHeader

type RawFileHeader struct {
	Magic          [9]byte // "SMBIOSRAW"
	Version        uint8   // File format version (1)
	EntryPointType uint8   // 0 = 32-bit, 1 = 64-bit
	MajorVersion   uint8   // SMBIOS major version
	MinorVersion   uint8   // SMBIOS minor version
	Revision       uint8   // SMBIOS revision (3.x only)
	Reserved       uint8   // Padding
	TableLength    uint32  // Length of raw table data that follows
	TableAddress   uint64  // Original table address (for reference)
}

RawFileHeader represents the header of a raw SMBIOS dump file This is a simple header followed by the raw SMBIOS table bytes

type SMBIOS

type SMBIOS struct {
	EntryPoint EntryPoint
	Structures []Structure
}

SMBIOS holds all parsed SMBIOS data

func Read

func Read() (*SMBIOS, error)

Read reads and parses SMBIOS data from the system This is the main entry point for the library

func ReadFromFile

func ReadFromFile(filename string) (*SMBIOS, error)

ReadFromFile reads SMBIOS data from a binary dump file The file format is a simple binary format: - 32 bytes: Entry point header - Remaining: Raw SMBIOS table data

func (*SMBIOS) GetStructure

func (sm *SMBIOS) GetStructure(structType uint8) *Structure

GetStructure returns the first structure of the specified type, or nil if not found

func (*SMBIOS) GetStructures

func (sm *SMBIOS) GetStructures(structType uint8) []Structure

GetStructures returns all structures of the specified type

func (*SMBIOS) WriteToFile

func (sm *SMBIOS) WriteToFile(filename string) error

WriteToFile writes SMBIOS data to a binary dump file

type Structure

type Structure struct {
	Header  Header
	Data    []byte   // Raw formatted section data (includes header)
	Strings []string // String table entries
}

Structure represents a single SMBIOS structure with its data and strings

func ParseStructures

func ParseStructures(tableData []byte, maxStructures int) ([]Structure, error)

ParseStructures parses raw SMBIOS table data into individual structures

func (*Structure) GetByte

func (s *Structure) GetByte(offset int) uint8

GetByte returns a byte at the given offset in the formatted section

func (*Structure) GetDWord

func (s *Structure) GetDWord(offset int) uint32

GetDWord returns a 32-bit little-endian value at the given offset

func (*Structure) GetQWord

func (s *Structure) GetQWord(offset int) uint64

GetQWord returns a 64-bit little-endian value at the given offset

func (*Structure) GetString

func (s *Structure) GetString(index uint8) string

GetString returns a string from the string table (1-indexed as per SMBIOS spec) Returns empty string if index is 0 or out of bounds

func (*Structure) GetWord

func (s *Structure) GetWord(offset int) uint16

GetWord returns a 16-bit little-endian value at the given offset