MAC Address Generator

About MAC Address Generator

This tool generates random MAC (Media Access Control) addresses for testing, virtualization, and network configuration. It supports multiple output formats and address types including unicast/multicast and locally administered addresses.

MAC Address Structure

A MAC address is a 48-bit (6-byte) identifier represented as 12 hexadecimal digits:

MAC Address Format (48 bits / 6 bytes):

┌─────────────────────────────────────────────────────────┐
│  AA : BB : CC : DD : EE : FF                            │
│  │         │         │         │         │         │   │
│  └─ Octet 0 ─┘ └─ Octet 1 ─┘ ... └─ Octet 5 ─┘       │
│                                                         │
│  First 3 bytes (AA:BB:CC) = OUI (Manufacturer ID)      │
│  Last 3 bytes (DD:EE:FF) = Device serial number        │
└─────────────────────────────────────────────────────────┘

First Octet Bit Structure:
┌────────────────────────────────────────────┐
│  Bit 0: Multicast flag (0=unicast, 1=multi)│
│  Bit 1: Local flag (0=global, 1=local)     │
│  Bits 2-7: OUI-specific bits               │
└────────────────────────────────────────────┘

Examples:
  02:00:00:00:00:00 → Unicast, Locally Administered
  03:00:00:00:00:00 → Multicast, Locally Administered
  00:00:00:00:00:00 → Unicast, Globally Unique (OUI assigned)
  FF:FF:FF:FF:FF:FF → Broadcast (special address)

MAC Address Format Comparison

Address Type Reference

Common OUI Assignments

MAC Generation Algorithm

JavaScript MAC Address Generation:

function generateMAC(type, format) {
  let bytes = [];

  // Set first byte based on address type
  switch(type) {
    case 'unicast-local':
      bytes[0] = 0x02;  // 0000 0010: local=1, multicast=0
      break;
    case 'multicast-local':
      bytes[0] = 0x03;  // 0000 0011: local=1, multicast=1
      break;
    case 'unicast-global':
      // Random even first byte (multicast bit = 0)
      bytes[0] = Math.floor(Math.random() * 128) * 2;
      break;
    default: // random
      bytes[0] = Math.floor(Math.random() * 256);
  }

  // Generate remaining 5 random bytes
  for (let i = 1; i < 6; i++) {
    bytes[i] = Math.floor(Math.random() * 256);
  }

  // Format output
  const hex = bytes.map(b =>
    b.toString(16).padStart(2, '0').toUpperCase()
  );

  switch(format) {
    case 'colon': return hex.join(':');
    case 'dash':  return hex.join('-');
    case 'dot':   return hex.join('').match(/.{1,4}/g).join('.');
    default:      return hex.join('');
  }
}

// Usage:
const mac = generateMAC('unicast-local', 'colon');
console.log(mac);  // e.g., "02:A4:B7:C3:D8:E1"

Common Use Cases

• Virtual Machine Networking: Assign unique MACs to VMs in VirtualBox, VMware, KVM, Hyper-V
• Container Networks: Generate MACs for Docker bridge networks, Kubernetes CNI plugins
• Network Testing: Simulate multiple devices for load testing, switch testing
• Privacy Protection: Use randomized MACs on public WiFi to prevent tracking
• Lab Environments: Avoid MAC conflicts between lab and production networks
• Software Development: Mock network interfaces for testing network applications
• MAC Filtering Tests: Test network access control lists with various MAC patterns

Locally Administered vs Globally Unique

Globally Unique MAC (OUI-assigned):
  First byte: Even number (multicast bit = 0)
  Second bit: 0 (global/administered by IEEE)
  Example: 00:1A:2B:3C:4D:5E (QEMU OUI)
  Use when: Emulating specific hardware, production systems

Locally Administered MAC:
  First byte: 02, 06, 0A, 0E, etc. (second bit = 1)
  Second bit: 1 (locally administered)
  Example: 02:00:00:00:00:01
  Use when: VMs, testing, privacy, avoiding conflicts

Why use locally administered for generated MACs:
  - Avoids conflicts with real hardware MACs
  - Clearly identifies software-generated addresses
  - No IEEE registration required
  - Safe for testing and development

MAC Address Validation

Valid MAC addresses must meet these criteria:

• Length: Exactly 6 bytes (48 bits, 12 hex digits)
• Characters: Only hexadecimal (0-9, A-F, case insensitive)
• Format: Consistent separator (all colons, all dashes, or none)
• Broadcast: FF:FF:FF:FF:FF:FF is valid but reserved
• Null: 00:00:00:00:00:00 is typically invalid for real interfaces