Building a Firmware and Version Inventory
The advisory arrives at ten past nine. A serious vulnerability in a firmware train you might be running, affected versions listed, fix available. Every admin who reads it asks the same question: are we affected? The shop with a firmware inventory opens a spreadsheet and filters by model and version. It answers in two minutes: "yes, four boxes, window booked." The shop without one starts a scavenger hunt. Someone logs into switches one at a time. Someone else goes looking for the password to the firewall nobody touches. The hunt can take days, and for the whole of it the honest answer to "are we exposed?" is "we don't know."
Most small shops do not know what versions they run. I did not, for longer than I like to admit, and I was the person who was supposed to. Firmware is the operating software baked into your network gear. It is the switch's operating system, the firewall's code, and the small brain inside the UPS. Every one has a version, every version has known bugs and holes, and the only question is whether you can see yours. You cannot judge your exposure to a vulnerability, plan an upgrade, or answer an auditor without that list.
This guide shows you how to build it. You will collect versions from every tier of device. That ranges from gear that answers politely over SNMP down to the printer that only confesses through its web page. You will design a register you can actually keep up. And you will put it to work on advisories, upgrade planning, and catching changes nobody scheduled. A useful first version takes one afternoon.
In this guide
- Two minutes or two days: what the inventory buys you
- SNMP: the workhorse collector
- CLI and API harvesting for depth
- The web-UI-only tier
- The firmware everyone forgets
- Designing the register
- Putting the inventory to work
- Keeping it honest
- The one-afternoon starter sweep
Two minutes or two days: what the inventory buys you
A firmware inventory earns its keep in three situations, and the advisory drill above is only the first. The second is upgrade planning. When you decide it is time to move a fleet of switches to a newer release, the plan starts with "who is on what today?" Devices on the same starting version can be upgraded the same way. The odd one out on some ancient release may need a different upgrade path entirely. Without the inventory, you discover that surprise mid-window, which is the worst possible time.
The third is the accountability answer. Sooner or later somebody official — an auditor, a cyber-insurance questionnaire, a customer's security review — asks how you manage firmware. "We track every device's version in a register, review advisories against it, and record upgrade decisions" is a sentence that ends the conversation pleasantly. "We update things when we remember" is a sentence that starts a much longer one.
All three share one design goal: being able to query your fleet without touching it. Everything below is just plumbing to get version strings out of devices and into one queryable place.
SNMP: the workhorse collector
For network gear, the cheapest source of version information is SNMP (Simple Network Management Protocol). It is the standard question-and-answer protocol that almost every business-grade switch, router, firewall, and even most printers speak. If SNMP is new to you, spend twenty minutes with our snmpwalk tutorial first. For this job you need one idea. Every fact a device knows about itself lives at a numbered address called an OID, and you can ask for any of them.
sysDescr: the version string almost everything carries
The single most useful address is sysDescr (system description), at OID 1.3.6.1.2.1.1.1.0. It is a free-text field where the device introduces itself, and nearly every vendor stuffs the model and firmware version into it:
snmpget -v2c -c public 10.20.0.2 1.3.6.1.2.1.1.1.0 SNMPv2-MIB::sysDescr.0 = STRING: Acme NetSwitch 4800 48-port, Software 4.2.7 (maintenance release), Boot loader 1.9
One query, and you know the model, the running software version, and often the boot loader version too. The catch is that sysDescr is free text. There is no standard for its layout, and vendors have treated that as a creative opportunity. So if you want to extract just the version number automatically you will end up writing a small parsing rule per vendor. That is annoying but very doable: the formats are stable for a given product line.
Vendor MIBs: versions as proper fields
Many devices also publish the version as a clean, dedicated field. The standard ENTITY-MIB (a MIB is a published dictionary that gives OIDs human names) includes entPhysicalSoftwareRev. That field lists the software revision of each physical component the device knows about:
snmpwalk -v2c -c public 10.20.0.2 1.3.6.1.2.1.47.1.1.1.1.10 ENTITY-MIB::entPhysicalSoftwareRev.1 = STRING: 4.2.7 ENTITY-MIB::entPhysicalSoftwareRev.14 = STRING: 1.9
Vendors also ship their own private MIBs with explicit version objects. Those are worth a look for gear you own a lot of, because a clean field beats parsing free text. Support for these varies by device and model; when a device offers nothing structured, sysDescr remains the reliable fallback.
The scheduled version poll
Here is the pattern that turns a one-off query into an inventory. Your monitoring system is already polling these devices every few minutes for health data. Asking for sysDescr once a day costs nothing. Configure a daily poll of the version string per device and store the answer. Your "current version" data refreshes itself forever. Even a scheduled script looping through a device list with snmpget gets you most of the value. A human never again logs into a healthy device just to read its version number.
Tip: store the raw version string alongside whatever version number you parse out of it. Parsing rules break when a vendor reformats the text; the raw string is your evidence and your debugging aid. Disk space is cheap, and a one-line string per device per day is not even a rounding error.
CLI and API harvesting for depth
SNMP gives you breadth. For depth — boot loader versions, secondary partition images, module firmware, license state — the device's own command line usually knows more. Almost every piece of network gear has some flavor of a show version command. Its output is the full confession: hardware revision, running image, backup image, uptime, serial number.
The trick is to collect that output on a schedule instead of by hand. A small script that connects to each device, runs the version command, and saves the output to a dated file is the classic pattern:
#!/bin/sh
# collect-versions.sh - run nightly from a scheduled task
while read host; do
ssh -o BatchMode=yes audit@"$host" "show version" \
> "versions/$host.txt" 2>&1
done < device-list.txt
Ten lines of script, a read-only account on each device, and every morning you have a fresh folder of version reports you can search with grep. Use a dedicated low-privilege account for this. A script that only ever needs to run show commands should not hold credentials that can change configuration. If a real network configuration tool ever enters your life, it will do this same collection with more polish. The folder-of-text-files version is the honest starter edition, and it works.
Modern gear increasingly offers a third door: an API (application programming interface). That is a way to ask the device questions over HTTPS and get structured answers back, typically as JSON. Where your gear has one, a version query via the API is the nicest option of all. There is no parsing, no screen-scraping, just a field named something like firmware_version with the value sitting in it. Firewalls and wireless controllers are the most likely candidates. Check the admin guide for whatever you own. If the API exists, one small scheduled request per device replaces the SSH gymnastics above.
The web-UI-only tier
And then there is the bottom shelf: devices that expose no SNMP, no usable CLI, no API. They have just a web page with the version printed somewhere under Settings, About, or Help. Cheap desktop switches, some UPS units, older printers, various appliances. For these, automation is off the table and honesty is the policy: they get a manual round.
Make the round cheap. Keep a short checklist of these devices with the URL of the page where the version hides. Batch the whole tour into one calendar slot per quarter, and update the register as you go. Twenty minutes, four times a year, is an acceptable price for a handful of boxes — as long as the tier stays a handful. The real fix is procurement: make "speaks SNMP or has an API" a line item on every future purchase. The web-UI-only tier is not a moral failing; it is a buying lesson wearing a power cable.
The firmware everyone forgets
When people say "firmware inventory," they picture switches and firewalls. But the versions that bite you are often the ones nobody thinks of as firmware at all. Walk this list against your own network:
- Server management controllers (BMCs). Inside almost every business server sits a tiny, always-on computer — the baseboard management controller. It lets you power-cycle and console the server remotely. Vendors brand it differently, but it runs its own firmware, it has its own network port, and its vulnerabilities are famous. It belongs in the register as its own row.
- Wireless access points. They are individually annoying to track. But if you have a wireless controller (hardware or cloud), it already knows every AP's firmware version and will list them in one place. One query to the controller covers the whole ceiling.
- UPS network cards. The management card in your UPS is a small networked computer with its own firmware and, historically, its own security advisories. It is also the device most likely to still be running whatever it shipped with.
- Printers. They have firmware, the firmware has vulnerabilities, and they are on your network. Their saving grace: most answer SNMP
sysDescrsurprisingly well. - Everything else with an Ethernet port. NAS boxes, IP cameras, door controllers, HVAC gateways, the smart PDU in the rack. If it has an address, it has firmware, and it goes in the register — even if its row mostly documents that nobody can update it.
Yes, the printers too. Yes, they have firmware; yes, it has holes; yes, they are on your network. You do not need automation for any of these on day one. You need rows. A register that lists the UPS card with a version and a "checked quarterly, by hand" note is a working register. This list is exactly the part a future advisory will ask about, precisely because everyone forgets it.
Designing the register
Now for the destination. The register itself is small and boring, which is the highest compliment infrastructure documentation can receive. One row per trackable component, and a short set of columns:
| Device | Component | Current version | Train | Last checked | Target version | Notes |
|---|---|---|---|---|---|---|
| core-sw-01 | System firmware | 4.2.7 | 4.2 maintenance | 2 days ago | 4.2.9 | Advisory fix; window booked |
| core-sw-02 | System firmware | 4.2.4 | 4.2 maintenance | 2 days ago | 4.2.9 | Drift — missed last window |
| fw-edge-01 | System firmware | 7.1.3 | 7.1 stable | 1 day ago | 7.1.3 | At target |
| srv-file-01 | BMC firmware | 2.60 | — | 34 days ago | 2.75 | Manual; next patch round |
| ups-rack-a | UPS network card | 1.4.2 | — | 88 days ago | 1.4.2 | Web UI only; quarterly round |
Two of these columns deserve a word. Train is the release family a version belongs to. Vendors typically maintain several in parallel (a conservative maintenance line receiving only fixes, a newer feature line receiving new capabilities and new bugs). Advisories are usually scoped per train, so recording it turns "affected: 4.2.0 through 4.2.7" into a filter instead of a research project. Last checked records when the current-version value was last confirmed — automatically for polled devices, by hand for the manual tier. You will see below why that timestamp is the register's own health meter.
Where should the register live? Not in a new standalone document. If you followed our guide to building a device inventory, you already have one list of every device you own. The one-source principle from that guide applies with full force here. The firmware register should be columns on that inventory, not a rival list that drifts out of sync with it. A device gets one row (plus extra rows for extra components like a BMC). Version data hangs off the same row as its address, location, and owner.
Finally, split the columns by who maintains them. Current version and last checked should be fed by collection — the SNMP poll, the script, the controller export. That is because hand-copied version numbers rot within a month. I kept that column by hand for a year. It was right for about a month of it. Target version and notes are the opposite. They record human decisions ("we are going to 4.2.9 because of the advisory") and no script can know them. Automated facts, hand-kept intentions, one table.
Putting the inventory to work
Once the register exists, four routines pay for it many times over.
The advisory drill
An advisory names affected models and versions. You filter the register by model and train, compare versions, and you have the exposure list — with hostnames — in minutes. Now the conversation is "these four devices need the fix, here is the proposed window," which is a plan, not a panic. Whether the fix goes in tonight or waits for the normal cycle is a separate judgment call. It deserves its own framework: see when to update firmware (and when to leave it alone).
The drift view
Sort the register by model and a pattern jumps out in most shops: identical hardware running different firmware. Three switches on 4.2.7, one on 4.2.4 because nobody circled back after the last upgrade night. That stray version is the box that behaves subtly differently, hits the bug the others do not, and confuses every future troubleshooting session. Same model, same version is the goal; the drift view is how you find the stragglers and feed them into the next window.
At Meridian Parts the core switch rebooted itself twice in one afternoon. The engineer on the incident call opened the release notes to see whether anyone had fixed that. Somebody had, two releases after the one the switch was running. The switch turned out to be eleven releases behind. Nobody had known, because nobody had ever asked it. Nobody had asked because it had never given anyone a reason to. The incident report described the firmware as "older than anticipated". The register was started the following Monday, and the first row anyone filled in was the core.
The upgrade-planning feed
The gap between the current-version column and the target-version column is your upgrade backlog. When you plan an upgrade night, the register tells you exactly which devices move, from what, to what. That determines the upgrade path and the rollback plan. The actual mechanics of doing that safely (canary devices, verification, rollback) are covered in a safe firmware upgrade procedure. The register is the input that procedure consumes. After the window, the next day's poll confirms the register matches the new reality.
The audit answer
When the questionnaire asks "do you maintain an inventory of software versions and review them against vendor advisories?", you answer yes. You can show the register, the last-checked stamps, and the decision notes. A genuinely strong answer, produced as a free side effect of a register you built for your own sake.
Keeping it honest
A register is only as good as its freshness, and there are two habits that keep it truthful. The first is a pleasant bonus: version-change detection. Since you are polling the version string daily anyway, compare each answer with yesterday's and raise an alert when they differ. When the alert fires the morning after your own upgrade window, it is a free confirmation that the upgrade took. When it fires and nobody scheduled anything, you have learned something important. Someone upgraded a device outside change control, or a box silently rolled back to its backup image after a crash. Or — the genuinely alarming case — someone who is not you has been changing your equipment. A version that changes when no change was planned is one of the cleanest unauthorized-change tells a small shop can get. It falls out of the inventory for free.
The second habit is watching the last-checked ages. A polled device whose last-checked stamp is three weeks old means collection is broken for that device. For example, credentials expired, an ACL changed, or a script is dying quietly. A manual-tier device a year past its quarterly round means the round is being skipped. Either way, the staleness column is the register auditing itself: glance down it monthly, and treat anything old as a small ticket. A register that shows you its own decay is trustworthy; one that cannot is a guess with a grid drawn round it.
The one-afternoon starter sweep
You do not need a project plan for this — you need one blocked-out afternoon. Here is the sweep, and the method to reach for per device class:
| Device class | Primary method | Fallback | Refresh rhythm |
|---|---|---|---|
| Switches & routers | SNMP sysDescr / ENTITY-MIB | CLI show version | Automatic, daily |
| Firewalls | API or SNMP | CLI / web UI | Automatic, daily |
| Wireless APs | Controller inventory (one query, all APs) | Per-AP web UI | Automatic, weekly |
| Servers (OS level) | WMI / SSH query | Manual | Automatic, daily |
| Server BMCs | Vendor CLI/API | BMC web UI | Quarterly round |
| UPS network cards | SNMP where supported | Web UI | Quarterly round |
| Printers | SNMP sysDescr | Web UI | Quarterly round |
| Appliances & NAS | API/SNMP where offered | Web UI | Quarterly round |
And the afternoon itself. Here is one rule before you start. Any device you cannot read gets the word "unknown" written in, never a blank. That is because a written-down unknown is a to-do and an empty cell is a lie of omission.
- 1. Add the columns. Open your device inventory and add current version, train, last checked, target, notes. Ten minutes.
- 2. Sweep the SNMP tier. Query
sysDescracross your network gear — by script or by walking your monitoring tool's device list — and fill the rows. - 3. Export the easy fleets. Wireless controller AP list, hypervisor host versions: bulk answers, minutes each.
- 4. Visit the stragglers. Web-UI-only boxes and BMCs, by hand, noting where each version hides for next time.
- 5. Mark the gaps honestly. Any device you could not read gets "unknown" in the version column, so the gap is recorded rather than hidden.
- 6. Schedule the refresh. Set up the daily poll or nightly script for the automatic tier, and a recurring quarterly slot for the manual round.
By evening you will know exactly what your network runs — probably for the first time. And the next advisory that lands will meet a shop that can answer in two minutes.
Where to go next
The register is not a project. It is a few columns on a list you already keep, and a poll your monitoring already runs. It is also one afternoon of walking the building for the boxes that will not answer. The next advisory will still land on a morning you had other plans for; that part does not change. What changes is that "are we affected?" gets an answer before the coffee is cold. And "we don't know" stops being a sentence you say about your own network.
Everything else in this topic stands on that register. It feeds the update-or-wait judgment in when to update firmware. It drives the wave planning in a safe upgrade procedure. And it pairs with the retirement dates in EOL tracking to tell you not just what you run, but how long you can keep running it. The rest of Firmware & Lifecycle Tracking builds on the rows you fill in this afternoon.
Put this into practice with SysPeep Monitor
A firmware register stands on two things: a complete device list and a collector that already talks to every box. SysPeep Monitor gives you both. It auto-discovers the devices on your network and polls them over SNMP, WMI, and SSH. That is the same plumbing this guide uses to read version strings. The free trial installs on any Windows machine in minutes.
Download Free TrialLearn About SysPeep