In this video I give a brief synopsis of the firepower 3100 appliances. Then I fire up a TLS 1.2 decrypt stress test using a Spirent CyberFlood.
ISE Device Extractor
So, I made a thing.
ISE Device Extractor is a small python program that extracts all of the Network devices from ISE and outputs them in an Ansible compatible inventory file. Repo is here:
ISE is a good source of truth for network devices. I couldn’t find an existing tool to give me output from ISE that I could use for Ansible playbooks, so I made one. Since YAML is super easy to parse, you can use the inventory file as an input for other tools as well. Example uses would be to check and make sure that devices are categorized correctly, or that the inventory is accurate.
If you would like to test it, devnetsandbox.cisco.com has a reservable ISE sandbox. Search the catalog for ISE and select Identity Services Engine with MUD.
Rest of the details are in the readme. Enjoy. 🙂
Monday Morning notes – 03.02.2020
It’s been quite a ride for the last month or so, so much going on. Last Monday morning I passed the new Cisco DEVASC exam (200-901) on the first day to test, making me a member of the Devnet 500 club.
Preparing for the exam really did a lot for sharpening up some relatively new skills I’ve acquired that haven’t had a lot of reinforcement. That’s the real value of IT certifications – having that performance-based focal point. When your learning is self-directed there is a real tendency to sort of wander from topic to topic and lose focus, and learning tracks are a great tool to combat that.
That said, I think the most important takeaway is that we’re rapidly transitioning to an API driven world and it’s important to get comfortable working with structured data and logical abstractions in general regardless of the job role.
Ok, about Terraform. What I’m working through is the approach I want to take. I want to bring a unique angle rather than join a chorus of people all saying and doing the same thing. If there are specific things you would like to see, let me know in the comments.
Thanks for reading and I’ll see you around.
Monday morning note 02.17.2020
Just a quick check-in for this week.
Life has gotten a bit hectic recently, and will likely remain so for another couple of weeks. Small things are beginning to take conscious effort and focus which is a reliable indicator that I need to trim the sails a little. What this means for this space is the first Terraform post is delayed for a week, possibly two.
On a brighter note, the weather was wonderful for this morning’s walk, my dogs were well behaved, and coffee is always there for us and wants us to be happy.
Until next time, may you care for yourself with ease.
Case study: Combating MAC address spoofing in access networks
Last week I went down an interesting rabbit hole of MAC address spoofing. I found that while the problem was well defined and easily researched, there were no simple prescriptive recipes for a solution. I thought it might be helpful to share this solution in the hopes it could be useful to others.
I would like to acknowledge the contributions of Marvin Rhoads for technical vetting and proofreading, and Brad Johnson (web page) for climbing down into the rabbit hole with me and lending his considerable expertise.
Media Access Control (MAC) Addresses commonly are used to identify endpoints for purposes of access control and authorization on access layer networks that have yet to implement 802.1x (dot1x) device authentication. The problem with this approach is MAC address spoofing is trivial to implement. However, with a defense in depth approach using basic tools and techniques, the risk and impact can be largely mitigated.
To explore the issues, we are going to evaluate the case of an organization that had recently implemented a network access control solution. A network penetration tester easily bypassed their access controls by cloning a mac address from an IP phone to a Linux laptop computer,
The organization had recently implemented Cisco Systems Identity Services Engine (ISE) and had hired a pen-testing firm to evaluate its efficacy in preventing unwanted access to the network. In general, Network Access Control (NAC) implementations take a phased approach to control risk and get immediate value from the tool, and this was the case here.
At the time the penetration test was performed, some of the network was using 802.1x authentication with digital certificates, and some of the network was using MAC Authentication Bypass (MAB) combined with device profiling to determine the correct level of authorization for a connecting device.
Additionally, the Authorization policies weren’t fully implemented, so effectively authorization was a simple ‘yes/no’ result where full access is granted based on a device profile match.
When the Pentester did her work, she grabbed the MAC address off the back of an IP phone in a common area, applied it to her Linux laptop computer, and used the network cable from the IP phone to connect to the network. ISE recognized her computer as the IP phone, and she was granted unrestricted access to the network.
The information security team had the impression that ISE was able to handle a basic access layer attack like MAC address spoofing, and wanted some answers regarding how this happened and what could be done to mitigate it until they were able to roll out dot1x authentication
Before getting into the details, we will set the stage by briefly reviewing how the ISE profiler works. Then we will:
- Dive into what happens when Windows and Ubuntu Linux devices connect to the network with the same MAC address as a test IP phone
- Review the ISE Anomalous Endpoint Detection (AED) feature and explain why it is ineffective in this case
ISE profiler primer
The ISE profiler has 11 modules that ingest information from a variety of sources to build a database of endpoints and endpoint attributes. The primary key for this data structure is the MAC address of the endpoint. The ISE user interface provides an interface to view the endpoint database and inspect individual endpoints through the Context VisibilityEndpoints Menu.
Endpoint Database and Endpoint Attributes
Figure – endpoint database
By clicking on the MAC address of the endpoint, we can view detailed information from the database
Figure – Summary information about the endpoint
In figure 2, we can conclude that Media Access Control (MAC) Authentication bypass is being employed because the username is the same value as the MAC address. Ultimately this means we are not doing authentication. However, we can use the profiling information to authorize a specific level of access, which we will review later.
In the following image, we can see some attributes that ISE learned, as well as a value called Total Certainty Factor (TCF)
Figure TCF and attributes learned from Device Sensor
So how is this information employed? ISE evaluates the attributes against a set of profiling policies, the policy with the highest TCF is assigned as the endpoint policy for that device. We then use that endpoint policy to decide how much access (if any) to authorize.
ISE profiling policies
Profiler polices assign point values to matching attributes. The highest Total Certainty Factor (TCF) score wins. The policies are arranged in a tree-like structure from coarse to finer-grained. The minimum score at each level of the tree has to be met before the child nodes will be evaluated.
Figure – Profiler policy for a 7965 IP phone
Logical policies are used to group like devices together where a collective policy decision would be made for them. It is the functional equivalent of putting users into groups for granting access to files and folders on a computer.
Figure – Logical profile
Policy Set Authorization (AuthZ) rule
Finally, we use the logical profile in an authorization rule, which then directs the network device to apply the authorization we have defined.
Figure – Authorization rule for IP Phones
So how does mac address spoofing bypass this system? Now that we have set the stage, we can start to talk about that.
Effect of MAC address spoofing on the profiler
Now we will see what happens when we try a Windows and then a Linux Computer using the MAC address of our previously profiled phone
For our first, we will connect a Windows 10 computer to the switch, with the same mac address as the test phone, and we will see what changes.
Figure – Windows 10 laptop
Reviewing figure 7, There are 4 items highlighted:
- Authorization profile
- Total Certainty Factor
The reason why we have an authorization result of DenyIP is that I had configured Anomalous endpoint detection. The dhcp-class-identifier change triggered the Anomalous Endpoint flag on the endpoint to true. I then used this as a condition in a rule to return the DenyIp authorization result. We will dive into the details in the AED section.
There are two main takeaways here:
- ISE was able to respond to the MAC address spoofing attempt and flagged the endpoint.
- The attributes from when the phone was profiled are still present, even though we can be reasonably sure the laptop did not send them.
It is the second point that’s important to understand. The absence of a value being sent (that was sent prior) does not equal a change as far as the profiler is concerned. The TCF changed by -30 because the dhcp-class-identifier value is scored in two locations for 10 and 20 points, respectively.
Figure – how attribute matches are scored
It is essential to grasp that except for DHCP, when endpoint attributes accumulate, they remain until there is a change. Usually, this is not too much of a problem….
Once a device has had the AED flag set, the only way to clear the condition is to delete the endpoint. I am going to unplug the laptop, delete the endpoint, and next, we will try the Ubuntu Laptop.
The endpoint was deleted, the phone plugged back in, and our endpoint has been recreated with the phone accurately identified. Now let us plug in the Linux laptop and take a look.
Figure – Linux laptop
The only informational DHCP attribute Ubuntu sends in its DHCP discovery request is host-name. The result is that the laptop received the IP_phones Authorization Profile. Why didn’t AED fire and block the endpoint?
Because we are not getting anything actionable, there is nothing to trigger ISE. If the residual attributes left from when the phone was plugged in were not persistent, this would trigger a reprofile and we would be able to do something. The reasons the attributes are cached are understandable, but it presents a difficulty here.
The main takeaways here are:
- In default DHCP configuration, the Ubuntu laptop doesn’t give up any useful information.
- We just got p0wned.
Anomalous Endpoint Detection (AED)
We saw that AED worked in the case of a Windows machine but not in the case of the Ubuntu Linux machine. Let us take a closer look at AED and see how it works.
According to the Documentation (Cisco, 2018), AED can trigger on a change in one of three things.
- NAS-Port-Type (i.e. wired or wireless)
- Endpoint policy change
If any of these conditions occur with AED enabled, the endpoint will be flagged. It should be noted that not getting the class-id when it was received prior will not trigger AED. And this is why we got p0wned by Linux.
While we are here, let us walk through how to configure AED.
- Enable it
- Create an Authorization exception rule that matches on the AnomalousBehaviour endpoint flag
- Apply an authorization profile that allows the device to receive an address (optional, I’ll explain)
In the profiler configuration settings, check off the AED boxes.
Figure – Enable AED
Define a DACL that only allows DHCP/Bootp
Reference the DACL in an authorization profile:
In the policy set, create an Exception rule that conditions on AnomalousBehaviour Endpoint Attribute. In this case, I also conditioned on IP phones because I only want the scope to cover the specific assets of interest. Assign the AuthZ profile.
Why the access-accept, and why give out an IP address? The simple answer is visibility. If we give the device an IP address, ISE can ingest the DHCP attributes and we will be able to tell from the ISE UI that a different device has been plugged in even though the endpoint was flagged by AED. If we were to prevent all access, we might not receive any new information until the endpoint was deleted and recreated.
Now we have discussed the limitations of AED and the inability to act with the Linux laptop because ISE is not receiving any actionable information. Even if we rolled out 802.1x, there might still be devices that require using MAB, so we cannot sidestep the issue.
There is a straightforward solution: Implement first-hop security and require the client to send a class-identifier in its DHCP requests. If the class-identifier does not match, or there is not one sent, then the device will not obtain an IP Address.
There are three tools we will employ to accomplish this:
- DHCP Snooping (which you have already enabled on your network, right?)
- IP source guard (depends on DHCP snooping, prevents user-assigned static addresses)
- DHCP policy on the DCHP Server
DHCP snooping listens to DHCP traffic and creates a table of IP MAC and Interface bindings. Configuring DHCP snooping is very straightforward. However, consult the documentation and make to understand how to scope it to specific VLANS and trust the uplinks leading towards the DHCP server. (Cisco Security Configuration Guide, no.date.)
ip dhcp snooping vlan 10,100
no ip dhcp snooping information option
ip dhcp snooping
!———–Trust the northbound link towards the DHCP server
ip dhcp snooping trust
IP Source Guard
IP source guard will check the DHCP snooping binding table as well as the static binding table for a matching entry when IP packets are received on the switchport. If there no match, the traffic will be dropped. This prevents an attacker from statically applying an IP address.
Ip source guard is a one-line command:
ip verify source
To close the loop, we will create a DHCP policy that will only offer addresses to devices that send the correct class-id in the DHCP Discover or Request packets. (Microsoft Docs, 2016). Creating the policy consists of the following steps:
- Create a vendor Class
- Create a policy that references the vendor class
Creating the Vendor Class.
In the DHCP management tool, right-click on the IP Address family icon and select define vendor classes. When defining the class, the beginning or the end of the string can be used for wildcard matches, but the characters must be exact. An easy way to get this is to copy it from the endpoint attribute in ISE.
Creating the policy that references the vendor class
- In the policies folder, right-click and select new policy. This will launch the new policy wizard.
- On the configure conditions window, click add to add a condition.
- Select vendor class, operator, the vendor class defined earlier, then wildcard if desired. Select add, and click ok.
- Use all of the addresses in the scope. NOTE: once done, the policy will reserve 100% of the addresses even if disabled. The policy must be deleted to release the reservation.
- Click through the rest of the wizard and select finish.
Strong authentication using 802.1x will protect against identity spoofing, but it is a significant undertaking for existing networks, and it takes time to roll out. Additionally, there may be devices that cannot perform 802.1x authentication, but they require network access. Therefore, we have to deploy a defense-in-depth strategy to secure the access network when device authentication is not possible.
- Use 802.1x with certificate authentication whenever possible.
- If you have a NAC such as ISE, employ least privilege authorization to mitigate impact.
- Deploy First Hop Security (FHS), primarily DHCP snooping and IP Source Guard.
- DHCP servers are a good control point to perform policy enforcement. Take advantage.
- Take operations security practices seriously and follow the cycle.
Cisco. (2018, May). Configure Anomalous Endpoint Detection and Enforcement on ISE 2.2. Retrieved from Cisco.com: https://www.cisco.com/c/en/us/support/docs/security/identity-services-engine-22/200973-configure-anomalous-endpoint-detection-a.html
Cisco Security Configuration Guide. (no.date.). Security Configuration Guide, Cisco IOS XE Fuji 16.9.x, Configuring DHCP. Retrieved from Cisco.com: https://www.cisco.com/c/en/us/td/docs/switches/lan/catalyst9300/software/release/16-9/configuration_guide/sec/b_169_sec_9300_cg/configuring_dhcp.html?bookSearch=true&arrowback=true
Microsoft Docs. (2016, August 31). Scenario: Secure a subnet to a specific set of clients. Retrieved from https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-r2-and-2012/dn425039(v%3Dws.11)
Monday Morning Brief: Terraform series coming
Just a quick post this morning to mention that I’m working on a thing about deploying infrastructure with Terraform. Tentatively should have the first installment out next Monday.
For the not-yet-informed. Terraform is an infrastructure deployment tool that takes a text file description of a distributed application infrastructure, compares it to what exists, and changes reality to match the description of what you want. It does this very well, and has a quick learning curve and excellent ease of use. If you’re doing production deploys into AWS or Azure, or even Cisco ACI, this is a tool you should get to know.
If you want to understand how Terraform does it’s thing from an architecture perspective here’s a link to a 30 minute talk that I found enlightening. TL;DR Graph theory is everywhere!
That’s it for this week. May you care for yourself with ease, and may the odds ever be in your favor.
PKIFNE #12: Diffie Hellman Groups
Today’s post is an excerpt from my CCIE Security notes, and it has a useful table of Diffie Hellman groups, which you can use as a job aid in IPSEC VPN designs. I Hope you find it useful.
About Diffie Hellman
The key bit of magic that makes IKE (Internet Key Exchange) possible is Diffie-Hellman. Diffie-Hellman allows anonymous entities to calculate a shared secret that can’t be discovered by a third party listening to the exchange. What’s amazing about it is the peers are able to do this using two different passwords that they keep private and never exchange. DH is one of the earliest examples of Public Key Cryptography.
- Diffie-Hellman does not provide authentication. It’s used to assist in creating a secure channel for authentication
- Diffie-Hellman does not provide encryption. It provides the keying material for encryption.
- Diffie-Hellman is used for control plane functions only.
At a high level it works like this:
If side a and side b use the same generator and modulus, resulting values from step 5 and 6 should be the same. This shared key is used as an input to the negotiated encryption algorithm.
In the case of Diffie-Hellman The generator and Prime (g,p) are predefined values (defined in a number of different RFCs) which are referenced as Diffie-hellman groups. The larger the Generator and Prime are, the more difficult it is to break. As computational power has increased substantially since the first DH groups were defined, the old groups are no longer safe to use.
The following Table lists the Diffie-Hellman Groups:
*NGE refers to Cisco Next Generation Encryption, which is the vendors set of recommended ciphersuites.
*NSA Suite B refers to the United States the National Security Agency’s published list of list of interoperable modern cryptographic standards.
Quick hits: Taking control of emotions
I recently took a course on critical thinking, and I would like to share a couple of ideas about working with emotions and using them as a diagnostic tool.
If we look at how the human mind works, we can simplify the order of operations down to three steps:
The implications of this are rather profound. If our emotions are driven by our thoughts, it follows that we can change our emotional experience of the world by changing our thinking.
It further follows that if we’re having emotions that don’t seem particularly helpful, such as a generally negative outlook, than the key is to examine the thinking that led to those feelings. Which brings us to the second idea.
Check your assumptions
Assumptions represent our implicit beliefs about the world, and they are usually subconscious in nature. We use assumptions to rapidly interpret and make decisions. This pretty helpful in a situation where we need to react immediately such as taking evasive action to avoid a car accident. They are less helpful when they are used to make judgments based on a perspective or situation that’s no longer relevant, such as being an adult instead of a child.
If we want to evaluate our thinking, and we know that our thinking is driven by subconscious assumptions, we have to find a way to bring those assumptions to the surface so we can take a look at them. How can we do that? We can ask questions!
Questions we might ask:
- What is the goal of this thinking? What problem am I trying to solve?
- What questions am I trying to answer?
- What facts do I have?
- What perspective am I looking at this from?
Putting it together
Once we’ve brought these assumptions to the surface, we can decide if they’re relevant and make sense. If they are, we now have an explicit reason and supporting argument to underpin our thinking.
If our assumptions don’t hold up, and we have no good supporting facts or reasons behind our thinking, then we can go back and look at the purpose of the thinking and see if it makes sense to reframe things in a way that can be supported by facts or reasons.
- Maybe I’m just tired or hungry.
- Maybe it’s something I can’t control and I have to let go.
- Maybe it’s an unhealthy a situation I need to extract myself from
- Maybe I need to look at this from a different perspective
Welp, that’s it for today. I hope was interesting and/or useful, and I’ll see you around.
Children of the Magenta Line
I believe it’s a safe assumption that the current crop of budding network engineers are being indoctrinated with the notion that if they don’t 100% automate all the things, their jobs and careers will be at risk. My friend Daniel Dibb deserves ample credit for repeatedly asking the question “What happens when we subsequently end up with a generation of automation engineers who don’t understand networking?”.
Yesterday morning I was drinking coffee, scrolling through my Twitter feed, when I came across a thread where Marko Milivojević posted a link to a youtube video of American Airlines Captain Warren Van Der Burgh, delivering a talk in 1997 called Children of the Magenta Line. The context is lessons learned from a rash of airline crashes caused by flight crews becoming too dependent on automation.
If you are an infrastructure engineer, or you manage infrastructure engineers, this video is worth 25 minutes of your time.
There are two quotes that stand out from this Video:
- We are Pilots and Captains, not Automation Managers
- You’ve got to pick the appropriate level of automation for the task at hand
In googling the name of the video, I came across this article which had a quote from William Langewiesche which also illustrates a fundamental problem with over reliance on automation:
“We appear to be locked into a cycle in which automation begets the erosion of skills or the lack of skills in the first place and this then begets more automation.”
Let’s learn from the Airline industry and not repeat their mistakes.
Have a good one, and I’ll see you around.
Quick hit: playing with Terraform & IOS-XE Day 0 automation
Over the last week or so I’ve been working on an Infrastructure as code Azure Hybrid cloud deployment, based on the Azure Spoke and Hub reference topology.
The gateways connecting Azure to the On-Prem datacenter in my case are Cisco Cloud Services Router 1000v (CSR1kv), using day 0 automation to inject a configuration into the Azure Router.
Here’s a link to the Azure Deployment Guide for the CSR1kv, which has some really interesting tidbits. I’ll dive into those in future post.
To actually execute the infrastructure build, I’m using a tool called Terraform.
Terraform does an incredible job of abstracting away all the details you normally have to worry about when provisioning cloud provider infrastructure. It’s a joy to work with. The documentation and examples are easy to follow, and the error messages tell you exactly what you did wrong and where to look.
If that wasn’t cool enough, the Terraform binary is actually built in to the Azure Cloud shell. The net of that is, once you have your deployment files built, you can work with them using just cloudshell, which is super convenient.
That’s it for today. Lot’s of neat stuff in this lab that I’m dying to talk about, can’t wait to share.