# EUI-64

> Source: Courseiva IT Certification Glossary — https://courseiva.com//glossary/eui-64

## Quick definition

EUI-64 is a way to turn a device's MAC address into a unique identifier for IPv6 networking. It takes the 48-bit MAC address, inserts the hex characters 'FFFE' in the middle, and flips a specific bit to mark it as locally unique. This creates a 64-bit identifier that helps the device generate its own IPv6 address without needing a manual configuration or DHCP server.

## Simple meaning

Imagine you live in a huge apartment complex and every apartment has a unique code assigned by the building manager. For example, each apartment gets a code like 'A1-B2-C3'. Now, the manager wants each apartment to also have its own mailbox number that is automatically generated from the apartment code, so no one has to manually assign mailbox numbers. The manager does something clever: he takes the apartment code, chops it in half, and inserts the number 'FFFE' in the middle. So 'A1-B2-C3' becomes 'A1-B2-FF-FE-C3'. Then he changes a special marker to show this mailbox number is not a standard one but one created from an apartment code. This new mailbox number is now unique and ready to be used as part of a full address (like adding it to the complex's main address).

In the real world, this is exactly what EUI-64 does for your computer's network card. Every network card has a MAC address, which is a 48-bit number like a unique apartment code. When your computer wants to create an IPv6 address automatically (called Stateless Address Autoconfiguration, or SLAAC), it takes its MAC address, splits it into two 24-bit halves, inserts 'FFFE' (which is 16 bits) in the middle, and then flips the seventh bit (a 'U/L' bit) to indicate that this identifier was derived from a MAC address. The result is a 64-bit interface identifier that, when combined with a 64-bit network prefix from a router, forms a complete IPv6 address. This process ensures that every device on a network can create a unique, globally unique address (or a link-local address) without any central server assigning it.

The beauty of EUI-64 is that it makes address configuration automatic and practically collision-free. Since MAC addresses are supposed to be globally unique, the resulting EUI-64 identifier is also unique. This simplifies network administration and is a key part of IPv6's plug-and-play design. However, because it uses the MAC address, it also allows anyone on the network to identify the manufacturer of your network card (the first 24 bits of the MAC address are the OUI), which is a privacy concern. For this reason, newer IPv6 implementations often use random or temporary interface identifiers instead of EUI-64, but the concept remains fundamental to understanding IPv6 addressing.

## Technical definition

EUI-64 (Extended Unique Identifier-64) is a standard method defined in RFC 4291 for deriving a 64-bit interface identifier from a 48-bit IEEE 802 MAC address (e.g., Ethernet MAC). This interface identifier is used primarily in IPv6 to form the host portion of an IPv6 address, especially in Stateless Address Autoconfiguration (SLAAC) and for creating link-local addresses.

The process works as follows. First, the 48-bit MAC address (typically expressed in hexadecimal, e.g., 00:1A:2B:3C:4D:5E) is divided into two 24-bit halves: the first 24 bits (the Organizationally Unique Identifier, OUI) and the last 24 bits (the NIC-specific portion). The 16-bit hex value 0xFFFE is inserted between these two halves, resulting in a 64-bit string: 00:1A:2B:FF:FE:3C:4D:5E. Next, the seventh bit (counting from the left, also known as the Universal/Local bit or U/L bit) is complemented (flipped). In the original MAC address, the seventh bit is the second bit of the first octet. For example, the first octet 0x00 in binary is 00000000; the seventh bit (bit position 1 in standard bit numbering) is 0. After flipping, it becomes 1, so 0x00 becomes 0x02. The full interface identifier then becomes 02:1A:2B:FF:FE:3C:4D:5E. This modified identifier is then used as the 64-bit interface ID in an IPv6 address.

The U/L bit is critical. A value of 0 indicates that the address is globally unique (assigned by the IEEE), while a value of 1 indicates that the address is locally administered. By flipping this bit from 0 to 1 (if the MAC is globally unique), the system marks that the EUI-64 identifier is derived from a MAC address and is not a permanent globally unique identifier. In practice, this bit flipping is often automatically handled by the operating system's network stack.

EUI-64 is used to create two primary types of IPv6 addresses: link-local addresses (starting with FE80::/10) and global unicast addresses (via SLAAC). In SLAAC, a router advertises the network prefix (64 bits) via Router Advertisement (RA) messages. The host then appends its EUI-64-derived interface identifier to form a full 128-bit IPv6 address. This eliminates the need for a DHCP server for address assignment in many scenarios, though DHCPv6 may still be used for additional configuration parameters.

From a protocol perspective, EUI-64 is an IEEE standard (IEEE EUI-64) and is also used in other contexts like FireWire (IEEE 1394) and some wireless protocols. In IPv6, it is defined in RFC 4291, RFC 4862 (IPv6 Stateless Address Autoconfiguration), and RFC 4941 (Privacy Extensions for SLAAC). The privacy extensions were introduced to address the tracking concerns inherent in using a static MAC-derived identifier. When privacy extensions are enabled, the operating system generates random or temporary interface identifiers, replacing the EUI-64 method for global addresses, but EUI-64 remains the default for link-local addresses on many systems and is a core concept for any IT professional studying IPv6.

In real IT implementation, network administrators must understand EUI-64 to troubleshoot SLAAC, to predict IPv6 addresses for network monitoring, and to recognize security implications. For example, if a device is using EUI-64, an attacker who knows the MAC address can calculate the IPv6 address, potentially making the device more discoverable. Conversely, knowing the EUI-64 address can help in forensics by linking an IPv6 address back to a specific network interface card vendor.

## Real-life example

Think about getting a new phone and setting it up for the first time. You turn it on, and it asks for your name, address, and phone number to register it with your carrier. But imagine instead that the phone automatically figures out its own unique device ID by using its serial number plus a secret code embedded in the hardware. That is essentially what EUI-64 does for network devices.

Let's make it even more concrete. Suppose you live in a neighborhood where every house has a specific number assigned by the city, like 123 Main Street. That number is unique and identifies your house. Now, the postal service decides that every house also needs a mailbox number for internal sorting, and they want to generate that mailbox number automatically from the existing house number. They take the house number, split it in half (12 and 3), insert a special separator code (like 'MH' for mailbox holder), and then adjust a flag digit to show this is a derived number. So 123 becomes 12-MH-3. That mailbox number is then combined with a zip code to form a complete mailing address.

In the networking world, the city house number is your MAC address, the zip code is the network prefix advertised by your router, and the mailbox number is the EUI-64 identifier. When you plug a device into an IPv6 network, your computer listens for a router advertisement that tells it the network prefix (like the zip code). It then constructs its own interface identifier (the mailbox number) from its MAC address using the EUI-64 process. The final IPv6 address is like a complete mailing address: network prefix + interface identifier. This automation is why you can often join an IPv6 network and get online without any manual configuration.

Now, consider a block of flats where each apartment has a unique door code. If you simply used the apartment's door code to generate a mailbox number, anyone who knows the door code would also know the mailbox number. That's a privacy concern. Similarly, because EUI-64 uses the MAC address, which is often constant, and because the MAC address reveals the device manufacturer, someone could track your device's movements across different IPv6 networks. That is why modern systems often replace EUI-64 with temporary random identifiers for global addresses, but the EUI-64 method is still the foundational concept you need to understand for network configuration and exams.

## Why it matters

EUI-64 matters in real-world IT because it is the default mechanism for IPv6 address generation in countless devices and operating systems. Understanding it is essential for network administrators who manage IPv6 deployments, especially in environments where legacy systems or simplified autoconfiguration is used. When a router sends a Router Advertisement, every device on that link that supports SLAAC will automatically generate an IPv6 address using EUI-64 (or similar). This means that the IPv6 addresses of all devices can be predicted if you know their MAC addresses, which is both a convenience for network inventory and a potential security concern.

From a practical standpoint, knowing how EUI-64 works helps with troubleshooting. For example, if a device is not getting an IPv6 address, you can check whether the router is sending RAs and whether the device is using SLAAC (which requires EUI-64) or expects DHCPv6. If you are configuring static IPv6 addresses for servers or network equipment, you might choose to use the EUI-64 format for consistency, or you might use a different method for security. Also, in security auditing, you can map IPv6 addresses to MAC addresses by reversing the EUI-64 process, which helps in identifying devices on the network.

Moreover, EUI-64 is a cornerstone concept for understanding IPv6 addressing architecture. IPv6 was designed with the intention of reducing reliance on DHCP and making address assignment simpler. EUI-64 is the technical expression of that philosophy. Without it, every device would need either a manual static address or a DHCPv6 server, defeating the purpose of autoconfiguration. For network professionals, grasping EUI-64 enables you to explain why IPv6 addresses on a LAN often look very similar (with the same prefix) but have unique host parts that might seem random. It also helps you understand why privacy extensions were introduced and why many modern systems now default to random interface identifiers rather than EUI-64. In short, EUI-64 is not just an exam topic; it is a real operational concept that affects address planning, security, and troubleshooting in IPv6 networks.

## Why it matters in exams

In the CCNA exam, EUI-64 is a core topic under IPv6 addressing and configuration. The exam objectives include 'Configure and verify IPv6 addressing' and 'Explain the operation of SLAAC.' Cisco expects candidates to understand how EUI-64 is used to generate the interface identifier for link-local and global unicast addresses. You must be able to identify the steps of the EUI-64 process, including the insertion of FFFE and the inversion of the U/L bit. Practical questions may ask you to determine the IPv6 address of a device given its MAC address, or to identify whether an address was generated using EUI-64 based on the pattern of the interface ID.

Exam questions can appear in multiple formats. Multiple-choice questions might ask: 'Which two steps are performed when an IPv6 address is formed using EUI-64?' with options like 'Insert FFFE between the two halves of the MAC address' and 'Flip the seventh bit of the first octet.' You could also see a scenario where you are given a MAC address (e.g., 00:1A:2B:3C:4D:5E) and asked to calculate the resulting EUI-64 interface identifier or the full link-local address. Troubleshooting questions might present a situation where a device is not generating a correct IPv6 address, and you need to identify that the U/L bit inversion was incorrectly applied.

The CCNA is the primary exam for EUI-64, but it also appears in other Cisco and networking certifications like CCNP, CompTIA Network+, and various IPv6 specialist exams. In CCNP, the concept is extended into more complex topics like OSPFv3, where you may need to understand how EUI-64 affects router IDs or neighbor discovery. For Network+, EUI-64 is a supporting concept; you need to know that it is a method for generating IPv6 addresses from MAC addresses, but you may not need to calculate the bits manually. For any exam that covers IPv6, the ability to recognize an EUI-64-derived address (by the presence of FFFE and the inverted U/L bit) is a key skill.

Therefore, when studying for the CCNA, you must practice converting several MAC addresses to EUI-64 identifiers manually. Understand that the U/L bit inversion is not just a memorization trick but has a real purpose (marking the address as locally derived). You should also understand the difference between EUI-64 and random interface IDs (used with privacy extensions). The exam will test your ability to apply this knowledge in practical scenarios, such as configuring an interface to use a specific static IPv6 address versus SLAAC, or identifying why a host's IPv6 address changed after a reboot (if privacy extensions are enabled).

## How it appears in exam questions

In exam questions, EUI-64 typically appears in three main patterns: calculation, identification, and scenario-based troubleshooting.

Calculation questions are the most straightforward. You might be given a MAC address such as 00:1A:2B:3C:4D:5E and asked to determine the resulting IPv6 link-local address (FE80::/10) or the interface identifier. The process includes: split the MAC into two halves (00:1A:2B and 3C:4D:5E), insert FFFE (00:1A:2B:FF:FE:3C:4D:5E), then flip the seventh bit of the first octet (00 becomes 02). So the interface identifier is 021A:2BFF:FE3C:4D5E, and the link-local address becomes FE80::021A:2BFF:FE3C:4D5E. You may be asked to select the correct address from multiple choices, or to fill in the missing part.

Identification questions may show you an IPv6 address like FE80::021A:2BFF:FE3C:4D5E and ask you to recognize that it was generated using EUI-64 because it contains 'FFFE' and the seventh bit is set to 1 (as indicated by the '02' start). Conversely, they might show an address like FE80::221A:2BFF:FE3C:4D5E (where '02' is replaced by '22') and ask why the address is invalid or what mistake was made. The exam may also ask whether an address is likely a static address, EUI-64, or a privacy extension address. EUI-64 addresses have a consistent pattern: a single 'FFFE' in the middle and a '02' (or '03' etc.) at the start of the interface ID.

Scenario-based questions are more complex. For example: 'A network engineer configures an IPv6 router to send Router Advertisements. A host with MAC address 00:1A:2B:3C:4D:5E connects to the network. Which IPv6 address will the host autoconfigure as its link-local address?' You must apply the EUI-64 process. Another scenario: 'After enabling privacy extensions, a host's IPv6 global address changes frequently. Why does this happen?' The answer relates to EUI-64 being replaced by random temporary addresses. Troubleshooting scenarios might describe a situation where two devices on the same VLAN cannot communicate because their IPv6 addresses overlap. You may need to determine whether both are using EUI-64 and have the same MAC address (e.g., in a virtual environment), leading to duplicate addresses.

Configuration questions may ask you to enable or disable SLAAC on a Cisco router, or to configure a static IPv6 address that mimics the EUI-64 format. You might be asked to use the 'ipv6 address autoconfig' or 'ipv6 address prefix eui-64' command. Understanding that 'eui-64' is a keyword in the IPv6 address configuration mode is important. For example, 'ipv6 address 2001:DB8::/64 eui-64' tells the router to generate the interface identifier using EUI-64 based on the interface's MAC address. Exam questions may test your knowledge of which command creates an address using EUI-64 versus a static address.

Overall, to succeed, you must be comfortable with hexadecimal and binary conversion, know the steps of EUI-64 by heart, and be able to apply them in both calculation and conceptual questions.

## Example scenario

You are a junior network administrator at a small company. The company decides to deploy IPv6 on its internal network. The IT manager wants all workstations to be able to automatically obtain IPv6 addresses without any manual input or a separate DHCP server. You decide to implement Stateless Address Autoconfiguration (SLAAC). You configure the router to send Router Advertisements with the network prefix 2001:DB8:ACAD:1::/64.

Now, consider a specific workstation with a MAC address of 00:50:56:C0:00:08 (which is a VMware vmxnet3 adapter). You want to predict what global unicast IPv6 address this workstation will generate. Following the EUI-64 process:

Step 1: Take the MAC address: 00:50:56:C0:00:08.
Step 2: Split into two halves: first half is 00:50:56, second half is C0:00:08.
Step 3: Insert FFFE in the middle: 00:50:56:FF:FE:C0:00:08.
Step 4: Convert the first octet (00) to binary: 00000000. The seventh bit (bit 1 counting from 0) is 0. Flip it to 1: 00000010, which is 0x02.
Step 5: The interface identifier becomes 0250:56FF:FEC0:0008.
Step 6: Combine with the network prefix: 2001:DB8:ACAD:1::0250:56FF:FEC0:0008.

The workstation will now have the address 2001:DB8:ACAD:1::0250:56FF:FEC0:0008. It will also have a link-local address starting with FE80: followed by the same interface identifier (FE80::0250:56FF:FEC0:0008).

Now, suppose you later add a second workstation with a different MAC address, say 00:50:56:C0:00:09. The EUI-64 process will produce a different interface identifier, ensuring that both workstations have unique addresses. This is all done automatically when the workstations boot up and receive a Router Advertisement.

Later, you notice that the first workstation's IPv6 address remains the same after multiple reboots. That is because the MAC address is fixed, so the EUI-64 derived address is stable. However, if you enable privacy extensions (RFC 4941) on this workstation, the device may generate temporary random addresses for outbound connections, while still using the EUI-64 address for inbound connections. As an administrator, understanding EUI-64 helps you predict and document the IPv6 addresses of all devices on your network, enabling you to set up firewall rules, monitoring, and logging based on IPv6 addresses without needing to rely on DNS alone.

## Common mistakes

- **Mistake:** Forgetting to flip the seventh bit (U/L bit) after inserting FFFE.
  - Why it is wrong: The U/L bit inversion is a mandatory step defined in RFC 4291. If you skip it, the resulting interface identifier does not conform to the standard, and the device will not use that address. In exams, the answer without the bit flip is considered incorrect.
  - Fix: Always remember that after inserting FFFE, you must convert the first octet to binary, flip the seventh bit (second from the left), and convert back to hex. For example, 00 becomes 02, 01 becomes 03, 02 becomes 00 (but only if it was originally local).
- **Mistake:** Placing FFFE between the wrong bytes, such as after the first byte instead of between the OUI and NIC parts.
  - Why it is wrong: The standard requires splitting the MAC address into two 24-bit halves: the first 3 bytes (OUI) and the last 3 bytes (NIC-specific). Inserting FFFE anywhere else, such as after the first byte (e.g., 00:FF:FE:1A:2B:3C:4D:5E), produces an incorrect 64-bit identifier.
  - Fix: Always split the MAC address exactly in half: first 3 hex bytes and last 3 hex bytes. Insert FFFE between them. For MAC 00:1A:2B:3C:4D:5E, the correct insertion is 00:1A:2B:FF:FE:3C:4D:5E.
- **Mistake:** Thinking EUI-64 only works with MAC addresses starting with '02' or '03'.
  - Why it is wrong: Any MAC address can be used, but the bit flip may change the first octet. For example, a MAC starting with '02' (which already has the U/L bit set to 1) will flip to '00'. The result is still a valid EUI-64 identifier, but the starting octet varies. Learners often mistakenly assume only certain starting hex values are valid.
  - Fix: Apply the bit flip to any MAC address. The resulting first octet will be different from the original. For example, a MAC of 02:1A:2B:3C:4D:5E becomes 00:1A:2B:FF:FE:3C:4D:5E after flipping the seventh bit (since 02's seventh bit is 1, it flips to 0).
- **Mistake:** Confusing EUI-64 with simply appending 'FFFE' to the MAC address without the bit flip.
  - Why it is wrong: Some learners think EUI-64 just means adding FFFE after the first 24 bits, but the bit flip is a critical second step. Without it, the address is not a valid EUI-64 interface identifier.
  - Fix: Use a mnemonic: 'Split, Insert FFFE, Flip the seventh bit.' Repeat the full process for every MAC-to-EUI-64 conversion.
- **Mistake:** Assuming that all IPv6 autoconfiguration addresses use EUI-64.
  - Why it is wrong: Modern operating systems often use privacy extensions (RFC 4941) or stable private addresses (RFC 7217) instead of EUI-64 for global or temporary addresses. Only the link-local address may still use EUI-64 by default. In questions, you may need to determine which address is derived from EUI-64 versus random.
  - Fix: Look for the pattern of 'FFFE' and the consistent first octet (usually 02, 03, etc.) to identify EUI-64 addresses. If the interface ID does not contain 'FFFE', it is likely not EUI-64.

## Exam trap

{"trap":"In a question, you are given a MAC address like '02:1A:2B:3C:4D:5E'. You apply EUI-64 and get '021A:2BFF:FE3C:4D5E' without realizing you need to flip the seventh bit, which was already 1. The correct answer should have the first octet as '00' after the flip.","why_learners_choose_it":"Learners memorize the steps as 'insert FFFE and flip the seventh bit' but forget to check the original MAC address. If the original MAC already has the U/L bit set to 1 (e.g., addresses starting with 02, 03, 06, 07, etc.), flipping it will change it to 0. Many learners assume the first octet will always become '02' or '03', but that is only true if the original MAC had a 0 in the seventh bit (like 00, 01, 04, 05, etc.). This trap is common because many example MACs used in tutorials start with '00', leading to overgeneralization.","how_to_avoid_it":"Always convert the first octet to binary and explicitly flip the seventh bit regardless of the original value. Do not assume the result will be '02'. Practice with a few MAC addresses that have different starting octets, such as 00:... (becomes 02), 02:... (becomes 00), 01:... (becomes 03), 03:... (becomes 01). Understand that the bit flip is based on binary value, not on a fixed pattern."}

## Commonly confused with

- **EUI-64 vs SLAAC (Stateless Address Autoconfiguration):** SLAAC is the overall process of a host automatically configuring an IPv6 address using Router Advertisements. EUI-64 is one method used by SLAAC to generate the interface identifier. SLAAC can also use other methods like privacy extensions. So EUI-64 is a component of SLAAC, not the whole process. (Example: When a host uses SLAAC, it may use EUI-64 to create its interface ID, or it may use a random number. The term EUI-64 refers to the specific derivation from the MAC address.)
- **EUI-64 vs MAC address (Media Access Control address):** A MAC address is a 48-bit hardware address assigned to a network interface. EUI-64 is a 64-bit identifier derived from that MAC address by inserting FFFE and flipping the U/L bit. They are not the same; one is the source, the other is the result. (Example: If a device has MAC address 00:1A:2B:3C:4D:5E, its EUI-64 identifier is 021A:2BFF:FE3C:4D5E. The two are different in length and content.)
- **EUI-64 vs Privacy Extensions (RFC 4941):** Privacy extensions generate temporary random interface identifiers to prevent tracking, replacing the EUI-64 method for global and temporary addresses. EUI-64 uses a fixed MAC address, while privacy extensions use random values. Both are methods for creating interface identifiers, but they have opposite goals: consistency versus privacy. (Example: A laptop using EUI-64 will have a stable IPv6 address, while a laptop using privacy extensions will change its global IPv6 address every few hours, making it harder to track.)

## Step-by-step breakdown

1. **Start with the 48-bit MAC address** — Every network interface has a unique MAC address, usually written as six hexadecimal octets (e.g., 00:1A:2B:3C:4D:5E). This address is the foundation for EUI-64. Without it, the identifier cannot be derived.
2. **Split the MAC address into two 24-bit halves** — The first three octets (e.g., 00:1A:2B) represent the Organizationally Unique Identifier (OUI) assigned to the hardware manufacturer. The last three octets (3C:4D:5E) are the NIC-specific portion. Splitting at the midpoint ensures the structure of the EUI-64 identifier mirrors the original address.
3. **Insert the hex value FFFE between the two halves** — Inserting 0xFFFE (16 bits) creates a 64-bit identifier. This constant pattern is used globally to denote an interface identifier derived from a MAC address. The insertion is done exactly at the midpoint: first half, then FFFE, then second half. For example, 00:1A:2B:FF:FE:3C:4D:5E.
4. **Flip the seventh bit of the first octet (the U/L bit)** — The seventh bit (also called the Universal/Local bit) in the first octet indicates whether the address is globally unique (bit=0) or locally unique (bit=1). By flipping this bit, the EUI-64 identifier is marked as being derived from a MAC address (which is globally unique, so originally bit=0, after flip bit=1). This prevents confusion with other types of identifiers. For example, 0x00 (binary 00000000) becomes 0x02 (00000010).
5. **Form the 64-bit interface identifier** — The resulting 64-bit value (e.g., 02:1A:2B:FF:FE:3C:4D:5E) is the EUI-64 interface identifier. This is now ready to be used as the host portion of an IPv6 address.
6. **Combine with a 64-bit network prefix to form a complete IPv6 address** — For a global unicast or unique local address, the network prefix (e.g., 2001:DB8::/64) is combined with the interface identifier. The final IPv6 address is 2001:DB8::021A:2BFF:FE3C:4D5E. For a link-local address, the prefix is always FE80::/64, resulting in FE80::021A:2BFF:FE3C:4D5E.

## Practical mini-lesson

EUI-64 may seem like a simple algorithmic process, but it has profound implications in network design, security, and operations. Let's dive deeper into what network professionals need to know about using EUI-64 in real environments.

First, understand that EUI-64 is the default method for generating the interface identifier on many Cisco routers and on most operating systems for the link-local address. When you enable IPv6 on a Cisco router interface, the router automatically creates a link-local address using EUI-64. For example, when you use the command 'ipv6 enable' on an interface, the router will generate an address like FE80::/10 using its MAC address. You can also optionally specify 'ipv6 address autoconfig' for global addresses, which also uses EUI-64 on Cisco devices. However, note that Cisco routers can be configured to use a static link-local address for consistency, which is often recommended for network operations to ensure router IDs are predictable.

In corporate networks, knowing the EUI-64 process helps you manually calculate the IPv6 address of a server or network device for documentation. For instance, if you have a server with a known MAC address, you can compute its IPv6 address and then set up firewall rules or IPsec policies based on that address. This is especially useful when DNS is not immediately available or when you need to pre-configure access lists. Because the EUI-64 address is stable (assuming the MAC address does not change), you can rely on it for long-term identification.

However, EUI-64 is not without its issues. The biggest practical concern is privacy: because the MAC address is embedded (with FFFE), anyone who sees the IPv6 address can recover the MAC address by reversing the process (removing FFFE and flipping the bit back). This allows for device tracking across networks. To mitigate this, most modern operating systems (Windows 10, macOS, Linux with NetworkManager) use privacy extensions (RFC 4941) for outbound connections, but the EUI-64 address is still used for inbound connections and as the primary link-local address. For sensitive environments, you may want to disable SLAAC entirely and use DHCPv6 or static addresses, or configure the OS to use stable private addresses (RFC 7217) which generate a random but stable ID per network.

What can go wrong with EUI-64? Duplicate addresses can occur in virtualized environments where multiple VMs share the same MAC address (e.g., if cloning a VM without regenerating MAC). In such cases, EUI-64 would produce identical interface identifiers, leading to duplicate address detection (DAD) failures. Also, if a device's MAC address changes (some hardware allows this), the IPv6 address will change as well, potentially breaking established connections. IPv6 has mechanisms like DAD to detect duplicates, but they waste bandwidth and time.

From a configuration perspective, on Cisco IOS, you can set an interface to use EUI-64 with the command 'ipv6 address prefix/64 eui-64'. For example, 'ipv6 address 2001:DB8::/64 eui-64'. This is useful when you want the interface to generate its own interface ID from its MAC address but keep the prefix static. Understanding this command is important for both CCNA and real-world configuration.

Finally, professionals should test their understanding by calculating EUI-64 addresses for several different MAC addresses and verifying them against actual device addresses (e.g., using 'ipconfig /all' on Windows or 'ifconfig' on Linux). This hands-on practice solidifies the concept and prepares you for both exams and real troubleshooting.

## Memory tip

Remember 'Split, FFFE, Flip' — the three steps of EUI-64. The 'Flip' always involves the seventh bit of the first octet.

---

Practice questions and the full interactive page: https://courseiva.com//glossary/eui-64