FortiWeb module
Puts the certificate on a Fortinet FortiWeb over its REST API v2.0 and keeps it current. By default no change the module makes drops a connection: it only uses operations measured hitless on FortiWeb 8.0.8 under continuous traffic, and it never writes a server policy — changing a policy's own certificate field or its intermediate group reloads the policy and drops its established connections. A target can allow those policy writes explicitly (update_policies, off by default).
What you set — and what CertAutoPilot does on its own
You do not pick where the certificate is used. CertAutoPilot follows the certificate object on the appliance: every place that already uses it — a policy's own certificate field, SNI members, multi-certificate entries, including bindings you add later in the FortiWeb GUI — is kept current on each renewal, and the intermediate groups those places use always carry the chain. Nothing has to be created on the appliance in advance.
A target needs only the connection (host, credential). The placement fields are optional and only matter for a first deploy, so a new certificate starts serving without a trip to the FortiWeb GUI:
- Take over what the site serves today: pick that object as the certificate name. On 8.0.7+ it is updated in place, and everything using it gets the new certificate — nothing else to set.
- Move it into existing places: list SNI members (group + domain) or multi-certificate entries. They must exist — CertAutoPilot never creates them — and a server policy must use them; a place no policy uses is still bound but warned about (
FORTIWEB_PLACEMENT_UNUSED), and the pickers mark such groups and entries. - Neither (a new site): the certificate object is imported and its intermediate group
cap-icg-<8 hex>is created with the chain; the run reportsFORTIWEB_NOT_BOUNDnaming both. Bind them once in the GUI — on 8.0.7+ select the certificate and that intermediate certificate group in the policy (one policy edit); on 8.0.5–8.0.6 bind it through a multi-certificate entry (select the entry and the group in the policy) or an SNI member, because a policy's own certificate field cannot follow later versions there — and every later renewal keeps both current.
Intermediate groups are managed for you: a policy's group is kept equal to the chain, and an SNI member without a group — or whose group also carries other certificates' CA certificates, unless that group is the chain_group you set — gets the certificate's own group cap-icg-<8 hex> (a member write, hitless). chain_group is an advanced option to give that group your own name instead of cap-icg-<8 hex>. The one thing CertAutoPilot cannot do for you is give a policy an intermediate group: that is a policy write, which reloads the policy and drops its connections, so a policy that serves the certificate without one stops the run (FORTIWEB_CHAIN_GROUP_MISSING) until you assign it once.
How a version reaches the appliance
The firmware version is read on every run (system/status.systemstatus) and decides the method:
| Firmware | Method |
|---|---|
| 8.0.7 and later | In place. One object named cert_name. Missing → imported. Present with other content → its certificate and key are replaced in place (update_certificate, introduced in 8.0.7). The name and every reference stay, so every policy, SNI member and multi-certificate entry that uses it — a policy's own certificate field included — gets the new version. No binding is touched. |
| 8.0.5 – 8.0.6 | New object per version. FortiWeb cannot replace a certificate there, so each version is imported as <cert_name>-<first 8 hex of the leaf's SHA-256> (-<first 16 hex> when that name is this certificate's own object but carries another version — after the appliance ran 8.0.7+ in between and updated it in place) and the SNI members and multi-certificate entries that used the previous version are moved to it. A policy that uses the previous version in its own certificate field is left as it is and reported with FORTIWEB_POLICY_BINDING_SKIPPED. |
| Version answered but not recognisable | The 8.0.5 method (it works on every firmware). A version that could not be read at all (timeout, error answer) stops the run before anything is written (FORTIWEB_CONNECT / FORTIWEB_API, retried) — falling back there would leave every policy that uses the certificate in its own field on the old version of an 8.0.7+ appliance. |
An appliance upgraded to 8.0.7+ keeps updating the object the certificate already serves (its versioned name from before the upgrade).
Each run, in order:
- Serve the chain first. Every CA certificate of the full chain CertAutoPilot holds — intermediates and the root — is imported once (an existing one is reused; FortiWeb does not deduplicate) and added to the intermediate groups that serve the certificate:
chain_group, the groups of the SNI members, of the policies that use the certificate (directly or through a multi-certificate entry) and of SNI members that serve a multi-certificate entry (one without a group gets the default group in a hitless member write). Group member changes are hitless. The new leaf is never served without its chain. When nothing serves the certificate yet (a first deploy, bound nowhere), the certificate's own groupcap-icg-<8 hex>(orchain_group, when set) is created with the chain, so it can be selected in a policy next to the certificate; the run reportsFORTIWEB_NOT_BOUNDwith both names. A serving group that also carries CA certificates outside this chain is reported withFORTIWEB_CHAIN_GROUP_SHARED(FortiWeb sends every member of a group, so those clients receive them too); the module never removes members it did not add and cannot change a policy's group. The root is part of the chain only when the chain CertAutoPilot holds carries it — an imported certificate keeps no root, and an ACME chain usually ends at the intermediate. - The certificate object is imported (a password-protected PKCS#12, tagged
certautopilot:<certificate id>in its comment) or, on 8.0.7+, updated in place and read back. - Bindings — configured SNI members and multi-certificate entries (and, before 8.0.7, the ones that served the previous version) are pointed at the object; each write is read back.
- Server policies are never written — unless the target's
update_policiesis on (below). - Earlier versions stay unless
delete_old_certis on (then an object this certificate created is deleted once nothing references it — never during a rollback). - Tidy the groups. FortiWeb sends every member of an intermediate group to clients, in member order. After every successful run, CA certificates this certificate added that no certificate served through the group still chains to leave the group — also in a group the certificate no longer uses (an SNI member moved to the certificate's own group, a
chain_groupyou cleared), so its chain stops reaching that group's other clients — and this chain's members are put back into chain order (issuer first, root last). Members someone else added and that are not part of this chain are never touched. This is a membership change only — no CA certificate is deleted, no connection drops — and it does not depend ondelete_old_cert. Whether a CA certificate is still needed is decided by its key identifier, so a CA renewed under the same name with a new key leaves the group once nothing chains to it. The chain is served in issuer order (issuer first, root last) whatever order the stored bundle had. If putting a group back into order fails, the run fails (FORTIWEB_API) — the chain may be incomplete on the wire until the next run adds the member back.
A re-run of the same version writes nothing. The object is recognised by its certificate — the SHA-256 of the certificate when the firmware lists it (8.0.8), otherwise its serial number, key identifiers and validity period (8.0.5 lists no certificate content). Names are never compared: FortiWeb renders a name differently per list (a common name containing a comma is quoted in the certificate list but not in the CA list), so a CA named for example "Example, Inc CA" or "Şirket Ara CA" is recognised the same way and never uploaded twice; before 8.0.7 an object with the expected name but another certificate is never overwritten (FORTIWEB_CONFLICT). Earlier versions are found from the remote state and from the ownership tag on the appliance (objects named cert_name or cert_name-<8 hex> tagged for this certificate), so none is forgotten after many renewals or a lost state — and another target that deploys the same certificate under another name is never mistaken for an earlier version. An object tagged for another CertAutoPilot certificate is refused (FORTIWEB_CONFLICT) even when this certificate's state names it.
The state also records which appliance and ADOM it was written on (the appliance's uuid — the same in every ADOM — and the ADOM name). If the target's address later reaches another appliance — a replacement unit, or the target edited to point elsewhere — or the target now names another ADOM, that record is not applied there: the run logs a warning and works as on a first deploy (objects found by their certificate and ownership tag), and Validate reports the target as not valid until the next deploy.
Requirements
- FortiWeb 8.0.5 or later. Measured on FortiWeb-KVM 8.0.5 (build 0110) and 8.0.8 standalone (evaluation, no licence) under continuous traffic. FortiWeb 7.x is not supported.
- HA clusters. The module leaves the cluster alone: it never writes HA settings, it only reports the HA mode. Point the target at the cluster's management address — FortiWeb answers it on whichever unit is primary and synchronizes the configuration to the other — not at a unit's reserved management interface. After a failover the other unit, which has its own uuid, answers the same address; on an HA member the module therefore does not treat a changed uuid as another appliance, and the earlier deploy's record still applies.
- ADOMs — with administrative domains enabled, a target works in the ADOM it names (
adom, empty = root); one ADOM per target. See ADOMs. - HTTPS from the CertAutoPilot worker to the management address (default port 443). Redirects are never followed.
- An administrator account — FortiWeb 8.0 has no API token, every request carries the username and password.
- Every policy that serves the certificate needs an intermediate group. If one does not have one (its own certificate field, or through a multi-certificate entry), serving the chain would need a policy change, so the run changes nothing and fails with
FORTIWEB_CHAIN_GROUP_MISSING. Assign a group once, in a maintenance window (it reloads that policy once); every renewal after that only edits the group's members.
Least-privilege account
Minimum access: a dedicated local administrator whose access profile has System (sysgrp) read-write and Server Policy (traroutegrp) read, every other group none. Only update_policies needs traroutegrp read-write; with ADOMs, the administrator's ADOM list must include the target's ADOM (an ADOM-scoped administrator is enough). It does not need the admin account or the prof_admin profile.
config system accprofile
edit "certautopilot"
set sysgrp rw
set traroutegrp r
next
end
| Permission group | Access | Why |
|---|---|---|
System (sysgrp) | read-write | Local certificates (import, in-place update, comment, delete), intermediate CAs and their groups, SNI members, multi-certificate entries, firmware version |
Server Policy (traroutegrp) | read (read-write only with update_policies) | Which policies use the certificate and which intermediate group serves them — written only when update_policies is on |
Every other group can stay at none. A missing permission fails the run with FORTIWEB_PERMISSION naming the group.
FortiWeb stops accepting logins after admin-lockout-threshold failed logins (3 by default) for admin-lockout-duration (60 s by default) — even the right password is refused meanwhile. The count is per source address, not per account (measured on 8.0.5 and 8.0.8): three wrong passwords for one administrator from CertAutoPilot's address made every administrator's login from that address fail for the window — another administrator's correct password included — while logins from another address still worked. A successful login resets the count. A login refused because CertAutoPilot's address is not in the administrator's trusted hosts counts too, and is answered with the same HTTP 401 as a wrong password.
So failed logins add up over every target and every credential CertAutoPilot uses on an appliance. The module never retries an authentication failure, and within one run (deploy, dry run, validate or health check):
- a wrong password costs one failed login per appliance, however many targets and ADOMs use it — once the appliance rejected it, no other target on it with that username is attempted;
- once the appliance has refused one login fewer than its threshold (2 with the default of 3; the module reads the appliance's own
admin-lockout-thresholdas soon as a login succeeds), nothing more is sent to that appliance in the run, whichever credential the remaining targets use.
Pickers and the preview follow the same rule across requests: a refused credential waits about 70 seconds, and after two refused logins on an appliance within that time no picker asks it again until they age out. A refused credential is also recorded in the database for about 70 seconds, so no other run, job or node of a multi-node installation sends that credential to the appliance in that window (keyed by the appliance, the credential and the moment its password was last entered — never by anything derived from the password; entering the password again makes it a new credential, tried at once). A node the device accepted the same credential from in the last 10 minutes does not wait for another node's refusal (a device can refuse only some addresses — trusted hosts); a credential read from a secret store without versions is held only by the node that was refused. What separate runs do not share is the per-appliance count: several jobs against one appliance with different stale credentials back to back can still reach the threshold, and so can people logging in to the GUI from the same address (a NAT gateway CertAutoPilot shares with them).
Updating server policies (update_policies)
By default the module never writes a server policy: FortiWeb reloads a policy when its certificate or its intermediate group changes, and drops every established connection of that policy. Two situations are therefore left to you and reported instead:
- A policy uses the certificate in its own certificate field on 8.0.5–8.0.6. Every version there is a new object, so the policy stays on the old version (
FORTIWEB_POLICY_BINDING_SKIPPED). - A policy serves the certificate without an intermediate group (any firmware). The module creates and fills the certificate's own group, but assigning it to the policy is a policy write, so the run refuses to change anything (
FORTIWEB_CHAIN_GROUP_MISSING).
Turn on Also update server policies (update_policies) on the target to let the module write both fields:
| Write | When | How often it drops the policy's connections |
|---|---|---|
| The policy's own certificate field → the new version | 8.0.5–8.0.6, the field still holds an earlier version | At every renewal (each version is a new object) |
The policy's intermediate group → the certificate's group (chain_group, or cap-icg-<8 hex>) | The policy serves the certificate without one | Once — later renewals only edit the group's members |
Policy writes run last, after every hitless write (chain, groups, SNI members, multi-certificate entries), each one is read back, and the result carries FORTIWEB_POLICY_UPDATED. The dry run and the placement preview list them first. The access profile then needs read-write on Server Policy (traroutegrp); without it the write fails with FORTIWEB_PERMISSION. On 8.0.7+ a policy's own field gets every version in place without a write, so there only the missing group is ever written. For a setup that never drops a connection, serve the policy through a multi-certificate entry instead of its own certificate field.
ADOMs
With administrative domains enabled, every request names the target's ADOM (the API's vdom; empty = root). Certificates, CA certificates, intermediate groups, SNI groups, multi-certificate entries and server policies live per ADOM, so a target only reads and changes its own ADOM — the pickers and the placement preview list that ADOM too — while the system status, HA mode and appliance uuid are shared. To serve one certificate in two ADOMs, add one target per ADOM; each has its own object, group and state.
- An ADOM-scoped administrator (an account with
set domains <adom>) with the profile above is enough: it reads the global settings, the system status and the HA mode, and every write the module makes is inside its ADOM (measured on 8.0.8). - An ADOM that does not exist, or is not assigned to the account, is answered with the same HTTP 401 as a wrong password, and did not count towards the lockout (measured). To tell the two apart, every target first authenticates once without an ADOM — the appliance then answers in the administrator's own default ADOM (in
rootwhen ADOMs are disabled; measured on 8.0.8), so a refusal there can only be the credential. That costs no extra failed login (a wrong password would have failed the target's first request anyway) and happens once per appliance and run. TheFORTIWEB_AUTHmessage then says which it was: the password (every target on the appliance with that username stops for the run) or the ADOM (only the targets naming that ADOM stop; the account's other ADOMs still deploy). A refusal in an ADOM that accepted the credential earlier in the same run is reported as the password having changed (or the address having been locked) in between. - That includes
roottargets and appliances without ADOMs, so an ADOM-only administrator whose target accidentally left the ADOM empty gets "ADOMroot… not assigned" and does not keep its correctly configured targets out. On an appliance without ADOMs, a target that names an ADOM is a 401 the appliance does not count (measured) — the module refuses it withFORTIWEB_VALIDATIONbefore that request anyway. - ADOM names are letters, digits and underscores (the appliance refuses a hyphen), up to 11 characters (the appliance's own limit on 8.0.5 and 8.0.8; a leading digit is allowed), and case-sensitive (
CAP_ADOM1is notcap_adom1). - On an appliance without ADOMs every object is in
root; a target that names another ADOM there is refused withFORTIWEB_VALIDATIONbefore anything is written and before any request names the ADOM — the credential probe already reads the ADOM switch (clear the field, or enable ADOMs). - Moving a target to another ADOM (editing its
adom) deploys the certificate there from scratch and marks the resultFORTIWEB_TARGET_MOVED. Nothing in the earlier ADOM is changed or removed — its certificate object and the CA certificates CertAutoPilot added keep serving the earlier version until you remove them; the job log names the ADOM and the object. To serve both ADOMs, add a second target instead of editing the first. - The health check reports
adom:<name>(oradom:disabled), and the job log and dry run name the ADOM when ADOMs are enabled; results label a target in an ADOM as<host> · <adom>.
Target
| Field | Default | Meaning |
|---|---|---|
host | — | Management hostname or IPv4: letters, digits, dots and hyphens only (no scheme, port, path or query; IPv6 is not accepted) |
port | 443 | Management HTTPS port |
ssl_verify | false | Verify the management certificate (self-signed out of the box; add a private CA with ca_cert) |
ca_cert | — | Optional PEM CA certificate(s) added to the host's trust roots while ssl_verify is on. Refused (400) while ssl_verify is off — see Trusting the appliance's certificate |
tls_fingerprint_sha256 | — | Optional SHA-256 fingerprint of the certificate the management interface serves; checked on every connection, with ssl_verify on or off. The health check shows the value — see Trusting the appliance's certificate |
http_timeout | 30 | Seconds per REST call (values below 5 are raised to 5) |
adom | root | The ADOM the target works in — only when ADOMs are enabled. Letters, digits and underscores, max 11, case-sensitive |
cert_name | auto cap-<token>-<slug> | Object name: letters, digits, . _ -, max 63, no two consecutive dots, not ending in a dot (the upload would become <name>..pfx, which FortiWeb refuses). 8.0.7+: the object itself — name an existing certificate to take it over (FORTIWEB_ADOPTED; it is tagged as owned by this certificate even when it already carries this version). A changed name is always used — e.g. after a key-type refusal (below). Earlier firmware: the base of <name>-<sha8> |
chain_group | cap-icg-<8 hex> | Advanced, usually empty. The name of the certificate's own intermediate group — created on the first deploy (also when nothing serves the certificate yet, so a policy can select it), always kept equal to the chain (intermediates and root), and given to SNI members that have no group. The groups that already serve the certificate are kept current either way |
sni | — | [{group, domains[]}] — existing SNI groups and the member domains that should serve this certificate. A member without a group gets chain_group (or this certificate's own cap-icg-<8 hex>); a member whose group also carries CA certificates outside this chain (another certificate's) is moved to that group too — unless that group is the chain_group you set — and the shared group itself is left alone. A group no server policy has enabled serves no client: the member is bound but FORTIWEB_PLACEMENT_UNUSED is reported. A plain member whose domain the certificate does not cover (*.example.com covers www.example.com; a wildcard member needs that wildcard) is skipped with FORTIWEB_PLACEMENT_SKIPPED — never bound to serve a certificate for another name; a regular-expression member is not judged |
multi_certificates | — | Multi-certificate entries; RSA → RSA slot, ECDSA → ECDSA slot, the other slot untouched. On 8.0.7+ an object cannot change key type in place: an RSA ↔ ECDSA change is refused without a write (FORTIWEB_VALIDATION) — set another cert_name, and the new key type is imported as its own object into the other slot while the previous one keeps its slot. If the slot that key type needs already holds this certificate's own object (the key type changed and back again — a rollback across an RSA ↔ ECDSA change), that object is updated instead and nothing is refused. |
delete_old_cert | false | Delete earlier versions this certificate created once nothing references them |
update_policies | false | Also write server policies — see Updating server policies. Every such write drops the policy's connections |
No placement is required. On 8.0.7+ bind the object once (policy, SNI member or multi-certificate entry) and the module keeps it current; a run with nothing using the certificate succeeds with FORTIWEB_NOT_BOUND. On earlier firmware the next renewal follows the SNI members and multi-certificate entries of the previous version. A configured placement that does not exist is skipped (FORTIWEB_PLACEMENT_SKIPPED); when all configured ones are missing and nothing uses the certificate, the run fails with FORTIWEB_PLACEMENT.
Saved targets are limited to 64 SNI groups and 64 multi-certificate entries; each SNI group needs at least one member domain and may be listed once; names up to 255 characters without control characters or surrounding spaces.
Module configuration: concurrency (API only; default 5, 1–50) — targets deployed in parallel per run. Targets on the same appliance always run one after another.
Trusting the appliance's certificate
Two optional ways to trust the management certificate, both empty by default — a target that sets neither behaves exactly as before 1.7.0:
- Verify it. Turn
ssl_verifyon; when the certificate comes from a private CA, paste that CA inca_cert(PEM, one or more certificates, up to 64 KiB) and it is added to the host's trust roots for this target.ca_certis only read whilessl_verifyis on — saving it with verification off is refused (400). - Pin it. Put the SHA-256 fingerprint of the certificate the appliance serves in
tls_fingerprint_sha256(64 hex characters, colons optional, any case). The pin is checked on every connection whetherssl_verifyis on or off, so a self-signed management certificate can be trusted exactly. The health check shows the value to paste: its checks listtls_fingerprint_sha256:AB:CD:…. A wrong pin refuses the connection before anything is sent: the target fails withTLS_TRUST_REFUSED(not retried — the other targets of the run are not rolled back for it) and the error names the fingerprint the appliance presented — update the pin when the management certificate changes.
A deploy, dry run or health check that sends a password to an appliance that is neither verified nor pinned reports the warning TLS_UNVERIFIED_PASSWORD with the served fingerprint. Clear it by pinning that fingerprint or by turning ssl_verify on (with ca_cert for a private CA). The TLS options are part of the credential-binding rule: for a target whose credential is bound, the person who entered the secret or an organization owner may change them freely; anyone else may only add a check — pin the served fingerprint while ssl_verify stays on, or add a pin or a ca_cert to a target that verified nothing. Turning ssl_verify off (even while adding a pin — that swaps the chain check for a certificate of the editor's choosing), adding a ca_cert beside the system roots while ssl_verify is on (a new trust anchor), or replacing or removing a pin or a CA is refused with 422 CREDENTIAL_TLS_CHANGE_NOT_ALLOWED, and a new FortiWeb target that only pins (ssl_verify off with a fingerprint) is judged like one that does not verify at all.
Pickers
The target form and the override drawer list what the appliance holds: certificates (subject, expiry, in use, and whose they are — this certificate's own object, another CertAutoPilot certificate's, which a deploy refuses with FORTIWEB_CONFLICT, or one CertAutoPilot did not create, which 8.0.7+ takes over), intermediate groups (members, who uses them), SNI groups (with the server policies that use each — a group no policy has enabled is marked, a certificate bound there reaches no client) and their member domains (with the certificate and chain group each serves; a member that serves a multi-certificate entry is marked — the deploy skips it, list the entry instead), and multi-certificate entries (with the policies or SNI members that use each, or marked when nothing does). The API also lists server policies with the certificate, SNI group, multi-certificate entry and intermediate group each uses. Every field also accepts a typed value. When the appliance rejects the credential (HTTP 401), pickers and the preview stop asking it for about 70 seconds and answer FORTIWEB_AUTH at once — opening dropdowns with a wrong password must not reach the appliance's lockout threshold (3 failed logins a minute from one address) and lock out the deployments too. Dropdowns opened together wait for the first one's login while the credential is not known to be good, so they cost one failed login between them; after two refused logins on an appliance (any credentials) within that time, every picker for it waits.
Preview what a deploy would do. Under the placements, on the target form and on every target row of the override drawer, a button asks the appliance — read-only, from the deploy's own plan — what a deploy would do with the placement as currently edited, before anything is saved: the firmware and the method it implies (in place on 8.0.7+, one object per version below), the certificate object (imported, updated in place, taken over, already current), the CA certificates to upload and the intermediate groups kept equal to the chain (or created), every SNI member and multi-certificate entry that would serve it (a place no policy uses is marked, an SNI member moving off a group shared with other certificates' CAs is shown, and without a certificate a member binding reads "if covered" — one that does not cover the domain is skipped), intermediate groups that also send other certificates' CA certificates, configured placements that would be skipped, policies that get it in place or stay on an earlier version, earlier versions kept or deleted, and the refusal a deploy would stop on (FORTIWEB_CHAIN_GROUP_MISSING, FORTIWEB_PLACEMENT, FORTIWEB_CONFLICT, FORTIWEB_VALIDATION). The override drawer asks for that distribution's certificate (its object name, key slot, chain and state are judged; the chain is the one that distribution deploys, the CA's own for a distribution set to the CA's default chain); the target form sends no certificate — a target serves many — so those are judged at deploy time, and a policy without an intermediate group is reported as the refusal every certificate with a chain meets.
Several certificates on one appliance. A fixed certificate name, an SNI member and a multi-certificate slot each serve ONE certificate. Leave the certificate name empty (one auto-named object per certificate) and set the members / entries per distribution in its overrides; a fixed name shared by two certificates is refused for the second one on 8.0.7+ (FORTIWEB_CONFLICT).
Per-distribution overrides
Certificate name, chain group, and the SNI / multi-certificate lists — all optional, for the same first-deploy purpose as on the target. A non-empty value replaces the target's for one distribution (a target row beats its group's row, which beats the Default row); an empty one inherits. See Per-distribution overrides.
Deleting a certificate or a target
Deleting the certificate, the distribution or the target forgets this appliance's state for it; nothing is removed from the appliance. The certificate object(s) and the CA certificates this certificate added to intermediate groups stay where they are (groups keep serving them) — remove them on the appliance if they are no longer needed. Deploying again later re-uses an object that still carries the same certificate.
Dry run, validate, health check
- Dry run — the same reads as a deploy, nothing written: the firmware and method, CA certificates to upload, groups that will carry the chain, create / update in place / take-over / reuse of the object, bindings to move, deletes — and as warnings policies left on an earlier version, an unbound certificate (with how to bind it), skipped or unused placements, groups that also send other certificates' CA certificates, earlier versions kept, a record from another appliance, and
TLS_UNVERIFIED_PASSWORDwhen the password goes to an appliance that is neither verified nor pinned; the firmware and method line is a note, and so is the served certificate's SHA-256 for a verified or pinned target. A target the deploy would refuse is reported as failed with the deploy's code: a policy without an intermediate group (FORTIWEB_CHAIN_GROUP_MISSING), none of the configured placements present (FORTIWEB_PLACEMENT), a key-type change in a multi-certificate slot. - Validate — the recorded object exists with the expected certificate and every recorded SNI member and multi-certificate entry still uses it. Like a deploy, it spends at most one failed login per appliance.
- Health check — authentication in the target's ADOM (reported as
adom:<name>/adom:disabled), the served certificate (tls_fingerprint_sha256:AB:CD:…— the value for a pin;TLS_UNVERIFIED_PASSWORDwhen neither verified nor pinned), HA mode (ha:<mode>, informational), firmware and method (in_place/repoint); before 8.0.7 a warning explains that policies using the certificate in their own field are not updated. A firmware version that cannot be read makes the target unhealthy (a deploy stops on it too). 15 s per target.
Rollback
Rollback re-deploys a previous retained version through the same steps: on 8.0.7+ the object is updated in place back to it; on earlier firmware its versioned object is reused if still there, otherwise re-imported. Nothing is deleted during a rollback.
Errors
See Error codes → FortiWeb. An appliance that presents a certificate other than the pinned tls_fingerprint_sha256 is the cross-module TLS_TRUST_REFUSED (nothing sent, not retried, the presented fingerprint in the error), not FORTIWEB_CONNECT — see Trusting the appliance's certificate.