Post

CVE-2026-13434: Audit HCO Feature Gates as Code

CVE-2026-13434 applies when ExternalNetResourceInjection is on. Check the KubeVirt CR, drop the gate, or fence networkName with a ValidatingAdmissionPolicy.

CVE-2026-13434: Audit HCO Feature Gates as Code

Personal site note: views expressed here are my own and do not necessarily represent Red Hat or any other organization. Red Hat lists this CVE as Fix deferred for OpenShift Virtualization 4 as of this writing. Check the CVE page before you tell a customer anything about a fixed image.

CVE-2026-13434 is a Moderate KubeVirt flaw that almost nobody is exposed to, and that is exactly why it is worth a post. It only matters when ExternalNetResourceInjection is enabled. Red Hat says that gate is off by default in every shipped OpenShift Virtualization release. On 4.21 and 4.22, if it is on, someone put it there. The real question is whether you can say who did it, when, and why.

Upstream HCO release-1.19 pins KubeVirt 1.9.1. Red Hat has not said what a shipped minor after 4.22 will do with the gate. That HCO branch already has an answer. On the hco.kubevirt.io/v1 HyperConverged, HCO appends ExternalNetResourceInjection when spec.deployment.deployNetworkResourcesInjector is true and virt-network-resources-injector is Ready. An omitted field means true. The property is v1-only. v1beta1 keeps an explicit value in the hco.kubevirt.io/v1-only-fields annotation and does not surface it on spec. OpenShift Virtualization 4.22 is the KubeVirt 1.8 line, HCO release-1.18. That branch has no injector deploy flag and no reconcile that turns this gate on. The KubeVirt CR is the object virt-controller actually reads, on either line.

The virt-handler CVEs in virt-handler CVEs: Namespace Edit Blast Radius were a patch-plus-RBAC week. This one is different, because there is no patch to chase yet. The control is configuration, so the fix is knowing your configuration. This post covers how to find the gate, how to remove it, and how to keep it out (or fence it in) with GitOps-owned YAML.

This is not an exploit write-up. You will not find a payload here.

What the gate does and why anyone turns it on

Some secondary networks need a node device resource, not just an IP: SR-IOV VFs, bridge-marker bridges, and macvtap. The NetworkAttachmentDefinition (NAD) carries a k8s.v1.cni.cncf.io/resourceName annotation, and something has to copy that resource request onto the virt-launcher pod so the scheduler places the VM on a node that has the device.

Historically, KubeVirt’s virt-controller did that itself. It read the NAD and injected the request. ExternalNetResourceInjection hands the job to the network-resources-injector mutating webhook. With the gate on, KubeVirt stops querying NADs and stops deploying the RBAC it used to read them. On paper that is a least-privilege improvement, because one fewer controller needs to read every NAD in the cluster.

That is the trap: the NAD lookup was also doing validation. Nobody had written down that it was.

 Gate off (default)Gate on
Who injects network device resourcesvirt-controller, after reading the NADnetwork-resources-injector webhook
NAD lookup on VMI startYesSkipped by design
Malformed networkNameFails the lookup; pod rendering blockedWritten through to the launcher pod
CVE-2026-13434Not vulnerableVulnerable

Upstream history (from the KubeVirt user guide): the gate was introduced in KubeVirt v1.8 as Beta and off. It was renamed from ShouldDisableNADResourceInjection before release. Red Hat says it first shipped in OpenShift Virtualization 4.21, and earlier minors are not affected. “Default” in the table is that shipped configuration. HCO release-1.19 moves a cluster into the right-hand column when its v1 injector flag is omitted or true and the injector deployment is Ready.

The trust-boundary failure

A VM owner writes spec.template.spec.networks[].multus.networkName. On the Multus default-network path, KubeVirt copies that string verbatim into the launcher pod’s v1.multus-cni.io/default-network annotation. According to Red Hat, the only admission check rejects an empty string. Nothing checks that the value is a name.

Multus on the node accepts more than a name in that annotation. It also accepts a structured network selection. With the NAD lookup gone, a tenant holding kubevirt.io:edit can put the structured form where a name belongs. Multus will then attach the launcher pod to a NAD in any namespace, with an IP and MAC the tenant chose. Red Hat’s write-up calls it what it is: cross-namespace network access and IP/MAC impersonation on segments that are normally kept away from tenant workloads.

That is a classic confused deputy. The tenant never touches the pod. virt-controller writes the annotation, and Multus trusts the annotation because a controller wrote it.

 Value
Red Hat impactModerate
CVSS v3.1 (Red Hat, preliminary)4.9, AV:N/AC:H/PR:L/UI:N/S:C/C:L/I:L/A:N
CWECWE-20, Improper Input Validation
Componentcontainer-native-virtualization/virt-controller-rhel9
PreconditionExternalNetResourceInjection present on the KubeVirt CR
Who can trigger itA user with kubevirt.io:edit in any namespace
AffectedOpenShift Virtualization 4.21 and later, gate on
Red Hat fix stateFix deferred; no RHSA
TrackerBugzilla 2493576

The 4.9 score is honest. The S:C (scope changed) is the part to say out loud in a review. The thing a tenant reaches is a network it was never given. What it can actually do there depends on what listens on that segment and whether anything enforces policy on it.

Are you exposed? Three checks

1. Is the gate on?

On 4.22, use the fully versioned resource name. The 4.22 release notes have a known issue: plain oc get hco now resolves to the new v1 API, which is not ready for production. The HyperConverged reads below use hyperconvergeds.v1beta1.hco.kubevirt.io on purpose, except the injector flag, which exists only on v1.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
HCO=hyperconvergeds.v1beta1.hco.kubevirt.io

# What HCO's typed API says
oc get $HCO kubevirt-hyperconverged -n openshift-cnv \
  -o jsonpath='{.spec.featureGates}{"\n"}'

# What someone forced into the KubeVirt CR, bypassing the typed API
oc get $HCO kubevirt-hyperconverged -n openshift-cnv \
  -o jsonpath='{.metadata.annotations.kubevirt\.kubevirt\.io/jsonpatch}{"\n"}'

# What KubeVirt actually runs with -- the ground truth.
# One name per line. jsonpath prints a string list space-separated, so
# `tr ','` plus `grep -x` misses the gate whenever any other gate is set.
# HCO always sets other gates.
oc get kubevirt kubevirt-kubevirt-hyperconverged -n openshift-cnv \
  -o jsonpath='{range .spec.configuration.developerConfiguration.featureGates[*]}{@}{"\n"}{end}' \
  | grep -ix externalnetresourceinjection

# HCO release-1.19 only, and only on the v1 API. The field is not in
# v1beta1; conversion stashes an explicit value in
# hco.kubevirt.io/v1-only-fields. 4.22 prints blank because the field
# does not exist yet. On release-1.19, blank or true means HCO enables
# the gate once virt-network-resources-injector is Ready. false keeps it off.
oc get hyperconvergeds.v1.hco.kubevirt.io kubevirt-hyperconverged -n openshift-cnv \
  -o jsonpath='{.spec.deployment.deployNetworkResourcesInjector}{"\n"}'

# Did HCO flag an unsupported modification?
oc get $HCO kubevirt-hyperconverged -n openshift-cnv \
  -o jsonpath='{.status.conditions[?(@.type=="TaintedConfiguration")]}{"\n"}'

The detail that matters: in the OpenShift Virtualization 4.22 HyperConverged v1beta1 API, spec.featureGates is a fixed map of named booleans, such as declarativeHotplugVolumes, persistentReservation, and decentralizedLiveMigration. ExternalNetResourceInjection is not one of them. I checked the upstream HCO release branches that pin KubeVirt 1.7 and 1.8, and I did not find the gate in the OpenShift Virtualization 4.21 or 4.22 docs either. On those releases, if your KubeVirt CR has it, the path is the kubevirt.kubevirt.io/jsonpatch annotation, which appends to /spec/configuration/developerConfiguration/featureGates. Red Hat’s own 4.22 virtualized-control-planes procedure uses that same mechanism for RebootPolicy, so expect to see jsonpatch annotations in the field.

Do not edit the KubeVirt CR directly and call it done. HCO reconciles its operands back to its opinionated state. On 4.21 and 4.22 the jsonpatch annotation is what survives, which is why you audit the annotation. On HCO release-1.19 the reconcile itself is the enable path: once the injector deployment is Ready, HCO writes the gate into featureGates with no jsonpatch involved. A clean annotation and a gate that is still on is the signature of that operator.

2. Who can trigger it?

Anyone who can create VMs. KubeVirt aggregates its roles into the default edit and admin roles. That is the same convenience that made the virt-handler CVEs a namespace-edit problem.

1
2
oc adm policy who-can create virtualmachineinstances.kubevirt.io -n <vm-namespace>
oc adm policy who-can create virtualmachines.kubevirt.io -n <vm-namespace>

3. Is anything already using a name that is not a name?

This is the hunt query. It flags any Multus networkName that is not a plain NAD name or <namespace>/<name>, and any namespace/ prefix that does not match the VMI’s own namespace:

1
2
3
4
5
6
7
8
oc get vmi -A -o json | jq -r '
  .items[] | .metadata.namespace as $ns | .metadata.name as $vmi
  | .spec.networks[]? | select(.multus) | .multus as $m
  | select(
      ($m.networkName | test("^([a-z0-9]([-a-z0-9]*[a-z0-9])?/)?[a-z0-9]([-a-z0-9.]*[a-z0-9])?$") | not)
      or (($m.networkName | contains("/")) and ($m.networkName | split("/")[0]) != $ns)
    )
  | "\($ns)\t\($vmi)\tdefault=\($m.default // false)\t\($m.networkName)"'

Run the same filter over oc get vm -A -o json against .spec.template.spec.networks[]? to catch stopped VMs. Then check what the nodes actually did. The k8s.v1.cni.cncf.io/network-status annotation on a launcher pod records the networks Multus really attached:

1
2
3
4
5
oc get pods -A -l kubevirt.io=virt-launcher -o json | jq -r '
  .items[] | .metadata.namespace as $ns | .metadata.name as $pod
  | (.metadata.annotations["k8s.v1.cni.cncf.io/network-status"] // "[]" | fromjson)[]
  | select(.name | contains("/")) | select((.name | split("/")[0]) != $ns)
  | "\($ns)\t\($pod)\t\(.name)\t\(.ips // [] | join(","))\t\(.mac // "")"'

A cross-namespace hit is not automatically an incident. Shared NADs in a platform namespace are a normal design. Every hit should map to a NAD you deliberately shared, though. If one doesn’t, treat the result as a finding, not as a curiosity.

Path A: drop the gate

This is Red Hat’s first mitigation, and for most clusters it is the whole answer. Removing the gate restores the NAD lookup, and the lookup rejects malformed names.

If the gate came in through a jsonpatch annotation, edit the patch array rather than deleting the annotation, unless you’ve confirmed that nothing else lives in it:

1
2
3
4
5
6
oc get $HCO kubevirt-hyperconverged -n openshift-cnv \
  -o jsonpath='{.metadata.annotations.kubevirt\.kubevirt\.io/jsonpatch}' | jq .
# Remove only the ExternalNetResourceInjection op, re-apply the remainder.
# If it was the only op:
oc annotate $HCO kubevirt-hyperconverged -n openshift-cnv \
  'kubevirt.kubevirt.io/jsonpatch-'

Then re-run check 1 against the KubeVirt CR, not the HyperConverged CR. The KubeVirt CR is what virt-controller reads.

That removal is the 4.21 and 4.22 mitigation. It is also what Red Hat’s CVE text is reaching for when it says “remove it from spec.featureGates.” On 4.22 the typed map has no such key, so the annotation is the switch.

HCO release-1.19 will put the gate back on the next reconcile if spec.deployment.deployNetworkResourcesInjector stays at its default. The handler appends ExternalNetResourceInjection when that flag is true and the injector deployment is Ready, and it writes every other Beta gate into disabledFeatureGates. The flag is on the v1 HyperConverged only. To drop the gate on that operator, set it to false there and let HCO reconcile. Check 1 should then come back empty, and the gate should show up under disabledFeatureGates. A v1beta1 manifest cannot carry the field in spec. Leaving it unset leaves the v1 default, which is true.

What you give up: if SR-IOV, bridge-marker, or macvtap NADs depended on network-resources-injector, scheduling falls back to virt-controller’s NAD query. That is the legacy behavior, and it worked before 4.21. Prove it on one SR-IOV VM before you assume. On release-1.19, setting the deploy flag false also stops HCO from running virt-network-resources-injector.

What Path A is not: a patch. There is no fixed image to move to. Red Hat lists OpenShift Virtualization 4 as Fix deferred, and Bugzilla 2493576 is still NEW. Upstream KubeVirt main still only rejects an empty networkName at admission. The user guide has the gate enabled by default in KubeVirt v1.9 and GA in v1.10, with the legacy NAD query removed entirely. HCO release-1.19 does not leave every Beta on. It opts out, then opts this gate back in for the injector. Red Hat has not published what a shipped minor will do with that reconcile. “Keep the gate off” still expires when the gate goes GA, unless input validation lands first. Plan for the day the off switch goes away.

Path B: keep the gate, fence the input

Sometimes the gate exists for a reason. Maybe network-resources-injector is how the SR-IOV team schedules VFs, and they will not go back. Red Hat’s fallback is to restrict kubevirt.io:edit to trusted users and enforce policy on sensitive segments. That is necessary, but it is not enough by itself, because “trusted users” is just a list of everyone who can create a VM. Add the validation that KubeVirt is missing.

A ValidatingAdmissionPolicy on the VMI

Fence the VirtualMachineInstance, not just the VirtualMachine. Every VM, VirtualMachinePool, and replica set ends in a VMI create, so the VMI is the choke point. Add the VM as well, so owners get the rejection at oc apply time rather than at start time.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingAdmissionPolicy
metadata:
  name: kubevirt-multus-networkname
spec:
  failurePolicy: Fail
  matchConstraints:
    resourceRules:
      - apiGroups: ["kubevirt.io"]
        apiVersions: ["v1"]
        operations: ["CREATE", "UPDATE"]
        resources: ["virtualmachineinstances", "virtualmachines"]
  variables:
    - name: nets
      expression: >-
        object.kind == 'VirtualMachineInstance'
          ? (has(object.spec.networks) ? object.spec.networks : [])
          : (has(object.spec.template) && has(object.spec.template.spec)
             && has(object.spec.template.spec.networks)
             ? object.spec.template.spec.networks : [])
    - name: names
      expression: >-
        variables.nets.filter(n, has(n.multus)).map(n, n.multus.networkName)
    # Namespaces that publish shared NADs on purpose. Keep this list short.
    - name: sharedNadNamespaces
      expression: "['virt-shared-networks']"
  validations:
    - expression: >-
        variables.names.all(nm,
          nm.matches('^([a-z0-9]([-a-z0-9]*[a-z0-9])?/)?[a-z0-9]([-a-z0-9.]*[a-z0-9])?$'))
      message: "multus.networkName must be a NAD name or <namespace>/<name>."
    - expression: >-
        variables.names.all(nm, !nm.contains('/')
          || nm.split('/')[0] == request.namespace
          || nm.split('/')[0] in variables.sharedNadNamespaces)
      message: "multus.networkName may only reference this namespace or an approved shared-NAD namespace."
---
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingAdmissionPolicyBinding
metadata:
  name: kubevirt-multus-networkname
spec:
  policyName: kubevirt-multus-networkname
  validationActions: ["Warn", "Audit"]   # flip to ["Deny", "Audit"] after a clean week
  matchResources:
    namespaceSelector:
      matchExpressions:
        - key: kubernetes.io/metadata.name
          operator: NotIn
          values: ["openshift-cnv"]

Notes from the lab, not the brochure:

  • Start in Warn/Audit. Your hunt query from check 3 tells you what Deny will break. Fix those first.
  • Server-side dry-run it. oc apply --dry-run=server on the policy catches CEL type and cost errors before a bad policy blocks every VMI create in the cluster. failurePolicy: Fail on VMIs is a sharp tool.
  • This rule holds whether or not the gate is on. It closes the CVE-2026-13434 input path on any cluster. It also closes the cross-namespace NAD reference that the legacy path would allow anyway. That makes it the control that survives the gate going GA.

RBAC and segment policy

  • Bind tenant VM operators to kubevirt.io:edit in their namespace, not to Kubernetes edit everywhere. That is the same advice as the virt-handler post, and for the same reason.
  • Red Hat’s mitigation says to enforce NetworkPolicy on sensitive segments. On a Multus attachment, the enforcement object is MultiNetworkPolicy, and it is opt-in on the cluster network operator. See OpenShift Network Policies: Tenant, Admin, Secondary. If the target segment is a localnet or VLAN with no policy, then IP/MAC impersonation is an L2 problem. KubeVirt can’t solve it for you. Turn on MAC spoof checking on the bridge NADs where the CNI supports it, as in OpenShift Virtualization Networking: Pod to Localnet.
  • Do not assume Multus namespace isolation saves you. Red Hat’s analysis says the launcher pod was attached across namespaces. Test your cluster’s behavior in a lab before you write “isolated” in a design doc.

Path A vs Path B, honestly

 Path A: drop the gatePath B: keep it, fence it
Closes CVE-2026-13434Yes, by restoring the NAD lookupYes, if the VAP is in Deny
CostSR-IOV/macvtap scheduling returns to virt-controllerOne more admission policy you own forever
Failure modeJsonpatch returns, or HCO 1.19 reconciles the gate back on while the injector stays deployedVAP left in Warn; allowlist grows without review
Survives upstream GA of the gateNo. The off switch goes awayYes
Red Hat-stated mitigationYesPartly. RBAC and policy are Red Hat’s; the VAP is mine

My recommendation: do both. Take Path A today on any cluster that does not need the gate. Deploy the Path B VAP everywhere, in Warn now and Deny after a clean week. It is cheap, and it is the only control here that does not depend on a Beta switch staying where you left it.

GitOps shape: the HyperConverged is a platform object

The real lesson is that a security-relevant switch sat in an annotation string, with no owner, no ticket, and no review. Fix that.

Argo owns an explicit HyperConverged

Declare every gate you care about with an explicit value, including the ones you want off. An explicit false is a decision. An omitted field is a default you did not read.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: cnv-hyperconverged
  namespace: openshift-gitops
spec:
  project: platform
  source:
    repoURL: https://git.example.com/platform/cluster-config.git
    targetRevision: main
    path: clusters/prod-east/openshift-cnv/hyperconverged
  destination:
    server: https://kubernetes.default.svc
    namespace: openshift-cnv
  syncPolicy:
    automated:
      selfHeal: true
      prune: false          # never let Argo delete the HyperConverged
    syncOptions:
      - ServerSideApply=true
---
# clusters/prod-east/openshift-cnv/hyperconverged/hyperconverged.yaml
apiVersion: hco.kubevirt.io/v1beta1
kind: HyperConverged
metadata:
  name: kubevirt-hyperconverged
  namespace: openshift-cnv
  annotations:
    # Intentionally no kubevirt.kubevirt.io/jsonpatch.
    # Adding one requires a security-reviewed PR. See SECURITY.md.
    platform.example.com/featuregate-review: "2026-10-22"
spec:
  featureGates:
    declarativeHotplugVolumes: true        # GA feature in 4.22; owner: storage
    decentralizedLiveMigration: false      # Tech Preview; owner: virt-platform; review 2027-01
    persistentReservation: false           # privileged helper; WSFC only
    downwardMetrics: false
    alignCPUs: false
  # ... the rest of your HyperConverged spec

There is one honest gap in that YAML. Argo diffs only the fields you declare. With server-side apply, it will not remove an annotation that another field manager added. Someone running oc annotate ... kubevirt.kubevirt.io/jsonpatch=... does not show up as drift in Argo. Something else has to watch for that.

If you also run the virt platform autopilot, it has its own opinions about spec.featureGates. Settle ownership first, as in Virtualization Autopilot vs GitOps on OpenShift.

Deny the out-of-band annotation

Here is a second ValidatingAdmissionPolicy, this one on the HyperConverged itself. Only the GitOps controller may set a KubeVirt jsonpatch, and nobody may use one to turn on this gate:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingAdmissionPolicy
metadata:
  name: hco-jsonpatch-guard
spec:
  failurePolicy: Fail
  matchConstraints:
    resourceRules:
      - apiGroups: ["hco.kubevirt.io"]
        apiVersions: ["*"]
        operations: ["CREATE", "UPDATE"]
        resources: ["hyperconvergeds"]
  variables:
    - name: patch
      expression: >-
        has(object.metadata.annotations)
          && 'kubevirt.kubevirt.io/jsonpatch' in object.metadata.annotations
          ? object.metadata.annotations['kubevirt.kubevirt.io/jsonpatch'] : ''
    - name: gitops
      expression: >-
        request.userInfo.username ==
        'system:serviceaccount:openshift-gitops:openshift-gitops-argocd-application-controller'
  validations:
    - expression: "variables.patch == '' || variables.gitops"
      message: "KubeVirt jsonpatch on the HyperConverged is GitOps-only. Open a PR."
    - expression: "!variables.patch.lowerAscii().contains('externalnetresourceinjection')"
      message: "ExternalNetResourceInjection is blocked (CVE-2026-13434). See SECURITY.md."
---
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingAdmissionPolicyBinding
metadata:
  name: hco-jsonpatch-guard
spec:
  policyName: hco-jsonpatch-guard
  validationActions: ["Deny", "Audit"]

Match the service account name to your Argo instance. Keep a break-glass path (a named cluster-admin group, with the binding itself managed in Git) so this does not become the thing that blocks an emergency HCO change at 2 a.m.

This policy stops a jsonpatch from naming the gate. It does not stop HCO release-1.19 from writing featureGates on the KubeVirt CR while the injector is deployed. That write never touches the annotation. Keep check 1 in the inventory. When the field exists, set spec.deployment.deployNetworkResourcesInjector: false on the v1 HyperConverged. v1beta1 has no such property. An omitted value is the default, and the default is on.

Route the alert you already have

HCO counts jsonpatch annotations in kubevirt_hco_unsafe_modifications and fires UnsupportedHCOModification when the count is nonzero. Its severity is info, so most Alertmanager configs drop it on the floor. Route it to the platform team’s channel. On a cluster that should have zero jsonpatches, that alert is your drift detector for free.

Beta and Tech Preview gates are a security surface

Feature-gate reviews tend to ask whether the feature is supported. They should also ask what the gate turns off. ExternalNetResourceInjection didn’t add a dangerous capability. It removed a lookup, and the lookup turned out to be a validation step nobody had written down. You only find that kind of change by reading what a gate disables, not just what it enables.

The July Hardening OpenShift Virtualization: First Priorities baseline said “closed feature gates.” Here is that idea as a control:

  1. Inventory four places: HyperConverged spec.featureGates, every *.jsonpatch annotation on the HyperConverged, the KubeVirt CR’s developerConfiguration.featureGates (one name per line), and, on HCO release-1.19 and later, spec.deployment.deployNetworkResourcesInjector from hyperconvergeds.v1.hco.kubevirt.io. The KubeVirt CR is what actually runs. An omitted injector flag on that operator means deployed. v1beta1 does not have the field.
  2. Every non-default gate gets an owner, a reason, and a review date, committed next to the YAML.
  3. Jsonpatch annotations are exceptions, not configuration. HCO already marks them as tainted and recommends removing them before an upgrade.
  4. Re-read the upstream graduation path for every Beta gate you enable. “Beta, off” can become “Beta, on” and then GA in two upstream releases.

The solutions architect takeaway

  1. Most shipped clusters are not exposed. Red Hat says the gate is off by default in every shipped OpenShift Virtualization release. Prove it against the KubeVirt CR, one feature gate per line, and write the answer down. On HCO release-1.19, also record spec.deployment.deployNetworkResourcesInjector from the v1 HyperConverged. Omitted means on.
  2. There is no patch to chase. Red Hat says Fix deferred, with no RHSA. The control is configuration, so do not promise a z-stream.
  3. On 4.22 the gate isn’t in the typed HCO API. If it is on, look for the kubevirt.kubevirt.io/jsonpatch annotation. On the KubeVirt 1.9 HCO, a clean annotation and a gate that is still on means the injector reconcile put it there. Use hyperconvergeds.v1beta1.hco.kubevirt.io for every command on 4.22, because of the known issue with the v1 API.
  4. Drop the gate and validate the input. A networkName VAP on the VMI closes this path whether or not the gate is on, and it survives upstream GA.
  5. Argo will not see an out-of-band annotation. Pair GitOps with an admission guard on the HyperConverged and a routed UnsupportedHCOModification alert.
  6. Review gates for what they disable. A “reduce controller RBAC” gate can quietly remove an input check.

Want help turning a feature-gate inventory into GitOps-owned policy? Reach out to your Red Hat account team, or run the three checks above on a non-prod OpenShift Virtualization cluster first.

Further reading

This post is licensed under CC BY 4.0 by the author.