Practical Deep Dive into Kubernetes Security
My review of Practical Deep Dive into Kubernetes Security, an attack-first workshop on HexArcana, and the best Kubernetes training I’ve seen.
TL;DR
“Practical Deep Dive into Kubernetes Security” is a six-week, hands-on workshop run by Jarosław Jedynak and Michał Leszczyński from ITSEC.RE, and delivered through Gynvael Coldwind’s HexArcana.
Each week pairs a live session with some capture the flag (CTF) challenges on a real cluster. The material is genuinely up to date and it goes surprisingly deep, all the way down to Linux internals. It’s built attack-first and it’s an advanced course.
It’s, by far, the best Kubernetes security training I’ve seen on the market. For €1,500, it sidesteps the two things that had blocked me for years: cost and length.
Workshops and training are things I’ve always appreciated. For sure, the amount of knowledge is close to infinite on the Internet; Google, and now the Large Language Models (LLMs), are powerful tools to feed our curiosity, and we can learn for free.
Nevertheless, to me, workshops and training, and to some extent, academic degrees, represent a source of knowledge, a place to go where some things about a topic are bundled.
Context
Kubernetes was one of those topics, and for years I looked for the right place to learn it.
Initial Blockers
With my love for the convenience of training courses, looking for one about Kubernetes is something I’ve been doing for a while. Despite several research attempts, two things always blocked me:
- Those training courses are usually expensive
- They are often short (i.e. a couple of days, sometimes three)
Many examples come to mind. I’m thinking for instance about the conference workshops, such as the ones delivered at Black Hat (e.g. 1, 2, 3) or “Container Security Workshop” presented by Iain Smart, Rory and Marion McCune. Closer to me, in France, companies such as Bureau Veritas or Synacktiv are also delivering Kubernetes workshops (e.g. 1, 2).
An alternative I also kept in mind for a while to improve my skills was considering the Certified Kubernetes Security Specialist (CKS) certification,1 but the requirement for me was always a blocker. Indeed, the Linux Foundation mandates that an applicant must hold the Certified Kubernetes Administrator (CKA) certification to be eligible to register and sit for the CKS exam.
The Opportunity
Finding a training not too pricey and in a long format seemed to become an impossible equation to resolve. Until this day, when the stars appeared to be aligned.
Going on LinkedIn isn’t something I do regularly, but once in a while, I give it a try. I saw a post from Gynvael Coldwind on his LinkedIn profile mentioning he was partnering with some friends to present a Kubernetes workshop. A short time after, I saw him solving a Kubernetes CTF challenge.
I waited a bit and then saw that the subscriptions for the workshop “Practical Deep Dive into Kubernetes Security” were open. Its description, shown below, was also quite interesting. A total of six modules would be delivered from June 9th to July 14th.2 The price was €1,500. So, I decided to give it a try!
Kubernetes now runs critical production workloads, yet many clusters rely on unsafe defaults, weak RBAC, exposed APIs, and poorly protected secrets. Generic tutorials rarely show how real attackers move inside Kubernetes – or how specific misconfigurations turn into full cluster compromise.
In this live, practical workshop, you work inside a dedicated cluster, reproduce real attack paths, and practice concrete hardening steps across build, deploy, and runtime phases. The workshop runs once this spring, starting June 9th at 7 PM CEST for six Tuesday sessions.
Disclosure
The following lines are based on my experience. My employer didn’t pay for this training and I don’t personally know any of the people who delivered it. I decided to write this blog post to help anyone who would consider this workshop.
About the Workshop
Before getting into the content itself, it’s worth saying a word about the people who delivered this workshop and the format it took. In my experience, both mattered just as much as the syllabus.
Trainers
His name was briefly mentioned in the lines above, but the first person to introduce is Gynvael Coldwind. He has been in the InfoSec industry for a while. More personally, Gynvael has been an inspiration to me when I was a student, a model, alongside people like Michał “lcamtuf” Zalewski or Mikko Hyppönen. Their stories and what they have done for the InfoSec community are remarkable. So when I saw he was organizing a Kubernetes workshop, I had a deeper look.
To be precise about the roles, Gynvael wasn’t one of the trainers. He is the person behind the hackArcana platform and looked after the organizational side of the event. The technical layer, such as the slides, the labs, and the teaching, was led entirely by Jarosław Jedynak and Michał Leszczyński. Both have remarkable CVs and own a company called ITSEC.RE, specialized in security audits with expertise in cloud environments and Kubernetes deployments.3
Each of them had their role. Jarosław Jedynak was presenting the slides and Michał Leszczyński was responsible for the lab. After a private chat with Michał, he informed me they had already been delivering Kubernetes security trainings for five years.
During the six weeks, both of them were excellent.
Format
As previously mentioned, something that stopped me going through a Kubernetes workshop was the length. Even if I appreciate that our time is limited, two or three days to cover something as big as Kubernetes and its attack surface isn’t sufficient in my opinion. Jarosław and Michał didn’t make an exception; on their website, they mention that they deliver a two-day course focused on Kubernetes security.
However, for “Practical Deep Dive into Kubernetes Security”, Jarosław and Michał partnered with Gynvael to deliver the training via his company, HexArcana. As a result, the format changed and used different tools:
- The sessions were YouTube lives. Questions could be asked directly.
- A Discord server was available, for any queries or remarks after the YouTube lives.
- The CTF challenges were hosted on a platform called hackArcana, which belongs to HexArcana.4
Content
With the people and the format covered, the following describes what the six weeks actually held, with one module per week, each mapping to a phase in a cluster’s life. I’m also giving a few notes about the lab containing the exercises.
Modules
The course was divided into six modules, one per week:
- Module 1 – Kubernetes Architecture
- Module 2 – Build Phase Security
- Module 3 – Deploy Phase Security
- Module 4 – Runtime Phase Security
- Module 5 – Administration, Access Control, and Networking
- Module 6 – Low-Level Container Security
The first three modules followed an image from source to cluster.
- Module 1 set the foundations, walking through the core components and how they actually communicate with each other. It also walked through the raw APIs sitting behind
kubectl. - Module 2 turned to the build phase: how container images are really structured, how to scan them for vulnerabilities, why minimal and distroless base images matter, and where a CI/CD pipeline can be poisoned.
- Module 3 then covered everything between building and running an image: signing and verifying it with cosign, hardening pods through
securityContextand Pod Security Standards, managing secrets, and showing just how much damage a single “Evil pod” can do.
The last three shifted from deploying to defending a live cluster.
- Module 4 moved into runtime, focusing on how an attacker with a foothold abuses service-account tokens, performs reconnaissance from inside a pod, and how audit logging can catch them.
- Module 5 unpacked the full access-control pipeline: authentication, RBAC, and admission control, alongside cluster networking and network policies. The real dangers of exposing components to the Internet were also covered.
- Module 6 went all the way down to the Linux primitives that make containers possible. This includes credentials, capabilities, seccomp, cgroups, and namespaces.
Lab Environment
The lab is where this workshop earned its “practical” label. Rather than a shared playground, each student got their own isolated environment, managed through a custom dashboard the trainers call “InfraUI”, shown below. The latter appeared to be built by ITSEC.RE. From there, you could provision your personal lab virtual machine (VM) with a single Initialize button. It was a Linux jump-box that became your home base for the exercises.
The lab was reachable through a zero-configuration web VNC client running entirely in the browser with nothing to install. If you decided to connect over a personal WireGuard VPN, you could also use a native VNC client, such as RealVNC Viewer over the same VPN, or simply your own local tools: ssh, curl, or PuTTY on Windows.
Looking at the hackArcana platform, it wasn’t surprising to see that the exercises followed a CTF model. As in a real CTF, they were weighted by difficulty, ranging from 5 points for the gentler warm-ups up to 150–200 for the ones that really made you dig.
Each challenge was launched from “InfraUI” with a Launch Task action. Under the hood, it spun up the machines that particular exercise needed (e.g. a k8s-task1 target). Starting a new task tore down the previous one, while your main lab VM was preserved.
There were a lot of thoughtful touches around the edges. A few could be mentioned, such as per-user rate limits on VM creation, a Destroy All button to reset everything quickly, automatic garbage collection of idle machines, a support identifier for when you needed help, and a detailed handbook covering setup end to end. None of it was glamorous, but together it made a difference.
Workshop Strengths
I want to highlight a few aspects that, in my opinion, made this workshop stand out: the way the modules were composed, how well the material was maintained, and the quality of the lab environment.
Module Composition
Something I found interesting when looking at those modules was how the workshop was framed. An introduction of the Kubernetes main components seems necessary, but then, all of the key phases you will encounter in companies, which consist of building, deploying, inspecting if everything goes well at runtime and administering the infrastructure, are covered. The last module, which was the closest to what I’m seeing, was more related to offensive security.
Still, for each module, a clear attacker’s view and defender’s view were presented. By the end of the workshop, I believe you have seen the same cluster from the perspective of a developer, an attacker with a foothold, and an administrator trying to lock it down.
To give additional context, the modules were covering the following areas:
- Module 1 – Kubernetes Architecture:
- Kubernetes components and how they interact
- Threat modeling the cluster: what attackers target and why
- Workshop environment walkthrough and lab access
- Lab: exploring the cluster from an attacker’s perspective
- Module 2 – Build Phase Security:
- Container image pitfalls and common misconfigurations
- Source code and dependency scanning in CI/CD pipelines
- Supply chain risks: what happens before the image reaches the cluster
- Lab: identifying and fixing vulnerable image builds
- Module 3 – Deploy Phase Security:
- Image signing and verification
- Namespaces, pod security standards, and admission policies
- Secrets management: what goes wrong and how to fix it
- Lab: hardening deployment manifests and catching misconfigurations before they reach production
- Module 4 – Runtime Phase Security:
- Service account tokens and their abuse
- Cloud environment pitfalls and metadata API attacks
- Privilege escalation and container breakout scenarios
- Lab: reproducing real runtime attack paths and applying mitigations
- Module 5 – Administration, Access Control, and Networking:
- Authentication mechanisms and common weaknesses
- RBAC deep dive: misconfigurations, auditing, and least privilege
- Admission controllers and policy enforcement
- CNI configuration, network policies, firewalls, and network-level attacks
- Service meshes and their role in cluster security
- Lab: attacking and hardening cluster access and network segmentation
- Module 6 – Low-Level Container Security:
- Linux namespaces, cgroups, and capabilities in depth
- Seccomp profiles: building and applying them
- Kernel exploits and container escape techniques
- Wrap-up, Q&A, and next steps in your Kubernetes security journey
- Lab: hands-on container isolation assessment and hardening
Well-Maintained Material
When it comes to cloud, and more specifically about Kubernetes, something which might be concerning to me is learning outdated content. Things are moving fast, probably too much, but still, being up-to-date with some of the latest core components seems to me essential for a trustworthy training. Indeed, I was afraid that some Kubernetes security content, which usually ages badly, would be presented in the slides.
Mentioning some history about Docker, deprecated Kubernetes APIs,5 or even old vulnerabilities, such as a server-side request forgery (SSRF) affecting the Kubelet and kube-proxy components (CVE-2020-8558),6 doesn’t harm. It might even be good to contextualize. But I’d have been frustrated to be stuck in the past for several hours.
Jarosław didn’t disappoint. I was happily surprised by how recent the content he covered was. As an example, he presented the Pod Security Standards very well via namespace labels, rather than the long-dead Pod Security Policies.7 He also mentioned projected volumes over legacy service-account tokens.8
The coverage of modern tooling was also excellent. To name a few which were reviewed, cosign,9 Kyverno,10 Syft,11 HashiCorp Vault,12 and one I like to use during my engagements, Trivy.13
The Lab
Another aspect which convinced me to apply for this workshop was the CTF approach. Practical hands-on experience is probably one of the best ways to assimilate concepts, especially some of the ones which can be found in the cloud.
For sure, CTF platforms specialized in cloud already exist. I’m thinking about BustaKube, Kubernetes Goat,14 iximiuz Labs,15 and more recently, the CTF Challenges from Wiz.16 But the fact that this training was combining the two was a huge plus to me.
Up-to-date content in the slides was good, but even the challenges were also using some recent vulnerabilities. Without disclosing too much, I’m thinking about two challenges:
- One was using a recent and interesting local privilege escalation, CVE-2025-32463.17 More specifically, the flaw allows a local user to escalate privileges to
rootunder specific misconfigurations or with crafted inputs. This GitHub repository gives additional details. - The last challenge required students to exploit the Copy Fail vulnerability, CVE-2026-31431.18 It was like an Offensive Security Certified Professional (OSCP) challenge, a tough one, but an absolute pleasure.
The lab was hosted on the platform hackArcana. Unsurprisingly, after a few challenges, it made a real difference to me. The diversity of the exercises, the stability of the infrastructure, and the amazing support of Michał during the workshop gave me a pleasant experience.
To put the concepts explained in the slides into practice was an excellent way to ensure they were understood deeply. The depth of the challenges and their number, 46, convinced me that it was an excellent workshop.
Workshop Limitations
Even though this workshop was overall a positive experience, I noticed a few things which might be improved. Those are mostly minor points.
A Very Theoretical First Module
The first negative aspect I noted about the training was probably the pace and the theory from the first day. This first session was highly theoretical. Jarosław was showing the core components of Kubernetes (i.e. Nodes, Pods, etc.) and how they interact with each other.
I don’t mind the theory but I believe it might discourage a few participants. Nevertheless, the trainer was honest with the audience. All the concepts were theoretical but necessary to go further. I agree with that statement.
To improve it, I think I’d have enjoyed maybe a few more diagrams about threat modeling to end the first module. As far as I know, evaluating the attack surface of a Kubernetes cluster is a tricky task (e.g. A Deep Dive Into Kubernetes Threat Modeling). Even if it stays purely theoretical, I’d have been very interested to hear Jarosław’s opinion about what he sees the most in terms of misconfigurations, or what false assumptions he encounters with his clients.
Lack of Direct Access to the Challenges
When the first module began, the first challenges were available on hackArcana. As a result, I could listen to the course and have a go at an exercise.
Starting at the third session, the trainers removed access to the challenges during the live. I think the goal was to ensure people would focus on the slides and not the challenges. I can understand the logic behind it, but this mixture of theoretical and practical was the best combination for me.
Maybe an alternative could be to leave the easiest challenges available and unblock the most difficult exercises, which required more digging and thinking, after the live.
A Few Technical Issues with the Lab
I can’t imagine how difficult it must have been for Michał to get this kind of infrastructure running. To have all the exercises ready and deployed for all students must have been, for sure, a deep commitment.
Overall, I didn’t face lots of technical issues. Everything was smooth; the machines started quickly. I faced a few problems, mostly related to some challenges which were sometimes unresponsive. I wasn’t sure if I was missing something or if the lab was having issues. For a CTF challenge, it might be frustrating; is there something I’m not seeing? Did I miss something in the course?
Once, after I lost one hour trying to solve an exercise, I had to message Michał on Discord. I told him that an instance was unresponsive. More precisely, the challenge was an introduction to Consul, a service networking solution.
Nevertheless, any technical issue I had, Michał was able to solve within the hour.
Sometimes Pressed for Time
One small thing struck me across the weeks: the live sessions ran to a fairly strict three hours. There were moments when I felt Jarosław was pressed for time, hurrying through the last few slides to fit everything in.
It’s a minor point, and a session has to end somewhere. However, because the training wasn’t in a two-day format, I don’t think it needed to land on exactly three hours. A little more room, even another 30 minutes, would have let the denser material breathe, with no real downside. Live sessions might introduce some unpredictable moments, and that might need to be considered. For instance, I remember the moment when the trainer’s cat appeared on screen. This made me laugh. Maybe an improvised fuzzing session?
Jarosław is excellent at teaching, and I don’t think people, including myself, would mind staying a bit longer to learn more.
Not a Self-Study Deck
I hesitate to call this a real limitation, but I think it’s worth flagging for anyone judging a workshop by its material alone.
Each week, Jarosław would explain a mechanism, demonstrate it live, and then hand the room over to the challenges. It works, but it means the slides are built to support a live session, not to stand on their own. I think that just reviewing the slides would make this workshop much less interesting.
I believe Jarosław and Michał are aware of this, and I suppose that’s why you can keep the videos. In other words, the demonstrations aren’t lost; you can rewatch the exact moment a concept was shown. In addition, some slides contain a few references which can be considered as stand-alone learning cards. For instance, the list of the main securityContext options.
As a result, I think this workshop should be considered as a whole, where the slides are maybe a third of the material. The demos, the labs, the support on Discord should be considered as well.
Who Should Attend?
I think anyone interested in Kubernetes security wouldn’t be disappointed by this training.19 However, I think it’s important to set the expectations of who could attend it.
No Beginners
I wouldn’t consider this workshop for people who are just starting to discover Kubernetes. Even though the core concepts are well detailed in the modules, and especially in the first one where the core components of Kubernetes are reviewed, I still believe that some experience with this platform is necessary to properly appreciate the workshop. In my opinion, without a working mental model of pods, services, and the control plane, Modules 2–6 will move too fast.
I must also admit I struggled a bit during some sessions, as there were some concepts about building and deploying within an infrastructure I wasn’t familiar with. As part of my job, I spend more time breaking Kubernetes clusters than deploying them.
Platform, DevOps, and Security Engineers
For Platform Engineers, DevOps, and/or Security Engineers, I highly recommend it. I believe that experienced people, who have already deployed and maintained some clusters, and who would like to understand the why underneath the hardening checklist, will enjoy it.
This offensive approach, as far as I can tell after discussing with some clients, would be an additional point of view for those engineers, who might not have the time to think that way.
Penetration Testers
Is this workshop worth it for penetration testers (pentesters) including Red Teamers? It might be the last question that can be asked. And the answer is yes.
From my perspective, and that’s probably why I really enjoyed it, the whole course is built attack-first. I didn’t see a lot of defensive theory where Jarosław could say “With a token, an attacker might target this and do that”. No, it’s the opposite: the framing is explicitly offensive.
We are indeed talking about “Evil pods”: once we have found a misconfiguration, how can we exploit it and go even further? Every module ends in CTF challenges on a real cluster where you have to actually pull a flag out of the environment. For penetration testers, I believe it’s the perfect approach.
The techniques map directly onto a real container kill chain. Across the modules you practice, in order of a real engagement:
- Recon / enumeration from a foothold:
kubectl auth can-i --list,kubectl auth whoami, discovering the auto-mounted service-account token at/var/run/secrets/, decoding the JWT to understand what you’re holding. - Credential access & lateral movement: exfiltrating secrets via
secretKeyRef, escalating from permission to create secrets to impersonating another service account.20 - Privilege escalation and container escape: privileged pods,
hostPathmounts to read host files or break out to the node, capability abuse, and the low-level Linux material (SUID/SGID,no_new_privs, namespaces) that actually explains why an escape works. - Persistence: tampering with containerd OverlayFS snapshots so a backdoor survives pod restarts, which is a genuinely sneaky, above-average technique.
- Supply-chain / CI-CD abuse: poisoned pipeline execution, OWASP Top 10 CI/CD Security Risks,21 and “Image archaeology”, which consists of digging secrets out of image layers and history.
- Initial access chain: starting an attack from a web-app vulnerability, a file inclusion, and pivoting into the cluster, which models how these breaches actually begin rather than assuming you’re already inside.
That sequence I described above lines up closely, in my opinion, with MITRE ATT&CK for Containers:22 discovery, credential access, privilege escalation, lateral movement, persistence.
As a result, a pentester can slot it straight into how they already think about engagements.
Recommendation
Unsurprisingly, I really enjoyed this workshop, for several reasons. To summarize the most important ones:
| Strengths | Limitations |
|---|---|
| Current, well-maintained material | A very theoretical first module |
| Genuine depth into container internals | Challenges locked during the lives from week three |
| An effective attack-and-defend teaching approach | A few unresponsive challenges, fixed within the hour |
| A fine balance of theory and practice | Sessions sometimes pressed for time |
| Excellent trainers | Slides that need the videos |
Even if it only flatters my ego (and it shouldn’t matter), I was happy to finish first on the CTF scoreboard. I’ve set that aside, though: it didn’t influence my opinion of this training.
Diagrams
The three diagrams of this post, to download and reuse.
References
-
“Certified Kubernetes Security Specialist (CKS)”. The Linux Foundation. (Archive)
-
“Practical Deep Dive into Kubernetes Security (Workshop)”. Gynvael Coldwind. (Archive)
-
“hackArcana – Capture the Flag Platform”. HexArcana. (Archive)
-
“Deprecated API Migration Guide”. Kubernetes Documentation. (Archive)
-
“CVE-2020-8558”. National Vulnerability Database, 2020. (Archive)
-
“Pod Security Standards”. Kubernetes Documentation. (Archive)
-
“Kyverno – Kubernetes Native Policy Management”. Kyverno. (Archive)
-
“CVE-2025-32463”. National Vulnerability Database, 2025. (Archive)
-
“CVE-2026-31431”. National Vulnerability Database, 2026. (Archive)
-
“Overview of Cloud Native Security”. Kubernetes Documentation. (Archive)
-
“OWASP Top 10 CI/CD Security Risks”. OWASP Foundation. (Archive)