Home Network Security Audit: What I Found When I Scanned My Own Network
Most people have never actually looked at their home network. They know the Wi-Fi password and nothing else. I wanted to know what was on mine, which services were reachable, and more importantly whether I could prove any of it rather than guess.
So I ran a full audit of my own Vodafone home network using nothing but Windows 11's built-in tooling and one free scanner. This is the write-up: what I found, how I verified it, and the one address that nearly sent me down the wrong path.
Why I did this, A home network audit isn't about hunting for hackers. It's about answering four questions honestly:
What is connected to my network?
Which services are actually reachable?
Which of those services need to be reachable?
Can I prove my answers, or am I assuming?
The fourth question is the one that separates a real audit from a list of IP addresses. And it's the one that made this project worth writing up.
Ground rules I set myself
Before running a single command, I wrote down my constraints:
Scan only my own network and devices I administer
Use a short, deliberate port list — not a full 65,535 sweep
Don't disable the firewall to make a test pass
Don't change any setting until I'd documented what it was
Distinguish between what's listening and what's reachable — always
That last rule turned out to matter more than the rest combined.
Phase 1 — Discovery
I opened Advanced IP Scanner and entered both address ranges in one pass:
192.168.1.1-254, 192.168.160.1-254
Scanning both together was deliberate. If I'd only scanned my own subnet, I'd never have seen the second range and never asked the question that became the centrepiece of this project.

The scan returned eight entries: my router, a Vodafone TV box, four handsets, my own laptop, and an unexplained address at 192.168.160.1.
Seven of them were expected. One wasn't.
Phase 2 — Baseline configuration
Before investigating anything, I recorded my own machine's configuration as a reference point.
cmd
ipconfig

This gave me the fixed points for everything that followed: my laptop sat at 192.168.1.72, the gateway and DNS were both 192.168.1.1, and DHCP had issued a lease good for roughly seven hours. The adapter was an Intel Wireless-AC 9260.
It also confirmed the network was a flat /24 with no VLAN segmentation — worth noting as a finding in itself.
Phase 3 — Cross-referencing the ARP cache
cmd
arp -a

This is where the audit first got interesting. My ARP cache contained two separate interface blocks.
The first, for 192.168.1.72, held seven dynamic entries that matched my scan almost exactly good corroboration that the scanner wasn't inventing devices.
The second, for 192.168.160.1, contained nothing but static broadcast and multicast entries. Zero dynamic neighbours.
That's a meaningful signal. A real LAN accumulates ARP entries as devices talk to each other. An interface with none had carried no traffic at all.
I had a working hypothesis now — but a hypothesis isn't evidence, so I kept going.
Phase 4 — Identifying the anomaly
This is the part of the project I'm most pleased with, because it's where I nearly drew the wrong conclusion twice.
First, I confirmed the address was real and local:
powershell
Get-NetIPAddress -AddressFamily IPv4 |
Format-Table InterfaceAlias, IPAddress, PrefixLength -AutoSize

192.168.160.1 was bound to an interface named Ethernet 2. The output also showed a cluster of 169.254.x.x APIPA addresses on four other adapters — link-local addresses on interfaces that were up but had never received a DHCP lease. Useful context, and a reminder that "up" doesn't mean "configured."
Then I identified the hardware behind it:
powershell
Get-NetAdapter |
Format-Table Name, InterfaceDescription, Status, MacAddress -AutoSize

Ethernet 2 VirtualBox Host-Only Ethernet Adapter Up 0A-00-27-00-00-0C
Confirmed. The mystery address was a VirtualBox host-only network interface running on my own laptop. Not a rogue device. Not a neighbour's hardware. Mine.
Two clues that nearly fooled me
The MAC address. The well-known VirtualBox OUI is 08:00:27. Mine read 0A:00:27 identical except the locally administered bit was flipped. A vendor lookup on that prefix returns nothing useful, so anyone relying on MAC-OUI databases would have drawn a blank. The adapter description settled it in one line.
The hostname. Advanced IP Scanner had labelled 192.168.160.1 as FabioRodrigues — the same name as my laptop. Suggestive, but not conclusive; plenty of things can echo a hostname. I logged it as corroboration, not proof.
I also knew the empty ARP cache meant something specific: the host-only network existed, but no virtual machine was running at the time of the scan. The infrastructure was there; nothing was attached to it.
Phase 5 — Routing verification
powershell
Get-NetRoute -AddressFamily IPv4 |
Format-Table DestinationPrefix, NextHop, InterfaceAlias, RouteMetric -AutoSize

One line mattered:
0.0.0.0/0 192.168.1.1 WiFi RouteMetric 0
A single default route, via the router, over Wi-Fi. Critically, no route existed through the 192.168.160.0/24 segment which independently corroborated that the adapter was host-only rather than NAT. If it had been NAT, there'd have been an outbound path.
Two separate commands now pointed the same direction. That's the standard I was holding myself to.
Phase 6 — Building the inventory
I converted the raw scan into a documented asset inventory with identification status for each entry.

The MAC address problem
Reading these closely revealed something important. The MACs beginning 8A, D2, E2, 36 and 0A all have the locally administered bit set meaning they're software-assigned, not burned into hardware. That's MAC randomisation, on by default on modern Android and iOS.
The practical consequence: the "Samsung" and "Huawei" vendor labels are leads, not proof. And any MAC-based allow-list I built on this network would break the next time a phone rejoined.
The one that got away
192.168.1.65, hostname K562.lan, Huawei-branded MAC. The name resembles an older Huawei handset model. It could be a forgotten tablet, a spare phone in a drawer, or something I've genuinely overlooked.
I marked it unresolved rather than guessing and left it connected. Not recognising a device is not a reason to block it.
Phase 7 — Enumerating listening services
With the network mapped, I turned the lens inward onto my own machine.
powershell
Get-NetTCPConnection -State Listen |
Select-Object LocalAddress, LocalPort, OwningProcess |
Sort-Object LocalPort

The skill here is reading the LocalAddress column, which tells you the exposure level before you even look at the port:
Value Meaning
127.0.0.1 Loopback only unreachable from the network
0.0.0.0 All IPv4 interfaces a candidate for remote access
:: All IPv6 interfaces (dual-stack, may accept IPv4)
A specific IP Bound to one interface only
A 0.0.0.0 binding makes a service a candidate. Windows Firewall still decides whether it's actually reachable.
Phase 8 — Attributing every port
Raw numbers are useless. I resolved each listener to its owning process:
powershell
Get-NetTCPConnection -State Listen |
Select-Object LocalAddress, LocalPort, OwningProcess,
@{Name="ProcessName";Expression={
(Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue).ProcessName
}} |
Sort-Object LocalPort

Everything decoded cleanly
Two observations stood out.
Port 139 was bound to two specific interface addresses rather than 0.0.0.0 NetBIOS binding per interface, meaning it would answer on both my Wi-Fi LAN and the host-only segment.
Steam was listening on 0.0.0.0:27036. Third-party software quietly widening my surface to every device on the network, including the virtual segment. Perfectly legitimate but exactly the kind of thing that never appears in a "what should be open?" mental checklist.
Phase 9 — Firewall and network profile review
powershell
Get-NetFirewallProfile |
Format-Table Name, Enabled, DefaultInboundAction, DefaultOutboundAction
Get-NetConnectionProfile

All three profiles Domain, Private, Public reported enabled. The strongest control on a Windows box, and it was doing its job.
The NotConfigured default actions looked alarming at first but aren't: no group policy has overridden the built-in defaults.
The active network, Vodafone-1815A8, was classified Public. That's the conservative default, but it does change behaviour sharing and discovery are restricted compared to Private. Worth reviewing, not worth blindly changing.
Phase 10 — Testing the router
powershell
$Target = "192.168.1.1"
$Ports = 80, 443, 22, 23, 8080, 8443
$Results = foreach ($Port in $Ports) {
$Reachable = Test-NetConnection -ComputerName $Target -Port $Port `
-InformationLevel Quiet -WarningAction SilentlyContinue
[PSCustomObject]@{ Target = $Target; TCPPort = $Port; TCPReachable = $Reachable }
}
$Results | Format-Table -AutoSize

The finding: the router serves its admin interface over plain HTTP, with no HTTPS listener responding.
Whether that's serious depends on one thing a port test can't tell you whether the login page redirects to HTTPS or sends credentials in the clear. That became an action item.
Silence on 22 and 23 meant remote administration was off or filtered. Good.
Phase 11 — Testing my own PC's service ports
powershell
$Target = "192.168.1.72"
$Ports = 135, 139, 445, 3389
# (same Test-NetConnection loop)

Result: 135 True, 139 True, 445 True, 3389 False.
My laptop was advertising RPC, NetBIOS and SMB to the LAN normal Windows services, but also the classic Windows attack surface. If you don't use file and printer sharing, they're pure extra exposure.
RDP being closed was a win: one fewer service to manage.
And here's where I had to be honest with myself. Testing my own IP from my own machine is not equivalent to testing from another device. Loopback shortcuts and local firewall behaviour can both skew results. With a single Windows PC, I could document listeners accurately but I could not claim independent verification of inbound reachability. I wrote that limitation into the report rather than glossing over it.
Phase 12 — Assessing the virtual interface's exposure
powershell
Get-NetTCPConnection -State Listen |
Where-Object {
$_.LocalAddress -eq "192.168.160.1" -or
$_.LocalAddress -eq "0.0.0.0"
} |
Select-Object LocalAddress, LocalPort, OwningProcess |
Sort-Object LocalPort

A short list: port 139 explicitly bound to 192.168.160.1, plus ports 135, 5040, 27036 and the RPC range on 0.0.0.0 and therefore reachable there too.
The distinction I kept repeating to myself: this shows what's listening. It does not show what a virtual machine can reach. Different claims.
I also confirmed the adapter was host-only rather than NAT supported by both the adapter description and the absence of any route through that subnet. Host-only means only the host and attached VMs can communicate, with no internet path. A deliberately contained little network, and the safest possible configuration for what it's for.
Phase 13 — Packaging the evidence
powershell
New-Item -ItemType Directory -Path "$HOME\Documents\HomeNetworkAudit" -Force
Get-NetTCPConnection -State Listen |
Select-Object LocalAddress, LocalPort, OwningProcess |
Sort-Object LocalPort |
Export-Csv "$HOME\Documents\HomeNetworkAudit\Windows-Listeners.csv" -NoTypeInformation
Get-NetIPAddress -AddressFamily IPv4 |
Select-Object InterfaceAlias, IPAddress, PrefixLength |
Export-Csv "$HOME\Documents\HomeNetworkAudit\IPv4-Interfaces.csv" -NoTypeInformation


Findings
ID Finding Risk Status
F-01 Router admin interface reachable on HTTP/80; HTTPS/443 not responding Medium Open
F-02 SMB, RPC and NetBIOS (135, 139, 445) reachable on the laptop Medium Open
F-03 Wi-Fi network profile classified as Public Low–Medium Review
F-04 Device 192.168.1.65 unidentified Medium Unresolved
F-05 Router and Wi-Fi hardening status unverified Medium Open
F-06 Flat /24 LAN with no segmentation; multiple virtual adapters add complexity Low Accepted
Positive observations: all firewall profiles enabled; router silent on 443/22/23/8080/8443; RDP closed; small, plausible device list; no indicators of compromise.
Overall risk: Moderate. Nothing alarming — but four genuine items worth acting on.
Remediation plan I issued
Within 24 hours
Identify 192.168.1.65 against the router's client list and physical equipment
Sign into the router locally: unique admin password, WAN administration disabled, firmware checked, WPS confirmed off
Within 7 days
Confirm WPA3-Personal or WPA2-AES; set a long unique passphrase; add a guest/IoT SSID if supported
Review inbound firewall rules; disable SMB/file sharing if unused, otherwise scope it
Patch Windows and applications
Monthly
Re-check the router's client list and firmware
Re-run the inventory and port review after adding devices
What I'd do differently
Three honest reflections:
1. Test from a second physical device. The biggest gap in this audit. A phone or second laptop would have converted "probably reachable" into "verified reachable." That's the next iteration.
2. Scan while something is actually running. My host-only network was empty during the scan. Repeating it with a VM powered on would have produced dynamic ARP entries and a much richer picture of that segment.
3. Build the inventory before the port tests. I did it in the right order here, but it's easy to get pulled into port results before you know what you're testing. The inventory gives every later finding a place to live.
Skills this project demonstrated:
Structured reconnaissance and asset inventory
Windows networking: ipconfig, arp, Get-NetIPAddress, Get-NetRoute, Get-NetAdapter, Get-NetNeighbor
Port and service enumeration with Get-NetTCPConnection and Test-NetConnection
Process attribution and service triage
Firewall and network-profile assessment
Distinguishing listening from reachable, and virtual from physical
Evidence handling, CSV export and report writing
Risk rating and remediation planning
The takeaway
The most valuable thing this project taught me wasn't a command. It was the discipline of not concluding from a single clue.
A MAC address pointed at VirtualBox. A hostname pointed at my own machine. Neither was proof. Get-NetAdapter was proof one command, one adapter description, one unambiguous answer. And it only worked because I'd refused to settle for a plausible story earlier.
Your network is probably fine. But "probably fine" isn't the same as "documented" — and the gap between those two is where every good audit lives.






Comments