Luarmor v4 loader: what 1,245 bytes do
Five lines, twelve data fields and a 2,000-byte cache test. A line-by-line reading of the loader we downloaded on 19 October 2026.
The loader we downloaded on 19 October 2026 is 1,245 bytes in five lines. It checks a cache, downloads a second stage, writes that stage to disk before checking it, and runs it with a short id built from the project. The visible code is short enough to read line by line.
What arrived
| Field | Value |
|---|---|
| URL |
https://api.luarmor.net/files/v4/loaders/<script-id>.lua
|
| Downloaded | 2026-10-19 10:38:23 UTC |
| Size | 1,245 bytes |
| Lines | 5, three of them long |
content-type |
text/plain |
| Server | Cloudflare |
| SHA-256, first copy |
c2cb4d2eaea6b92ecc3de2a23f4f24a51ee60f467cc73bb14b4351c55a30f66a
|
| SHA-256, second copy |
7c124a9fb26ffe34e7c2a4d0614da57791969ceb7103dbb03272d3b70ef5e2fc
|
| Stable | No |
The second copy was requested 28 seconds after the first. Neither hash identifies the loader tomorrow, because the body is generated per request.
text/plain matters for one practical reason: the body is Lua source,
not JSON or a binary, so any tool that saves text can keep a faithful copy.
Its first comment says Do not save this file. We kept a copy to read
it. Reading it is not running it, and nothing here needs an executor.
The two comments
The two short lines are operational notes. The first says not to save the file. The second says to always use the loadstring. The first is an instruction, not a control: saving the file does not stop it from working.
The second describes the distribution model. The seller hands out a one-line loadstring, and the body behind it can change without the seller resending anything. That is the reason the hash moves while the URL stays the same.
The five lines
| Line | What it holds |
|---|---|
| 1 | A comment: do not save this file |
| 2 | A comment: always use the loadstring |
| 3 | _bsdata0, a table of twelve fields |
| 4 |
Two cache variables, a readfile call and a length test
|
| 5 |
The cache branch, the download, writefile and
loadstring
|
Lines 3 to 5 carry all the logic. Everything the loader does happens in those three statements.
_bsdata0 and its twelve fields
The third line assigns a table with twelve values. Four stay the same across the two downloads. Eight change.
| # | Type | Observation | Changes |
|---|---|---|---|
| 0 | integer | 18410634, different per request |
Yes |
| 1 | hex | 201 bytes, non-printable when decoded | Yes |
| 2 | hex | 68 bytes, non-printable when decoded | Yes |
| 3 | integer | 32-bit unsigned value | Yes |
| 4 | integer | 1792406303, the generation time |
Yes |
| 5 | integer | 2460466 |
No |
| 6 | integer | Identifier-like value | Yes |
| 7 | integer | Identifier-like value | Yes |
| 8 | integer | 7949296 |
No |
| 9 | integer | Identifier-like value | Yes |
| 10 | bytes | 28 bytes | No |
| 11 | bytes | 23 bytes | No |
Field 4 was 1792406303 in the first copy and
1792406331 in the second, 28 seconds later. The difference matches
the interval between the requests exactly. Converted, the first value is
2026-10-19 10:38:23 UTC, which is when the first download happened.
The two hex fields decode to bytes that do not print as text. Without the code that consumes them, no decryption is possible. A published decoded version of those blobs would be a guess with a hash attached.
In this build _bsdata0 appears once, in its own declaration, and
nothing in the visible code reads it. It may be a watermark tied to the request,
material the second stage expects, or a leftover from a build that consumes it
elsewhere. Nothing in the file separates those cases, so the purpose stays open.
The cache check
Line 4, with the short id replaced by a placeholder, is:
local f,b,a="static_content_170926","<short-id>-ocmid";
pcall(function() a=readfile(f.."/init-"..b..".lua") end)
if a and #a>2000 then a=loadstring(a) else a=nil; end;
f is the cache folder. The name is generic and shared by every
script that uses this loader convention. b is a short value plus the
-ocmid suffix; in our copy it was d049a886a1f-ocmid. It
is not the 32-character ID in the loader URL. a starts as that
string, then becomes the file contents.
The readfile call sits inside pcall, so a missing folder
or a missing file produces no message. a stays as the filename
string, the length test fails, and the loader moves to the network branch.
The test is #a > 2000. For a Lua string, # returns
the length in bytes. A file of 2,001 bytes passes. A file of 2,000 does not.
There is no hash, no version and no timestamp comparison.
readfile returns whatever the file contains. It does not check who
wrote it, when, or whether it belongs to this loader. The only gate is length,
which means any process with access to that folder can place code there and have
it compiled on the next run. The folder path on each platform is in
What is the
static_content folder.
The network branch
When the cache is missing or too short, line 5 runs. The six steps happen in this order:
if a then
return a()
else
pcall(makefolder,f)
a=game:HttpGet("https://cdn.luarmor.net/v4_init_ocmid.lua"..(_ca920af6193 or ""))
writefile(f.."/init-"..b..".lua", a)
ldrupd8m=a
return loadstring(a)(b)
end
| Step | Action | Comment |
|---|---|---|
| 1 | if a then return a() |
A long cached file runs and the network is never touched |
| 2 | pcall(makefolder,f) |
Creates the folder, ignores the error if it exists |
| 3 | game:HttpGet(...) |
Downloads the second stage |
| 4 | writefile(...) |
Writes it to disk before anything checks it |
| 5 | ldrupd8m=a |
Leaves the full text as a global |
| 6 | loadstring(a)(b) |
Compiles and runs it with the short id |
_ca920af6193 is not defined anywhere in the file. It is read as a
global, and in our run it was nil, so the URL had no suffix. A
generator could define it to append a cache-buster. As written, the loader refers
to a value that may not exist.
The write happens before loadstring sees the text. If the response
is corrupt or hostile, the copy is already on disk. The next run will try to
compile it again if it is longer than 2,000 bytes, because the only test is
length.
What came back: 327 bytes
We requested the second-stage URL 10 seconds after the loader. It returned 327
bytes with SHA-256
a1c78c98252fe597102e2ecf7923997e87435d2898588a7c166418fd4512d692,
served by Cloudflare.
The file has four lines: two comments, a LocalPlayer:Kick, and a
while wait(1) loop. The first comment says that seeing this file
means the executor is not supported. The loop keeps the chunk from returning.
This is the rejection branch. A recognised client receives a different init, and that init is where the key, HWID and expiry checks live. The rejection is short by design: it needs no data from the project, so it can be served to any request that does not look like a supported client. If the client passes, the next failure is a key code. Each code is listed in Luarmor error codes.
327 is below 2,000, so the file is written but never reused. The next run downloads it again. That is consistent with a rejection message: it should not be cached as if it were the script.
The globals it leaves behind
| Global | Contents | Effect |
|---|---|---|
_bsdata0 |
The twelve-field table | Readable by later scripts in the session |
ldrupd8m |
The full second-stage text | A later script can read or replace it |
_ca920af6193 |
Never defined by the loader | An optional cache-buster slot |
Globals in an executor session are shared. A later script can read
_bsdata0, replace ldrupd8m before anything uses it, or
define _ca920af6193 and change the next URL. The loader does not
clean up after itself.
What the design means
There is no pinning: the URL is mutable, and the body carries no signature or hash that the loader verifies. The only integrity check is the length of the cached file.
The body is generated per request, and the hash changes with the clock, so a hash identifies one copy.
An old build can run indefinitely, because the cache has no version, and a
seller's update may never arrive on a machine that already has a long cached
file. purge_cache() exists for exactly this reason. For what the
method removes, see
what purge_cache()
does.
The write happens before validation, so a bad response persists even if the code that follows fails. The shared folder name makes collisions possible between scripts that use the same convention.
The response depends on the client. The same URL serves a rejection to
curl and a different init to a recognised client, so the stub you
read can only show the wrapper. That is why
which executors
work with Luarmor is a question about the request that arrives.
Silent pcall calls hide the ordinary failures. A missing folder, a
missing file or a failed write produces no message, and the loader looks idle
when it is stuck.
The first stage and the second stage answer different questions. The first answers where the next stage is and whether a cache exists. The second answers whether this client and this key may run it. The stub can show the transport; the licence decision happens in the second file.
None of this needs a hostile seller. The fragility is in the design, visible in five lines, and it explains most of what users notice without opening the file.
Reproduce the request
You need no executor for any of this. These commands save the body and its headers:
curl -sS -D headers.txt -o loader.lua \
"https://api.luarmor.net/files/v4/loaders/<script-id>.lua"
wc -c loader.lua
sha256sum loader.lua
Run the request twice, about 30 seconds apart, and compare. wc -c
gives the byte count. sha256sum gives the hash. In our sample the
size stayed at 1,245 bytes and the hash changed.
To read the fields, print the third line and split it on commas. Field 4 converts with any Unix time tool. The other integers have no documented meaning. The table lists each value and whether it changed between the two copies.
To see the rejection branch, request
https://cdn.luarmor.net/v4_init_ocmid.lua with curl and
no executor headers. Read the body. That shows what an unrecognised client
receives, not what your client receives.
Record the date with every number. The size, the field count and the threshold belong to the copy from 19 October 2026, and the loader can change without a new version name.
FAQ
Why is the loader so small?
Because it is a wrapper, not the script. Its job is to find a cached second stage or download one, then hand it the short id. The payload lives behind the second URL, and the checks that matter happen there. A larger first stage would duplicate work the service already does.
What is _bsdata0?
A table of twelve values attached to the request. Eight change between downloads, four stay constant, and field 4 is a Unix timestamp of generation. The visible code never reads it, so its purpose cannot be settled from this file alone. It may be a watermark or material the second stage expects, and a leftover from another build is possible.
Does the loader contain the script?
No. The first stage contains a table, a cache test and a download. The script arrives through the second stage. In our fetch, that second stage was a 327-byte rejection, because curl is not a supported client. A supported client receives a different init.
Why does it write a file before running it?
To reuse it on the next launch without a network request. The write comes first because the loader caches the text and then compiles it. The order also means a bad response is stored before anyone checks it, and the next run may compile it again if it is long enough.
What is the second stage?
The file at cdn.luarmor.net/v4_init_ocmid.lua. In our fetch it held a kick message for unsupported clients. For a recognised client it carries the licence checks and whatever follows them. The first stage passes the short id to it as an argument.
Can I read the loader without running it?
Yes. A curl request returns the text, wc -c gives the size and sha256sum gives the hash. Reading the five lines needs no executor and no Roblox client. Do not run the file to answer a question that a text editor can answer.
Why does the fourth field look like a date?
It is a Unix timestamp. 1792406303 converts to 2026-10-19 10:38:23 UTC, the time of the first download. The second copy, 28 seconds later, held 1792406331. The difference matches the interval, which is how the field was identified as generation time.
Is the loader the same for every user?
No. The URL is the same for everyone in a project, but the body is generated per request. Eight of the twelve fields changed in 28 seconds, including the timestamp. Two requests made at the same moment are likely to differ as well, because several fields change per request. A published hash describes one copy only.
What happens if the cached file is corrupt?
If it is longer than 2,000 bytes, the loader tries to compile it. A failed loadstring leaves a as nil, so the loader falls through to the network branch and downloads a fresh copy. The bad file is overwritten only when that download succeeds. If the file is shorter than the threshold, it is discarded at once.
Does the 2,000-character test count characters or bytes?
It counts bytes. In Lua, # on a string returns its length in bytes, and the loader uses that value. For plain ASCII the two numbers match, so the distinction rarely matters. For a file with multi-byte characters, the byte count can pass the threshold before the character count does.