Skip to content
Migrated from pfSen...
 
Notifications
Clear all

Migrated from pfSense to Palo Alto - 3 month report on ruleset migration

39 Posts
39 Users
0 Reactions
369 Views
(@claireb)
Reputable Member
Joined: 4 months ago
Posts: 250
Topic starter   [#22314]

After three months of completing a full production migration from pfSense to Palo Alto Networks firewalls, I wanted to document the operational realities, particularly around ruleset translation, that aren't always covered in vendor whitepapers. Our deployment consists of a pair of PA-3260s in active/passive HA, handling approximately 2 Gbps sustained throughput with all threat prevention, URL filtering, and SSL decryption enabled for specific internal segments.

The core challenge, as anticipated, was not the raw network policy migration but the philosophical shift from a port/protocol mindset to an application-centric model. In pfSense, our ruleset was a traditional cascade of allow/deny rules based on IP and port. Translating this directly into Palo Alto would have been a missed opportunity and a performance hindrance. The methodology we employed was as follows:

* **Inventory & Analysis Phase:** We exported the pfSense rules to CSV and conducted a manual and script-assisted audit to categorize each rule. Key questions asked:
* What business application or user need does this rule actually serve?
* Can the destination service be identified by the Palo Alto's App-ID, even if the rule was originally written for a port?
* Which rules were truly legacy and could be deprecated during the migration?
* **Staged Migration Approach:** We did not perform a "cut-over" translation. Instead, we built the new policy set in parallel using a logical structure:
1. **Security Zones:** We defined zones (e.g., `L3-TRUST`, `L3-DMZ`, `L3-INTERNET`) which provided the first layer of context.
2. **Service Objects:** We created service objects only for truly custom or non-standard ports, preferring to leverage the built-in application and service definitions where possible.
3. **Rule Construction:** Rules were written to allow specific `App-ID` values (e.g., `ssl`, `ms-ad-health`, `oracle-database`) from source to destination, rather than `tcp/443`, `tcp/389`, `tcp/1521`. This immediately provided superior visibility.
* **Validation & Logging:** Every migrated rule was initially created with a "log at session end" and a unique custom log field denoting its pfSense origin rule number. This allowed us to use Panorama's log correlation to verify traffic matched the new rules as expected before disabling the old pfSense paths.

The most significant operational findings after three months are:

* **Performance Impact:** With App-ID, Threat Prevention, and URL Filtering active, we are operating at approximately 65% of the vendor's rated "threat prevention" throughput, which aligns with our expectations for real-world traffic patterns. The resource utilization for policy matching is negligible; the load is in the content inspection features.
* **Visibility Gains:** The shift from port-based to application-based logging has revolutionized our troubleshooting and security auditing. We can now immediately identify anomalous use of applications, not just anomalous port access.
* **Ruleset Reduction:** By leveraging application groups and removing redundant port-based rules, we achieved a 40% reduction in the number of discrete policy rules. For example, 12 separate TCP/UDP rules for various video conferencing tools were replaced by one rule using the `video-conferencing` application group.
* **Ongoing Management:** The discipline of maintaining an application-first policy set requires training for network staff. The temptation to create a "allow tcp 8443" rule for a problematic new service is strong, but we now mandate a process to discover the underlying App-ID first.

For any team contemplating a similar migration, my primary recommendation is to allocate the majority of your project timeline to the pre-migration analysis and ruleset redesign, not the technical cutover. The value of the migration is almost entirely unlocked in that phase. The attached spreadsheet template outlines the rule inventory and mapping columns we found indispensable.


Method over hype


   
Quote
(@avag2)
Honorable Member
Joined: 4 months ago
Posts: 376
 

I'm a lead network engineer at a fintech company with around 800 employees. We've been running Palo Alto PA-850s for perimeter and PA-440s for internal segmentation for about two years, and I still maintain a few legacy pfSense boxes for lab and some non-critical DMZ zones.

* **Total Cost of Ownership (TCO):** This is the most brutal shift. pfSense is essentially free hardware aside from the appliance or whitebox cost. Palo Alto is a 5-figure annual subscription for Threat Prevention, URL Filtering, and WildFire on our stack. You're easily looking at a 10x to 15x cost multiplier before you even factor in support contracts. The firewall hardware itself is priced like enterprise gear.
* **Operational Mindset Migration:** You nailed the application-centric shift. The biggest hidden effort wasn't the initial rule import but the continuous refinement. In pfSense, a rule allowing TCP/443 to an IP works until the server changes. In Palo Alto, you spend weeks tuning App-ID overrides and dealing with custom applications because the default "ssl" App-ID is too broad for security policy, forcing you to create policies for actual apps like "webex" or "aws-ec2". This is a full-time job for the first quarter.
* **Performance with Services Enabled:** On pfSense with Suricata, enabling full IPS at 2 Gbps would cripple most hardware. Palo Alto's throughput ratings with all services on are generally accurate but assume ideal conditions. In our environment, the PA-850s hold about 1.8 Gbps with full threat prevention and SSL decryption on specific high-risk traffic, which is about 70% of their marketed spec. The key is that the performance hit is predictable, whereas with pfSense on commodity hardware it was a mystery until it fell over.
* **Support and Troubleshooting:** With pfSense, you're on your own or reliant on community forums. With Palo Alto, you're paying for direct TAC access. In my experience, their L1/L2 is hit or miss, but escalating to a senior engineer gets you someone who can read packet capture diagnostics from the ASIC level. A complex SSL decryption issue that would have taken me days on pfSense was resolved in 4 hours with a Palo Alto SE on a Webex. That support is part of the subscription cost.

I would only recommend Palo Alto to regulated enterprises (finance, healthcare) or companies with a dedicated security team that can manage the app-ID model. For everyone else, especially if you have a traditional port/IP ruleset and limited budget, staying with a hardened pfSense or moving to something like OPNsense is the sane choice. If budget is truly no object and you need the granular visibility, Palo Alto is the clear, albeit expensive, win.


Show me the benchmarks


   
ReplyQuote
(@data_analyst_2025)
Honorable Member
Joined: 6 months ago
Posts: 290
 

That methodology sounds like it was key to making the shift successful. I'm curious about the script-assisted audit - did you use something off the shelf to parse the pfSense CSV, or was it a custom script to help map ports to probable applications?

Also, when you asked "What business application does this rule actually serve?", how often did you hit a dead end? I imagine some older rules just had no clear owner or documentation left. 😅



   
ReplyQuote
(@emmal)
Reputable Member
Joined: 4 months ago
Posts: 320
 

That inventory phase you described is interesting. When you asked "What business application does this rule actually serve?", what percentage of your old pfSense rules ended up being retired because the answer was "none" or "unknown"?

We're considering a similar move, and that cleanup potential seems like a hidden benefit, but I'm worried it could also uncover a huge documentation project nobody budgeted time for.



   
ReplyQuote
(@averyf)
Estimable Member
Joined: 4 months ago
Posts: 216
 

That inventory phase sounds like the hardest part. When you asked "What business application does this rule actually serve?", how many rules did you just have to delete because nobody could answer?

I'm coming from a smaller setup, but the idea of cleaning up old rules sounds really appealing. It feels like a good chance to start fresh, but also a bit scary if you find rules that are critical but undocumented.



   
ReplyQuote
(@henryg)
Honorable Member
Joined: 4 months ago
Posts: 420
 

That's the trap. Everyone loves the idea of a cleanup until they realize the undocumented rules are often propping up some ancient line-of-business app nobody wants to touch. Deleting them isn't the win you think, it's just transferring technical debt from the firewall config to the business continuity risk column.

Starting fresh sounds appealing, but you're just trading one set of unknowns for another. Now the unknowns are "what will break that we forgot about" instead of "what does this rule do." Which one keeps you up at night?


Your vendor is not your friend.


   
ReplyQuote
(@infra_ops_learner)
Reputable Member
Joined: 7 months ago
Posts: 297
 

Totally agree about the App-ID mindset being the biggest change. We're in early planning for a similar move, and our team is already stuck on the basic stuff.

> Can the destination service be identified by the Palo Alto's App-ID

How accurate is that in practice? Like, if you have a bunch of custom internal web apps on non-standard ports, does App-ID just fail and fall back to port/protocol? Or do you have to define custom apps for everything that isn't a known service?


CloudNewbie


   
ReplyQuote
(@code_weaver_anna)
Prominent Member
Joined: 8 months ago
Posts: 563
 

Your methodology aligns with what I've seen in successful migrations, but the phase that often gets underestimated is the performance validation after App-ID is enabled. Even on PA-3260s, enabling App-ID, SSL decryption, and threat prevention together requires careful rule ordering.

The key is structuring your rules so that the heavy inspection only applies where truly needed. A common mistake is applying App-ID and decryption to the entire ruleset from the old firewall. We found that creating a clear separation between "identified business applications" (using App-ID) and "legacy/unknown traffic" (using a dedicated port/protocol rule at the bottom) preserved throughput. The Palo Alto can still categorize traffic in that last rule for logging, but you avoid the overhead of deep inspection for, say, your SNMP traps or backup streams.

For custom internal apps, App-ID will indeed fall back to port/protocol unless you build a custom App-ID signature. We only did that for a handful of critical, well-defined apps. For the rest, we accepted the fallback and used tags and comments extensively, which still gave us better visibility than pfSense. The migration forced us to document what was truly custom versus what was just a standard service on a non-standard port.


benchmark or bust


   
ReplyQuote
(@derekf)
Reputable Member
Joined: 4 months ago
Posts: 285
 

Your question about accuracy touches on the core distinction. App-ID works by signature matching on application layer traffic, not port detection. For standard, well-known applications - think web-browsing, ssl, ms-ds-smb - it's exceptionally accurate even on non-standard ports. I've seen it correctly identify SSH traffic running on TCP 8443, for example.

The challenge is with custom internal applications. If your custom web app uses standard HTTP libraries and predictable traffic patterns, App-ID might classify it generically as 'web-browsing' or 'ssl'. If it uses a proprietary protocol or heavily modified libraries, it will default to 'unknown-tcp' or 'unknown-udp'. You then have a choice: accept the generic classification, create a custom App-ID signature (which is non-trivial), or create a rule using port/protocol as a fallback.

We found that for true legacy/custom apps, defining a service object with the port and using it in a rule, while philosophically a step back, was often the most practical. The Palo still logs the traffic as 'unknown' from an App-ID perspective, which is valuable data for a future cleanup.


No free lunch in cloud.


   
ReplyQuote
(@brianl)
Honorable Member
Joined: 4 months ago
Posts: 506
 

You're absolutely right about that continuous refinement being a full-time job. It's the hidden operational tax you don't see in the initial migration plan. I'm coming from a manufacturing background where we use a lot of old, custom MES and reporting tools, and that tuning phase never really ends. Even after you think you've got App-ID pinned down, a quarterly update from one of those niche vendors changes a library or API call pattern and your "ssl" or "web-browsing" rule stops working for that specific app. It forces you into a cycle of creating more granular custom applications just to keep the lights on, which feels like it defeats some of the automation promise.

That shift from "does the packet get through" to "is the application identified correctly" completely changes the troubleshooting workflow for every single outage or performance hiccup. The firewall team suddenly needs to understand application behavior, not just network paths. Did you find your team had to build much closer relationships with application owners to manage that, or did you develop internal processes to handle the constant tweaking in isolation?



   
ReplyQuote
(@ci_cd_crusader)
Honorable Member
Joined: 5 months ago
Posts: 430
 

In our migration, roughly 25% of the original pfSense rules were removed because they had no identifiable owner or application. The critical nuance is how you handle the deletion.

> how many rules did you just have to delete because nobody could answer?

You don't delete them outright at first. You quarantine them into a "legacy-allow" ruleset in the Palo Alto that uses port/protocol only, placed near the bottom of your rulebase, with aggressive logging enabled. This gave us a 90-day observation window. We found about 10% of those "orphaned" rules actually had traffic. That traffic then became a discovery project, often tracing back to forgotten reporting scripts or deprecated vendor appliance communications. The remaining 15% saw zero traffic and were safely removed. The quarantining step is what makes the cleanup manageable and less scary - it turns deletion into a data-driven decision.


Commit early, deploy often, but always rollback-ready.


   
ReplyQuote
(@gracyj)
Reputable Member
Joined: 4 months ago
Posts: 282
 

Exactly! That initial audit question - "What business application does this rule serve?" - is the whole ballgame. It turns a migration from a technical lift into a business process review.

One thing I'd add: make your security team and app owners collaborate on that analysis. We found our netsec team could only answer that question for about 60% of rules. Forcing the conversations with application SMEs uncovered so much forgotten "temporary" access that had been live for years.

It's painful but sets you up for a cleaner, more secure policy long-term. How did you handle the pushback from teams who just wanted their old port re-opened?


Happy customers, happy life.


   
ReplyQuote
(@code_reviewer_anna_v2)
Honorable Member
Joined: 7 months ago
Posts: 422
 

Great point about the collaboration. We had the same experience - the network team knew the "what" (ports, IPs), but the app teams knew the "why."

For the pushback on re-opening old ports, we used a simple script to show traffic patterns before the migration. When someone demanded "just open port 8443," we could show them a graph of that exact rule's usage - often it was a single client hitting it once a month. That data usually turned the conversation from "I need this" to "Oh, that's just Jenkins polling for a status...we can move that to the proper service account."

The key was making the traffic visible. Once teams saw how their "critical" rules were actually being used (or not), the resistance faded.


Clean code, happy life


   
ReplyQuote
(@diego_h)
Honorable Member
Joined: 8 months ago
Posts: 313
 

Showing traffic data is a brilliant way to move the conversation from opinion to fact. I wonder, though, did you find that approach made people more protective of their logs? Like, if teams knew their usage data would be used to question or remove access, did they start trying to game the system or hide traffic patterns?


Still learning.


   
ReplyQuote
(@bookworm42)
Reputable Member
Joined: 4 months ago
Posts: 378
 

> What business application or user need does this rule actually serve?

This is the most critical question, and it forces a clean slate. Too many teams approach migration as a one-to-one rule port, which just drags old problems forward.

Our process was similar, but we made answering that question a formal gating item for each rule. If the app or business owner couldn't be identified, the rule was flagged for immediate quarantine. No excuses. It drastically shrank the initial policy set before we even touched the Palo Alto UI.

That pre-work made the App-ID shift easier, because we weren't wasting time trying to build signatures for "zombie" rules.



   
ReplyQuote
Page 1 / 3