Search
Find a vulnerability
Search criteria
3 vulnerabilities found for MAR-2000 firmware by Moxa
GCVE-1988-2026-0503
Vulnerability from gna-1988 – Published: 2026-11-02 07:30 – Updated: 2026-11-02 07:30
VLAI
EPSS
VEX
Title
[0day-rubbish] Moxa MAR-2000 firmware FWR_MAR2000_V1.0_Build_15010909 IPsec tunnel address command injection through the route-management shell commands (7.2)
Summary
0day Rubbish Research Team is publicly disclosing a vulnerability in the Moxa
MAR-2000 series industrial 4G/LTE cellular router, firmware image
FWR_MAR2000_V1.0_Build_15010909, from Moxa Inc. (Taiwan). An authenticated
administrator converts one stored VPN address field into arbitrary command
execution as the identity of the product's model process, because the IPsec
model manages the tunnel's addresses and routes by interpolating stored,
never-validated configuration values into shell command lines. The payload
is committed by one request and executes at a lifecycle moment the product
performs on its own. This is one of three independent command injection
findings documented for this product and released together as a set.
Type and root cause. CWE-78, OS command injection, with CWE-20 co-equal, in
the IPsec model at /home/model/network/ipsec/ipsec.py inside the ARM
Debian 6.0.8 root filesystem of the firmware, which runs the vendor's MIRF
(Mobile Intelligent Routing Framework) stack: a Node.js Express 4.0
management application on port 80 bound to all interfaces, the express-sanji
middleware bridging REST resources onto a local MQTT broker, and Python 2.6
model scripts that persist configuration and act on it. The model stores
tunnelModeTable - whose keys include localVpnIp, tunnelRemoteVpnIp and
tunnelRemoteVpnInterface - together with transModeTable, as JSON
configuration written through the authenticated PUT /api/v1/network/ipsec
resource. When the IPsec service applies the tunnel, the model calls its
lifecycle functions, and every one of the four interpolates the stored
fields into an ip command line and hands it to
subprocess.call(cmd, shell=True):
```
add_ip: cmd = 'ip addr add %s dev eth%s' % (localVpnIp + '/'
+ <computed subnet part>, tunnelRemoteVpnInterface)
del_ip: 'ip addr del %s dev eth%s' with the same stored fields
add_route: cmd = 'ip route add to %s via %s src %s' % (ipRange,
localVpnIp, localVpnIp)
del_route: cmd = 'ip route del %s' % ipRange
```
The stored value sits at the front of the command line, ahead of every
literal token the product contributes, so a semicolon inside the value ends
the ip operation before any product token can interfere with the injected
statement. One stored localVpnIp arms several commands at once: it is the
operand of add_ip and del_ip and both the via and src operands of
add_route, so whichever lifecycle function a tunnel apply reaches first
carries the payload. The write side applies exactly one filter,
clean_data(), whose entire behaviour is to delete dictionary keys the model
does not recognise: no value is inspected, an address format is never
checked, and the payload rides a key the whitelist expects, so the filter
is not even encountered as an obstacle. An administrator who stores
"10.10.10.1; <command>; #" in that field has authored
```
ip addr add 10.10.10.1; <command>; #/24 dev eth0
```
- the ip segment fails harmlessly as an address operation, the injected
statement executes under the shell, and the hash sign comments away the
template tail. A fifth related construction sits in the same model:
update_config_file() assembles IPsec configuration lines interpolating
transModeTable's transServerIp and transClientIp into the stored
configuration file - the same unvalidated-field pattern, not exercised in
this research record, reported as structure rather than as a detonated
sink.
Authentication and reach. The validateUser middleware is the only
authentication check on the REST surface: it requires a server-side session
for every non-GET method, and login is POST /api/login compared against
bcrypt-hashed entries in the SQLite user table. The PUT that plants the
payload requires the session; past that check there is no second
authorisation layer, the broker leg carries no identity, and the model
implements no permission judgement, so the product's single documented
role, the device administrator, is the whole security boundary. The
listener binds all interfaces on port 80 in the shipped firmware; no WAN
exposure is assumed anywhere in the published rating.
Severity. The published score is 7.2 High,
CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, from ISS = 0.914816, impact
5.873119, exploitability 1.234708 and base 7.107826 rounded up to 7.2,
Privileges Required High being the product's single administrator role. A
labelled conditional and never the headline: where a deployment still runs
the factory default administrator pair carried by the shipped firmware's
SQLite user table, the prerequisite collapses and the chain reads 9.8
Critical on the PR:N vector (exploitability 3.887043, base 9.760161); a
changed credential removes it, and the default pair is disclosed as a
separate weakness, never folded into the published vector. A PR:L reading
of 8.8 High is published only as the arithmetic of the rejected variant.
The score provenance is disclosed in public: the research record behind
this advisory carried 8.8 for all three same-product findings, that figure
is the arithmetic of a PR:L vector, no artefact shows a lower-privileged
product role, and every published number was recomputed from its own
vector - which lowered the researchers' own figure by 1.6 points. A
Scope-Changed reading computes to 9.1 and is deliberately not published,
because the model process belongs to the same single-purpose appliance
authority, and managing the appliance's interfaces and routes through its
management plane is the product's design rather than an escape.
Verification method, and its boundary. Two evidence classes carry the
finding, kept separate in the published advisory. The firmware's own
application sources establish the configuration write, the key-only
validation, and the four command constructions, read from the shipped
files. The dynamic layer is a sink-level replication on an isolated cloud
Linux sandbox: each of the four constructions, with the same template, the
same field position and the same shell=True hand-off, was executed with an
injected address value and separately with a benign control. All four
produced a marker file containing uid=0(root) under the payload; the
control produced no marker and no side effect of any kind. The boundary is
stated plainly: end-to-end detonation against powered-on hardware,
including the exact tunnel-apply moment at which the stored value is
consumed, is outside this research record, and the on-device model process
identity was neither measured nor claimed - uid=0(root) is the replication
sandbox's identity and nothing broader rests on it.
Impact. Arbitrary command execution as the identity of the Python model
process, begun by one authenticated configuration write and delivered by a
lifecycle step the product performs on its own, with no race and no
protocol manipulation anywhere in the chain. The payload is stored
configuration: it persists across reboots, is read fresh at each tunnel
application, and the same single field reaches several sinks at once. The
executing process is the device's own model daemon performing a
routine-sounding job, so detection signals are content-level: tunnel-table
values whose address operand contains a semicolon, pipe,
dollar-parenthesis, backtick or newline; unexplained child processes under
the model daemon; ip command failures whose operand text contains shell
metacharacters - and a legitimate address never contains any of them.
Reaching the route-management sinks also means owning the device's
forwarding state, on a device deployed as communication infrastructure. The
web stack's separate property of answering unauthenticated GET requests
across the API surface - which lets an intruder enumerate stored tunnel
settings - is a read-exposure issue reported on its own and is not part of
this chain.
Remediation: manage addresses and routes without a shell, building each ip
operation as an argument vector launched without /bin/sh, which removes the
metacharacter question for all four constructions at once; validate every
address-shaped field at the model's write boundary so the component that
interpolates the value rejects non-addresses, not only a web form the
backend cannot assume is the only writer; turn clean_data() into a value
validator at that natural choke point; treat the configuration-file
assembly under the same rule; and add a regression test that stores a
metacharacter-bearing localVpnIp, drives a tunnel apply, and asserts
rejection at write time or execution without shell interpretation.
Operators until a patch exists: change the factory default administrator
credential at commissioning, keep the management listener off WAN-facing
addresses, audit stored IPsec tunnel tables for shell metacharacters, and
disable IPsec where tunnels are not used so the model's lifecycle has
nothing to apply.
Proof of concept. The published tool is a standard-library-only Python 3
client that drives the entry path: it logs in, reads the current IPsec
configuration, writes the tunnel table's local VPN address field carrying
the payload, and reports what the stored value will do at each of the four
constructions and at which lifecycle occasion the model consumes it. It
takes target, credential, command and timeout arguments; the default target
is loopback; it verifies each response and exits non-zero with an explicit
message on failure. It does not attempt to drive the tunnel lifecycle
itself, and no persistence, reverse shell or destructive action is
implemented. Use it only against systems you own or are authorised to test.
The vendor's product security team mailbox, published on the vendor's own
security advisories page, was used for the unconditional notification; no
report form was submitted and no individual was addressed by name. This
disclosure is unconditional: the research is published, no permission was
asked for, no embargo was requested, nothing is withheld pending a reply,
and remediation questions are answered at no cost. No vulnerability
identifier has been assigned to this finding.
Two companion advisories for the same product are published alongside this
one, independent findings that share only the entry architecture - a
different model file, REST resource, configuration field and sink each: an
Executer program-activation injection through the stored argument field of
a shell-interpreted program launch, and a scenario ping condition injection
through the auto-executing ping thread, both at the second and third URLs
below.
Full technical analysis and the reproducible proof of concept, published
unconditionally:
https://0day-rubbish.com/blog/mar-2000-network-ipsec-command-injection
Companion advisories for the same product, independent findings:
https://0day-rubbish.com/blog/mar-2000-executer-program-argument-command-injection
https://0day-rubbish.com/blog/mar-2000-scenario-ping-command-injection
Project archive (ongoing disclosure series):
https://github.com/Exploit-Garbage/0day-Rubbish
--
0day Rubbish Research Team
disclosure () 0day-rubbish com
https://0day-rubbish.com
_______________________________________________
Sent through the Full Disclosure mailing list
https://nmap.org/mailman/listinfo/fulldisclosure
Web Archives & RSS: https://seclists.org/fulldisclosure/
Severity
No CVSS data available.
Assigner
References
9 references
Impacted products
1 product
| Vendor | Product | Version | |
|---|---|---|---|
| Moxa | MAR-2000 firmware |
Affected:
unknown
|
{
"containers": {
"cna": {
"affected": [
{
"product": "MAR-2000 firmware",
"vendor": "Moxa",
"versions": [
{
"status": "affected",
"version": "unknown"
}
]
}
],
"credits": [
{
"lang": "en",
"type": "finder",
"value": "disclosure via Fulldisclosure"
}
],
"descriptions": [
{
"lang": "en",
"value": "0day Rubbish Research Team is publicly disclosing a vulnerability in the Moxa\nMAR-2000 series industrial 4G/LTE cellular router, firmware image\nFWR_MAR2000_V1.0_Build_15010909, from Moxa Inc. (Taiwan). An authenticated\nadministrator converts one stored VPN address field into arbitrary command\nexecution as the identity of the product\u0027s model process, because the IPsec\nmodel manages the tunnel\u0027s addresses and routes by interpolating stored,\nnever-validated configuration values into shell command lines. The payload\nis committed by one request and executes at a lifecycle moment the product\nperforms on its own. This is one of three independent command injection\nfindings documented for this product and released together as a set.\n\nType and root cause. CWE-78, OS command injection, with CWE-20 co-equal, in\nthe IPsec model at /home/model/network/ipsec/ipsec.py inside the ARM\nDebian 6.0.8 root filesystem of the firmware, which runs the vendor\u0027s MIRF\n(Mobile Intelligent Routing Framework) stack: a Node.js Express 4.0\nmanagement application on port 80 bound to all interfaces, the express-sanji\nmiddleware bridging REST resources onto a local MQTT broker, and Python 2.6\nmodel scripts that persist configuration and act on it. The model stores\ntunnelModeTable - whose keys include localVpnIp, tunnelRemoteVpnIp and\ntunnelRemoteVpnInterface - together with transModeTable, as JSON\nconfiguration written through the authenticated PUT /api/v1/network/ipsec\nresource. When the IPsec service applies the tunnel, the model calls its\nlifecycle functions, and every one of the four interpolates the stored\nfields into an ip command line and hands it to\nsubprocess.call(cmd, shell=True):\n\n```\nadd_ip: cmd = \u0027ip addr add %s dev eth%s\u0027 % (localVpnIp + \u0027/\u0027\n + \u003ccomputed subnet part\u003e, tunnelRemoteVpnInterface)\ndel_ip: \u0027ip addr del %s dev eth%s\u0027 with the same stored fields\nadd_route: cmd = \u0027ip route add to %s via %s src %s\u0027 % (ipRange,\n localVpnIp, localVpnIp)\ndel_route: cmd = \u0027ip route del %s\u0027 % ipRange\n```\n\nThe stored value sits at the front of the command line, ahead of every\nliteral token the product contributes, so a semicolon inside the value ends\nthe ip operation before any product token can interfere with the injected\nstatement. One stored localVpnIp arms several commands at once: it is the\noperand of add_ip and del_ip and both the via and src operands of\nadd_route, so whichever lifecycle function a tunnel apply reaches first\ncarries the payload. The write side applies exactly one filter,\nclean_data(), whose entire behaviour is to delete dictionary keys the model\ndoes not recognise: no value is inspected, an address format is never\nchecked, and the payload rides a key the whitelist expects, so the filter\nis not even encountered as an obstacle. An administrator who stores\n\"10.10.10.1; \u003ccommand\u003e; #\" in that field has authored\n\n```\nip addr add 10.10.10.1; \u003ccommand\u003e; #/24 dev eth0\n```\n\n- the ip segment fails harmlessly as an address operation, the injected\nstatement executes under the shell, and the hash sign comments away the\ntemplate tail. A fifth related construction sits in the same model:\nupdate_config_file() assembles IPsec configuration lines interpolating\ntransModeTable\u0027s transServerIp and transClientIp into the stored\nconfiguration file - the same unvalidated-field pattern, not exercised in\nthis research record, reported as structure rather than as a detonated\nsink.\n\nAuthentication and reach. The validateUser middleware is the only\nauthentication check on the REST surface: it requires a server-side session\nfor every non-GET method, and login is POST /api/login compared against\nbcrypt-hashed entries in the SQLite user table. The PUT that plants the\npayload requires the session; past that check there is no second\nauthorisation layer, the broker leg carries no identity, and the model\nimplements no permission judgement, so the product\u0027s single documented\nrole, the device administrator, is the whole security boundary. The\nlistener binds all interfaces on port 80 in the shipped firmware; no WAN\nexposure is assumed anywhere in the published rating.\n\nSeverity. The published score is 7.2 High,\nCVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, from ISS = 0.914816, impact\n5.873119, exploitability 1.234708 and base 7.107826 rounded up to 7.2,\nPrivileges Required High being the product\u0027s single administrator role. A\nlabelled conditional and never the headline: where a deployment still runs\nthe factory default administrator pair carried by the shipped firmware\u0027s\nSQLite user table, the prerequisite collapses and the chain reads 9.8\nCritical on the PR:N vector (exploitability 3.887043, base 9.760161); a\nchanged credential removes it, and the default pair is disclosed as a\nseparate weakness, never folded into the published vector. A PR:L reading\nof 8.8 High is published only as the arithmetic of the rejected variant.\nThe score provenance is disclosed in public: the research record behind\nthis advisory carried 8.8 for all three same-product findings, that figure\nis the arithmetic of a PR:L vector, no artefact shows a lower-privileged\nproduct role, and every published number was recomputed from its own\nvector - which lowered the researchers\u0027 own figure by 1.6 points. A\nScope-Changed reading computes to 9.1 and is deliberately not published,\nbecause the model process belongs to the same single-purpose appliance\nauthority, and managing the appliance\u0027s interfaces and routes through its\nmanagement plane is the product\u0027s design rather than an escape.\n\nVerification method, and its boundary. Two evidence classes carry the\nfinding, kept separate in the published advisory. The firmware\u0027s own\napplication sources establish the configuration write, the key-only\nvalidation, and the four command constructions, read from the shipped\nfiles. The dynamic layer is a sink-level replication on an isolated cloud\nLinux sandbox: each of the four constructions, with the same template, the\nsame field position and the same shell=True hand-off, was executed with an\ninjected address value and separately with a benign control. All four\nproduced a marker file containing uid=0(root) under the payload; the\ncontrol produced no marker and no side effect of any kind. The boundary is\nstated plainly: end-to-end detonation against powered-on hardware,\nincluding the exact tunnel-apply moment at which the stored value is\nconsumed, is outside this research record, and the on-device model process\nidentity was neither measured nor claimed - uid=0(root) is the replication\nsandbox\u0027s identity and nothing broader rests on it.\n\nImpact. Arbitrary command execution as the identity of the Python model\nprocess, begun by one authenticated configuration write and delivered by a\nlifecycle step the product performs on its own, with no race and no\nprotocol manipulation anywhere in the chain. The payload is stored\nconfiguration: it persists across reboots, is read fresh at each tunnel\napplication, and the same single field reaches several sinks at once. The\nexecuting process is the device\u0027s own model daemon performing a\nroutine-sounding job, so detection signals are content-level: tunnel-table\nvalues whose address operand contains a semicolon, pipe,\ndollar-parenthesis, backtick or newline; unexplained child processes under\nthe model daemon; ip command failures whose operand text contains shell\nmetacharacters - and a legitimate address never contains any of them.\nReaching the route-management sinks also means owning the device\u0027s\nforwarding state, on a device deployed as communication infrastructure. The\nweb stack\u0027s separate property of answering unauthenticated GET requests\nacross the API surface - which lets an intruder enumerate stored tunnel\nsettings - is a read-exposure issue reported on its own and is not part of\nthis chain.\n\nRemediation: manage addresses and routes without a shell, building each ip\noperation as an argument vector launched without /bin/sh, which removes the\nmetacharacter question for all four constructions at once; validate every\naddress-shaped field at the model\u0027s write boundary so the component that\ninterpolates the value rejects non-addresses, not only a web form the\nbackend cannot assume is the only writer; turn clean_data() into a value\nvalidator at that natural choke point; treat the configuration-file\nassembly under the same rule; and add a regression test that stores a\nmetacharacter-bearing localVpnIp, drives a tunnel apply, and asserts\nrejection at write time or execution without shell interpretation.\nOperators until a patch exists: change the factory default administrator\ncredential at commissioning, keep the management listener off WAN-facing\naddresses, audit stored IPsec tunnel tables for shell metacharacters, and\ndisable IPsec where tunnels are not used so the model\u0027s lifecycle has\nnothing to apply.\n\nProof of concept. The published tool is a standard-library-only Python 3\nclient that drives the entry path: it logs in, reads the current IPsec\nconfiguration, writes the tunnel table\u0027s local VPN address field carrying\nthe payload, and reports what the stored value will do at each of the four\nconstructions and at which lifecycle occasion the model consumes it. It\ntakes target, credential, command and timeout arguments; the default target\nis loopback; it verifies each response and exits non-zero with an explicit\nmessage on failure. It does not attempt to drive the tunnel lifecycle\nitself, and no persistence, reverse shell or destructive action is\nimplemented. Use it only against systems you own or are authorised to test.\n\nThe vendor\u0027s product security team mailbox, published on the vendor\u0027s own\nsecurity advisories page, was used for the unconditional notification; no\nreport form was submitted and no individual was addressed by name. This\ndisclosure is unconditional: the research is published, no permission was\nasked for, no embargo was requested, nothing is withheld pending a reply,\nand remediation questions are answered at no cost. No vulnerability\nidentifier has been assigned to this finding.\n\nTwo companion advisories for the same product are published alongside this\none, independent findings that share only the entry architecture - a\ndifferent model file, REST resource, configuration field and sink each: an\nExecuter program-activation injection through the stored argument field of\na shell-interpreted program launch, and a scenario ping condition injection\nthrough the auto-executing ping thread, both at the second and third URLs\nbelow.\n\nFull technical analysis and the reproducible proof of concept, published\nunconditionally:\n https://0day-rubbish.com/blog/mar-2000-network-ipsec-command-injection\n\nCompanion advisories for the same product, independent findings:\n https://0day-rubbish.com/blog/mar-2000-executer-program-argument-command-injection\n https://0day-rubbish.com/blog/mar-2000-scenario-ping-command-injection\n\nProject archive (ongoing disclosure series):\n https://github.com/Exploit-Garbage/0day-Rubbish\n\n--\n0day Rubbish Research Team\ndisclosure () 0day-rubbish com\nhttps://0day-rubbish.com\n_______________________________________________\nSent through the Full Disclosure mailing list\nhttps://nmap.org/mailman/listinfo/fulldisclosure\nWeb Archives \u0026 RSS: https://seclists.org/fulldisclosure/"
}
],
"problemTypes": [
{
"descriptions": [
{
"cweId": "CWE-20",
"description": "CWE-20",
"lang": "en",
"type": "CWE"
},
{
"cweId": "CWE-78",
"description": "CWE-78",
"lang": "en",
"type": "CWE"
}
]
}
],
"providerMetadata": {
"dateUpdated": "2026-11-02T07:30:04Z",
"orgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
"shortName": "VULNARCHIVE"
},
"references": [
{
"tags": [
"technical-description",
"exploit"
],
"url": "https://vuln.freearchive.org/archive/full-disclosure/2026/Oct/53"
},
{
"tags": [
"technical-description"
],
"url": "https://seclists.org/fulldisclosure/2026/Oct/53"
},
{
"url": "https://0day-rubbish.com"
},
{
"url": "https://0day-rubbish.com/blog/mar-2000-executer-program-argument-command-injection"
},
{
"url": "https://0day-rubbish.com/blog/mar-2000-network-ipsec-command-injection"
},
{
"url": "https://0day-rubbish.com/blog/mar-2000-scenario-ping-command-injection"
},
{
"url": "https://github.com/Exploit-Garbage/0day-Rubbish"
},
{
"url": "https://nmap.org/mailman/listinfo/fulldisclosure"
},
{
"url": "https://seclists.org/fulldisclosure/"
}
],
"source": {
"defect": [
"https://seclists.org/fulldisclosure/2026/Oct/53"
],
"discovery": "EXTERNAL"
},
"title": "[0day-rubbish] Moxa MAR-2000 firmware FWR_MAR2000_V1.0_Build_15010909 IPsec tunnel address command injection through the route-management shell commands (7.2)",
"x_gcve": [
{
"recordType": "advisory",
"relationships": [],
"vulnId": "GCVE-1988-2026-0503",
"x_vulnarchive": {
"archiveUrl": "https://vuln.freearchive.org/archive/full-disclosure/2026/Oct/53",
"automated": true,
"contentSha256": "495adc35af2466ab65f47c5822fd2ba376f90412a5f9bfa9ee356b5e7850970a",
"evidenceScore": 11,
"messageId": "",
"originalUrl": "https://seclists.org/fulldisclosure/2026/Oct/53",
"policy": "vulnarchive-1",
"sourceFormat": "text/html",
"sourcePublishedAt": "2026-10-27T16:39:01Z"
}
}
]
}
},
"cveMetadata": {
"assignerOrgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
"assignerShortName": "VULNARCHIVE",
"datePublished": "2026-11-02T07:30:04Z",
"dateUpdated": "2026-11-02T07:30:04Z",
"state": "PUBLISHED",
"vulnId": "GCVE-1988-2026-0503"
},
"dataType": "CVE_RECORD",
"dataVersion": "5.2"
}
GCVE-1988-2026-0502
Vulnerability from gna-1988 – Published: 2026-11-02 07:30 – Updated: 2026-11-02 07:30
VLAI
EPSS
VEX
Title
[0day-rubbish] Moxa MAR-2000 firmware FWR_MAR2000_V1.0_Build_15010909 command injection in the Executer program activation path (7.2)
Summary
0day Rubbish Research Team is publicly disclosing a vulnerability in the Moxa
MAR-2000 series industrial 4G/LTE cellular router, firmware image
FWR_MAR2000_V1.0_Build_15010909, from Moxa Inc. (Taiwan). An authenticated
administrator converts one stored configuration field into arbitrary command
execution as the identity of the product's model process, because the
Executer model builds the launch command of an operator program as a shell
string whose program-argument column is never validated by any layer of the
backend. This is one of three independent command injection findings
documented for this product and released together as a set.
Type and root cause. CWE-78, OS command injection, with CWE-20 co-equal, in
the Executer model at /home/model/system/executer/executer.py inside the
ARM Debian 6.0.8 root filesystem of the firmware, which runs the vendor's
MIRF (Mobile Intelligent Routing Framework) stack: a Node.js Express 4.0
management application on port 80 bound to all interfaces, the express-sanji
middleware bridging REST resources onto a local MQTT broker, and Python 2.6
model scripts that persist configuration and act on it. The model stores
one row per operator program in an SQLite table whose columns include
fileName and argument. On activation it assembles the command as
str(execute_file) + " " + str(argument) and launches it with
subprocess.Popen(full_command, shell=True, preexec_fn=os.setsid), where the
row's argument bytes are concatenated verbatim and shell=True delegates the
parsing to /bin/sh: semicolons, background operators, pipes, backticks and
command substitution all have their ordinary meaning. The value's
provenance is a database column set by an HTTP request: the row writer is
generic, taking every key of the PUT /api/v1/system/executer/program/<id>
request's data object and committing it with a plain SQL
UPDATE ... SET ... statement, with no per-column semantics anywhere on the
write path. The only gate on execution is a liveness check - the file must
exist under the user-program directory - and the product's own multipart
upload route, POST /api/v1/system/executer/program, satisfies it: the upload
applies only a filename normalisation, with no allowed-type list and no file
filter. The chain is therefore: log in, upload a benign script through the
product's own route, store "; <command>; #" in the row's argument field, and
activate the row with PUT /api/v1/system/executer/activatedProgram carrying
programId and runBit 1. The shell runs the uploaded script first, the
semicolon ends it, the injected statement runs, and the trailing hash
comments out the rest of the line. The same model contains a second,
structurally identical sink in its deletion path: it builds
"rm -rf %s" from the row's unvalidated fileName column and executes it with
subprocess.call(..., shell=True), guarded only by a comparison of the raw
value against a single slash, which blocks exactly one value and nothing
else, and requires no upload and no activation.
The two-request chain looks like this after login:
```
[1] POST /api/v1/system/executer/program multipart, benign script
-> stored under the user-program directory
[2] PUT /api/v1/system/executer/program/<id>
{"data": {"fileName": "<uploaded basename>",
"argument": "; <command>; #"}}
-> generic row writer commits both columns verbatim (SQLite)
[3] PUT /api/v1/system/executer/activatedProgram
{"data": {"programId": <id>, "runBit": 1}}
-> Popen("<dir>/<file> ; <command>; #", shell=True)
```
Authentication and reach. The validateUser middleware is the only
authentication check on the REST surface: it requires a server-side session
for every non-GET method, and login is POST /api/login compared against
bcrypt-hashed entries in the SQLite user table. Past that check there is no
second authorisation layer - the message bridge performs no permission
translation and the broker leg carries no identity - so the product's single
documented role, the device administrator, is the whole security boundary.
The listener binds all interfaces on port 80 in the shipped firmware; no
WAN exposure is assumed anywhere in the published rating.
Severity. The published score is 7.2 High,
CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, from ISS = 0.914816, impact
5.873119, exploitability 1.234708 and base 7.107826 rounded up to 7.2,
Privileges Required High being the product's single administrator role. A
labelled conditional and never the headline: where a deployment still runs
the factory default administrator pair carried by the shipped firmware's
SQLite user table, the prerequisite collapses and the chain reads 9.8
Critical on the PR:N vector (exploitability 3.887043, base 9.760161); a
changed credential removes it, and the default pair is disclosed as a
separate weakness, never folded into the published vector. A PR:L reading
of 8.8 High is published only as the arithmetic of the rejected variant. The
score provenance is disclosed in public: the research record behind this
advisory carried 8.8 for all three same-product findings, that figure is the
arithmetic of a PR:L vector, no artefact shows a lower-privileged product
role, and every published number was recomputed from its own vector - which
lowered the researchers' own figure by 1.6 points. A Scope-Changed reading
computes to 9.1 and is deliberately not published, because the model
process belongs to the same single-purpose appliance authority, and
commanding the appliance's own operating system through its management
plane is the product's design rather than an escape.
Verification method, and its boundary. Two evidence classes carry the
finding, kept separate in the published advisory. The firmware's own
application sources establish the entry path, the storage semantics and the
exact sink construction, read from the shipped files. The dynamic layer is
a sink-level replication on an isolated cloud Linux sandbox: the model's
exact concatenation with the shell=True launch, carrying a benign upload
stand-in, an injection payload and a benign control; with the payload in the
argument position a marker file containing uid=0(root) was created, and the
control produced the benign program launch and nothing else. The deletion
construction was replicated with the same method and also produced its
marker. The boundary is stated plainly: end-to-end detonation against
powered-on hardware is outside this research record, and the identity of the
model process on the device was neither measured nor claimed - uid=0(root)
is the replication sandbox's identity and nothing broader rests on it.
Impact. Arbitrary command execution as the identity of the Python model
process, begun by one authenticated configuration write and one activation
request, with no memory corruption and no protocol manipulation in the
chain. The command line is a stored configuration value that persists across
reboots and re-executes on every activation of the row, so the payload is
reboot-durable without persistence work by the attacker. The deletion sink
extends the class to a field reachable without any upload and allows
destructive filesystem operations wherever the injected metacharacters
lead. The compromise yields the router's complete configuration, control of
its forwarding and cellular function, and availability at will over a
device deployed as communication infrastructure. The two requests that
matter are indistinguishable in shape from ordinary administrator activity,
so the readable signals are content-level: program rows whose argument
contains shell metacharacters, unexpected files in the user-program
directory, unexpected child processes under the model daemon. The web
stack's separate property of answering unauthenticated GET requests across
the API surface is a read-exposure issue reported on its own and is not
part of this chain.
Remediation: execute activated programs without a shell, with the
executable path and the argument as separate execv-style arguments; validate
the argument at the row-write boundary in the model rather than only in a
web form; constrain fileName to the set of stored uploads and associate rows
to files by an opaque server-side handle; rebuild the deletion path with an
argument vector; restrict the multipart upload to executable-basename types
and add a regression test that writes a metacharacter-bearing argument,
activates the row, and asserts rejection at write time or execution without
shell interpretation. Operators until a patch exists: change the factory
default administrator credential at commissioning, keep the management
listener off WAN-facing addresses, audit the program table and user-program
directory on a schedule, and disable the Executer feature where operator
programs are not used.
Proof of concept. The published tool is a standard-library-only Python 3
client that drives the full chain: it logs in, uploads a benign two-line
shell script through the multipart route, writes the argument payload into a
chosen row, activates the row, and reports; it verifies both the write and
the activation responses and exits non-zero with an explicit message at each
failure point. Target, credential, row id, marker command and timeouts are
arguments; the default target is loopback. No persistence, no reverse shell,
no destructive action; the default command writes a single marker file so
the outcome is observable without a second channel. Use it only against
systems you own or are authorised to test.
The vendor's product security team mailbox, published on the vendor's own
security advisories page, was used for the unconditional notification; no
report form was submitted and no individual was addressed by name. This
disclosure is unconditional: the research is published, no permission was
asked for, no embargo was requested, nothing is withheld pending a reply,
and remediation questions are answered at no cost. No vulnerability
identifier has been assigned to this finding.
Two companion advisories for the same product are published alongside this
one, independent findings that share only the entry architecture - a
different model file, REST resource, configuration field and sink each: an
IPsec tunnel address injection through the route-management shell commands,
and a scenario ping condition injection through the auto-executing ping
thread, both at the second and third URLs below.
Full technical analysis and the reproducible proof of concept, published
unconditionally:
https://0day-rubbish.com/blog/mar-2000-executer-program-argument-command-injection
Companion advisories for the same product, independent findings:
https://0day-rubbish.com/blog/mar-2000-network-ipsec-command-injection
https://0day-rubbish.com/blog/mar-2000-scenario-ping-command-injection
Project archive (ongoing disclosure series):
https://github.com/Exploit-Garbage/0day-Rubbish
--
0day Rubbish Research Team
disclosure () 0day-rubbish com
https://0day-rubbish.com
_______________________________________________
Sent through the Full Disclosure mailing list
https://nmap.org/mailman/listinfo/fulldisclosure
Web Archives & RSS: https://seclists.org/fulldisclosure/
Severity
No CVSS data available.
Assigner
References
9 references
Impacted products
1 product
| Vendor | Product | Version | |
|---|---|---|---|
| Moxa | MAR-2000 firmware |
Affected:
unknown
|
{
"containers": {
"cna": {
"affected": [
{
"product": "MAR-2000 firmware",
"vendor": "Moxa",
"versions": [
{
"status": "affected",
"version": "unknown"
}
]
}
],
"credits": [
{
"lang": "en",
"type": "finder",
"value": "disclosure via Fulldisclosure"
}
],
"descriptions": [
{
"lang": "en",
"value": "0day Rubbish Research Team is publicly disclosing a vulnerability in the Moxa\nMAR-2000 series industrial 4G/LTE cellular router, firmware image\nFWR_MAR2000_V1.0_Build_15010909, from Moxa Inc. (Taiwan). An authenticated\nadministrator converts one stored configuration field into arbitrary command\nexecution as the identity of the product\u0027s model process, because the\nExecuter model builds the launch command of an operator program as a shell\nstring whose program-argument column is never validated by any layer of the\nbackend. This is one of three independent command injection findings\ndocumented for this product and released together as a set.\n\nType and root cause. CWE-78, OS command injection, with CWE-20 co-equal, in\nthe Executer model at /home/model/system/executer/executer.py inside the\nARM Debian 6.0.8 root filesystem of the firmware, which runs the vendor\u0027s\nMIRF (Mobile Intelligent Routing Framework) stack: a Node.js Express 4.0\nmanagement application on port 80 bound to all interfaces, the express-sanji\nmiddleware bridging REST resources onto a local MQTT broker, and Python 2.6\nmodel scripts that persist configuration and act on it. The model stores\none row per operator program in an SQLite table whose columns include\nfileName and argument. On activation it assembles the command as\nstr(execute_file) + \" \" + str(argument) and launches it with\nsubprocess.Popen(full_command, shell=True, preexec_fn=os.setsid), where the\nrow\u0027s argument bytes are concatenated verbatim and shell=True delegates the\nparsing to /bin/sh: semicolons, background operators, pipes, backticks and\ncommand substitution all have their ordinary meaning. The value\u0027s\nprovenance is a database column set by an HTTP request: the row writer is\ngeneric, taking every key of the PUT /api/v1/system/executer/program/\u003cid\u003e\nrequest\u0027s data object and committing it with a plain SQL\nUPDATE ... SET ... statement, with no per-column semantics anywhere on the\nwrite path. The only gate on execution is a liveness check - the file must\nexist under the user-program directory - and the product\u0027s own multipart\nupload route, POST /api/v1/system/executer/program, satisfies it: the upload\napplies only a filename normalisation, with no allowed-type list and no file\nfilter. The chain is therefore: log in, upload a benign script through the\nproduct\u0027s own route, store \"; \u003ccommand\u003e; #\" in the row\u0027s argument field, and\nactivate the row with PUT /api/v1/system/executer/activatedProgram carrying\nprogramId and runBit 1. The shell runs the uploaded script first, the\nsemicolon ends it, the injected statement runs, and the trailing hash\ncomments out the rest of the line. The same model contains a second,\nstructurally identical sink in its deletion path: it builds\n\"rm -rf %s\" from the row\u0027s unvalidated fileName column and executes it with\nsubprocess.call(..., shell=True), guarded only by a comparison of the raw\nvalue against a single slash, which blocks exactly one value and nothing\nelse, and requires no upload and no activation.\n\nThe two-request chain looks like this after login:\n\n```\n[1] POST /api/v1/system/executer/program multipart, benign script\n -\u003e stored under the user-program directory\n[2] PUT /api/v1/system/executer/program/\u003cid\u003e\n {\"data\": {\"fileName\": \"\u003cuploaded basename\u003e\",\n \"argument\": \"; \u003ccommand\u003e; #\"}}\n -\u003e generic row writer commits both columns verbatim (SQLite)\n[3] PUT /api/v1/system/executer/activatedProgram\n {\"data\": {\"programId\": \u003cid\u003e, \"runBit\": 1}}\n -\u003e Popen(\"\u003cdir\u003e/\u003cfile\u003e ; \u003ccommand\u003e; #\", shell=True)\n```\n\nAuthentication and reach. The validateUser middleware is the only\nauthentication check on the REST surface: it requires a server-side session\nfor every non-GET method, and login is POST /api/login compared against\nbcrypt-hashed entries in the SQLite user table. Past that check there is no\nsecond authorisation layer - the message bridge performs no permission\ntranslation and the broker leg carries no identity - so the product\u0027s single\ndocumented role, the device administrator, is the whole security boundary.\nThe listener binds all interfaces on port 80 in the shipped firmware; no\nWAN exposure is assumed anywhere in the published rating.\n\nSeverity. The published score is 7.2 High,\nCVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, from ISS = 0.914816, impact\n5.873119, exploitability 1.234708 and base 7.107826 rounded up to 7.2,\nPrivileges Required High being the product\u0027s single administrator role. A\nlabelled conditional and never the headline: where a deployment still runs\nthe factory default administrator pair carried by the shipped firmware\u0027s\nSQLite user table, the prerequisite collapses and the chain reads 9.8\nCritical on the PR:N vector (exploitability 3.887043, base 9.760161); a\nchanged credential removes it, and the default pair is disclosed as a\nseparate weakness, never folded into the published vector. A PR:L reading\nof 8.8 High is published only as the arithmetic of the rejected variant. The\nscore provenance is disclosed in public: the research record behind this\nadvisory carried 8.8 for all three same-product findings, that figure is the\narithmetic of a PR:L vector, no artefact shows a lower-privileged product\nrole, and every published number was recomputed from its own vector - which\nlowered the researchers\u0027 own figure by 1.6 points. A Scope-Changed reading\ncomputes to 9.1 and is deliberately not published, because the model\nprocess belongs to the same single-purpose appliance authority, and\ncommanding the appliance\u0027s own operating system through its management\nplane is the product\u0027s design rather than an escape.\n\nVerification method, and its boundary. Two evidence classes carry the\nfinding, kept separate in the published advisory. The firmware\u0027s own\napplication sources establish the entry path, the storage semantics and the\nexact sink construction, read from the shipped files. The dynamic layer is\na sink-level replication on an isolated cloud Linux sandbox: the model\u0027s\nexact concatenation with the shell=True launch, carrying a benign upload\nstand-in, an injection payload and a benign control; with the payload in the\nargument position a marker file containing uid=0(root) was created, and the\ncontrol produced the benign program launch and nothing else. The deletion\nconstruction was replicated with the same method and also produced its\nmarker. The boundary is stated plainly: end-to-end detonation against\npowered-on hardware is outside this research record, and the identity of the\nmodel process on the device was neither measured nor claimed - uid=0(root)\nis the replication sandbox\u0027s identity and nothing broader rests on it.\n\nImpact. Arbitrary command execution as the identity of the Python model\nprocess, begun by one authenticated configuration write and one activation\nrequest, with no memory corruption and no protocol manipulation in the\nchain. The command line is a stored configuration value that persists across\nreboots and re-executes on every activation of the row, so the payload is\nreboot-durable without persistence work by the attacker. The deletion sink\nextends the class to a field reachable without any upload and allows\ndestructive filesystem operations wherever the injected metacharacters\nlead. The compromise yields the router\u0027s complete configuration, control of\nits forwarding and cellular function, and availability at will over a\ndevice deployed as communication infrastructure. The two requests that\nmatter are indistinguishable in shape from ordinary administrator activity,\nso the readable signals are content-level: program rows whose argument\ncontains shell metacharacters, unexpected files in the user-program\ndirectory, unexpected child processes under the model daemon. The web\nstack\u0027s separate property of answering unauthenticated GET requests across\nthe API surface is a read-exposure issue reported on its own and is not\npart of this chain.\n\nRemediation: execute activated programs without a shell, with the\nexecutable path and the argument as separate execv-style arguments; validate\nthe argument at the row-write boundary in the model rather than only in a\nweb form; constrain fileName to the set of stored uploads and associate rows\nto files by an opaque server-side handle; rebuild the deletion path with an\nargument vector; restrict the multipart upload to executable-basename types\nand add a regression test that writes a metacharacter-bearing argument,\nactivates the row, and asserts rejection at write time or execution without\nshell interpretation. Operators until a patch exists: change the factory\ndefault administrator credential at commissioning, keep the management\nlistener off WAN-facing addresses, audit the program table and user-program\ndirectory on a schedule, and disable the Executer feature where operator\nprograms are not used.\n\nProof of concept. The published tool is a standard-library-only Python 3\nclient that drives the full chain: it logs in, uploads a benign two-line\nshell script through the multipart route, writes the argument payload into a\nchosen row, activates the row, and reports; it verifies both the write and\nthe activation responses and exits non-zero with an explicit message at each\nfailure point. Target, credential, row id, marker command and timeouts are\narguments; the default target is loopback. No persistence, no reverse shell,\nno destructive action; the default command writes a single marker file so\nthe outcome is observable without a second channel. Use it only against\nsystems you own or are authorised to test.\n\nThe vendor\u0027s product security team mailbox, published on the vendor\u0027s own\nsecurity advisories page, was used for the unconditional notification; no\nreport form was submitted and no individual was addressed by name. This\ndisclosure is unconditional: the research is published, no permission was\nasked for, no embargo was requested, nothing is withheld pending a reply,\nand remediation questions are answered at no cost. No vulnerability\nidentifier has been assigned to this finding.\n\nTwo companion advisories for the same product are published alongside this\none, independent findings that share only the entry architecture - a\ndifferent model file, REST resource, configuration field and sink each: an\nIPsec tunnel address injection through the route-management shell commands,\nand a scenario ping condition injection through the auto-executing ping\nthread, both at the second and third URLs below.\n\nFull technical analysis and the reproducible proof of concept, published\nunconditionally:\n https://0day-rubbish.com/blog/mar-2000-executer-program-argument-command-injection\n\nCompanion advisories for the same product, independent findings:\n https://0day-rubbish.com/blog/mar-2000-network-ipsec-command-injection\n https://0day-rubbish.com/blog/mar-2000-scenario-ping-command-injection\n\nProject archive (ongoing disclosure series):\n https://github.com/Exploit-Garbage/0day-Rubbish\n\n--\n0day Rubbish Research Team\ndisclosure () 0day-rubbish com\nhttps://0day-rubbish.com\n_______________________________________________\nSent through the Full Disclosure mailing list\nhttps://nmap.org/mailman/listinfo/fulldisclosure\nWeb Archives \u0026 RSS: https://seclists.org/fulldisclosure/"
}
],
"problemTypes": [
{
"descriptions": [
{
"cweId": "CWE-20",
"description": "CWE-20",
"lang": "en",
"type": "CWE"
},
{
"cweId": "CWE-78",
"description": "CWE-78",
"lang": "en",
"type": "CWE"
}
]
}
],
"providerMetadata": {
"dateUpdated": "2026-11-02T07:30:04Z",
"orgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
"shortName": "VULNARCHIVE"
},
"references": [
{
"tags": [
"technical-description",
"exploit"
],
"url": "https://vuln.freearchive.org/archive/full-disclosure/2026/Oct/52"
},
{
"tags": [
"technical-description"
],
"url": "https://seclists.org/fulldisclosure/2026/Oct/52"
},
{
"url": "https://0day-rubbish.com"
},
{
"url": "https://0day-rubbish.com/blog/mar-2000-executer-program-argument-command-injection"
},
{
"url": "https://0day-rubbish.com/blog/mar-2000-network-ipsec-command-injection"
},
{
"url": "https://0day-rubbish.com/blog/mar-2000-scenario-ping-command-injection"
},
{
"url": "https://github.com/Exploit-Garbage/0day-Rubbish"
},
{
"url": "https://nmap.org/mailman/listinfo/fulldisclosure"
},
{
"url": "https://seclists.org/fulldisclosure/"
}
],
"source": {
"defect": [
"https://seclists.org/fulldisclosure/2026/Oct/52"
],
"discovery": "EXTERNAL"
},
"title": "[0day-rubbish] Moxa MAR-2000 firmware FWR_MAR2000_V1.0_Build_15010909 command injection in the Executer program activation path (7.2)",
"x_gcve": [
{
"recordType": "advisory",
"relationships": [],
"vulnId": "GCVE-1988-2026-0502",
"x_vulnarchive": {
"archiveUrl": "https://vuln.freearchive.org/archive/full-disclosure/2026/Oct/52",
"automated": true,
"contentSha256": "2411179a70ba593d7df9352ac3f4c930deb26f30d8f08c87c5a00196a05d3527",
"evidenceScore": 11,
"messageId": "",
"originalUrl": "https://seclists.org/fulldisclosure/2026/Oct/52",
"policy": "vulnarchive-1",
"sourceFormat": "text/html",
"sourcePublishedAt": "2026-10-27T16:38:41Z"
}
}
]
}
},
"cveMetadata": {
"assignerOrgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
"assignerShortName": "VULNARCHIVE",
"datePublished": "2026-11-02T07:30:04Z",
"dateUpdated": "2026-11-02T07:30:04Z",
"state": "PUBLISHED",
"vulnId": "GCVE-1988-2026-0502"
},
"dataType": "CVE_RECORD",
"dataVersion": "5.2"
}
GCVE-1988-2026-0504
Vulnerability from gna-1988 – Published: 2026-11-02 07:30 – Updated: 2026-11-02 07:30
VLAI
EPSS
VEX
Title
[0day-rubbish] Moxa MAR-2000 firmware FWR_MAR2000_V1.0_Build_15010909 scenario ping condition command injection through the auto-executing ping thread (7.2)
Summary
0day Rubbish Research Team is publicly disclosing a vulnerability in the Moxa
MAR-2000 series industrial 4G/LTE cellular router, firmware image
FWR_MAR2000_V1.0_Build_15010909, from Moxa Inc. (Taiwan). An authenticated
administrator converts one saved monitoring-condition field into recurring,
product-scheduled arbitrary command execution, because the thread that
implements the scenario ping condition builds its command line from the
condition's stored parameter values and hands them to a shell, and no layer
of the backend inspects what those values hold. The delivery needs no second
request: the product's own scenario watchdog evaluates the condition on its
schedule, which also makes the payload recur on every evaluation cycle until
the condition is deleted. This is one of three independent command injection
findings documented for this product and released together as a set.
Type and root cause. CWE-78, OS command injection, with CWE-20 co-equal, in
the Scenario model at /home/model/scenario/scenario.py inside the ARM
Debian 6.0.8 root filesystem of the firmware, which runs the vendor's MIRF
(Mobile Intelligent Routing Framework) stack: a Node.js Express 4.0
management application on port 80 bound to all interfaces, the express-sanji
middleware bridging REST resources onto a local MQTT broker, and Python 2.6
model scripts that persist configuration and act on it. The scenario
facility is how an operator automates behaviour on a schedule; a condition
of type ping is the canonical connectivity check. A saved ping condition
carries a parameter object with ip (required), interface (defaulting to
eth0) and times (defaulting to 3). When the watchdog reaches the condition
it starts a background thread whose run method assembles
```
cmd = "ping %s -c 1 -w 5 -I %s " % (ip, interface)
subprocess.Popen(cmd, shell=True, stdout=PIPE, stderr=PIPE)
```
The interpolation is textual into a single string handed to /bin/sh, so the
stored bytes are parsed as command syntax, and both stored fields - ip and
interface - sit in operand positions of the same template, giving two
stored fields of one class inside one condition. The values got there
through PUT /api/v1/scenario, where the model's put handler validates only
that the submitted data object exists and is non-empty. No parameter value
is examined at any layer of the stack: not by the Express middleware, not
by the message translation, not on the broker leg, not at storage, and not
when the thread reads the condition back.
Two payload-engineering results are published with the finding because they
were measured, not intuited. The template places the stored ip value before
the -c 1 and -w 5 flags, so the naive semicolon form that works against
several other sinks does not fit here: it splits the line in front of the
count flag, leaves an unbounded ping in the foreground of the evaluating
thread, and in the replication record the marker never appeared before the
thread was torn down. The two verified forms are a command substitution,
which the shell expands during command expansion before the ping binary even
starts and whose expansion result is discarded into the ping operand, and a
newline separator, which leaves the ping its own line with the flags intact
and runs the injected text as a second command line. The failing form is
also a finding in its own right: the same unvalidated field, used with the
naive form, turns the monitoring thread into a blocked thread - a
denial-of-service lever against the product's scenario machinery.
The one-request chain looks like this after login:
```
PUT /api/v1/scenario
{"data": {"condition": [{
"name": "connectivity_check",
"type": "ping",
"parameter": {
"ip": "$(id > <marker>)",
"interface": "eth0",
"times": 3
}}]}}
-> stored verbatim (the put handler checks only that data exists,
is non-empty); the watchdog's next evaluation starts the thread
-> cmd = "ping $(id > <marker>) -c 1 -w 5 -I eth0 "
-> the shell expands the substitution before ping execs; the
marker carries the proof, ping then exits quickly, and the
condition re-evaluates on the next cycle
```
Authentication and reach. The validateUser middleware is the only
authentication check on the REST surface: it requires a server-side session
for every non-GET method, and login is POST /api/login compared against
bcrypt-hashed entries in the SQLite user table. The PUT that stores the
payload requires the session; past that check there is no second
authorisation layer, the broker leg carries no identity, and the model
implements no permission judgement, so the product's single documented
role, the device administrator, is the whole security boundary. The
listener binds all interfaces on port 80 in the shipped firmware; no WAN
exposure is assumed anywhere in the published rating.
Severity. The published score is 7.2 High,
CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, from ISS = 0.914816, impact
5.873119, exploitability 1.234708 and base 7.107826 rounded up to 7.2,
Privileges Required High being the product's single administrator role. A
labelled conditional and never the headline: where a deployment still runs
the factory default administrator pair carried by the shipped firmware's
SQLite user table, the prerequisite collapses and the chain reads 9.8
Critical on the PR:N vector (exploitability 3.887043, base 9.760161); a
changed credential removes it, and the default pair is disclosed as a
separate weakness, never folded into the published vector. A PR:L reading
of 8.8 High is published only as the arithmetic of the rejected variant.
The score provenance is disclosed in public: the research record behind
this advisory carried 8.8 for all three same-product findings, that figure
is the arithmetic of a PR:L vector, no artefact shows a lower-privileged
product role, and every published number was recomputed from its own
vector - which lowered the researchers' own figure by 1.6 points. A
Scope-Changed reading computes to 9.1 and is deliberately not published,
because the model process belongs to the same single-purpose appliance
authority, and running scheduled monitoring through the management plane
is the product's design rather than an escape.
Verification method, and its boundary. Two evidence classes carry the
finding, kept separate in the published advisory. The firmware's own
application sources establish the scenario write path, the write handler's
validation scope and the thread construction, read from the shipped files.
The dynamic layer is a sink-level replication on an isolated cloud Linux
sandbox: the exact template with the same shell=True launch and both pipes
captured, executed under the substitution form, the newline form, the naive
semicolon form and a benign control. Both verified forms produced a marker
file containing uid=0(root); the naive form produced no marker in the tested
window, for the unbounded-ping reason described above; the control ran a
normal bounded ping and produced nothing. The boundary is stated plainly:
end-to-end detonation against powered-on hardware, including the
watchdog's exact evaluation interval, is outside this research record, and
the on-device model process identity was neither measured nor claimed -
uid=0(root) is the replication sandbox's identity and nothing broader
rests on it.
Impact. Recurring arbitrary command execution as the identity of the
Python model process, begun by one authenticated configuration write and
delivered by the product's own periodic evaluation. The execution is not a
one-shot and needs no persistence work: the saved condition re-evaluates on
every cycle until deleted, and the payload survives reboots because it is
stored configuration, so deleting the malicious condition is the only
ordinary remediation short of a patch. The compromise yields the router's
complete configuration, control of the monitoring-as-automation features on
a device deployed as communication infrastructure, and availability at
will. Detection is structurally quiet - the executing process is the
product's own monitoring thread - so the readable signals are
content-level: a saved ping condition whose ip or interface contains a
dollar-parenthesis, semicolon, pipe, backtick or newline; ping processes
running with no count flag; unexpected child processes under the model
daemon. The web stack's separate property of answering unauthenticated GET
requests across the API surface - which lets an intruder enumerate saved
scenarios, including a poisoned one, without a login - is a read-exposure
issue reported on its own and is not part of this chain.
Remediation: run the connectivity check without a shell, as an argument
vector or library call, which removes the metacharacter question from the
thread entirely and eliminates the unbounded-ping failure mode; validate
condition parameters at the model's write boundary where they are stored -
address form for ip, interface selector form for interface, bounded numeric
for times; reject failing conditions rather than storing them for the
watchdog; give the evaluation machinery a failure budget, reaping threads
that outlive it and logging evaluations that produce unexpected process
trees; and treat the recurring property as a design rule: any value a
scheduled reaction will eventually consume must be validated at store
time, because the schedule converts a stored input into an automatically
repeated one. Operators until a patch exists: change the factory default
administrator credential at commissioning, keep the management listener
off WAN-facing addresses, sweep saved scenarios for ping conditions with
metacharacter-bearing parameters, and disable the scenario feature where
scheduled monitoring is not used.
Proof of concept. The published tool is a standard-library-only Python 3
client that drives the entry path: it logs in, reads the current scenario
configuration, saves a ping condition whose parameter.ip carries the
substitution-form payload, and reports what the condition will do on the
next evaluation. It takes target, credential, command and timeout
arguments; the default target is loopback; it verifies each response and
exits non-zero with an explicit message on failure. It deliberately does
not attempt to compute or drive the watchdog's interval. No persistence,
reverse shell or destructive step; the default command writes one marker
file. Use it only against systems you own or are authorised to test.
The vendor's product security team mailbox, published on the vendor's own
security advisories page, was used for the unconditional notification; no
report form was submitted and no individual was addressed by name. This
disclosure is unconditional: the research is published, no permission was
asked for, no embargo was requested, nothing is withheld pending a reply,
and remediation questions are answered at no cost. No vulnerability
identifier has been assigned to this finding.
Two companion advisories for the same product are published alongside this
one, independent findings that share only the entry architecture - a
different model file, REST resource, configuration field and sink each: an
Executer program-activation injection through the stored argument field of
a shell-interpreted program launch, and an IPsec tunnel address injection
through the route-management shell commands, both at the second and third
URLs below.
Full technical analysis and the reproducible proof of concept, published
unconditionally:
https://0day-rubbish.com/blog/mar-2000-scenario-ping-command-injection
Companion advisories for the same product, independent findings:
https://0day-rubbish.com/blog/mar-2000-executer-program-argument-command-injection
https://0day-rubbish.com/blog/mar-2000-network-ipsec-command-injection
Project archive (ongoing disclosure series):
https://github.com/Exploit-Garbage/0day-Rubbish
--
0day Rubbish Research Team
disclosure () 0day-rubbish com
https://0day-rubbish.com
________________
Severity
No CVSS data available.
Assigner
References
9 references
Impacted products
1 product
| Vendor | Product | Version | |
|---|---|---|---|
| Moxa | MAR-2000 firmware |
Affected:
unknown
|
{
"containers": {
"cna": {
"affected": [
{
"product": "MAR-2000 firmware",
"vendor": "Moxa",
"versions": [
{
"status": "affected",
"version": "unknown"
}
]
}
],
"credits": [
{
"lang": "en",
"type": "finder",
"value": "disclosure via Fulldisclosure"
}
],
"descriptions": [
{
"lang": "en",
"value": "0day Rubbish Research Team is publicly disclosing a vulnerability in the Moxa\nMAR-2000 series industrial 4G/LTE cellular router, firmware image\nFWR_MAR2000_V1.0_Build_15010909, from Moxa Inc. (Taiwan). An authenticated\nadministrator converts one saved monitoring-condition field into recurring,\nproduct-scheduled arbitrary command execution, because the thread that\nimplements the scenario ping condition builds its command line from the\ncondition\u0027s stored parameter values and hands them to a shell, and no layer\nof the backend inspects what those values hold. The delivery needs no second\nrequest: the product\u0027s own scenario watchdog evaluates the condition on its\nschedule, which also makes the payload recur on every evaluation cycle until\nthe condition is deleted. This is one of three independent command injection\nfindings documented for this product and released together as a set.\n\nType and root cause. CWE-78, OS command injection, with CWE-20 co-equal, in\nthe Scenario model at /home/model/scenario/scenario.py inside the ARM\nDebian 6.0.8 root filesystem of the firmware, which runs the vendor\u0027s MIRF\n(Mobile Intelligent Routing Framework) stack: a Node.js Express 4.0\nmanagement application on port 80 bound to all interfaces, the express-sanji\nmiddleware bridging REST resources onto a local MQTT broker, and Python 2.6\nmodel scripts that persist configuration and act on it. The scenario\nfacility is how an operator automates behaviour on a schedule; a condition\nof type ping is the canonical connectivity check. A saved ping condition\ncarries a parameter object with ip (required), interface (defaulting to\neth0) and times (defaulting to 3). When the watchdog reaches the condition\nit starts a background thread whose run method assembles\n\n```\ncmd = \"ping %s -c 1 -w 5 -I %s \" % (ip, interface)\nsubprocess.Popen(cmd, shell=True, stdout=PIPE, stderr=PIPE)\n```\n\nThe interpolation is textual into a single string handed to /bin/sh, so the\nstored bytes are parsed as command syntax, and both stored fields - ip and\ninterface - sit in operand positions of the same template, giving two\nstored fields of one class inside one condition. The values got there\nthrough PUT /api/v1/scenario, where the model\u0027s put handler validates only\nthat the submitted data object exists and is non-empty. No parameter value\nis examined at any layer of the stack: not by the Express middleware, not\nby the message translation, not on the broker leg, not at storage, and not\nwhen the thread reads the condition back.\n\nTwo payload-engineering results are published with the finding because they\nwere measured, not intuited. The template places the stored ip value before\nthe -c 1 and -w 5 flags, so the naive semicolon form that works against\nseveral other sinks does not fit here: it splits the line in front of the\ncount flag, leaves an unbounded ping in the foreground of the evaluating\nthread, and in the replication record the marker never appeared before the\nthread was torn down. The two verified forms are a command substitution,\nwhich the shell expands during command expansion before the ping binary even\nstarts and whose expansion result is discarded into the ping operand, and a\nnewline separator, which leaves the ping its own line with the flags intact\nand runs the injected text as a second command line. The failing form is\nalso a finding in its own right: the same unvalidated field, used with the\nnaive form, turns the monitoring thread into a blocked thread - a\ndenial-of-service lever against the product\u0027s scenario machinery.\n\nThe one-request chain looks like this after login:\n\n```\nPUT /api/v1/scenario\n{\"data\": {\"condition\": [{\n \"name\": \"connectivity_check\",\n \"type\": \"ping\",\n \"parameter\": {\n \"ip\": \"$(id \u003e \u003cmarker\u003e)\",\n \"interface\": \"eth0\",\n \"times\": 3\n }}]}}\n-\u003e stored verbatim (the put handler checks only that data exists,\n is non-empty); the watchdog\u0027s next evaluation starts the thread\n-\u003e cmd = \"ping $(id \u003e \u003cmarker\u003e) -c 1 -w 5 -I eth0 \"\n-\u003e the shell expands the substitution before ping execs; the\n marker carries the proof, ping then exits quickly, and the\n condition re-evaluates on the next cycle\n```\n\nAuthentication and reach. The validateUser middleware is the only\nauthentication check on the REST surface: it requires a server-side session\nfor every non-GET method, and login is POST /api/login compared against\nbcrypt-hashed entries in the SQLite user table. The PUT that stores the\npayload requires the session; past that check there is no second\nauthorisation layer, the broker leg carries no identity, and the model\nimplements no permission judgement, so the product\u0027s single documented\nrole, the device administrator, is the whole security boundary. The\nlistener binds all interfaces on port 80 in the shipped firmware; no WAN\nexposure is assumed anywhere in the published rating.\n\nSeverity. The published score is 7.2 High,\nCVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, from ISS = 0.914816, impact\n5.873119, exploitability 1.234708 and base 7.107826 rounded up to 7.2,\nPrivileges Required High being the product\u0027s single administrator role. A\nlabelled conditional and never the headline: where a deployment still runs\nthe factory default administrator pair carried by the shipped firmware\u0027s\nSQLite user table, the prerequisite collapses and the chain reads 9.8\nCritical on the PR:N vector (exploitability 3.887043, base 9.760161); a\nchanged credential removes it, and the default pair is disclosed as a\nseparate weakness, never folded into the published vector. A PR:L reading\nof 8.8 High is published only as the arithmetic of the rejected variant.\nThe score provenance is disclosed in public: the research record behind\nthis advisory carried 8.8 for all three same-product findings, that figure\nis the arithmetic of a PR:L vector, no artefact shows a lower-privileged\nproduct role, and every published number was recomputed from its own\nvector - which lowered the researchers\u0027 own figure by 1.6 points. A\nScope-Changed reading computes to 9.1 and is deliberately not published,\nbecause the model process belongs to the same single-purpose appliance\nauthority, and running scheduled monitoring through the management plane\nis the product\u0027s design rather than an escape.\n\nVerification method, and its boundary. Two evidence classes carry the\nfinding, kept separate in the published advisory. The firmware\u0027s own\napplication sources establish the scenario write path, the write handler\u0027s\nvalidation scope and the thread construction, read from the shipped files.\nThe dynamic layer is a sink-level replication on an isolated cloud Linux\nsandbox: the exact template with the same shell=True launch and both pipes\ncaptured, executed under the substitution form, the newline form, the naive\nsemicolon form and a benign control. Both verified forms produced a marker\nfile containing uid=0(root); the naive form produced no marker in the tested\nwindow, for the unbounded-ping reason described above; the control ran a\nnormal bounded ping and produced nothing. The boundary is stated plainly:\nend-to-end detonation against powered-on hardware, including the\nwatchdog\u0027s exact evaluation interval, is outside this research record, and\nthe on-device model process identity was neither measured nor claimed -\nuid=0(root) is the replication sandbox\u0027s identity and nothing broader\nrests on it.\n\nImpact. Recurring arbitrary command execution as the identity of the\nPython model process, begun by one authenticated configuration write and\ndelivered by the product\u0027s own periodic evaluation. The execution is not a\none-shot and needs no persistence work: the saved condition re-evaluates on\nevery cycle until deleted, and the payload survives reboots because it is\nstored configuration, so deleting the malicious condition is the only\nordinary remediation short of a patch. The compromise yields the router\u0027s\ncomplete configuration, control of the monitoring-as-automation features on\na device deployed as communication infrastructure, and availability at\nwill. Detection is structurally quiet - the executing process is the\nproduct\u0027s own monitoring thread - so the readable signals are\ncontent-level: a saved ping condition whose ip or interface contains a\ndollar-parenthesis, semicolon, pipe, backtick or newline; ping processes\nrunning with no count flag; unexpected child processes under the model\ndaemon. The web stack\u0027s separate property of answering unauthenticated GET\nrequests across the API surface - which lets an intruder enumerate saved\nscenarios, including a poisoned one, without a login - is a read-exposure\nissue reported on its own and is not part of this chain.\n\nRemediation: run the connectivity check without a shell, as an argument\nvector or library call, which removes the metacharacter question from the\nthread entirely and eliminates the unbounded-ping failure mode; validate\ncondition parameters at the model\u0027s write boundary where they are stored -\naddress form for ip, interface selector form for interface, bounded numeric\nfor times; reject failing conditions rather than storing them for the\nwatchdog; give the evaluation machinery a failure budget, reaping threads\nthat outlive it and logging evaluations that produce unexpected process\ntrees; and treat the recurring property as a design rule: any value a\nscheduled reaction will eventually consume must be validated at store\ntime, because the schedule converts a stored input into an automatically\nrepeated one. Operators until a patch exists: change the factory default\nadministrator credential at commissioning, keep the management listener\noff WAN-facing addresses, sweep saved scenarios for ping conditions with\nmetacharacter-bearing parameters, and disable the scenario feature where\nscheduled monitoring is not used.\n\nProof of concept. The published tool is a standard-library-only Python 3\nclient that drives the entry path: it logs in, reads the current scenario\nconfiguration, saves a ping condition whose parameter.ip carries the\nsubstitution-form payload, and reports what the condition will do on the\nnext evaluation. It takes target, credential, command and timeout\narguments; the default target is loopback; it verifies each response and\nexits non-zero with an explicit message on failure. It deliberately does\nnot attempt to compute or drive the watchdog\u0027s interval. No persistence,\nreverse shell or destructive step; the default command writes one marker\nfile. Use it only against systems you own or are authorised to test.\n\nThe vendor\u0027s product security team mailbox, published on the vendor\u0027s own\nsecurity advisories page, was used for the unconditional notification; no\nreport form was submitted and no individual was addressed by name. This\ndisclosure is unconditional: the research is published, no permission was\nasked for, no embargo was requested, nothing is withheld pending a reply,\nand remediation questions are answered at no cost. No vulnerability\nidentifier has been assigned to this finding.\n\nTwo companion advisories for the same product are published alongside this\none, independent findings that share only the entry architecture - a\ndifferent model file, REST resource, configuration field and sink each: an\nExecuter program-activation injection through the stored argument field of\na shell-interpreted program launch, and an IPsec tunnel address injection\nthrough the route-management shell commands, both at the second and third\nURLs below.\n\nFull technical analysis and the reproducible proof of concept, published\nunconditionally:\n https://0day-rubbish.com/blog/mar-2000-scenario-ping-command-injection\n\nCompanion advisories for the same product, independent findings:\n https://0day-rubbish.com/blog/mar-2000-executer-program-argument-command-injection\n https://0day-rubbish.com/blog/mar-2000-network-ipsec-command-injection\n\nProject archive (ongoing disclosure series):\n https://github.com/Exploit-Garbage/0day-Rubbish\n\n--\n0day Rubbish Research Team\ndisclosure () 0day-rubbish com\nhttps://0day-rubbish.com\n________________"
}
],
"problemTypes": [
{
"descriptions": [
{
"cweId": "CWE-20",
"description": "CWE-20",
"lang": "en",
"type": "CWE"
},
{
"cweId": "CWE-78",
"description": "CWE-78",
"lang": "en",
"type": "CWE"
}
]
}
],
"providerMetadata": {
"dateUpdated": "2026-11-02T07:30:04Z",
"orgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
"shortName": "VULNARCHIVE"
},
"references": [
{
"tags": [
"technical-description",
"exploit"
],
"url": "https://vuln.freearchive.org/archive/full-disclosure/2026/Oct/55"
},
{
"tags": [
"technical-description"
],
"url": "https://seclists.org/fulldisclosure/2026/Oct/55"
},
{
"url": "https://0day-rubbish.com"
},
{
"url": "https://0day-rubbish.com/blog/mar-2000-executer-program-argument-command-injection"
},
{
"url": "https://0day-rubbish.com/blog/mar-2000-network-ipsec-command-injection"
},
{
"url": "https://0day-rubbish.com/blog/mar-2000-scenario-ping-command-injection"
},
{
"url": "https://github.com/Exploit-Garbage/0day-Rubbish"
},
{
"url": "https://nmap.org/mailman/listinfo/fulldisclosure"
},
{
"url": "https://seclists.org/fulldisclosure/"
}
],
"source": {
"defect": [
"https://seclists.org/fulldisclosure/2026/Oct/55"
],
"discovery": "EXTERNAL"
},
"title": "[0day-rubbish] Moxa MAR-2000 firmware FWR_MAR2000_V1.0_Build_15010909 scenario ping condition command injection through the auto-executing ping thread (7.2)",
"x_gcve": [
{
"recordType": "advisory",
"relationships": [],
"vulnId": "GCVE-1988-2026-0504",
"x_vulnarchive": {
"archiveUrl": "https://vuln.freearchive.org/archive/full-disclosure/2026/Oct/55",
"automated": true,
"contentSha256": "bd54cb1f0a8d0dd62a3289db8dbbbe1fa1b09ce63a65c32cabfb1d0b13740ba0",
"evidenceScore": 11,
"messageId": "",
"originalUrl": "https://seclists.org/fulldisclosure/2026/Oct/55",
"policy": "vulnarchive-1",
"sourceFormat": "text/html",
"sourcePublishedAt": "2026-10-27T16:39:17Z"
}
}
]
}
},
"cveMetadata": {
"assignerOrgId": "4e2abfbf-4a2a-4b76-a4e0-d77c18ba156c",
"assignerShortName": "VULNARCHIVE",
"datePublished": "2026-11-02T07:30:04Z",
"dateUpdated": "2026-11-02T07:30:04Z",
"state": "PUBLISHED",
"vulnId": "GCVE-1988-2026-0504"
},
"dataType": "CVE_RECORD",
"dataVersion": "5.2"
}