# Ruby Deserialization Security: Kubernetes Auditing & Production Hardening

---

*Originally published on* [*Naveed Ahmed's Engineering Blog*](https://blog.naveedkumbhar.com/ruby2shell/)*.*

One overlooked data-processing decision can create a serious application security problem.

In Ruby, object deserialization is a good example.

The Marshal module can reconstruct Ruby objects from serialized data. But allowing untrusted input into that process can introduce dangerous behavior.

For engineers managing Ruby applications in Kubernetes, securing the application means understanding both the code and the runtime environment.

## 1\. Understanding Ruby Deserialization Risks

Ruby provides the `Marshal.load` method to reconstruct serialized objects.

For trusted data, this is useful.

But untrusted serialized input should not be passed directly to this method.

Potential risks depend on the application and the types of objects involved.

The safest approach is to avoid native object deserialization for external input wherever possible.

## 2\. Find Unsafe Deserialization Paths

Start by examining application code:

```bash
grep -RInE 'Marshal\.(load|restore)' \
  --include='*.rb' app lib
```

Review the results carefully.

Ask whether the serialized data originates from trusted internal operations or can be influenced by users or external services.

Also inspect background jobs, cache integrations, and session handling.

## 3\. Audit Kubernetes Workloads

List Ruby application images:

```bash
kubectl get pods -n production \
  -o custom-columns='POD:.metadata.name,IMAGES:.spec.containers[*].image'
```

Inspect the runtime version:

```bash
kubectl exec -n production deploy/rails-api \
  -c web -- ruby -v
```

These commands help identify running software for further assessment.

## 4\. Scan Container Images

Use Trivy to scan for known vulnerabilities:

```bash
trivy image --scanners vuln \
  --severity HIGH,CRITICAL \
  registry.example.com/rails-api:production
```

Use SBOMs where possible to improve dependency tracking.

Remember that a vulnerability scan doesn't automatically detect unsafe application logic.

## 5\. Harden Production Applications

A practical security strategy includes:

- Avoiding unsafe deserialization of untrusted data
- Using suitable formats and strict input validation
- Updating Ruby and application dependencies
- Rebuilding container images
- Running workloads with limited privileges
- Restricting unnecessary network access
- Monitoring errors and abnormal application behavior

These controls are valuable even when no specific runtime CVE applies.

---

## Read the Full Ruby Security Guide

I wrote a longer article discussing Ruby2Shell claims, Ruby deserialization security, Kubernetes investigation, and production hardening.

[**Read the Complete Ruby2Shell Technical Guide**](https://blog.naveedkumbhar.com/ruby2shell/)

The article's specific CVE-2026-113840 claims require confirmation from an official security advisory.

---

## Final Thoughts

Application security isn't just about patching packages.

It's also about understanding how your software handles data, where that data comes from, and what privileges the application has.

**Does your team include unsafe deserialization checks in its DevSecOps pipeline?**

I'd be interested to hear your approach.

---

*Written by Naveed Ahmed — Lead DevOps & Platform Architect*

[Engineering Blog](https://blog.naveedkumbhar.com) | [GitHub](https://github.com/naveedkumbhar) | [LinkedIn](https://pk.linkedin.com/in/naveedkumbhar)