Why your Luarmor loader changes every time
Two downloads 28 seconds apart differed in 8 of 12 fields. That is why no loader hash stays valid, and why the file is built per request.
Your Luarmor loader changes because the server writes it for each request. Two downloads of the same URL, 28 seconds apart, differed in 8 of 12 fields and produced different SHA-256 hashes. One of the changing fields was the Unix timestamp of the moment the file was generated. A checksum you saved yesterday identifies yesterday's copy and nothing else.
Luarmor is a licence service that sellers use to gate their scripts. The loader is the small public stub that a buyer pastes into an executor. Its job is to start a chain, not to hold the script.
Two downloads of the same URL
On 19 Oct 2026 we requested
https://api.luarmor.net/files/v4/loaders/3be1e03d24dcc7d08bb520772f708bfe.lua
twice, with no cookie and no executor attached. The first response arrived at
10:38:23 UTC: 1,245 bytes, five lines, content-type: text/plain,
served by Cloudflare. The second arrived at 10:38:51 UTC from the same URL. It
was also 1,245 bytes.
The bytes were not the same. The first copy hashed to c2cb4d2e...
and the second to 7c124a9f.... Same URL, same length, different
file. That measurement explains why checksums in guides go stale within a
minute.
A different file does not mean the seller touched the script. The server
generated a fresh wrapper, which it does on every request. The first two lines
even ask you not to save the file and to always use the loadstring
form, which fits a wrapper that is rebuilt each time.
The field that carries the time
The third line declares a table called _bsdata0 with twelve entries.
Entry 4 was 1792406303 in the first download and
1792406331 in the second. The difference is 28 seconds, the exact
gap between the two requests. Read as Unix time, the first value is 19 Oct 2026
at 10:38:23 UTC, the same second as the first response.
The visible code never reads that entry. It sits in the table, unused, next to eleven others. But a value that tracks the clock proves how the file is produced: the server assembled it while answering, rather than serving a stored copy.
Eight fields move, four stay
| Field | Value type | Changed between the two downloads |
|---|---|---|
| 0 | integer | yes |
| 1 | 201-byte hex blob | yes |
| 2 | 68-byte hex blob | yes |
| 3 | integer | yes |
| 4 | integer, generation time | yes |
| 5 | integer | no |
| 6 | integer | yes |
| 7 | integer | yes |
| 8 | integer | no |
| 9 | integer | yes |
| 10 | 28 bytes | no |
| 11 | 23 bytes | no |
Eight of the twelve changed between our two downloads. Field 4 is a generation timestamp, so at least that field moves on every request, and any field derived from it moves with it. The four that stayed constant are two integers and two short binary blobs.
What the changing fields encode is not documented. The hex entries are binary, and no part of the visible file reads them. The constant entries are the better clue, because a value that never moves is usually a build marker or a fixed key.
A checksum needs a fixed input
A hash answers one question: is this input the same as the input I hashed before. It works when the input is stable, like a release archive. Here the input includes the generation time, so two correct downloads never match.
A hash posted in a forum describes one download at one second. A scan result tied to a hash describes that download, not the URL. So "the hashes do not match" is not evidence of anything, because they are not meant to match.
A hash could not have told you whether the loader was safe even if it had matched. What you can check is structure, set out line by line in the anatomy of the v4 loader.
Where the code that runs comes from
The stub does not contain the protected script. If the cache is missing or too
short, it fetches a second file from
cdn.luarmor.net/v4_init_ocmid.lua, writes it to disk and runs it with
a short project id as an argument. In our request that second file was 327 bytes
and contained a rejection: two comments, a Kick call and an endless
loop.
So the visible loader is a five-line runner. Its per-request fields sit unused while the logic arrives from another host.
Reproducing the comparison
You do not need an executor for this; any HTTP client works.
- Request the loader URL and save the body.
- Wait a few seconds and request it again.
- Hash both files with
sha256sumand compare. -
Read entry 4 in
_bsdata0in both copies and convert it as Unix time. - Compare the remaining entries.
The hashes will differ. Entries 5, 8, 10 and 11 should not. If a constant field changes, the generator has changed, which is a real update rather than per-request noise. Read the file as text; do not run it.
What stays the same
The URL keeps the same shape: /files/v4/loaders/ plus an identifier.
The file keeps five lines and roughly the same length. In our copy the cache
folder was static_content_170926 and the threshold for reusing a
cached file was 2,000 characters.
Those constants are what a stable hash would have told you. For the cache side, see The folder the loader writes to, and a fresh download follows purging it.
What the change does not prove
A new hash means the server generated a fresh file, which it does on every request. It does not mean the seller updated the script, and it does not mean anything hostile happened.
To judge the loader you have to follow the chain: which host it calls, what that host returns, and what runs next. The first link is what loadstring(game:HttpGet()) does. The rest depends on a second response that you cannot see unless the service decides to send it to you.
FAQ
Why is my loader different from the one in a tutorial?
The tutorial captured one request. Yours is generated later, so the timestamp field and the fields built from it differ. The five-line structure, the host, the path and the cache name should still match. Diff the two files and you will see the differences sit inside the data table, not in the code that runs.
Can I identify a loader by its size?
Partly. In our copy the file was 1,245 bytes, and both downloads had that length. Size narrows the field but does not identify a build, because two different generations can share a length. Use the host, the path, the line count and the cache folder name as a set, not the byte count alone.
Does a new hash mean the seller shipped an update?
No. The server stamps every response with the generation time, so the hash changes on every request, even two requests a second apart. A real update could show up as a new size, a different line structure, or a changed constant entry such as field 5 or field 8.
Is the script inside the loader?
No. The loader is a runner. It checks a local cache, fetches v4_init_ocmid.lua from cdn.luarmor.net, writes it to disk and executes it. The protected script arrives later in the chain. That is why reading the stub tells you how the loader starts, not what the script does.
Why does a hash from a forum never match mine?
The hash was taken from a different request. Even the same person on the same machine, one minute later, gets a different file. A published hash can only identify the copy that was hashed, so treat it as a date stamp on an old analysis rather than a value you can check today.
Can I save the loader and run it later?
The file itself asks you not to. A saved copy is a snapshot from one request, and nothing in it refreshes the second stage if the service changes. The supported path is the loadstring form that requests the loader each time, so any change on the server reaches you on the next run.
Does the timestamp mean the script was rebuilt?
No. The timestamp records when the loader text was generated, which happens on every request. It says nothing about the protected script, which is fetched separately. The two can change on different schedules, so judge the payload by the CDN response, not by this field.
What should I compare instead of the hash?
Compare the shape: host, path, line count, the two comments, the cache folder name and the four constant entries in the data table. Then compare the second stage, which is a separate download. If both match, you are looking at the same generation of the loader even when the hashes differ.