Why FreeIPA security hardening is harder than it looks
A FreeIPA server holds the Kerberos keys, user credentials, host policy and the certificate authority for every Linux host enrolled in the realm. A weakness on that server does not stay local. It can affect every client that trusts the realm, which is why hardening it deserves more planning than a typical application server. Treat each FreeIPA server as identity infrastructure, not as one more service to patch on the usual schedule.
FreeIPA is not a single product. It combines 389 Directory Server for the LDAP data, MIT Kerberos for single sign-on, the Dogtag certificate system for issuing certificates, and optional ISC BIND DNS and NTP services, according to the FreeIPA About page. Hardening therefore spans several components, each with its own configuration, logs and defaults. A control that works in the directory layer can be undone by a setting in the Kerberos or DNS layer, so a review that checks only one component will leave gaps in the others.
Several factors make the work harder than it looks. Defaults and quick-start settings are tuned for a lab that needs to come up quickly, not for a production realm facing hostile traffic. Replicas trust each other and the data they replicate, so a compromised or poorly configured replica can spread its state across the topology. The first server holds a special role for certificate renewal and CRL publication by default, according to the FreeIPA backup documentation, so its availability and protection matter more than its position in the list suggests. Finally, password, lockout and OTP policies are easy to loosen during troubleshooting and hard to tighten again once users and scripts depend on the looser settings.
This page covers hardening only: the controls, settings and checks that reduce risk on existing FreeIPA servers. It does not cover the initial realm and DNS design, replica topology for availability, HBAC rule design, or moving identities from another directory. Those topics have their own pages and are referenced where they affect hardening decisions. Before you change anything, confirm with your own environment which FreeIPA version you run, which components are enabled, and where the first server and CA are located, because those answers determine the rest of the plan.
Which FreeIPA components carry the attack surface
FreeIPA is a bundle of separate services, and each one has its own role in authentication and trust. Hardening starts by knowing which component holds which data and what a compromise of that component exposes, because the Directory Server, the Kerberos KDC and the certificate authority depend on each other.
389 Directory Server
The 389 Directory Server is the multi-master LDAPv3 directory that holds users, groups, hosts and policies. Because every other FreeIPA service reads its identity data from here, a compromise exposes the full identity store and the policy that governs access. Check who holds directory administrative rights, which replicas accept connections, and how access control instructions are reviewed after changes.
MIT Kerberos KDC
The MIT Kerberos key distribution center issues the tickets that give single sign-on to Linux hosts and services. It stores the long-term keys for principals, so access to its database or its key material is equivalent to impersonating the accounts it serves. Confirm that key material is protected on every KDC replica, that the release in use includes the current security fixes, and that ticket lifetimes match your policy.
Dogtag certificate authority
The Dogtag certificate authority issues the certificates that FreeIPA uses for hosts, services and users. A compromised CA can issue certificates for names it should never sign, so its signing keys are the most sensitive assets in the deployment. Confirm which replica runs the CA, who may request and approve certificates, and that renewal and CRL publication are tracked on the server that performs them by default.
SSSD on client hosts
SSSD runs on every enrolled Linux client and caches identity and authentication data so logins work when a server is unreachable. Its cache and configuration determine what a local attacker or a misconfigured host can learn about the domain. Check cache permissions, the offline credential settings you allow, and that clients use the DNS servers and DNS over TLS settings you intend.
ISC BIND DNS and NTP services
The optional ISC BIND DNS service and the NTP service are built into FreeIPA deployments when you enable them. DNS answers decide where clients send Kerberos and LDAP traffic, and time skew breaks Kerberos. Tampering with either can redirect logins or invalidate tickets. Confirm which of these services you run, which replicas serve them, and how client resolver settings point to them.
Web UI and API
The web UI and the API give administrators and scripts the same control over the directory, policies and certificates. Any weakness in authentication or access checks on these interfaces reaches every component behind them. The 4.13.4 stabilization release hardened authentication checks across the API, so confirm the release you run includes it and that administrative access to these interfaces is limited to named roles.
Hardening decisions and their trade-offs
This table sets out six hardening decisions for FreeIPA, each with a fitting use case and the operational cost of the option. Read each row as a choice to make for your own environment, since the options are not ranked against one another. The main takeaway is that every stronger control shifts effort to a different team, whether that is platform operations, helpdesk, change management or audit evidence.
| Decision | Options and fitting use case | Operational cost |
|---|---|---|
| Server roles | Dedicated IdM servers suit environments where identity services need separate patching, access and change control. Co-located services suit smaller estates with few hosts and a single operations team. | Dedicated servers add hosts to build, patch, monitor and back up. Co-located services share maintenance windows, so a reboot or change for one service affects identity login for all. |
| Patch windows | Scheduled patch windows fit environments that must apply FreeIPA security releases promptly, such as after a CVE fix. Strict change freezes fit environments where any identity outage needs formal approval. | Frequent windows need a rehearsed upgrade path across replicas. Long freezes leave security fixes unapplied for longer, and the risk must be recorded and accepted by the owner. |
| OTP for users | Enforcing OTP for all users fits organizations with uniform login policy. Enforcing OTP only for privileged accounts fits environments where most logins are automated or where token rollout is phased. | Enforcing OTP for everyone means token issuance, lost-token handling and enrollment support for the whole user base. Privileged-only enforcement keeps that load smaller but leaves standard accounts with password-only sign-in. |
| Password and lockout policy | Strict password complexity, expiry and lockout thresholds fit regulated environments with written password standards. Looser settings fit environments with heavy shared-host use or many service interactions. | Strict lockout thresholds increase unlock requests and password resets handled by helpdesk. Overly tight policies also tend to raise password reuse and written-down credentials, which must be confirmed against your own standard. |
| DNS over TLS | DNS over TLS between clients and IdM DNS servers fits environments that need encrypted name resolution. Plain DNS suits legacy clients that cannot use encrypted transport, such as older resolvers. | Encrypted DNS needs client support checked per operating system and resolver. Keeping plain DNS for legacy clients means that resolution traffic stays unencrypted for those hosts, which should be recorded as an accepted risk. |
| CA on every replica or designated replicas | Running the CA on every replica spreads certificate issuance across the topology. Running it only on designated replicas limits where CA keys and administration live, which suits stricter key-custody requirements. | Every CA replica widens the set of servers that hold CA material and need hardening and monitoring. Designated replicas concentrate renewal and CRL duties, so the first server's role and its backup must be planned explicitly. Confirm the current behavior in the deployment recommendations and backup documentation for your version. |
How to harden a FreeIPA deployment, step by step
This sequence takes an existing FreeIPA deployment from an unverified state to one where servers, patch level, authentication policy, access rules, DNS traffic and the certificate authority each have a documented check. The steps run in order because later steps depend on the inventory and patch level established earlier.
Inventory servers, replicas, services and policies
Before changing anything, list every IdM server and replica, the datacenter each one sits in, the services each runs (DNS, PKI, NTP), the replication agreements between them, and the current password, Kerberos and host access policies. Your team or a partner gathers this from the ipa command's server and topology listings and from a review of exported configuration. The step is done when the inventory matches the live topology, each replica's role has a named owner, and replica counts are compared against the FreeIPA deployment recommendations: two to three replicas per datacenter and no more than four replication agreements per replica.
Move IdM servers onto dedicated hosts
Run each IdM server on a host that carries no other application, such as web servers, build agents or database services, because the FreeIPA deployment recommendations call for dedicated servers. Platform engineering moves or rebuilds the workloads that share a host, then reinstalls the IdM role on a clean host where needed. Confirm the result by reviewing the running process list and installed packages on each host, and check that only the IdM components and the OS agents your monitoring requires remain. Record host ownership and patch windows for each server.
Apply the 4.13.4 stabilization release
Upgrade to FreeIPA 4.13.4, a stabilization release dated July 9, 2026, which fixed two CVEs. One of them fixed LDAP access control flaws that could let unauthenticated clients obtain credentials, and the release also hardened authentication checks across the API. Take a fresh backup, then upgrade one replica at a time, confirming replication health before moving to the next. The step is done when the installed version reads 4.13.4 on every server, replication is clean across the topology, and a test login from a Linux client succeeds afterward.
Set password and lockout policies
Define the global password policy and the group policies that apply to user populations. Cover minimum length, complexity, password history, maximum age, and the lockout settings that control the failed-attempt threshold, the window in which failures are counted and the lockout duration. Set the values to match your written security standard and record the reasoning behind each one. The step is done when a test account in each policy group is locked out after the configured number of failures, unlocks on the configured schedule, and can change its password successfully from a Linux client through SSSD.
Enforce OTP for privileged and remote users
Enroll administrators, service desk staff and remote users with OTP tokens, then enable the authentication policy that requires a second factor for them. FreeIPA supports HOTP and TOTP tokens, including software tokens and hardware keys such as YubiKeys, and can proxy OTP checks to an existing RADIUS server if you run one. Agree on enrollment, token replacement and lost-token procedures before rollout. The step is done when a test privileged user is denied without the second factor and accepted with it, and an administrator can revoke a token and see the revoked token refused at the next login.
Tighten least-privilege roles and HBAC rules
Review role and privilege assignments, remove standing administrator membership that is no longer needed, and split broad roles into narrower roles tied to specific tasks. Replace the default allow_all host-based access control rule with rules that name the users, groups, hosts and services permitted to log in, and bring sudo rules under central management. Test each rule before enforcement. The step is done when the effective role list for each admin group has been reviewed and signed off, a non-permitted user is denied on a test host, and each permitted path logs in successfully.
Enable DNS over TLS for supported clients
FreeIPA 4.13.0 introduced DNS over TLS between clients and IdM DNS servers. Inventory which client operating systems and resolver stacks in your environment support it, because the protection applies only to clients that use it. Enable the feature on the IdM DNS servers, configure the supported clients, and confirm that clients trust the TLS certificate chain. Keep each client's resolv.conf pointing to at least two DNS servers, and document which traffic remains plain DNS. The step is done when a resolver log or packet capture confirms encrypted transport from a supported client, and a client without the feature still resolves names.
Confirm CA and backup protection with a restore rehearsal
Confirm which server holds the CA renewal and CRL publication role, because the first server handles these by default. Protect and monitor that server, and confirm the CA signing material and its backups are stored with restricted access. Schedule regular ipa-backup runs, full or data-only as your recovery plan requires. Restoring an outdated backup into an active replica topology can break replication, so rehearse restores only in an isolated environment. The step is done when a restore rehearsal produces a working CA that issues certificates and a topology where replication recovers, with the results recorded as the baseline for future rehearsals.
Controls to enforce on the identity servers
These six controls cover the host, the software, the login path, the administrator model and the access policy. Each closes a gap that an attacker or an overly permissive configuration could use, so enforce them together and verify each one on every replica.
Dedicated identity servers
Run FreeIPA servers only for identity services. FreeIPA combines 389 Directory Server, MIT Kerberos, the Dogtag certificate system and optional DNS and NTP, and the deployment recommendations call for dedicated servers without other applications. Shared hosts widen the attack surface of the KDC and the CA and make patch windows harder to schedule. Check that no web application, build agent or file service runs on these hosts, that administrative access is limited to named staff, and that the operating system image carries only the packages FreeIPA needs.
Apply security releases promptly
Track FreeIPA stabilization and security releases and apply them to every replica. Release 4.13.4, dated July 9, 2026, fixed two CVEs, including LDAP access control flaws that could let unauthenticated clients obtain credentials, and it hardened authentication checks across the API. Upgrade one replica at a time, confirm that each server runs the patched build, and verify replication health afterward. Record the version of every server in your change log so the audit trail shows when each fix landed.
Password and lockout policy
Set password complexity, expiry, history and account lockout settings in FreeIPA so that every user and service account follows one documented standard. Confirm which policy scopes your FreeIPA version offers, such as global or group-level policies, so that administrators can carry stricter settings than general staff. Ask your security team to set the thresholds, then test them against SSSD logins, Kerberos ticket renewal and any service account that authenticates with a password. Confirm the values against your own control framework and documented risk decisions.
OTP for chosen groups
Require two-factor authentication for the groups that need it, such as administrators and remote users. FreeIPA supports HOTP (RFC 4226) and TOTP (RFC 6238) tokens, including software tokens and hardware tokens such as YubiKeys, and it can proxy OTP checks to an existing RADIUS server. Decide which groups must enforce OTP, how tokens are issued and revoked, and whether RADIUS is part of the design. Test enrollment and the recovery path before enforcement, because a lost token can lock out the only administrator.
Least-privilege administrative roles
Replace shared administrator accounts with named accounts assigned to roles that carry only the rights each job needs. Shared administrator use removes accountability, and broad rights spread across many people let one compromised login reach the whole realm. Map each duty, such as certificate requests, host enrollment or user support, to a role, and review role membership on a set schedule. Keep directory manager and root access under break-glass procedures with logging and a named owner.
Remove allow_all permissiveness
Remove default rules that let any authenticated user reach any host. Access should come from explicit host-based access control and sudo rules that name the users, groups, hosts and services involved. Review existing allow_all rules before removing them, because some services may depend on them, and test each replacement so that legitimate logins keep working. The host-based access control and sudo rules topic covers rule design and rollout, so use it for the detailed steps and use this card to confirm that the permissive rule is gone and access is verified.
Protecting the certificate authority and backups
The Dogtag certificate authority signs trust for your FreeIPA realm. Host certificates, service certificates and any certificate issued through IdM chain back to it, so a compromised CA lets an attacker issue identities that the rest of the environment will accept. Hardening starts with two decisions: who can administer the CA, and on which machines it runs. Limit CA administration to a short, named list of administrators, require individual accounts instead of shared ones, and record every administrative action. Then decide where the CA runs and confirm that the hosts carrying it are dedicated to identity services and sit behind the same access controls you apply to domain controllers and privileged management systems.
The FreeIPA backup documentation states that the first server in the topology handles certificate renewal and CRL publication by default. That role makes it the most sensitive host in the deployment, so it needs tighter access than the other replicas. Identify it before go-live by checking which server holds the renewal and CRL role in your topology. Restrict SSH and administrative sessions to it, place it on a management network segment, and forward its authentication and audit logs to a central system that someone watches. Also confirm with the documentation for your release whether this role can be moved, and plan any move as a tested change, not as an emergency step during an incident.
The ipa-backup tool produces either full backups or online data-only backups. Both contain sensitive identity data, and depending on the scope you choose, they may include key material as well. A backup file therefore deserves the same protection as the live directory. Before the first scheduled run, decide where files are written, how they are encrypted at rest, which accounts can read or copy them, and how access is logged. Then test each control. Confirm that a non-administrator cannot read the backup directory, that offsite copies remain encrypted, and that an access to a backup file produces a log entry you can review. Agree retention periods with your compliance owner, because every retained copy extends the period in which stolen data remains useful to an attacker.
The backup documentation also warns that restoring an outdated backup into an active replica topology can break replication. A restore should therefore be a controlled change with a named owner, a written runbook, and an agreed decision on whether you recover a single server or rebuild the topology from it. Before anyone runs ipa-restore, confirm which backup is the newest known good copy, freeze changes that would diverge from it, and agree how replicas will be reinitialized afterward. Rehearse this procedure in a non-production realm built from a copy of your data. On certificates, FreeIPA 4.13.0 introduced random certificate serial numbers by default. Confirm in your version how the CA assigns serial numbers, whether any certificate profile overrides that behavior, and how restored CA data interacts with serials already issued.
What drives hardening effort and how to keep it down
This table lists the main factors that raise the effort of hardening a FreeIPA deployment, how each one changes the work, and a practical way to reduce it. Read each row against your own topology, host count and compliance scope to see which drivers apply most to your rollout. The main takeaway is that most of the effort comes from scope decisions made early, so fix the topology, rule inventory and evidence plan before estimating work.
| Driver | How it raises effort | How to keep it down |
|---|---|---|
| Servers and datacenters | Each additional replica and site adds replication checks, certificate and DNS placement decisions, and separate verification of failover paths. Hardening every server consistently multiplies the review work. | Standardize one server build and one hardening baseline across replicas. Keep replicas in each datacenter within the recommended count and confirm the replication agreement limits before adding sites. |
| Enrolled hosts and users under OTP and password policy | Enforcing OTP or stricter password and lockout rules changes login for every affected user and host. Exceptions for service accounts, older clients and shared hosts create extra testing and support. | Roll out OTP and policy by group in stages. Identify service accounts and non-interactive logins early and handle them with explicit, documented exceptions. |
| Custom or legacy rules | Legacy allow_all access, unused HBAC rules, hand-made sudo entries and migrated rules that were never reviewed each need analysis before they can be replaced or removed. | Inventory existing HBAC and sudo rules first, then replace allow_all with scoped rules in batches. Remove unused rules and document the purpose of each remaining one. |
| Active Directory trusts | A cross-forest trust adds DNS domain separation checks, ID mapping decisions and policy questions for AD users who sign in to Linux hosts. Trust-related settings must be verified against both directories. | Confirm the DNS domain layout before trust work starts. Scope which AD groups may log in to which hosts and test them as a separate change from the core hardening. |
| Compliance evidence requirements | Assessors may ask for configuration exports, change records, access reviews, backup restore evidence and proof of patch currency. Gathering and labeling this evidence takes time on top of the technical changes. | Agree the control list and evidence format with your assessor before work starts. Capture configuration and test results as the changes are made, not at the end. |
| Testing environments | Without a non-production FreeIPA topology, every policy, OTP and HBAC change is tested in production or on a small ad hoc setup, which increases rework and rollback risk. | Build a test topology that mirrors replica count and client OS mix. Use it to rehearse policy changes, backup and restore, and the 4.13.x upgrade path before production. |
| Security release currency | Security fixes such as those in the 4.13.4 release notes require prompt checks on every replica, and delayed updates increase the number of versions to review at once. | Track FreeIPA release notes and your OS package updates on a fixed cadence. Upgrade replicas one at a time and confirm replication health after each step. |
How to verify hardening and confirm it fails safely
Hardening is only finished when each control has been tested and the result has been written down. Start with the version. Run the installed FreeIPA package version on every server and compare it with the FreeIPA 4.13.4 release notes, which list two CVE fixes, including LDAP access control flaws that could let unauthenticated clients obtain credentials. Record the package versions, the date you checked, and the operating system release for each host. A server that reports an older build fails this check, even if its services appear to run normally. Next, test authentication from the client side. Sign in as a test user with a password alone and then with the password plus a token, using both a software token and a hardware token if you issue both. Confirm that accounts in scope cannot pass with a password alone where your policy requires OTP. For lockout, deliberately fail logins from a dedicated test account until the lockout threshold is reached, then confirm the lock lasts for the duration your password policy sets and that the account recovers as documented. Use values from your own policy export, not from memory, and note which service accounts would be affected by the same lockout.
Verify access control from the outside in. From a host or account that should have no directory rights, attempt anonymous and low-privilege LDAP searches against the IdM servers and confirm they are refused. Repeat the test with a user who should only see their own entry. Test host-based access control the same way: a user outside an HBAC rule should be denied on the target host, and the denial should appear in the logs. For certificate authority duties, confirm that certificate renewal and CRL publication are running on the server you intended, not on a replica that was added later. Check the CA renewal master setting and the certmonger tracking state on each server, and verify that the published CRL is reachable where your relying parties expect it. Test DNS over TLS from a dedicated test client, not from an IdM server. Confirm that the client resolver is configured to use the encrypted path to the IdM DNS servers, and capture a query to show that name resolution succeeds over that path. Then check how the client behaves when the encrypted service is unavailable. Your team needs to know whether resolution fails closed or silently falls back to plain DNS, because the answer determines your risk. FreeIPA 4.13.0 introduced DNS over TLS between clients and IdM DNS servers, so confirm the behavior on your exact version rather than assuming it from older guides.
Failure testing is where safe behavior is proven. For a lost OTP token, confirm who may reset a token, what identity check the help desk performs, and whether the reset is logged. Enroll a second test token, simulate losing the first, and walk through the reset. The test passes if the lost token stops working, the reset requires the approved steps, and no shortcut exists that skips OTP for that account. For a replica that is down, stop one replica in a test topology and confirm that clients fall back to the second DNS server listed in their resolver configuration, that logins still succeed, and that the replica rejoins replication cleanly once it returns. Check replication status on all remaining servers before and after. Rehearse a backup restore in an isolated environment that has no route to production replicas. The backup documentation warns that restoring an outdated backup into an active replica topology can break replication, so the rehearsal should prove that your restore procedure keeps the restored system isolated until its state is verified. Time the steps, note what the operator had to decide, and list any manual actions that a runbook must cover. Repeat the rehearsal after any topology change, not only once at go-live. Record every test as evidence. For each check, keep the test identifier, the date, the FreeIPA and operating system versions, the exact commands or console steps, the output or captured logs, the expected result, the actual result, and the name of the person who ran and reviewed it. Store failures with the corrective action and the retest result. Ask your auditor or internal assessor which format they accept before you start, because a clear record of a failed test that was fixed is usually more useful than a clean page with no detail.
Questions buyers ask before hardening FreeIPA
How much effort does hardening a FreeIPA deployment take?
Effort depends mostly on the current state of your deployment, not on the hardening checklist itself. The main drivers are the number of servers and datacenters, whether the certificate authority and DNS run on replicas, how many hosts still rely on the allow_all HBAC rule, whether OTP is already in use, and how many services depend on RADIUS or Active Directory trusts. Deployments with a documented change process and a non-production realm usually need less rework.
Ask for a written scope that breaks effort down by policy area and host group. Confirm whether the scope includes testing on a non-production topology, whether it includes a backup restore test, and which steps recur after go-live, such as applying security releases.
Can our in-house team harden FreeIPA without outside help?
Yes, a team with Linux, Kerberos, LDAP and PKI experience can complete most of the work, provided it has time for testing and a clear change process. The skills that tend to be scarce are certificate authority operations, replication topology and DNS, because a mistake in those areas can break logins across the estate.
FreeIPA's backup documentation warns that restoring an outdated backup into an active replica topology can break replication, so restore testing needs someone who understands the topology. Before you decide, confirm who owns the CA, who can roll back a policy change quickly, and whether you have a non-production realm where OTP and password changes can be tested first.
How long does a FreeIPA hardening project usually run?
Duration depends on scope, and no single timeline fits every deployment. A single datacenter with two replicas and a short list of hosts has far fewer moving parts than several datacenters with a CA, DNS on multiple replicas and an Active Directory trust.
The scope items that move the timeline most are which hardening areas are included (server placement, release currency, password and lockout policy, OTP enforcement, replacing allow_all with HBAC rules, role design, DNS over TLS, and protection of the CA and backups), how many hosts must be enrolled, and how many change windows your organization allows. Ask for a fixed scope in writing with phases, milestones and the client dependencies behind each one.
What do we need to provide for a hardening engagement?
Three things matter most: access, change windows and named owners. For access, expect to need administrative accounts on the IdM servers, read access to replicas, the ability to review DNS and CA configuration, permission to run backups and a test restore, and access to a non-production environment if one exists.
For change windows, agree dates for replica work and for enforcement of OTP and password policies, because those changes affect logins. For named owners, assign one person for identity, one for the CA, one for DNS, and one for each host or service group that will test changes. Also prepare a current inventory of enrolled clients and any RADIUS or Active Directory dependencies. Confirm the access model and approval steps in writing before work starts.
Does hardening FreeIPA make our environment compliant with audits?
No. Hardening configures controls and produces evidence, but auditors and certification bodies decide whether your environment meets a framework and issue the attestations or certifications. DeployOpen prepares systems, controls and evidence for compliance assessments, but it does not issue audit reports or certifications.
Map each control your framework requires to a FreeIPA setting, a named process owner and an evidence source, such as policy exports, access review records, backup test logs and change tickets. Confirm with your assessor which evidence they accept and in what format before the work begins, so the hardening output matches what the assessment will request.
What happens to existing users when we change OTP and password policies?
Existing users feel the change at their next authentication, so plan for lockouts and help desk load. Password policy changes such as minimum length, history or expiry generally apply when passwords are set or changed, so a current password may remain valid until it expires. Lockout thresholds can take effect immediately, so review them before enforcement.
OTP enforcement is the most disruptive change. Users without a registered token may be unable to log in once OTP is required. FreeIPA supports HOTP and TOTP tokens, including software tokens and hardware tokens such as YubiKeys, so enroll tokens before enforcement. Use a staged rollout with a pilot group, broader groups after that, and a documented rollback step. Confirm the exact behavior for your FreeIPA version in a test realm first.
Why does FreeIPA release currency matter for hardening?
Because security fixes change what an unpatched server exposes. FreeIPA 4.13.4, a stabilization release dated July 9, 2026, fixed two CVEs, including LDAP access control flaws that could let unauthenticated clients obtain credentials, and it hardened authentication checks across the API.
Check which release each server runs, then plan upgrades one replica at a time so the topology stays available. Confirm that your operating system lifecycle supports the target release, and ask how the upgrade will be tested in a non-production realm before it reaches production replicas. Make the upgrade schedule part of the written scope so it is not left to informal follow-up.
How DeployOpen scopes, hardens and hands over FreeIPA work
DeployOpen approaches FreeIPA security hardening as a fixed-scope piece of work inside your own infrastructure, whether that is cloud accounts, data centers or an air-gapped network. Each step is agreed in writing, from the hosts and policies in scope to the documented controls that come out the other end.
How we scope
- Inventory every FreeIPA server, replica, client group and DNS and CA role before any change is proposed
- Agree in writing which hardening items apply: dedicated hosts, password and lockout policy, OTP enforcement, HBAC rules and CA and backup protection
- Confirm which FreeIPA release and operating system versions are in use, and which security fixes must be applied first
- Name the environments, change windows and approvers, so the quote reflects the actual number of servers and sites
How we build
- Replace allow_all with HBAC rules in staged groups, testing each rule on pilot hosts before rollout through SSSD
- Set password, lockout and OTP policies, then test login paths for users, service accounts and existing RADIUS integrations
- Review least-privilege roles and the CA and DNS over TLS configuration, recording each change against the agreed scope
- Check replica topology against the vendor's deployment recommendations and verify that backups are taken and restorable
How we hand over
- Deliver a configuration record covering policies, HBAC rules, role assignments, replica layout and backup schedule
- Provide test evidence for each hardening item, including login, OTP and certificate checks, so your auditors or assessors can review it
- Document restore steps for ipa-backup and ipa-restore, including the warning about restoring outdated backups into an active replica topology
- Walk your team through the operating runbook, including how the first server handles certificate renewal and CRL publication
How we support
- Engagements are fixed-scope, so ongoing work is quoted separately from the original deliverables
- Ongoing support, upgrades and continuous testing are available as a retainer if you want DeployOpen to track FreeIPA security releases
- Ask in the quote how security fix releases, such as the 4.13.x stabilization updates, would be assessed and applied to your replicas
- Confirm with DeployOpen how support covers CA, DNS and backup checks after go-live, and what response terms apply

