root@generate-random:~/mac-addresses/go$ _

Generate Random MAC Addresses in Go

Complete code tutorial with examples and best practices

[ Code Example - Quick Summary ]

Language: Go

What: Generate random MAC addresses in Go using math/rand and formatting. Covers standard format, locally administered addresses, vendor prefixes, and validation for microservices testing.

Try it: Use our interactive Mac-addresses generator or integrate this code into your Go application.

Generate random MAC addresses in Go using math/rand and formatting. Covers standard format, locally administered addresses, vendor prefixes, and validation for microservices testing. Looking for other languages? Check our code examples in PHP , JavaScript , Python , Java , C# , C++ and Ruby or use our interactive web generator.

Go Code Example

package main

import (
    "fmt"
    "math/rand"
    "regexp"
    "strings"
    "time"
)

func init() {
    rand.Seed(time.Now().UnixNano())
}

// Generate random MAC address (standard format)
func randomMacAddress() string {
    octets := make([]string, 6)
    for i := 0; i < 6; i++ {
        octets[i] = fmt.Sprintf("%02X", rand.Intn(256))
    }
    return strings.Join(octets, ":")
}

// Generate locally administered MAC address (bit 1 of first octet set)
func randomLocalMacAddress() string {
    // First octet: set bit 1 (locally administered), clear bit 0 (unicast)
    firstOctet := (rand.Intn(128) & 0xFE) | 0x02
    octets := []string{fmt.Sprintf("%02X", firstOctet)}

    for i := 1; i < 6; i++ {
        octets = append(octets, fmt.Sprintf("%02X", rand.Intn(256)))
    }
    return strings.Join(octets, ":")
}

// Generate MAC with specific vendor prefix (OUI)
func randomMacWithVendor(vendorPrefix string) string {
    vendor := strings.Split(vendorPrefix, ":")
    octets := vendor

    for i := len(vendor); i < 6; i++ {
        octets = append(octets, fmt.Sprintf("%02X", rand.Intn(256)))
    }
    return strings.Join(octets, ":")
}

// Generate MAC with different separator
func randomMacFormatted(separator string) string {
    octets := make([]string, 6)
    for i := 0; i < 6; i++ {
        octets[i] = fmt.Sprintf("%02X", rand.Intn(256))
    }
    return strings.Join(octets, separator)
}

// Validate MAC address format
func isValidMacAddress(mac string) bool {
    patterns := []string{
        `^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$`,  // 00:1A:2B:3C:4D:5E
        `^([0-9A-Fa-f]{2}-){5}[0-9A-Fa-f]{2}$`,  // 00-1A-2B-3C-4D-5E
        `^[0-9A-Fa-f]{12}$`,                      // 001A2B3C4D5E
    }

    for _, pattern := range patterns {
        matched, _ := regexp.MatchString(pattern, mac)
        if matched {
            return true
        }
    }
    return false
}

// Generate multiple MAC addresses
func generateMacAddresses(count int) []string {
    macs := make([]string, count)
    for i := 0; i < count; i++ {
        macs[i] = randomMacAddress()
    }
    return macs
}

func main() {
    fmt.Println("Random MAC:", randomMacAddress())
    fmt.Println("Local MAC:", randomLocalMacAddress())
    fmt.Println("Vendor MAC:", randomMacWithVendor("00:1A:2B"))
    fmt.Println("Dash format:", randomMacFormatted("-"))
    fmt.Println("No separator:", randomMacFormatted(""))
    fmt.Println("Is valid:", isValidMacAddress("00:1A:2B:3C:4D:5E"))
    fmt.Println("Batch:", generateMacAddresses(3))
}

[EXPLANATION]

Go's rand.Intn(256) generates random octets, and fmt.Sprintf("%02X") formats as 2-digit uppercase hexadecimal with zero-padding. strings.Join() concatenates with separators. Locally administered MACs use bitwise operations (& 0xFE and | 0x02). regexp.MatchString() validates patterns. make([]string, 6) pre-allocates slices for efficiency. Always call rand.Seed() once at program start for proper randomization.

Expected Output

Random MAC: A3:45:B7:89:CD:EF
Local MAC: 02:45:B7:89:CD:EF
Vendor MAC: 00:1A:2B:89:CD:EF
Dash format: A3-45-B7-89-CD-EF
No separator: A345B789CDEF
Is valid: true
Batch: [12:34:56:78:9A:BC DE:F0:12:34:56:78 9A:BC:DE:F0:12:34]