[ ROOT ]
$GENERATE-RANDOM.ORG
▶ Random Everything - 100+ Free Generators // v2.8.5
root@generate-random:~/mac-addresses/code-examples$ _

Random MAC Address Code Examples

Locally administered, vendor-prefixed and formatted MACs in PHP, JavaScript, Python, Java, C#, C++, Ruby and Go

Each example below builds the same five things: a fully random MAC address, a locally administered unicast one such as 02:45:B7:89:CD:EF, one that keeps a vendor prefix, the same value with colon, hyphen or no separators, and a batch, plus a format check. The guide explains the two flag bits that decide whether an address is usable on an interface; each language section then shows the code and what is specific to that language. Prefer no code? The interactive MAC address generator does the same in the browser.

Six octets and two flag bits

A MAC address (EUI-48) is 48 bits, written as six octets: 248 ≈ 2.8 × 1014 values. In a manufacturer's address the first three octets are an OUI that the IEEE Registration Authority assigned to that vendor, and the last three are the vendor's serial number for the interface. The two lowest bits of the first octet are not part of the number, they are flags:

  • Bit 0 (value 0x01), I/G: 0 is an individual (unicast) address, 1 a group (multicast) address. FF:FF:FF:FF:FF:FF is broadcast.
  • Bit 1 (value 0x02), U/L: 0 means universally administered (vendor-assigned), 1 means locally administered (assigned by software or an administrator).

So the fully random function is only good for testing parsers: half of its results are multicast, which no network interface can use as its own address (Linux refuses to set one), and most of the rest fall inside vendor OUI space.

Locally administered unicast is the safe choice

To build an address you can assign to a VM, a container or a test device, take a random first octet, clear bit 0 and set bit 1: (b & 0xFE) | 0x02. The second hex digit of the result is always 2, 6, A or E, as in 02:, 36:, DA: or FE:, which makes these addresses easy to recognize. That leaves 46 random bits, about 7 × 1013 addresses; even 10,000 VMs have roughly a one-in-a-million chance of sharing one. A duplicate only causes trouble inside the same layer-2 segment, where it does break both hosts' traffic.

IEEE 802c divides the local space further by the next two bits; a second digit of 2 is the quadrant left for administrators, which is why 02: is the conventional choice. Hypervisors use their own prefixes: QEMU/KVM 52:54:00, VirtualBox 08:00:27, VMware 00:50:56, Hyper-V 00:15:5D.

Secure or non-secure random?

For test data and VM provisioning the default generator is enough; a seeded one even keeps a lab's addresses stable between rebuilds. MAC randomization for privacy is the case where it does matter: phones and laptops present a random locally administered address per Wi-Fi network (iOS 14+ and Android 10+ by default, Windows as an option) precisely so that a network cannot follow the device. An address generated for that purpose must come from a secure source, or the next address can be predicted from the last.

Common mistakes

  • Inventing a vendor prefix. Any OUI you type, including the 00:1A:2B used in the examples, may be assigned to a real manufacturer, and random NIC bits after it can match a real device. Use a real OUI only when you need the vendor lookup to succeed.
  • Comparing formatted strings. 00:1a:2b:3c:4d:5e, 00-1A-2B-3C-4D-5E and Cisco's 001a.2b3c.4d5e are the same address. Strip separators and lowercase before comparing or storing, or store the 48-bit integer.
  • Reading bit 0 as the leftmost bit. Bit 0 is the least significant bit of the first octet, even though Ethernet transmits it first.
  • Forgetting EUI-64. SLAAC interface IDs built from a MAC (modified EUI-64, RFC 4291) insert FF:FE in the middle and invert the U/L bit, so 02:… becomes 00:… in the IPv6 address.

Common Use Cases

  • Addresses for virtual machines, containers and virtual interfaces (KVM, Hyper-V, Docker, veth, TAP)
  • Device identifiers for IoT fleets and network-device simulators
  • Seed data for asset inventories, DHCP lease tables and network management databases
  • Tests for MAC parsing, normalization, validation and filtering code
  • Sample data for network monitoring dashboards and switch or router logs

Random MAC Address Code Examples in PHP

Generate random MAC addresses in PHP for network testing, device simulation, and development. Covers standard format, locally administered addresses, vendor prefixes, and validation.

<?php
// Generate random MAC address (standard format)
function randomMacAddress() {
    $octets = [];
    for ($i = 0; $i < 6; $i++) {
        $octets[] = sprintf("%02X", mt_rand(0, 255));
    }
    return implode(":", $octets);
}

// Generate locally administered MAC address (bit 1 of first octet set)
function randomLocalMacAddress() {
    $octets = [];
    // First octet: set bit 1 (locally administered), clear bit 0 (unicast)
    $firstOctet = (mt_rand(0, 255) & 0xFE) | 0x02;
    $octets[] = sprintf("%02X", $firstOctet);

    for ($i = 1; $i < 6; $i++) {
        $octets[] = sprintf("%02X", mt_rand(0, 255));
    }
    return implode(":", $octets);
}

// Generate MAC with specific vendor prefix (OUI)
function randomMacWithVendor($vendorPrefix = "00:1A:2B") {
    $vendor = explode(":", $vendorPrefix);
    $octets = $vendor;

    for ($i = count($vendor); $i < 6; $i++) {
        $octets[] = sprintf("%02X", mt_rand(0, 255));
    }
    return implode(":", $octets);
}

// Generate MAC with different separator
function randomMacFormatted($separator = ":") {
    $octets = [];
    for ($i = 0; $i < 6; $i++) {
        $octets[] = sprintf("%02X", mt_rand(0, 255));
    }
    return implode($separator, $octets);
}

// Validate MAC address format
function isValidMacAddress($mac) {
    $patterns = [
        "/^([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
    ];

    foreach ($patterns as $pattern) {
        if (preg_match($pattern, $mac)) {
            return true;
        }
    }
    return false;
}

// Generate multiple MAC addresses
function generateMacAddresses($count = 10) {
    $macs = [];
    for ($i = 0; $i < $count; $i++) {
        $macs[] = randomMacAddress();
    }
    return $macs;
}

// Usage examples
echo "Random MAC: " . randomMacAddress() . "\n";
echo "Local MAC: " . randomLocalMacAddress() . "\n";
echo "Vendor MAC: " . randomMacWithVendor("00:1A:2B") . "\n";
echo "Dash format: " . randomMacFormatted("-") . "\n";
echo "No separator: " . randomMacFormatted("") . "\n";
echo "Is valid: " . (isValidMacAddress("00:1A:2B:3C:4D:5E") ? "true" : "false") . "\n";
print_r(generateMacAddresses(3));

How it works in PHP

This implementation uses mt_rand() for generating random octets (0-255) and sprintf("%02X") for hexadecimal formatting with zero-padding. Locally administered MAC addresses have bit 1 set in the first octet (0x02) and bit 0 cleared (unicast). Vendor prefixes (OUI - Organizationally Unique Identifier) are the first 3 octets. Common formats include colon-separated (00:1A:2B:3C:4D:5E), dash-separated (00-1A-2B-3C-4D-5E), and no separator (001A2B3C4D5E). Validation uses regex patterns for different formats.

Sample 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
Array
(
    [0] => 12:34:56:78:9A:BC
    [1] => DE:F0:12:34:56:78
    [2] => 9A:BC:DE:F0:12:34
)

PHP notes

  • filter_var($mac, FILTER_VALIDATE_MAC) accepts colon, hyphen and Cisco dot formats, so no regex is needed.
  • For a secure address: $b = random_bytes(6); $b[0] = chr((ord($b[0]) & 0xFE) | 0x02);, then bin2hex($b).
  • implode(':', str_split(bin2hex($b), 2)) adds the separators.

Random MAC Address Code Examples in JavaScript

Generate random MAC addresses in JavaScript for Node.js and frontend applications. Covers standard format, locally administered addresses, vendor prefixes, and validation.

// Generate random MAC address (standard format)
function randomMacAddress() {
    return Array.from({length: 6}, () =>
        Math.floor(Math.random() * 256).toString(16).padStart(2, "0").toUpperCase()
    ).join(":");
}

// Generate locally administered MAC address (bit 1 of first octet set)
function randomLocalMacAddress() {
    const octets = [];
    // First octet: set bit 1 (locally administered), clear bit 0 (unicast)
    const firstOctet = ((Math.floor(Math.random() * 256) & 0xFE) | 0x02);
    octets.push(firstOctet.toString(16).padStart(2, "0").toUpperCase());

    for (let i = 1; i < 6; i++) {
        octets.push(Math.floor(Math.random() * 256).toString(16).padStart(2, "0").toUpperCase());
    }
    return octets.join(":");
}

// Generate MAC with specific vendor prefix (OUI)
function randomMacWithVendor(vendorPrefix = "00:1A:2B") {
    const vendor = vendorPrefix.split(":");
    const octets = [...vendor];

    for (let i = vendor.length; i < 6; i++) {
        octets.push(Math.floor(Math.random() * 256).toString(16).padStart(2, "0").toUpperCase());
    }
    return octets.join(":");
}

// Generate MAC with different separator
function randomMacFormatted(separator = ":") {
    return Array.from({length: 6}, () =>
        Math.floor(Math.random() * 256).toString(16).padStart(2, "0").toUpperCase()
    ).join(separator);
}

// Validate MAC address format
function isValidMacAddress(mac) {
    const patterns = [
        /^([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
    ];

    return patterns.some(pattern => pattern.test(mac));
}

// Generate multiple MAC addresses
function generateMacAddresses(count = 10) {
    return Array.from({length: count}, () => randomMacAddress());
}

// Usage examples
console.log("Random MAC:", randomMacAddress());
console.log("Local MAC:", randomLocalMacAddress());
console.log("Vendor MAC:", randomMacWithVendor("00:1A:2B"));
console.log("Dash format:", randomMacFormatted("-"));
console.log("No separator:", randomMacFormatted(""));
console.log("Is valid:", isValidMacAddress("00:1A:2B:3C:4D:5E"));
console.log("Batch:", generateMacAddresses(3));

How it works in JavaScript

JavaScript's Math.random() generates random values for each octet, toString(16) converts to hexadecimal, and padStart(2, "0") zero-pads to 2 digits. Array.from() creates arrays efficiently. Locally administered MACs have bit 1 set (0x02) and bit 0 cleared in the first octet. Bitwise operations (& 0xFE, | 0x02) manipulate individual bits. Common separators include colon (:), dash (-), and none. Validation uses regex with some() to check multiple patterns.

Sample 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" ]

JavaScript notes

  • const b = crypto.getRandomValues(new Uint8Array(6)); b[0] = (b[0] & 0xfe) | 0x02; gives a secure locally administered address.
  • @faker-js/faker's faker.internet.mac() randomizes all twelve digits, so about half of its results are multicast; faker.internet.mac('-') sets the separator.
  • os.networkInterfaces() in Node lists the real MACs on the machine, useful to make sure a generated address does not clash locally.

Random MAC Address Code Examples in Python

Generate random MAC addresses in Python using random and Faker library. Covers standard format, locally administered addresses, vendor prefixes, and validation.

import random

# Generate random MAC address (standard format)
def random_mac_address():
    octets = [random.randint(0, 255) for _ in range(6)]
    return ":".join(f"{octet:02X}" for octet in octets)

# Generate locally administered MAC address (bit 1 of first octet set)
def random_local_mac_address():
    # First octet: set bit 1 (locally administered), clear bit 0 (unicast)
    first_octet = (random.randint(0, 255) & 0xFE) | 0x02
    octets = [first_octet] + [random.randint(0, 255) for _ in range(5)]
    return ":".join(f"{octet:02X}" for octet in octets)

# Generate MAC with specific vendor prefix (OUI)
def random_mac_with_vendor(vendor_prefix="00:1A:2B"):
    vendor = vendor_prefix.split(":")
    octets = [int(octet, 16) for octet in vendor]

    for _ in range(6 - len(octets)):
        octets.append(random.randint(0, 255))

    return ":".join(f"{octet:02X}" for octet in octets)

# Generate MAC with different separator
def random_mac_formatted(separator=":"):
    octets = [random.randint(0, 255) for _ in range(6)]
    return separator.join(f"{octet:02X}" for octet in octets)

# Validate MAC address format
def is_valid_mac_address(mac):
    import re
    patterns = [
        r"^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$",  # 00:1A:2B:3C:4D:5E
        r"^([0-9A-Fa-f]{2}-){5}[0-9A-Fa-f]{2}$",  # 00-1A-2B-3C-4D-5E
        r"^[0-9A-Fa-f]{12}$",                      # 001A2B3C4D5E
    ]

    return any(re.match(pattern, mac) for pattern in patterns)

# Generate multiple MAC addresses
def generate_mac_addresses(count=10):
    return [random_mac_address() for _ in range(count)]

# Using Faker library (install: pip install faker)
# from faker import Faker
# fake = Faker()
# mac = fake.mac_address()  # Format: XX:XX:XX:XX:XX:XX

# Usage examples
print("Random MAC:", random_mac_address())
print("Local MAC:", random_local_mac_address())
print("Vendor MAC:", random_mac_with_vendor("00:1A:2B"))
print("Dash format:", random_mac_formatted("-"))
print("No separator:", random_mac_formatted(""))
print("Is valid:", is_valid_mac_address("00:1A:2B:3C:4D:5E"))
print("Batch:", generate_mac_addresses(3))

How it works in Python

Python's random.randint(0, 255) generates random octets, and f-strings with {octet:02X} format as 2-digit uppercase hexadecimal. List comprehensions create octet arrays efficiently. Locally administered MACs use bitwise operations (& 0xFE clears bit 0, | 0x02 sets bit 1). The Faker library provides fake.mac_address() for realistic MAC generation. Validation uses re.match() with any() to check multiple patterns. Format specifier :02X means 2-digit uppercase hex with zero-padding.

Sample 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"]

Python notes

  • The whole address fits in one draw: n = (random.getrandbits(48) & ~(1 << 40)) | (1 << 41), since the first octet is the top byte of the 48-bit integer.
  • Faker's mac_address() returns unicast by default (multicast=False) but does not set the locally administered bit.
  • uuid.getnode() returns this machine's MAC as an integer, or a random number with the multicast bit set when no hardware address is found.
  • Use secrets.token_bytes(6) for the secure variant.

Random MAC Address Code Examples in Java

Generate random MAC addresses in Java using Random and JavaFaker. Covers standard format, locally administered addresses, vendor prefixes, and validation.

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class MacAddressGenerator {
    private static final Random random = new Random();

    // Generate random MAC address (standard format)
    public static String randomMacAddress() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 6; i++) {
            if (i > 0) sb.append(":");
            sb.append(String.format("%02X", random.nextInt(256)));
        }
        return sb.toString();
    }

    // Generate locally administered MAC address (bit 1 of first octet set)
    public static String randomLocalMacAddress() {
        StringBuilder sb = new StringBuilder();
        // First octet: set bit 1 (locally administered), clear bit 0 (unicast)
        int firstOctet = (random.nextInt(256) & 0xFE) | 0x02;
        sb.append(String.format("%02X", firstOctet));

        for (int i = 1; i < 6; i++) {
            sb.append(":");
            sb.append(String.format("%02X", random.nextInt(256)));
        }
        return sb.toString();
    }

    // Generate MAC with specific vendor prefix (OUI)
    public static String randomMacWithVendor(String vendorPrefix) {
        String[] vendor = vendorPrefix.split(":");
        StringBuilder sb = new StringBuilder();

        for (String octet : vendor) {
            sb.append(octet).append(":");
        }

        for (int i = vendor.length; i < 6; i++) {
            sb.append(String.format("%02X", random.nextInt(256)));
            if (i < 5) sb.append(":");
        }
        return sb.toString();
    }

    // Generate MAC with different separator
    public static String randomMacFormatted(String separator) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 6; i++) {
            if (i > 0) sb.append(separator);
            sb.append(String.format("%02X", random.nextInt(256)));
        }
        return sb.toString();
    }

    // Validate MAC address format
    public static boolean isValidMacAddress(String mac) {
        String[] patterns = {
            "^([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 (String pattern : patterns) {
            if (mac.matches(pattern)) {
                return true;
            }
        }
        return false;
    }

    // Generate multiple MAC addresses
    public static List<String> generateMacAddresses(int count) {
        return IntStream.range(0, count)
                .mapToObj(i -> randomMacAddress())
                .collect(Collectors.toList());
    }

    // Using JavaFaker library (add dependency: com.github.javafaker:javafaker:1.0.2)
    // import com.github.javafaker.Faker;
    // Faker faker = new Faker();
    // String mac = faker.internet().macAddress();
    // String macWithOui = faker.internet().macAddress("02:00:00"); // the argument is a prefix, not a separator

    public static void main(String[] args) {
        System.out.println("Random MAC: " + randomMacAddress());
        System.out.println("Local MAC: " + randomLocalMacAddress());
        System.out.println("Vendor MAC: " + randomMacWithVendor("00:1A:2B"));
        System.out.println("Dash format: " + randomMacFormatted("-"));
        System.out.println("No separator: " + randomMacFormatted(""));
        System.out.println("Is valid: " + isValidMacAddress("00:1A:2B:3C:4D:5E"));
        System.out.println("Batch: " + generateMacAddresses(3));
    }
}

How it works in Java

Java uses Random.nextInt(256) for generating octets and String.format("%02X") for hexadecimal formatting with zero-padding. StringBuilder efficiently concatenates strings. Locally administered MACs use bitwise operations (& 0xFE and | 0x02). String.matches() validates against regex patterns. IntStream and streams provide functional-style batch generation. JavaFaker offers internet().macAddress() and macAddress(prefix), which keeps a given prefix and randomizes the rest.

Sample 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]

Java notes

  • Java bytes are signed: write b[0] = (byte) ((b[0] & 0xFE) | 0x02) after new SecureRandom().nextBytes(b).
  • HexFormat.ofDelimiter(":").withUpperCase().formatHex(b) (Java 17+) formats the six bytes in one call.
  • NetworkInterface.getHardwareAddress() returns the real interfaces' MACs as byte[].

Random MAC Address Code Examples in C#

Generate random MAC addresses in C# using Random and Bogus library. Covers standard format, locally administered addresses, vendor prefixes, and validation for .NET testing.

using System;
using System.Linq;
using System.Text.RegularExpressions;

public class MacAddressGenerator
{
    private static readonly Random random = new Random();

    // Generate random MAC address (standard format)
    public static string RandomMacAddress()
    {
        var octets = Enumerable.Range(0, 6)
            .Select(_ => random.Next(256).ToString("X2"));
        return string.Join(":", octets);
    }

    // Generate locally administered MAC address (bit 1 of first octet set)
    public static string RandomLocalMacAddress()
    {
        // First octet: set bit 1 (locally administered), clear bit 0 (unicast)
        var firstOctet = (random.Next(256) & 0xFE) | 0x02;
        var octets = new[] { firstOctet.ToString("X2") }
            .Concat(Enumerable.Range(0, 5).Select(_ => random.Next(256).ToString("X2")));
        return string.Join(":", octets);
    }

    // Generate MAC with specific vendor prefix (OUI)
    public static string RandomMacWithVendor(string vendorPrefix = "00:1A:2B")
    {
        var vendor = vendorPrefix.Split(":");
        var remaining = Enumerable.Range(0, 6 - vendor.Length)
            .Select(_ => random.Next(256).ToString("X2"));
        return string.Join(":", vendor.Concat(remaining));
    }

    // Generate MAC with different separator
    public static string RandomMacFormatted(string separator = ":")
    {
        var octets = Enumerable.Range(0, 6)
            .Select(_ => random.Next(256).ToString("X2"));
        return string.Join(separator, octets);
    }

    // Validate MAC address format
    public static bool IsValidMacAddress(string mac)
    {
        var patterns = new[]
        {
            @"^([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
        };

        return patterns.Any(pattern => Regex.IsMatch(mac, pattern));
    }

    // Generate multiple MAC addresses
    public static string[] GenerateMacAddresses(int count = 10)
    {
        return Enumerable.Range(0, count)
            .Select(_ => RandomMacAddress())
            .ToArray();
    }

    // Using Bogus library (Install-Package Bogus)
    // using Bogus;
    // var faker = new Faker();
    // string mac = faker.Internet.Mac();
    // string macDash = faker.Internet.Mac("-");

    public static void Main()
    {
        Console.WriteLine($"Random MAC: {RandomMacAddress()}");
        Console.WriteLine($"Local MAC: {RandomLocalMacAddress()}");
        Console.WriteLine($"Vendor MAC: {RandomMacWithVendor("00:1A:2B")}");
        Console.WriteLine($"Dash format: {RandomMacFormatted("-")}");
        Console.WriteLine($"No separator: {RandomMacFormatted("")}");
        Console.WriteLine($"Is valid: {IsValidMacAddress("00:1A:2B:3C:4D:5E")}");
        Console.WriteLine($"Batch: {string.Join(", ", GenerateMacAddresses(3))}");
    }
}

How it works in C#

C# uses Random.Next(256) for generating octets and .ToString("X2") for 2-digit uppercase hexadecimal formatting. LINQ's Enumerable.Range() and Select() provide functional-style generation. string.Join() concatenates with separators. Locally administered MACs use bitwise operations (& 0xFE, | 0x02). Regex.IsMatch() validates patterns. Bogus library offers Internet.Mac() with optional separator for realistic test data in xUnit, NUnit, and MSTest.

Sample 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

C# notes

  • Regex.IsMatch() is case-sensitive unless you pass RegexOptions.IgnoreCase; the patterns here list both A-F and a-f for that reason.
  • RandomNumberGenerator.Fill(span) or Random.Shared.NextBytes(bytes) fills all six octets in one call.
  • System.Net.NetworkInformation.PhysicalAddress holds a MAC as bytes; its ToString() prints 12 uppercase hex digits with no separators.

Random MAC Address Code Examples in C++

Generate random MAC addresses in C++ using std::random and string formatting. Covers standard format, locally administered addresses, vendor prefixes, and validation.

#include <iostream>
#include <random>
#include <sstream>
#include <iomanip>
#include <vector>
#include <regex>
#include <algorithm>

class MacAddressGenerator {
private:
    std::mt19937 rng;
    std::uniform_int_distribution<int> octet_dist;

public:
    MacAddressGenerator() :
        rng(std::random_device{}()),
        octet_dist(0, 255) {}

    // Generate random MAC address (standard format)
    std::string randomMacAddress() {
        std::ostringstream oss;
        for (int i = 0; i < 6; ++i) {
            if (i > 0) oss << ":";
            oss << std::hex << std::uppercase << std::setw(2)
                << std::setfill('0') << octet_dist(rng);
        }
        return oss.str();
    }

    // Generate locally administered MAC address (bit 1 of first octet set)
    std::string randomLocalMacAddress() {
        std::ostringstream oss;
        // First octet: set bit 1 (locally administered), clear bit 0 (unicast)
        int firstOctet = (octet_dist(rng) & 0xFE) | 0x02;
        oss << std::hex << std::uppercase << std::setw(2)
            << std::setfill('0') << firstOctet;

        for (int i = 1; i < 6; ++i) {
            oss << ":";
            oss << std::hex << std::uppercase << std::setw(2)
                << std::setfill('0') << octet_dist(rng);
        }
        return oss.str();
    }

    // Generate MAC with specific vendor prefix (OUI)
    std::string randomMacWithVendor(const std::string& vendorPrefix) {
        std::ostringstream oss;
        oss << vendorPrefix;

        // Count colons to determine how many octets to add
        int vendorOctets = std::count(vendorPrefix.begin(), vendorPrefix.end(), ':') + 1;

        for (int i = vendorOctets; i < 6; ++i) {
            oss << ":";
            oss << std::hex << std::uppercase << std::setw(2)
                << std::setfill('0') << octet_dist(rng);
        }
        return oss.str();
    }

    // Generate MAC with different separator
    std::string randomMacFormatted(const std::string& separator) {
        std::ostringstream oss;
        for (int i = 0; i < 6; ++i) {
            if (i > 0) oss << separator;
            oss << std::hex << std::uppercase << std::setw(2)
                << std::setfill('0') << octet_dist(rng);
        }
        return oss.str();
    }

    // Validate MAC address format
    bool isValidMacAddress(const std::string& mac) {
        std::vector<std::regex> patterns = {
            std::regex("^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$"),  // 00:1A:2B:3C:4D:5E
            std::regex("^([0-9A-Fa-f]{2}-){5}[0-9A-Fa-f]{2}$"),  // 00-1A-2B-3C-4D-5E
            std::regex("^[0-9A-Fa-f]{12}$"),                      // 001A2B3C4D5E
        };

        for (const auto& pattern : patterns) {
            if (std::regex_match(mac, pattern)) {
                return true;
            }
        }
        return false;
    }

    // Generate multiple MAC addresses
    std::vector<std::string> generateMacAddresses(int count) {
        std::vector<std::string> macs;
        for (int i = 0; i < count; ++i) {
            macs.push_back(randomMacAddress());
        }
        return macs;
    }
};

int main() {
    MacAddressGenerator generator;

    std::cout << "Random MAC: " << generator.randomMacAddress() << std::endl;
    std::cout << "Local MAC: " << generator.randomLocalMacAddress() << std::endl;
    std::cout << "Vendor MAC: " << generator.randomMacWithVendor("00:1A:2B") << std::endl;
    std::cout << "Dash format: " << generator.randomMacFormatted("-") << std::endl;
    std::cout << "No separator: " << generator.randomMacFormatted("") << std::endl;
    std::cout << "Is valid: " << std::boolalpha << generator.isValidMacAddress("00:1A:2B:3C:4D:5E") << std::endl;

    auto batch = generator.generateMacAddresses(3);
    std::cout << "Batch: ";
    for (size_t i = 0; i < batch.size(); ++i) {
        if (i > 0) std::cout << ", ";
        std::cout << batch[i];
    }
    std::cout << std::endl;

    return 0;
}

How it works in C++

C++ uses std::mt19937 for high-quality random generation and std::uniform_int_distribution for octets (0-255). std::ostringstream builds strings efficiently. Format manipulators std::hex, std::uppercase, std::setw(2), and std::setfill('0') create 2-digit uppercase hex with zero-padding. Bitwise operations (& 0xFE, | 0x02) set locally administered bit. std::regex_match() validates patterns. std::count() counts colons to determine vendor prefix length.

Sample 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

C++ notes

  • std::uniform_int_distribution<uint8_t> is undefined behavior (char-sized types are not allowed); draw int from 0 to 255 as the example does.
  • std::hex and std::uppercase stay set on the stream, while std::setw(2) applies only to the next value, which is why the example repeats it.
  • std::count comes from <algorithm>.

Random MAC Address Code Examples in Ruby

Generate random MAC addresses in Ruby using rand and Faker gem. Covers standard format, locally administered addresses, vendor prefixes, and validation for Rails/RSpec testing.

require "securerandom"

# Generate random MAC address (standard format)
def random_mac_address
  Array.new(6) { rand(0..255) }.map { |octet| "%02X" % octet }.join(":")
end

# Generate locally administered MAC address (bit 1 of first octet set)
def random_local_mac_address
  # First octet: set bit 1 (locally administered), clear bit 0 (unicast)
  first_octet = (rand(0..255) & 0xFE) | 0x02
  octets = [first_octet] + Array.new(5) { rand(0..255) }
  octets.map { |octet| "%02X" % octet }.join(":")
end

# Generate MAC with specific vendor prefix (OUI)
def random_mac_with_vendor(vendor_prefix = "00:1A:2B")
  vendor = vendor_prefix.split(":")
  remaining = Array.new(6 - vendor.length) { "%02X" % rand(0..255) }
  (vendor + remaining).join(":")
end

# Generate MAC with different separator
def random_mac_formatted(separator = ":")
  Array.new(6) { "%02X" % rand(0..255) }.join(separator)
end

# Validate MAC address format
def valid_mac_address?(mac)
  patterns = [
    /^([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
  ]

  patterns.any? { |pattern| mac.match?(pattern) }
end

# Generate multiple MAC addresses
def generate_mac_addresses(count = 10)
  count.times.map { random_mac_address }
end

# Using Faker gem (add to Gemfile: gem 'faker')
# require 'faker'
# mac = Faker::Internet.mac_address
# mac_dash = Faker::Internet.mac_address(prefix: "02").tr(":", "-")

# Usage examples
puts "Random MAC: #{random_mac_address}"
puts "Local MAC: #{random_local_mac_address}"
puts "Vendor MAC: #{random_mac_with_vendor('00:1A:2B')}"
puts "Dash format: #{random_mac_formatted('-')}"
puts "No separator: #{random_mac_formatted('')}"
puts "Is valid: #{valid_mac_address?('00:1A:2B:3C:4D:5E')}"
puts "Batch: #{generate_mac_addresses(3).join(', ')}"

How it works in Ruby

Ruby's rand(0..255) generates random octets, and "%02X" % octet formats as 2-digit uppercase hexadecimal with zero-padding. Array.new(6) { } creates arrays with block initialization. Locally administered MACs use bitwise operations (& 0xFE and | 0x02). match?() checks regex patterns efficiently. Faker gem provides Internet.mac_address(prefix:) (colon-separated only; tr(":", "-") gives dashes) for realistic test data in Rails, RSpec, and FactoryBot.

Sample 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

Ruby notes

  • In Ruby ^ and $ match at line breaks, so "00:1A:2B:3C:4D:5E\nanything" passes the patterns; use \A and \z for strict validation.
  • Faker::Internet.mac_address does not clear the multicast bit; mac_address(prefix: "02") gives local unicast results.
  • SecureRandom.random_bytes(6).bytes returns six secure integers to mask and format.

Random MAC Address Code Examples in Go

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

package main

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

// 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(256) & 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))
}

How it works in Go

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. Since Go 1.20 the global source is seeded automatically, so no rand.Seed call is needed.

Sample 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]

Go notes

  • net.HardwareAddr is the standard type: its String() prints lowercase colon form, and net.ParseMAC accepts colon, hyphen and dot formats as well as 64-bit EUI-64 values.
  • For the secure variant, fill a 6-byte slice with crypto/rand.Read, then apply the same two masks to buf[0].

Try the Interactive Generator

Need values right now rather than code? The MAC address generator runs in the browser and exports to TXT, CSV or JSON.

OPEN THE MAC ADDRESS GENERATOR →