Skip to main content
Video tutorial · 2:27

Microsoft IIS module

Deploys certificates to Windows Server IIS over WinRM: imports the PKCS#12 into the local machine certificate store and updates the site's HTTPS binding(s) — one binding, all matching bindings, or an explicit host-header list. Works with Windows Server 2016+.

Overview​

  • Transport: WinRM (HTTP 5985 or HTTPS 5986).
  • Auth: NTLM (default), Basic, or Kerberos — set on the target (aligned with WinRM/Exchange); the credential carries only username + password. (Credentials created before 1.5.49 may still carry auth fields — they are honored when the target sets no auth type.) Over plain HTTP 5985 every auth type additionally needs AllowUnencrypted=true on the target machine (the client does not encrypt the WSMan body); over HTTPS 5986 it is not needed.
  • Artifact: PKCS#12 bundle (cert + private key + chain) generated on the fly, imported into Cert:\LocalMachine\<store>. It is encrypted with TripleDES-SHA1 under a random one-time 256-bit password, because Windows Server 2016 cannot open an AES-encrypted PKCS#12 ("The specified network password is not correct."). The file is deleted right after the import.
  • Binding: updates the IIS site's HTTPS binding to reference the new thumbprint; the old certificate is left in the store unless Remove old cert after bind is on.
  • Rollback: supported — a rollback re-imports a previous retained certificate version's PFX into the store and repoints the bindings (Rollback).

Prerequisites​

Minimum access​

Give the account CertAutoPilot signs in with (the iis_winrm credential, a domain or local Windows account) exactly this:

  • Membership in the local Administrators group on each IIS server a target names. That one membership covers everything the module does: opening the WinRM shell, writing its temporary files in C:\Windows\Temp, importing into Cert:\LocalMachine\My or WebHosting, changing the HTTPS binding, recycling an application pool and removing the old certificate.
  • Only for a local account other than the built-in Administrator, over NTLM or Basic: LocalAccountTokenFilterPolicy = 1 on the server (see below).
  • Only for auth_type kerberos: a domain account, with the server addressed by its AD host name.

Not needed: Domain Admin, any right in Active Directory, IIS Manager users or the Management Service (WMSvc), CredSSP or Kerberos delegation, or an execution-policy change. Remote Management Users alone is not enough (see below).

# Elevated PowerShell on the IIS server
Add-LocalGroupMember -Group 'Administrators' -Member 'CORP\svc-certdeploy'

Server setup​

Missing any of these produces a WinRM error at deploy time — see Troubleshooting for the exact symptom each one causes.

  • WinRM enabled on the target: Enable-PSRemoting -Force. Reachable on 5985 (HTTP) or 5986 (HTTPS) from the backend, with a firewall rule opening that port. For HTTPS WinRM the listener needs a valid server cert bound (winrm quickconfig -transport:https, or create the listener against an existing cert's thumbprint).

  • WebAdministration PowerShell module — the module runs Import-Module WebAdministration on the target. It ships with the IIS Management Scripts and Tools feature: Install-WindowsFeature Web-Scripting-Tools. Without it you get IIS_MODULE_MISSING. (This is not the "Management Service"/WMSvc — the module uses WinRM + PowerShell, not the IIS remote-management extension.)

  • A local Administrator account for the credential. Remote Management Users is not enough: that group grants the PowerShell remoting endpoint, while CertAutoPilot runs its commands through the WinRS shell, which the default security descriptor (RootSDDL) grants to Administrators only — such an account authenticates and is then refused with HTTP 500 … Access is denied (reproduced live). And the module's operations — Import-PfxCertificate into Cert:\LocalMachine\My and the IIS binding update — require Administrator (Remote Management Users lets you connect but the cert import then fails). A constrained JEA endpoint does not help: it is a PowerShell remoting endpoint, and the module never uses one.

  • LocalAccountTokenFilterPolicy = 1 — required when the credential is a local admin account on a host where UAC is enabled (EnableLUA=1, the default). Without it UAC filters the admin token on a network logon, so the connection is not treated as an administrator and WinRM denies the operation with "Access is denied" → the module reports IIS_AUTH … HTTP 401. (With UAC disabled the setting has no effect — verified on a live host.) Set it once:

    New-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System' `
    -Name LocalAccountTokenFilterPolicy -Value 1 -PropertyType DWORD -Force

    (No effect for the built-in Administrator or domain accounts; needed for other local admins over NTLM.)

  • Auth method + username format must match the target's WinRM config:

    • NTLM (default, recommended): username .\user for a local account, or DOMAIN\user. No server-side auth changes needed on the default WinRM configuration. Note that the client authenticates with NTLM but does not encrypt the WSMan message body, so over plain HTTP 5985 the service needs AllowUnencrypted="true" (see Troubleshooting); prefer HTTPS 5986 in production.
    • Basic: username is the bare user (no .\ — Basic cannot parse the .\ prefix). Requires Basic="true" on the WinRM service, plus AllowUnencrypted="true" for HTTP or a working HTTPS 5986 listener. (Large transfers work over NTLM too — see Troubleshooting.)
  • IIS installed with the HTTPS binding(s) the certificate should land on already in place. The module never creates a binding, in any placement mode; with no matching binding the run fails with IIS_BINDING_NOT_FOUND.

Setup, step by step​

The IIS module connects over WinRM, so the transport setup is the same as the WinRM module — step by step. Do those 6 steps first (enable WinRM → prefer HTTPS 5986 → firewall → local admin → LATFP if a local admin over NTLM → CAP target auth = NTLM DOMAIN\user), then add the two IIS-specific ones below. Run each on the target IIS server, elevated, and check the result before moving on.

Step A — Install the IIS scripting tools​

The module runs Import-Module WebAdministration on the target; without it you get IIS_MODULE_MISSING.

Install-WindowsFeature Web-Scripting-Tools

Check:

Get-Module -ListAvailable WebAdministration # should list the module

Step B — Confirm the site has an HTTPS binding​

single / all_matching modes update an existing HTTPS binding — they never create one.

Import-Module WebAdministration
Get-WebBinding | Where-Object protocol -eq 'https' # at least one row for the target site

If there's none, add one in IIS Manager (or with New-WebBinding) before deploying.

Step C — Create the credential + target in CertAutoPilot​

Then follow Create the module credential and Create an IIS target below.

Create the module credential​

  1. Settings → Distribution → Credentials → New.
  2. Module type: IIS (WinRM).
  3. Username and password — just the account name, no DOMAIN\\ prefix (the domain/realm comes from the target; a prefixed name is used as-is).
  4. Save. The auth method itself (NTLM / Basic / Kerberos + Realm / KDC Address) is chosen on the target, not here.

Create an IIS target​

  1. Settings → Distribution → Targets → New. Module: IIS.
  2. Fields:
    • Hostname — reachable from the backend. A bare host name, FQDN or IP — saving refuses a URL (https://…) or a path, because each failed the first deploy with a message about the network instead of the field. A port typed into it (win01:5986) is moved into Port (refused only when the two disagree); brackets around an IPv6 address are dropped, while unbalanced brackets, or an unbracketed IPv6 address ending in :5985/:5986 (write [fd00::5]:5986), are refused. Each refusal is an HTTP 400 naming the field.
    • Port — defaults to 5986 (HTTPS) / 5985 (HTTP) based on the Use TLS toggle. Saving refuses the two mismatches WinRM never answers helpfully: TLS on with 5985, TLS off with 5986. A target saved before this check (for example behind a port-forward) stays editable as long as its hostname, port and TLS setting are left unchanged.
    • Use TLS — on for 5986. Strongly recommended.
    • TLS skip verify — accept self-signed WinRM listener cert. OK for initial bring-up, disable for prod.
    • Auth Type — ntlm, basic, or kerberos; leave empty to use the credential's auth fields (legacy). Setting it here overrides the credential's auth_type/domain/kdc_host as a group. For Kerberos, set the Realm (and optionally a KDC Address) and address the target by its AD FQDN, never an IP. With Kerberos, each WinRM connection logs in to the domain controller once and reuses the ticket for its requests (an unused login is closed after 60 s); CERTAUTOPILOT_WINRM_KERBEROS_LOGIN_CACHE=false in the backend's environment goes back to a login per request.
    • Credential: pick the one from the step above.
    • Certificate store: usually WebHosting or My (Personal).
    • Placement: Single binding (exact) — site name + binding IP (* = All Unassigned) + port (default 443), with a Host Header sub-mode (auto-select / no-SNI / specific hostname) — or Filtered selection — sites (one, a list, or every site), IPs, ports and host headers combined freely. See Binding placement below.
    • Remove old cert after bind: optionally delete the previously bound certificate from the store after a successful bind — only if no other IIS SSL binding still references it.
    • Verify Binding Names (verify_binding_names, off by default): refuse to put the certificate on a binding it does not serve — see Binding name check. A distribution can force it on or off for its own certificate.
    • Connect timeout / Command timeout: default 15 s / 60 s (allowed 5–120 s and 10–300 s). While a command runs, the host may hold each output poll open for up to 60 s (CertAutoPilot waits 60 s plus a 15 s margin), so a command that prints nothing for a while neither fails nor loses its output; every other request keeps these timeouts. One WinRM shell serves a whole target's deploy (fewer round trips on slow links); set CERTAUTOPILOT_WINRM_SHELL_REUSE=false in the backend's environment to go back to a shell per command.
    • App pool name (app_pool_name) — comma-separated pool names. When set it overrides auto-detection: exactly these pools are recycled, regardless of which bindings changed.
    • Restart app pool (restart_app_pool) — recycle the pool(s) after a successful binding update. Off by default.
    • Restart scope (restart_scope) — site_only (default) or site_and_subapps.
    • Certificate store (cert_store) — My (default) or WebHosting; nothing else is accepted.
    • Per-host deploy timeout (target_timeout_seconds, 30-3600): the whole time budget for deploying to one host (upload → import → bind → validate → app-pool recycle). Blank/0 = auto (5× the command timeout + 30 s). Raise it for slow hosts or a large PFX over slow WinRM.
  3. Save, then click Test connection on the target (or Health Check on the module): it runs the preflight over WinRM and reports anything the host lacks for a deploy (administrator token, WebAdministration, language mode, …) with the fix, plus warnings such as a lowered envelope limit — see WinRM troubleshooting.

Binding placement​

The placement says which existing HTTPS bindings a run updates. The target form offers two ways to write it:

  • Single binding (exact) — apply_mode: single (the default). One site, one Binding IP + Port and the Host Header sub-mode select exactly one binding. More than one match fails with IIS_BINDING_AMBIGUOUS, none with IIS_BINDING_NOT_FOUND.
  • Filtered selection — apply_mode: selector. Independent filters for sites, IPs, ports and host headers, combined freely: some sites, every site, every site on some ports, some sites on some IPs, only these host headers, and so on.

Filtered selection​

FieldEffect
SitesExactly one of: site_name (one site), site_names (a list, up to 100) or all_sites: true (every site on the machine, stopped ones included). With every site, excluded_sites (up to 100) skips named sites by their exact name (case-insensitive). An excluded site the server does not have is skipped with the warning IIS_EXCLUDED_SITE_NOT_FOUND (the job log names it) and the run goes on — a list shared through a distribution override's Default or group row names sites some servers do not have. One exception stops the run before anything is imported: an excluded site that a previous deploy recorded and that was renamed to a site this placement would bind fails with IIS_SITE_RENAMED — otherwise it would be swept up. A rename CertAutoPilot cannot prove (nothing recorded, see below) is not caught: after renaming an excluded site, update excluded_sites. A named site that does not exist fails the run with IIS_SITE_NOT_FOUND (site(s) not found: … for a list); one that was renamed in IIS fails with IIS_SITE_RENAMED, naming the new name. Any site name works, apostrophes and brackets included.
binding_ipsOnly bindings on these IPv4 addresses (up to 32). Empty — or * in the list — means any IP. IPv6 addresses are refused: IPv6 bindings cannot be selected.
binding_portsOnly bindings on these ports (up to 50). Empty means any port.
host_headersOnly bindings with these host headers (up to 100), exact names, case-insensitive, a trailing dot ignored. Empty means any host header, the one without a host header included. Wildcards are not expanded: *.example.com matches only an IIS binding whose host header is literally *.example.com.
include_catch_allWith host_headers: also take the binding that has no host header. Refused without host_headers (an empty list already takes it).
excluded_bindingsHost headers to skip (up to 100), reported as excluded and left untouched. A header cannot be both listed and excluded.
expect_singleExactly one binding must be selected: none fails with IIS_BINDING_NOT_FOUND, more than one with IIS_BINDING_AMBIGUOUS. Needs one site (refused with every site or a site list).

A binding is selected when it is an HTTPS binding on a site in scope and passes every filter; the lists are normalised when saved (sorted, de-duplicated, host headers lower-cased). A listed host header that no selected binding carries is reported as no such binding and makes the run partial. With the selection, the legacy single-value fields binding_ip, binding_port and host_header are refused (use the lists), and the selection-only fields (site_names, all_sites, binding_ips, include_catch_all, expect_single) are refused in every other mode.

Examples:

GoalSelection
Every site, port 443all_sites: true, binding_ports: [443]
Every site except the admin site, ports 443 and 8443all_sites: true, excluded_sites: ["Admin Site"], binding_ports: [443, 8443]
Two sites, only one IPsite_names: ["Shop", "Portal"], binding_ips: ["10.0.0.5"]
These host headers wherever they are, plus each site's catch-allall_sites: true, host_headers: ["a.example.com", "b.example.com"], include_catch_all: true
One site, exactly one binding on port 8443site_name: "Shop", binding_ports: [8443], expect_single: true
Every site is machine-wide — Dry Run first

A selection over every site touches each non-excluded site whose bindings pass the filters. Dry Run and the placement preview list the bindings before anything changes — always run one before the first execute.

Earlier modes​

Targets saved with all_matching, explicit_list or all_sites keep working and select exactly the bindings they did before — the API still accepts them, and the deploy, Dry Run and preview run them through the same matcher as a selection. The target form opens them as a Filtered selection and saves them as one:

Earlier modeSame selection
all_matching (a site, Binding IP, binding_ports or Binding Port, excluded_bindings)that site, that IP (* = any), those ports
explicit_list (a site, Binding IP + Port, host_headers)that site, IP, port and host headers
all_sites (excluded_sites, Binding IP, binding_ports or Binding Port, excluded_bindings)every site with the same exclusions, IP and ports

The override drawer does the same for a legacy port or host-header row: it opens as a Filtered selection and is saved back as one.

One difference to know before re-saving an explicit_list target or a host-header override row: it bound the first binding carrying each listed host header, while a selection binds every binding that passes the filters. The two differ only when one host header is bound on several IPs or ports — the placement preview shows the difference before you save.

Central Certificate Store bindings​

Bindings with the CCS flag (sslFlags bit 2) load their certificate from a file share, not the machine certificate store — a store-thumbprint bind cannot update them. Every placement except single reports such bindings as skipped_ccs and marks the run partial so they are visible rather than silently wrong.

For very large machines, the per-binding result list stored on the distribution is capped at 200 entries (binding_results_truncated: true is set); the scalar counters (bindings_updated, bindings_failed, bindings_name_mismatch, sites_updated, …) remain authoritative. Consider raising the target's command timeout when thousands of bindings match. With Restart App Pool on, a selection that can span several sites recycles only the pools of the sites whose bindings were actually updated.

Binding name check​

With Verify Binding Names (verify_binding_names) on, a deploy refuses to bind this certificate to a binding it does not serve, instead of binding it and leaving browsers to report a name error. It is opt-in (off by default); a distribution can force it on or off for its certificate (overrides). With it off, nothing is compared and the deploy behaves as before.

Only a binding whose certificate would change is checked — a binding already carrying this certificate is not re-judged, and in the multi-binding modes Central Certificate Store bindings are skipped before the check. The certificate's names are its DNS SANs (its Common Name only when it has no DNS SAN); IP SANs are not names. Names compare case-insensitively, without a trailing dot, and internationalised labels the way Windows maps them (the same IdnMapping the host applies — straße compares as strasse, and a name typed with combining accents as its composed form — then in punycode form), so the check agrees with what the binding actually serves.

BindingAccepted when
Has a host headerA certificate name covers it: an exact match, or a one-label wildcard — *.hb.com covers www.hb.com, but never hb.com itself and never a.b.hb.com. Partial-label wildcards (f*.hb.com) never match. An IIS wildcard host header *.hb.com is covered only by the literal name *.hb.com.
No host headerThe certificate currently on the binding (looked up by thumbprint in the binding's own store) shares at least one name with the new one. Nothing bound, that certificate not found in the store, or a certificate with no names = nothing to compare, accepted. Names the old certificate served that the new one does not are reported as the warning IIS_BINDING_NAMES_DROPPED — the deploy still succeeds.

What a refusal does depends on the apply mode:

ModeRefused binding
singleThe target fails with IIS_NAME_MISMATCH (not retried). The check runs before the certificate is imported, so nothing is imported or bound.
Filtered selection (and all_matching, explicit_list, all_sites)The binding is skipped (name_mismatch in the per-binding result, with the reason) and the others are updated; the target is partial (reason binding_name_mismatch — unless a missing or failed binding already set binding_not_found / binding_update_partial) with the warning IIS_NAME_MISMATCH_SKIPPED. If every candidate is refused (CCS bindings aside), the target fails with IIS_NAME_MISMATCH. The certificate is imported only before the first binding actually bound, so a run that binds nothing leaves the store untouched.

With the check on and a certificate that carries no DNS name at all, the target fails with IIS_NAME_MISMATCH before any remote call. A refusal writes nothing, so it does not trigger auto-rollback of the other targets. Dry Run applies the same rules, and so does the placement preview in a distribution's override drawer (it knows the certificate); the preview in the target form has no certificate and cannot.

Per-distribution binding overrides​

One IIS target (the WinRM connection) can serve many certificates. When linking a certificate to a distribution, open the certificate's Distributions → Overrides drawer and set the IIS binding placement for that certificate (a * default row applies to targets without a specific entry). The drawer offers the same two ways as the target form:

  • Filtered selection (apply_mode: "selector" on the override) — the selection fields: sites (one, a list, or every site with exclusions), binding_ips, binding_ports, host_headers, include_catch_all, excluded_bindings, expect_single. Every binding filter comes from the override — an empty list there means any, never "keep the target's". The sites are the one thing inherited: leave them empty and the override applies to the target's own site scope — its one site, its list, or every site (a target saved in the earlier all_sites mode included, with its excluded sites). A selection row with no sites and no filters at all is valid and means every HTTPS binding on the target's sites.
  • Single binding (exact) — site_name (optional), binding_ip, binding_port, host_header: exactly one existing binding.

Rows saved before the selection existed keep their meaning until they are edited: without apply_mode the mode is derived from which fields are filled. The drawer opens a single-binding row as Single binding (exact), and a port or host-header row as a Filtered selection, which it saves back with apply_mode: "selector" — see Earlier modes for the one difference that makes for a host-header list.

Override fields (no apply_mode)Effective modeWhat gets updated
host_header / binding_port / binding_ip (+ optional site_name)singleExactly one existing HTTPS binding
binding_ports list (+ optional excluded_bindings, site_name)all_matchingEvery existing HTTPS binding on the site at the listed ports
host_headers list (+ optional single binding_port, site_name)explicit_listExactly the listed host headers at one port

In that legacy form binding_ports and host_headers are mutually exclusive (422), and the selection-only fields are refused (422) — they need apply_mode: "selector". A legacy row that leaves site_name empty inherits the target's one site, so a per-target row of that shape is refused (422) when the target covers every site or a list of sites; a selection row has no such limit. The Default (all targets) row and the group rows are not bound to one target, so a site-less legacy row that lands on such a target is caught at deploy instead — that target fails with IIS_SITE_NOT_FOUND (Dry Run reports the same).

An override can cover every site

Choosing every site in an override is a project operator action, like the rest of the override drawer, and overrides do not pass the configuration-changes approval. To have an administrator review such a change, have an organization owner gate Distribution actions in the project's approval policy (Settings → Approvals). Keep different certificates' selections disjoint — overlapping ones re-bind each other's bindings on every renewal.

Upgrade every node before using a filtered selection

A node older than 1.5.54 does not know the selection fields. A target saved as a filtered selection stops there with "no site to deploy to" — a selection naming one site stores it as a one-entry site list precisely so an older node cannot sweep it. An override in the selection form on a target that is still in an earlier mode is read only in part (its site list, every-site choice and IP list are ignored) or as empty, in which case the target's own placement is deployed for that certificate. On a multi-node installation, upgrade every node before saving a filtered selection; before going back to an older release, re-save such targets and overrides in an earlier mode.

  • The HTTPS binding must already exist on the site — deploys update bindings, they never create them (IIS_BINDING_NOT_FOUND otherwise; Dry Run catches it first).
  • host_header is tri-state: omitted = any binding on the site, an explicit empty value (the "Pin the catch-all binding" checkbox, or "" via the API) = only the no-host-header binding, a hostname = exact match.
  • An override replaces the placement as soon as any placement field is filled — or it says apply_mode: "selector", which on its own means every binding on the target's sites. An entirely empty entry is rejected (omit the override to keep the target's placement).
  • Overrides carry placement, with one exception: Verify binding names (verify_binding_names) — Follow target (unset), On or Off — forces the binding name check for this certificate. It is resolved on its own: this certificate's row, else its group's row, else the Default (all targets) row, else the target. It is not placement: a row that sets only this flag is accepted and leaves the placement to the group row, the Default row or the target (precedence).
  • Every other behavior stays on the target: app pool recycling, certificate store, remove_old_cert_after_bind, timeouts.
  • Don't point two certificates at the same binding (or overlapping selections): an IIS binding holds exactly one certificate, so each renewal would flip it back and forth.
  • Certificates coexist in the Windows store under distinct thumbprints, each with its own per-certificate remote state; concurrent deploys to the same host are serialized by a per-device lock (shared with the WinRM and Exchange modules, so cross-module deploys to one box serialize too).
  • Trust model: setting overrides is a project operator action, like creating the target itself — but a target change goes through the configuration-changes approval (all operators by default), an override does not — so it deliberately delegates per-certificate placement on reviewed targets, and every change is audited with the actor and full payload.

Choosing from the server (live pickers)​

Both the IIS target form and the per-distribution override drawer can read the server and offer what is actually there instead of asking you to type names from memory:

  • Sites — every site, with its state, application pool and how many HTTPS bindings it has (a site with none cannot serve a certificate).
  • Bindings — the site's HTTPS bindings, each labelled with the certificate it carries right now (subject and expiry) so you can see at a glance whether picking it would displace an unrelated certificate. The binding IP, port and host-header pickers are all views over this one listing. For a filtered selection over several sites or all sites (or an override inheriting such a target) they list the bindings of every site the selection covers — the listed sites, or all sites minus the excluded ones — not just one site's. In single-binding mode the three pickers narrow each other to bindings that exist: pick a host header and the port list shows only the ports it is bound on; pick a port and the host list shows only that port's host headers (a port with only the catch-all binding lists none — pin the catch-all instead). When the fields do not name exactly one binding, a warning under them says so before the preview or a deploy: none — a typed value, or a placement saved earlier (IIS_BINDING_NOT_FOUND, with what the site has on that port) — or several, typically no host header on a shared port (IIS_BINDING_AMBIGUOUS). In an override row the warning appears only when the row carries its own placement; without one the group row's, the Default row's or the target's placement applies. It uses the listing a picker already loaded, so it shows once one of the pickers has been opened.
  • Application pools — for the recycle field.

The lists are read-only (Get- cmdlets only), fetched over the target's normal WinRM connection, and rate-limited to 60 requests per minute per project. Large machines are capped at 500 entries per listing. Nothing is read until you open a list — opening a form never touches your servers, so a drawer covering ten targets does not dial ten machines.

Which bindings would this touch?​

Next to the placement fields — in the target form and in each certificate's per-target override row (not the Default row or a group row, which span several machines) — Preview affected bindings asks the server to resolve the placement you have typed and lists exactly what a deploy would update, with the certificate currently on each binding. It needs no saved distribution, and it changes nothing.

It exists because the two ways a placement goes wrong are invisible while typing:

  • Too wide. A site name with no host header or port matches every HTTPS binding on the site. In single-binding mode a deploy then fails with IIS_BINDING_AMBIGUOUS — the preview lists the bindings it caught and says so, instead of stopping at the first one.
  • Too narrow, or a typo. Nothing matches (IIS_BINDING_NOT_FOUND), or a listed host header exists nowhere in the selected sites — which downgrades a real run to partial. Both are flagged before you save.

Rows are labelled will be updated, excluded (host header in excluded_bindings), central store — skipped (a Central Certificate Store binding the deploy skips) or no such binding. The matching is the same the deploy uses, so the list is the real blast radius rather than an estimate. The preview runs only when you ask for it; once open it re-runs shortly after you stop editing, never on every keystroke.

In a certificate's override drawer the preview also knows the certificate, and judges each selected binding the way Dry Run does, with the same words:

  • already current — no change — the binding already carries this certificate (Dry Run: already-current).
  • not served by this certificate — with Verify Binding Names on (the row's own setting, else its group row's, else the Default row's, else the target's), a binding the deploy would refuse; hover it for the reason (Dry Run: name-mismatch). A binding without a host header that passes shows, on hover, the names its current certificate serves that this one does not.

In the target form there is no certificate — a target serves many — so every selected binding reads will be updated and the name check is not applied.

The drawer's preview follows your unsaved edits, while Dry Run and Run use the saved overrides; the drawer says "Unsaved changes" while the two differ. Save, then Dry Run, to compare like with like.

Two rules to know:

  • Typing always works. Every picker has a manual-entry toggle, and it falls back to a plain input when the server can't be reached, so an unreachable host never blocks the form. When a listing fails, the server's own reason is shown (for example that the site does not exist) rather than a generic error.
  • Who may browse. Listing through a saved target is a project operator action (same level as setting overrides). Browsing from a target form that hasn't been saved yet sends the connection details you just typed and is therefore restricted to project admins — a saved target has been through the configuration-changes approval, an unsaved one has not. The same rule covers the credential: a saved target is browsed with the credential it was saved with; pairing it with a different credential (changing the dropdown on an existing target before saving) also needs project admin, because that pairing is exactly what the approval reviewed. In the override drawer the "Default (all targets)" row and the group rows have no single server behind them, so their fields stay manual-entry.

Dry Run​

Dry Run connects but changes nothing. It lists a per-binding plan — one entry per matched binding showing the site, the binding, and the action:

  • update — the binding would be (re)bound to the new certificate.
  • already-current — the binding already serves this certificate.
  • skipped_ccs — a Central Certificate Store binding that the deploy will skip (multi-binding modes only; a single deploy binds CCS bindings like any other, so its plan never shows this).
  • excluded — a binding whose host header is in excluded_bindings; skipped.
  • missing — a listed host header no selected binding carries; the deploy reports it and degrades to partial. Over several sites the row reads "no such binding on any selected site".
  • name-mismatch — with Verify Binding Names on, a binding the deploy would change but this certificate does not serve, with the reason. The deploy skips it (multi-binding modes) or refuses the run with IIS_NAME_MISMATCH (single). When the deploy would fail outright — single mode, or no binding left to bind — the dry run also adds a warning saying so.

With the name check on, an update binding without a host header also lists the names its current certificate serves that the new one would drop (IIS_BINDING_NAMES_DROPPED), and a certificate with no DNS name fails the dry run with IIS_NAME_MISMATCH.

The plan selects bindings exactly as the deploy does: single applies the host-header filter and the "more than one binding" check; every other placement — a filtered selection and the earlier all_matching / explicit_list / all_sites modes — runs the deploy's own matcher, so it lists the same bindings the deploy would bind (with expect_single, more than one fails the dry run with IIS_BINDING_AMBIGUOUS). A placement that can span several sites (every site, or a site list) also shows a summary line (sites in scope, matched_sites, matched_bindings, ccs_skipped, excluded_bindings, name_mismatch when the name check is on, and per-site counts for the first 50 sites). The per-binding list stops at 500 rows, and a final truncated row says how many more exist (the counters count all of them). Always Dry Run before the first execute to confirm the scope.

A failed pre-flight is shown as one line — the code and its message, for example IIS_BINDING_AMBIGUOUS: Multiple matching HTTPS bindings — not PowerShell's full error record.

Timing. Different hosts are checked side by side (up to 8 at a time; targets on the same host one after another), and the whole dry run is bounded at 100 seconds. Each target's own budget (Target Timeout, else 2 × the command timeout + 15 s) is shortened to what is left, so a slow host is reported on its own row while every other target still returns its plan. The error names the bound that fired and the step it cut off — IIS_CONNECT: the pre-flight did not finish within the <n>s this target had (cut off during “run pre-flight”), or IIS_CONNECT: “run pre-flight” did not finish within the command timeout (<n>s) when a single round trip hit Command Timeout. Each target shows how long it took; hover the time to see its round trips (upload pre-flight script, run pre-flight — the binding discovery rides in the same run). A slow upload or run on one host points at that host — endpoint protection scanning C:\Windows\Temp, a cold PowerShell, WinRM quotas.

SNI bindings are read like any other

The current thumbprint is read from each binding's own certificateHash, which IIS exposes per binding — SNI bindings included. So a binding that already carries the new certificate is reported already-current in Dry Run whatever its SNI flag, a multi-binding sweep of an unchanged certificate updates nothing and reports Changed = false, and Remove old cert after bind finds the previous certificate of an SNI binding. (Verified on Windows Server 2025 / IIS 10, where certificateHash is the hex thumbprint string; a host returning raw bytes is converted the same way.)

Execution flow​

Targets on different hosts deploy in parallel — up to Parallel Windows Hosts at once (Settings → General, distribution_windows_max_concurrency, default 8). Targets on the same host always run one after another, so two sites on one server never race on its IIS configuration. Each target has its own deploy budget (target_timeout_seconds, else five times the command timeout plus 30 s — 330 s by default); a target the job had no time left to start is reported cancelled. Per host:

  1. Already bound? When this target's recorded state says an earlier run already bound this very certificate (a retry after a later step timed out, or a re-run of the same version), one read-only check asks whether every selected binding already carries it and the certificate is in the store. If so, the uploads and the import+bind are skipped and the run goes straight to the app-pool recycle and cleanup; any doubt runs the normal deploy.
  2. Backend builds a PKCS#12 bundle from cert + key + chain, password-wrapped with an ephemeral passphrase.
  3. Uploads the PKCS#12 to a temp file under C:\Windows\Temp, created as a new file readable only by the executing user, SYSTEM and Administrators (nothing inherited from the folder). A leftover staging file CertAutoPilot cannot remove is refused rather than written into, and a host that refuses the restricted create gets the file restricted with icacls in the same step — if that fails too, the file is deleted and the transfer fails with IIS_HOST_PREREQ. The bundle travels on the remote command's standard input rather than its command line, so the key material never reaches Windows process-creation auditing, and the target verifies the content it received before the file is put in place. Each upload is bounded by the target's command timeout, like every other remote command.
  4. Uploads the bundle's password as its own file (same transfer, same restricted ACL) — it never appears in a script or an error message.
  5. Selects the binding(s). With Verify Binding Names on, each binding whose certificate would change is name-checked first. Then imports with Import-PfxCertificate into the configured store (skipped when the store already holds the thumbprint; in the multi-binding modes only once a binding is actually going to be bound), then replaces the HTTPS binding's SSL cert on the IIS site ((Get-WebBinding).AddSslCertificate) — one binding in single mode, each selected binding independently in the multi-binding modes, where a binding that already carries the thumbprint is left untouched. The certificate in the store gets the friendly name CAP-<certificate name> (the name it has in CertAutoPilot, or its primary domain when it has none), so it is easy to find in the IIS binding dialog and certlm.msc; a certificate already in the store is renamed the same way (any friendly name it had is replaced). A run that finds the binding already serving this exact certificate stops before this step, so renaming a certificate in CertAutoPilot shows on the server with its next deployed version. A failure to set the name is logged and does not fail the deploy.
  6. single mode only: a second script validates that the thumbprint is in the store and that the binding (and the site/port's IIS:\SslBindings entries) carry it. A failed validation fails the target with IIS_VALIDATE_STORE / IIS_VALIDATE_BINDING; the result still reports whether the bind changed the binding, so auto-rollback can act on it.
  7. Optionally recycles the site's app pool(s). A recycle makes the post-deploy validation wait 30 seconds and retry more patiently before it judges the binding.
  8. Optionally removes the previously bound certificate from the store (Remove old cert after bind) — only when the binding actually changed and no other IIS SSL binding still references it; not during a rollback.
  9. Deletes the temp files (the script's own finally, and again from the backend regardless of how the run ended), then emits the result (per-binding in multi-binding modes).
Old certificates in the store

By default old certificates stay in the store untouched — deleting them blindly can break other applications on the same host. Enable Remove old cert after bind to have the module delete the previously bound certificate after a successful bind, but only when no other IIS SSL binding on the machine still references it. Anything older than that (or referenced elsewhere) still needs an occasional manual sweep (e.g. Get-ChildItem Cert:\LocalMachine\WebHosting | Where NotAfter -lt (Get-Date)).

Retries & partial results​

A step that runs out of time says which step and how long it ran: for example "“import and bind” did not finish within the command timeout (60s) — it ran 1m0s (raise command_timeout_seconds, or find out why the host is slow)", or that the target's deploy budget ran out during it (raise target_timeout_seconds), followed by the round-trip times of the steps before it.

Failures are classified so fan-out can auto-retry the transient ones: a dropped/timed-out WinRM connection (IIS_CONNECT) or a failed PFX transfer is retried; a genuine binding/validation error (IIS_BINDING_NOT_FOUND, IIS_VALIDATE_BINDING, …) is not — re-running can't fix it, and neither is a refusal by the host (IIS_AUTH, HTTP 401/403): a rejected credential cannot succeed on a second attempt and every retry adds a failed-logon record. Not retried either: an HTTP 200 that is not a WinRM reply (IIS_CONNECT — another web server or a proxy on the port) and a script that printed more than 64 MiB, stopped on the host (WINRM_OUTPUT_LIMIT). An untrusted or mismatched WinRM listener certificate is IIS_AUTH too, and not retried: only a change to the trust, the address or tls_skip_verify fixes it. The bind is idempotent (a cert already in the store is not re-imported; in the multi-binding modes a binding already carrying the thumbprint is left alone, and in single mode the bind call is repeated but binding the same certificate again changes nothing — the result then reports Changed = false), so a retry after a partial network failure is safe. Full class table: Distribution error codes.

A multi-binding run reports partial when some bindings succeed and others are skipped or fail — binding_update_partial when bindings failed or CCS bindings were skipped, binding_not_found when some requested host headers had no binding, binding_name_mismatch when the binding name check skipped bindings this certificate does not serve. IIS_NAME_MISMATCH is a validation error and is not retried.

No command-line size limits

Multi-binding and machine-wide placements generate large PowerShell scripts. To stay clear of the Windows command-line length limit, any script above a small threshold is streamed to a temporary .ps1 on the target (over the file transport) and run with -File, then deleted — so machine-wide runs work regardless of how many bindings match. This is automatic and needs no configuration.

Rollback​

Supported via previous-version re-deploy: a rollback re-imports a previous retained certificate version's PFX into the certificate store and repoints the HTTPS bindings at its thumbprint — the module's normal deploy path, fed older material. During a rollback run the remove_old_cert_after_bind behavior is suppressed, so the newer certificate stays in the Windows certificate store and rolling forward again is instant. Eligibility, the version picker, and auto-rollback: Rollback.

Troubleshooting​

IIS_AUTH ... HTTP 401 — the host refused the request​

The most common failure, and it is almost always authorization — not the transfer itself. The message now carries the facts the host gave: the HTTP status, the auth schemes the listener offered (server offers …), the server's own words when it sent any, and the check list below. (Before 1.5.53 all of these collapsed into 401 - invalid content type, which named neither a cause nor a next step.)

Failures that never reach WinRM — nothing listening on the port, TLS on/off mismatched with the listener, an untrusted listener certificate, DNS, a web site answering on the port — name themselves in the message too; the complete catalogue for all three Windows modules is WinRM troubleshooting.

Read the offered schemes first — they identify the cause. A default WinRM listener offers Basic, Negotiate on plain HTTP. What is missing is the signal (each row below was reproduced on a live Windows Server):

The message saysWhat it meansFix
server offers Basic, Negotiate and the target is NTLMThe credential itself was refused, or the account is not authorized for WinRMSteps 1–2 below
server offers Negotiate on plain HTTPAllowUnencrypted=false — Windows withholds the Basic challenge entirely when it will not accept unencrypted trafficStep 3
HTTP 500 with nothing else, on plain HTTPAllowUnencrypted=false — some hosts refuse the unencrypted request with an empty 500 instead of the 401Step 3
server offers Basic only, target is NTLMNegotiate is disabled on the service, or incoming NTLM is blocked by policyStep 4
server offers Kerberos onlySame as above on a domain-hardened hostStep 4
  1. Is the account a local Administrator? A valid account that is not one gets the same bare 401 as a wrong password when it is in no WinRM-authorized group, and HTTP 500 … Access is denied (named as such in the message) when it is only in Remote Management Users. Either way the fix is the Administrators group — the certificate import needs it regardless:

    net user <user> # Account active? Password expires?
    net localgroup Administrators | findstr /i <user>
    net localgroup Administrators <user> /add

    The Security log tells the two apart (verified on a live host): a 4625 event means the logon was rejected — 0xC000006D wrong password, 0xC0000064 no such user, 0xC000015B the account may not log on over the network (a "Deny access to this computer from the network" right, common in hardened baselines). No 4625 at all means the logon succeeded and WinRM refused the account's authorization — i.e. it is not an administrator.

  2. With UAC enabled, is LocalAccountTokenFilterPolicy = 1 set? A local admin over a network logon gets a filtered (non-admin) token without it. This only applies when UAC is on (EnableLUA=1); with UAC disabled the setting has no effect:

    $p = Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System'
    $p.EnableLUA # 1 = UAC on (then the next value matters)
    $p.LocalAccountTokenFilterPolicy # should be 1

    (See Prerequisites for the command to set it.) Not needed for the built-in Administrator or for domain accounts.

  3. Plain HTTP (5985) without AllowUnencrypted? The client does not encrypt the WSMan body, so over HTTP the service must have AllowUnencrypted="true" — for NTLM, Basic and Kerberos alike. The tell is in the message: the listener still offers Negotiate but no Basic challenge. Basic additionally needs Basic="true" and a bare username (user, not .\user):

    winrm get winrm/config/service/auth # Basic = true ?
    winrm get winrm/config/service # AllowUnencrypted = true ?
    winrm set winrm/config/service/auth '@{Basic="true"}'
    winrm set winrm/config/service '@{AllowUnencrypted="true"}'
    Restart-Service WinRM

    Prefer HTTPS 5986 in production; nothing above is needed there.

Large transfers over NTLM are fine

Earlier releases suggested switching to Basic when only the PFX transfer failed, on the theory that NTLM could not carry a large WinRM body. Re-tested on a live Windows Server against the current transport (which streams the payload on the remote process's stdin): 64 KiB, 1 MiB and 4 MiB transfers all succeed over NTLM. If only the transfer fails while small commands succeed, look at the host — a disk-full C:\Windows\Temp, an AV/EDR hook, or a WinRM quota — not at the auth type.

  1. NTLM disabled on a hardened / domain-joined box. When the message says the listener offers no Negotiate, NTLM can never succeed there. Two causes: Negotiate="false" on the service, or incoming NTLM blocked by policy. Check what it offers — on the box winrm get winrm/config/service/auth (Negotiate must be true), or from anywhere a raw POST returns the accepted methods:

    curl -s -i -X POST http://<host>:5985/wsman \
    -H "Content-Type: application/soap+xml;charset=UTF-8" --data x | grep -i WWW-Authenticate

    If it lists only Negotiate + Kerberos and NTLM keeps failing, incoming NTLM is blocked by Network security: Restrict NTLM: Incoming NTLM traffic (commonly enforced by a domain GPO). Three options:

    # (a) Allow incoming NTLM. On a domain box this is usually GPO-controlled — set it in the
    # domain GPO or it reverts on the next gpupdate/reboot. Local override for a quick test:
    New-ItemProperty 'HKLM:\SYSTEM\CurrentControlSet\Control\Lsa\MSV1_0' `
    -Name RestrictReceivingNTLMTraffic -Value 0 -PropertyType DWORD -Force # 0=Allow all
    Restart-Service WinRM
    (b) Switch the IIS TARGET to Kerberos. Set Auth Type = kerberos on the target together
    with the Realm (uppercase AD domain, e.g. CORP.LOCAL); the credential keeps its
    bare username, and address the target by its AD FQDN — Kerberos does not
    authenticate against a bare IP. Nothing needs to be installed on the CertAutoPilot
    host: the Kerberos configuration is built in memory and the domain controller is
    discovered automatically via the AD DNS SRV record (or pinned with the optional
    KDC Address field when this host's DNS cannot resolve AD records). This matches
    exactly what a hardened GPO baseline leaves enabled (Negotiate/Kerberos = true).
    (c) Or set the TARGET's Auth Type to Basic over HTTPS (port 5986). This only works if Basic
    CAN be enabled — check `winrm get winrm/config/service/auth`:
    `Basic = false [Source="GPO"]` means Basic is also policy-locked and cannot be
    turned on from the box.

    An unrecognized auth_type on an IIS target is rejected when the target is saved; one left in a legacy credential fails the connection with invalid auth_type — neither falls back to NTLM silently.

Confirm what the server sees: on the target, the Security event log records the WinRM logon. A successful logon is event 4624 (Logon Type 3, NTLM V2) — if you see 4624 (not 4625) but the deploy still fails, authentication works and the problem is authorization (steps 1–2), not the password.

"Failed to connect to WinRM"​

Check winrm quickconfig on the target, confirm the listener exists (winrm enumerate winrm/config/listener), and verify the firewall allows the port. From the backend host: Test-NetConnection <host> -Port 5985 (or 5986). If the target field points at the IIS site port (443/80) instead of the WinRM port (5985/5986), you also get a 401 with an HTML body — put the WinRM port in Port, and the site port in Binding Port.

Port 5986 open, but the TLS handshake resets​

If a connection to 5986 is accepted and then reset during the TLS handshake (connection reset / abrupt close before any HTTP response), the WinRM HTTPS listener has no usable server certificate bound — the port answers because the listener exists, but Windows aborts the handshake when it cannot present a certificate (missing, expired, or its private key inaccessible). Fix it on the target:

winrm enumerate winrm/config/listener # HTTPS listener present? CertificateThumbprint set and valid?
# Bind a server-auth certificate (from your internal CA; CN/SAN must match the hostname CAP dials):
New-Item -Path WSMan:\localhost\Listener -Transport HTTPS -Address * -CertificateThumbprint <thumbprint> -Force
Restart-Service WinRM

The backend must trust the certificate's chain, or the target must set TLS Skip Verify (not recommended for production). Until the listener is fixed, the target can run over HTTP 5985 with NTLM.

IIS_MODULE_MISSING​

The WebAdministration PowerShell module isn't on the target. Install it: Install-WindowsFeature Web-Scripting-Tools (IIS Management Scripts and Tools). The target's health check reports this before any deployment does.

IIS_HOST_PREREQ — the host cannot run the deployment​

The host answered, the credential was accepted, but something about the host stops the scripts from running. At deploy time that is PowerShell locked to Constrained Language, or a transfer larger than the host's WinRM message-size limit (Windows answers HTTP 413; the health check only warns about a low limit — a certificate upload usually fits), or a staging file in C:\Windows\Temp that cannot be created restricted to the connecting account — a leftover .captmp CertAutoPilot cannot remove, or icacls failed on a host that refused the restricted create (the file is removed, nothing is imported). The health check reports more under this code before any deploy: a non-administrator or UAC-filtered account, an unwritable C:\Windows\Temp, a PowerShell older than 3, an inaccessible certificate store. The message names which one and the command that fixes it. Not retried — a retry repeats the same refusal. Full catalogue: WinRM troubleshooting.

"Access is denied" during Import-PfxCertificate (IIS_AUTH)​

The account lacks permission to write to the LocalMachine cert store — it is not a local Administrator, or LocalAccountTokenFilterPolicy is unset so its admin token is filtered. See step 1–2 above. The target fails with IIS_AUTH. A different message, "Access to the path 'C:\Windows\Temp\…' is denied", is a filesystem permission problem on the staged temp file and is reported as IIS_IMPORT_FAILED — check the temp directory's ACLs, not the account.

A bind exception (IIS_BINDING_FAILED)​

In single mode an exception from AddSslCertificate (for example when HTTP.sys refuses the certificate) fails the target with IIS_BINDING_FAILED and the exception's own message; the certificate is already in the store. In the multi-binding modes the failing binding is recorded individually and the run is partial (or IIS_BINDING_FAILED when no binding could be updated).

IIS_BINDING_NOT_FOUND — no binding matched​

No HTTPS binding on the selected site(s) matched the requested IPs/ports (or host headers) — or, with expect_single, none was left after the host-header filter. The run fails with IIS_BINDING_NOT_FOUND — it is never a silent no-op. The module never creates bindings, so the binding must already exist.

The message says what to fix, in one line, and Deploy, Dry Run and Preview affected bindings say the same thing:

  • what the placement asked for (ip=* port=443 host=www.example.com, or the selection's sites, IPs, ports and host headers);
  • the binding(s) a previous deploy of this certificate updated that are no longer on the site — the binding was changed or removed in IIS (its host header, port or IP edited, switched to http, or deleted);
  • the site's HTTPS bindings as they are now (at most 15 listed).

For example, after the host header www.example.com was edited to shop.example.com in IIS Manager:

IIS_BINDING_NOT_FOUND: no HTTPS binding on site 'Shop' matches ip=* port=443 host=www.example.com - the binding(s) a previous deploy updated are no longer there, changed or removed in IIS: *:443:www.example.com - HTTPS bindings on the site now: *:443:shop.example.com

Update the target (or the distribution override) to the binding that now exists, or put the binding back in IIS. The "no longer there" part needs a previous deploy of the certificate to this target; without one only the request and the current bindings are named. The Preview shows the error instead of an empty list.

IIS_SITE_NOT_FOUND — site does not exist, or no site at all​

Either a named site does not exist on the server (check Get-IISSite; pick it from the site picker instead of typing it — for a site list the message names every missing site, and nothing is bound), or the resolved placement has no site: a legacy per-certificate override that leaves the site empty inherits the target's one site, and a target covering every site or a site list has none to inherit. Per-target overrides of that shape are refused when linking; the Default (all targets) row and the group rows are not bound to one target, so they fail at deploy (and Dry Run) with this code instead.

A site in excluded_sites of an every site placement that does not exist is not this error: it is skipped with the warning IIS_EXCLUDED_SITE_NOT_FOUND (Dry Run lists it too) — unless it was renamed (below). The target's health check reports a missing site as a warning (the target stays healthy: every distribution may override the target's own site); only a renamed site makes it unhealthy.

IIS_SITE_RENAMED — the site was renamed in IIS​

A site the placement names (or an excluded site, when its new name is a site the placement would bind) is no longer on the server under that name, but the site a previous deploy recorded under it is — with a new name. A deploy records each site it touches: its IIS id, all of its HTTPS bindings (up to 20) and its root folder (the physical path of the site's root application). CertAutoPilot recognises a rename by the same id, every recorded binding still on that site, and either a recorded binding with a host header or the same root folder (compared without regard to case or a trailing \). IIS gives a new site the lowest free id, so a site that was deleted and replaced by another one — often with the same catch-all binding such as *:443: but its own folder — is not mistaken for a rename (that case is IIS_SITE_NOT_FOUND). A site that lost a recorded binding also reads as IIS_SITE_NOT_FOUND. The message names the new name, for example:

IIS_SITE_RENAMED: site 'Shop' appears to have been renamed to 'Shop (old)' in IIS (site id 4) - update the target

Nothing is imported or bound, and the other targets of the run are not rolled back. Deploy, Dry Run, the health check and the placement preview all report it. Update the target to the new name — the Update to “…” button beside the error opens the target with the new name filled in (an ordinary edit, so it goes through your approval policy) — or, if the name comes from a distribution's override, change the override. CertAutoPilot never edits the target by itself. The record lives with the deployments to the target: a site renamed before any certificate was deployed to it through CertAutoPilot — or after every certificate that was deployed there has been deleted — has nothing recorded and reads as IIS_SITE_NOT_FOUND.

IIS_NAME_MISMATCH — the certificate does not serve the binding​

Verify Binding Names is on (on the target, or forced by the distribution's override) and refused the binding: the certificate's names do not cover its host header, or — for a binding without a host header — share no name with the certificate currently on it. The message names the site, the binding and the reason. Nothing was imported or bound, and the error is not retried. In the multi-binding modes this code means every candidate was refused; a run where only some were refused is partial instead. It is also raised before any remote call when the certificate carries no DNS name.

Run Dry Run to see each refused binding (name-mismatch) and why, then fix the placement (site, port, host header, excluded_bindings) or deploy the right certificate. Turn the check off for this distribution only if the binding is meant to change. Remember that *.example.com does not cover example.com.

See also​

Warnings​

A run can succeed and still carry warnings, shown in the Warnings column of the target result:

CodeMeaning
IIS_TEMP_CLEANUP_FAILEDThe uploaded PFX/password temp files could not be removed from the host.
IIS_INSECURE_TRANSPORTtls_skip_verify is on: the WinRM HTTPS listener certificate was not verified. (Plain HTTP 5985 does not raise it — that case only writes a job-log warning when the auth type is Basic.)
IIS_LARGE_PFXThe PFX was large enough to risk WSMan quota limits.
IIS_PARTIAL_POOL_RECYCLESome application pools recycled, others failed.
IIS_ALL_POOL_RECYCLE_FAILEDEvery pool recycle failed (the certificate is still bound).
IIS_IPV6_BINDING_SKIPPEDAn IPv6 binding was skipped.
IIS_OLD_CERT_IN_USEThe previous certificate was left in place because another binding still uses it.
IIS_OLD_CERT_CLEANUP_FAILEDRemoving the previous certificate from the store failed.
IIS_CCS_BINDING_SKIPPEDA Central Certificate Store binding cannot be updated through the machine store and was skipped.
IIS_NAME_MISMATCH_SKIPPEDVerify Binding Names skipped one or more bindings this certificate does not serve; the others were updated and the target is partial (reason binding_name_mismatch, unless a missing or failed binding set its own reason first).
IIS_BINDING_NAMES_DROPPEDWith Verify Binding Names on, a binding without a host header was updated, but the certificate previously on it also served names the new one does not cover (listed in the job log).
IIS_EXCLUDED_SITE_NOT_FOUNDA site in excluded_sites of an every-site placement is not on this server; it was skipped and the run went on (the job log and Dry Run name it). An excluded site renamed to a site the run would bind stops the run with IIS_SITE_RENAMED instead.
IIS_RESULT_UNREADABLEA follow-up script (application-pool recycle, old-certificate cleanup) ran and exited cleanly, but its result could not be read — so whether the pools recycled or the old certificate was removed is unknown. The certificate itself is bound; re-run the deployment or check the host.

Video tutorial

Short, hands-on videos showing this feature working for real. English audio, English and Turkish subtitles. All video tutorials →

Deploy a Certificate to Microsoft IIS over WinRMYouTube ↗