- I'll be using VIRL to build an Internetwork
and I will actually show this demo.
This configuration is a little more complex,
than the VIRL example you saw back in Lesson 1,
we'll build a topology with multiple routers and switches
and perform a traceroute to see each hop
from Kali Linux client to an Ubuntu server,
we'll demonstrate both IPv4 and IPv6 connectivity
through out topology, let's get started.
There are a couple of tricks you can use
to make your experience better,
when using Kali Linux on VIRL,
to start, when you download the image
from the offensive security website,
it's in VMware VMDK format,
VIRL can convert it to the date of OpenStack format for you,
but before you install VIRL, you'll wanna add
any additional software, that you might need,
most notably cloud-init,
this will automate the IP address
and configuration for your VM.
In User Resource Manager, in your Notary Sources,
you can add your Kali image to VIRL,
for ease of use, name your image Kali,
although VIRL already has configurations for Kali,
you'll wanna make sure that the hardware video model
is set to VGA and the hardware disk bus is set to SCSI,
so the system boots properly.
Here's our topology, which I've already laid out,
we have a Kali Linux machine on the left
and then on the right, we have an Ubuntu server,
each is connected to their own layer two switch running IOS,
in the middle of our network,
we have a partial mesh of four routers.
To automatically configure our Internetwork with AutoNetkit,
we'll configure our Management Network
to Private simulation network
and Use an LXC management node,
we'll configure Cisco Discovery Protocol to true,
so that we see our neighbors
and set the IP address address family to dual stack,
this will configure both IPv4 and IPv6 for us,
the IPv4 Infrastructure Subnet will be used
for the point-to-point links between nodes,
we're using 10.0.0.0,
the Loopback Subnet will be 192.168.0.0
and the VRF Subnet will not be used,
we also have the same Subnets
for IPv6 Infrastructure and Loopbacks, set as shown here.
We'll make sure our Interior Gateway Protocols
are enabled and set to Open shortest path first,
both OSPF version two for IPv4
and OSPF version three for IPv6 will be configured.
Now we'll generate our initial configurations
to push to the devices,
we'd like to see the configurations generated,
so we'll click Yes.
You can navigate to each device configuration
by clicking on the special scroll bar
on the right-hand side of the window,
you'll see that not only do we have
router and switch configurations,
but we also have our host configurations
in cloud-init format as well.
If there are any questions about what usernames
and passwords to use, make sure you take a look here.
We'll choose No for AutoNetkit visualization,
this is a useful feature to browse through your network
and automatically generate a network drawing
for future reference.
You'll see that all of our routers now have
v4 and v6 addresses, these were their Loopback interfaces.
Let's go ahead and start the simulation.
I'm gonna go ahead and log into my Kali Linux machine,
now I've customized my environment,
before installing in VIRL,
so I'm using the XFCE environment, rather than GNOME,
so my desktop may look a little bit different from yours.
Let's take a look at my machine's IP address configuration,
you'll see my management network on ethernet0
and my network face and interface on ethernet1,
I have a v4 address on both interfaces,
but you'll note that ethernet1
has both a v4 and v6 configuration.
Let's use the telnet command to log into the router,
username is Cisco and password is Cisco,
we'll look at the routing table,
you'll see that we have all of our routes
in OSPF as fully adjacent and converged,
the 10.0.0.8 subnet connects to the Ubuntu server,
AutoNetkit tries to conserve as much address space as it can
and allocates subnets with the prefix link
only enough to give all the hosts on each link an address.
I'll ping the router that is connected
to the server at 10.0.0.9,
then we'll log out and traceroute to that IP from Kali.
You can see the intermediate routers and their IP addresses,
now if we traceroute to 10.0.0.10,
you'll see that we reach our server,
note that the path to the server
is different from the path to the router,
this is because one of the routers in the path
is load balancing using Equal Cost Multipath or ECMP,
router IOSv1 has multiple next hops
to the 10.0.0.8 subnet.
Let's look at the routing table for the Kali host.
VIRL has already set up static routes
to the subnets and my routed network,
it has also done this for IPv6 as well,
using Copy and Paste for the linked IPv6 address,
I'll use traceroute over IPv6 to my server
and the last hop router,
you'll notice that the path to the server
and the router are different,
again, this is because of Equal Cost Multipath.
This concludes this demo of using VIRL
to simulate an Internetwork
with hosts, routers and switches.
Thank you for watching.