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.
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 resources | virt-controller, after reading the NAD | network-resources-injector webhook |
| NAD lookup on VMI start | Yes | Skipped by design |
Malformed networkName | Fails the lookup; pod rendering blocked | Written through to the launcher pod |
| CVE-2026-13434 | Not vulnerable | Vulnerable |
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 impact | Moderate |
| CVSS v3.1 (Red Hat, preliminary) | 4.9, AV:N/AC:H/PR:L/UI:N/S:C/C:L/I:L/A:N |
| CWE | CWE-20, Improper Input Validation |
| Component | container-native-virtualization/virt-controller-rhel9 |
| Precondition | ExternalNetResourceInjection present on the KubeVirt CR |
| Who can trigger it | A user with kubevirt.io:edit in any namespace |
| Affected | OpenShift Virtualization 4.21 and later, gate on |
| Red Hat fix state | Fix deferred; no RHSA |
| Tracker | Bugzilla 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 whatDenywill break. Fix those first. - Server-side dry-run it.
oc apply --dry-run=serveron the policy catches CEL type and cost errors before a bad policy blocks every VMI create in the cluster.failurePolicy: Failon 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:editin their namespace, not to Kubernetesediteverywhere. 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 gate | Path B: keep it, fence it | |
|---|---|---|
| Closes CVE-2026-13434 | Yes, by restoring the NAD lookup | Yes, if the VAP is in Deny |
| Cost | SR-IOV/macvtap scheduling returns to virt-controller | One more admission policy you own forever |
| Failure mode | Jsonpatch returns, or HCO 1.19 reconciles the gate back on while the injector stays deployed | VAP left in Warn; allowlist grows without review |
| Survives upstream GA of the gate | No. The off switch goes away | Yes |
| Red Hat-stated mitigation | Yes | Partly. 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:
- Inventory four places: HyperConverged
spec.featureGates, every*.jsonpatchannotation on the HyperConverged, the KubeVirt CR’sdeveloperConfiguration.featureGates(one name per line), and, on HCOrelease-1.19and later,spec.deployment.deployNetworkResourcesInjectorfromhyperconvergeds.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. - Every non-default gate gets an owner, a reason, and a review date, committed next to the YAML.
- Jsonpatch annotations are exceptions, not configuration. HCO already marks them as tainted and recommends removing them before an upgrade.
- 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
- 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 recordspec.deployment.deployNetworkResourcesInjectorfrom the v1 HyperConverged. Omitted means on. - 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.
- On 4.22 the gate isn’t in the typed HCO API. If it is on, look for the
kubevirt.kubevirt.io/jsonpatchannotation. On the KubeVirt 1.9 HCO, a clean annotation and a gate that is still on means the injector reconcile put it there. Usehyperconvergeds.v1beta1.hco.kubevirt.iofor every command on 4.22, because of the known issue with the v1 API. - Drop the gate and validate the input. A
networkNameVAP on the VMI closes this path whether or not the gate is on, and it survives upstream GA. - Argo will not see an out-of-band annotation. Pair GitOps with an admission guard on the HyperConverged and a routed
UnsupportedHCOModificationalert. - Review gates for what they disable. A “reduce controller RBAC” gate can quietly remove an input check.
Related posts
- virt-handler CVEs: Namespace Edit Blast Radius
- Hardening OpenShift Virtualization: First Priorities
- OpenShift Network Policies: Tenant, Admin, Secondary
- OpenShift Virtualization Networking: Pod to Localnet
- Virtualization Autopilot vs GitOps on OpenShift
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
- CVE-2026-13434 (Red Hat)
- Bugzilla 2493576
- CVE-2026-13434 (cve.org)
- KubeVirt user guide: Network Resource Injection
- HCO cluster configuration: feature gates and jsonpatch annotations
- HCO release-1.19: where the injector reconcile enables the gate
- UnsupportedHCOModification runbook
- OpenShift Virtualization 4.22 release notes
- OpenShift Virtualization 4.22