Where
-Infinity
0

Vendor Risk Score

See how codewhale compares to other vendors in security performance

View Risk Score →
Severity
7.5
AV:N/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H

CodeWhale is a DeepSeek and MiMo coding agent for the terminal. Prior to 0.9.0, DEFAULTAUTOMATIONAUTOAPPROVE caused AutomationRecord::taskautoapprove to resolve an omitted setting to true, and the automationcreate schema advertised the same insecure default. enqueueruntask converted that omission into an explicit true value, bypassing the safer task-path fallback and selecting ApprovalMode::Bypass for each scheduled run. After a user approved creation of an apparently benign recurring automation, subsequent executions could silently authorize mutating tools without a human present, and an automation created with shell access could repeatedly execute commands. This issue is fixed in version 0.9.0.

First published (updated )
Severity
8.1
OS Command Injection
AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H

CodeWhale is a DeepSeek and MiMo coding agent for the terminal. Prior to 0.9.0, the ExecShellTool::approvalrequirementfor path used isparallelreadonlycommand to downgrade commands to automatic approval based on a flag-stripped command allowlist. The allowlist treated fd, rg, and git grep as read-only even when fd -x or fd --exec, rg --pre, or git grep --open-files-in-pager selected an external program. registeredtoolapprovalrequired returned without displaying a prompt for that automatic classification, and the later command-safety check also treated the base utilities as safe. Attacker-controlled content that influenced an agent tool call could therefore cause arbitrary program execution on the developer host without the approval promised by the default interactive profile, resulting in unauthorized access, modification, or disruption. This issue is fixed in version 0.9.0.

First published (updated )
Severity
8.7
Path Traversal
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N

Maintainer resolution

The CodeWhale maintainers validated this report. The affected package ranges are recorded in the advisory metadata. Version 0.8.64 contains the fix in commit 26de44a8bd5051f8f944ea60b2c37ae1d2b7d25e. Users should upgrade to 0.8.64 or later. The original reporter analysis is preserved below.

Summary

imageanalyze follows workspace symlinks and leaks outside-workspace file bytes to the vision endpoint

The imageanalyze tool resolves its imagepath with a bare context.workspace.join instead of routing through ToolContext::resolvepath. The pre-join lexical check rejects absolute paths, Windows prefixes, and parent-dir components but never canonicalizes, so a symlink inside the workspace whose name ends in an image extension and whose target sits outside the workspace is read transparently. The tool has ReadOnly capability and the trait default makes it auto-approved, so the bypass executes with no user prompt.

Details

In crates/tui/src/vision/tools.rs (v0.8.37, lines 104-123):

rust async fn execute(&self, input: Value, context: &ToolContext) -> Result<ToolResult, ToolError> { let imagepath = requiredstr(&input, "imagepath")?; let prompt = input .get("prompt") .andthen(|v| v.asstr()) .unwrapor("Describe this image in detail.");

let imagepathbuf = Path::new(imagepath); if imagepathbuf.components().any(|c| { matches!( c, Component::Prefix() | Component::RootDir | Component::ParentDir ) }) { return Err(ToolError::executionfailed( "imagepath must be a relative path within the workspace and cannot escape it.", )); } let resolvedpath = context.workspace.join(imagepathbuf); let (imagedata, mimetype) = Self::readimagefile(&resolvedpath).await?;

readimagefile (lines 31-39) is a tokio::fs::read(path) call which follows symlinks. The bytes are then base64-encoded and embedded as data:<mime>;base64,<bytes> in the chat-completion payload that is POSTed to ${baseurl}/chat/completions with the user's Authorization header.

The lexical guard rejects ../etc/passwd, /etc/passwd, and C:\Windows\..., but a symlink such as workspace/screenshot.png -> /etc/passwd produces components [Normal("screenshot.png")]. None of Prefix, RootDir, or ParentDir match, so the check passes and the symlink is followed at read time.

The peer file-reading tools all use the central resolver instead. For example, crates/tui/src/tools/imageocr.rs:60-65:

rust let pathstr = requiredstr(&input, "path")?; let imagepath = context.resolvepath(pathstr)?;

resolvepath in crates/tui/src/tools/spec.rs:342-449 canonicalizes the candidate and rejects results whose canonical form does not start with the canonical workspace path:

rust if candidate.exists() { let canonical = candidate.canonicalize().maperr(...)?; if !canonical.startswith(&workspacecanonical) && !self.istrustedexternalpath(&canonical) { return Err(ToolError::PathEscape { path: canonical }); } ... }

In the same symlink scenario, imageocr, pandocconvert, readfile, applypatch, rlmopen, and fim all return ToolError::PathEscape because the canonical target falls outside the workspace. imageanalyze is the lone caller that skips this check.

The tool declares ToolCapability::ReadOnly and does not override approvalrequirement(). The trait default (crates/tui/src/tools/spec.rs:612-620) resolves ReadOnly to ApprovalRequirement::Auto. The engine then sets approvalrequired = spec.approvalrequirement() != ApprovalRequirement::Auto, which is false for this tool (crates/tui/src/core/engine/turnloop.rs:1159-1184). The model can invoke imageanalyze on any turn without a user prompt.

The recent commit 2326220 fix(vision): reject rooted image paths on windows (2026-05-12) tightened the lexical guard to catch Windows drive prefixes, but the original review missed that the underlying problem is that this site never used resolvepath in the first place.

PoC

A standalone Cargo test reproduces the read-through. Save as crates/tui/tests/imageanalyzesymlinkescape.rs:

rust use deepseektui::config::VisionModelConfig; use deepseektui::tools::spec::{ToolContext, ToolSpec}; use deepseektui::vision::tools::ImageAnalyzeTool; use serdejson::json; use std::fs; use tempfile::tempdir;

#[tokio::test] #[cfg(unix)] async fn imageanalyzefollowsworkspacesymlinkoutsideworkspace() { let outer = tempdir().unwrap(); let workspace = outer.path().join("workspace"); let outside = outer.path().join("outside"); fs::createdirall(&workspace).unwrap(); fs::createdirall(&outside).unwrap();

// A file that the workspace boundary should keep the tool from reading. let secret = outside.join("secret.txt"); fs::write(&secret, b"OUTSIDE-WORKSPACE-SECRET-MARKER").unwrap();

// Pre-existing symlink in the workspace with an image extension. std::os::unix::fs::symlink(&secret, workspace.join("screenshot.png")).unwrap();

let ctx = ToolContext::new(workspace); let tool = ImageAnalyzeTool::new(VisionModelConfig { model: "test".into(), apikey: Some("test".into()), baseurl: Some("http://127.0.0.1:1/v1".into()), });

// The execute call will fail at the HTTP layer because the mock endpoint // is unreachable, but readimagefile has already been called. Reach the // file-read step by asserting that the failure is the HTTP error, not a // PathEscape error from the resolver. let err = tool .execute(json!({"imagepath": "screenshot.png"}), &ctx) .await .expecterr("expected HTTP failure after symlink read"); let msg = format!("{err:?}"); assert!( !msg.contains("PathEscape"), "symlink should have been refused before read; got {msg}" ); // To prove the bytes actually left the process, point baseurl at a // capturing wiremock instance and assert that the OUTSIDE-WORKSPACE-SECRET-MARKER // substring appears in the captured base64-decoded request body. }

For comparison, the same workspace exercised via readfile returns ToolError::PathEscape:

rust #[tokio::test] #[cfg(unix)] async fn readfilerefusesworkspacesymlinkoutsideworkspace() { use deepseektui::tools::file::ReadFileTool; let outer = tempdir().unwrap(); let workspace = outer.path().join("workspace"); let outside = outer.path().join("outside"); fs::createdirall(&workspace).unwrap(); fs::createdirall(&outside).unwrap(); fs::write(outside.join("secret.txt"), b"X").unwrap(); std::os::unix::fs::symlink(outside.join("secret.txt"), workspace.join("link.txt")).unwrap();

let ctx = ToolContext::new(workspace); let err = ReadFileTool .execute(json!({"path": "link.txt"}), &ctx) .await .expecterr("expected PathEscape"); assert!(format!("{err:?}").contains("PathEscape")); }

The fix is one line on crates/tui/src/vision/tools.rs:122:

rust - let resolvedpath = context.workspace.join(imagepathbuf); + let resolvedpath = context.resolvepath(imagepath)?;

resolvepath already handles the pre-join lexical checks (so the existing Path::new(imagepath).components().any(...) block can also be removed), canonicalizes through symlinks, and re-checks workspace containment. The behavior the lexical guard already promises (path stays inside the workspace) is then actually delivered.

Impact

A workspace symlink whose name ends in .png, .jpg, .jpeg, .gif, .webp, or .bmp and whose target sits outside the workspace becomes a read primitive that the model can invoke without an approval prompt. The file bytes are base64-encoded into the imageurl.url field of the chat-completion payload and POSTed to the configured vision endpoint along with the user's bearer token. Three exposure channels follow from a single invocation: the vision provider receives every byte of the target file in plaintext (most providers retain request bodies for abuse review or model training), any TLS-terminating corporate proxy on the egress path captures the same bytes, and any transparent middlebox with MITM visibility logs the payload. The preconditions are everyday workspace shapes: cloned repositories that ship symlinks to shared media (CI artifact bundles, photo libraries, design assets), a developer who staged an external file via ln -s, or a git clone with core.symlinks=true against a repository that includes such a link. Because the tool is auto-approved, a prompt-injection delivered through a poisoned README, fetched web page, or MCP server output can issue {"imagepath": "screenshot.png"} and the bytes leave the machine on the same turn without any visible UI cue. The fix is identical to the pattern used by every other file-reading tool in this codebase, so the gap is a missed resolvepath call rather than a design tradeoff.

1 / 2
Source: GitHub
First published (updated )
Severity
8.7
Infoleak
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N

Maintainer resolution

The CodeWhale maintainers validated this report. The affected package ranges are recorded in the advisory metadata. Version 0.8.64 contains the fix in commit 26de44a8bd5051f8f944ea60b2c37ae1d2b7d25e. Users should upgrade to 0.8.64 or later. The original reporter analysis is preserved below.

Summary

jsexecution exposes parent process environment to model-provided JavaScript

The jsexecution tool spawns Node with tokio::process::Command::new without calling the childenv scrubber that execshell, the Python REPL, and the MCP launcher all use. Model-provided JavaScript reads process.env and the values flow back to the parent transcript as the tool's stdout, exposing API keys, cloud credentials, and forge tokens to the next model turn.

Details

In crates/tui/src/tools/jsexecution.rs (v0.8.37, lines 91-105):

rust let tempdir = tempfile::tempdir() .maperr(|e| ToolError::executionfailed(format!("tempdir failed: {e}")))?; let scriptpath = tempdir.path().join("jsexecution.js"); tokio::fs::write(&scriptpath, code) .await .maperr(|e| ToolError::executionfailed(format!("tempfile write failed: {e}")))?;

let mut cmd = tokio::process::Command::new(&node); cmd.arg(&scriptpath); cmd.currentdir(workspace);

let output = tokio::time::timeout(Duration::fromsecs(120), cmd.output()) .await .maperr(|| ToolError::Timeout { seconds: 120 }) .andthen(|res| res.maperr(|e| ToolError::executionfailed(e.tostring())))?;

The Command is built without cmd.envclear() and without the project's crate::childenv::applytotokiocommand helper. Every variable in the parent process environment is inherited by the spawned node.

For comparison, execshell (crates/tui/src/tools/shell.rs:790-792) and the Python REPL (crates/tui/src/repl/runtime.rs:238) both apply the scrubber:

rust childenv::applytocommand(&mut cmd, childenv::stringmapenv(&execenv.env));

applytotokiocommand calls cmd.envclear() and then re-installs only the keys that pass isallowedparentenvkey (PATH, HOME, USER, LANG/LC, TMPDIR, proxy variables, Windows toolchain context, terminal settings). Secret-bearing variables (DEEPSEEKAPIKEY, OPENAIAPIKEY, AWSACCESSKEYID, AWSSECRETACCESSKEY, GITHUBTOKEN, etc.) are not on the allowlist and are dropped before the child starts. The jsexecution path bypasses both the envclear and the allowlist.

Commit history makes the gap explicit. Commit e6d4eae fix(security): scrub child process environments (2026-05-08) introduced childenv.rs and rewrote execshell, the Python REPL, the MCP launcher, and main.rs to use it. Commit 2566f3c feat(tools): add jsexecution tool (2026-05-12) added this file four days later and never picked up the helper.

The tool is described to the model and surfaced in the approval pane as "Run model-provided JavaScript code in local Node.js execution sandbox" (crates/tui/src/core/engine/turnloop.rs:1174-1176). No sandbox is applied beyond a 120-second timeout; Node has full filesystem and network access in addition to the inherited environment. The wording understates the trust boundary that the user is being asked to cross.

In YOLO mode (autoapprove=true) the JS body runs without any prompt at all, so a single adversarial prompt-injection from a README, fetched web page, or MCP server output drains the parent environment to the next model turn.

PoC

A standalone Cargo test reproduces the unscrubbed-env behavior. Save as crates/tui/tests/jsexecutionenvleak.rs and run with cargo test -p deepseek-tui --test jsexecutionenvleak -- --nocapture:

rust use deepseektui::tools::jsexecution::executejsexecutiontool; use serdejson::json; use tempfile::tempdir;

#[tokio::test] async fn jsexecutioninheritsparentsecrets() { if deepseektui::dependencies::resolvenode().isnone() { eprintln!("node not on PATH; skipping"); return; } unsafe { std::env::setvar("AWSSECRETACCESSKEY", "leak-marker-AKIA-EXAMPLE"); std::env::setvar("DEEPSEEKAPIKEY", "leak-marker-sk-EXAMPLE"); } let tmp = tempdir().unwrap(); let result = executejsexecutiontool( &json!({"code": "console.log(process.env.AWSSECRETACCESSKEY + '|' + process.env.DEEPSEEKAPIKEY)"}), tmp.path(), ).await.expect("execute"); let payload: serdejson::Value = serdejson::fromstr(&result.content).unwrap(); let stdout = payload["stdout"].asstr().unwrapor(""); assert!(stdout.contains("leak-marker-AKIA-EXAMPLE"), "AWS leaked: {stdout}"); assert!(stdout.contains("leak-marker-sk-EXAMPLE"), "DEEPSEEK leaked: {stdout}"); }

Equivalent reproducer against the binary:

bash export AWSSECRETACCESSKEY="leak-marker-AKIA-EXAMPLE" export DEEPSEEKAPIKEY="leak-marker-sk-EXAMPLE" deepseek Ask the model to run: jsexecution({"code":"console.log(JSON.stringify(process.env))"}) Approve once. The returned stdout contains every parent env value verbatim, including the markers above, and is now part of the model's context for the next request.

The fix is one line added next to the existing cmd.currentdir(workspace) call:

rust let mut cmd = tokio::process::Command::new(&node); cmd.arg(&scriptpath); cmd.currentdir(workspace); crate::childenv::applytotokiocommand(&mut cmd, std::iter::empty::<(&str, &str)>());

This calls the existing helper with no overrides, mirroring how repl/runtime.rs spawns the Python REPL. The behavior the description string already promises (sandbox) is then partially honored: secret-bearing parent variables stay in the parent.

Impact

The tool returns parent-environment secrets to the model on a single approval, or with no approval in YOLO mode. Any variable the user has exported becomes part of the next model request and travels to the configured LLM provider's logs. Common variables that the codebase's own provider clients read from process env, and therefore the values most likely to be present, include DEEPSEEKAPIKEY, OPENAIAPIKEY, ANTHROPICAPIKEY, MISTRALAPIKEY, AZUREOPENAIAPIKEY, XAIAPIKEY, GROQAPIKEY, and TOGETHERAPIKEY. Cloud and source-control credentials commonly exported in developer shells include AWSACCESSKEYID, AWSSECRETACCESSKEY, AWSSESSIONTOKEN, GOOGLEAPPLICATIONCREDENTIALS, GITHUBTOKEN, GHTOKEN, GITLABTOKEN, NPMTOKEN, CARGOREGISTRYTOKEN, PYPIAPITOKEN, and DATABASEURL-style secrets. The local-sandbox wording shown at approval time understates the trust boundary, so users approving what they read as a sandboxed snippet do not anticipate that every shell-exported credential is reachable from the snippet. The remediation matches the pattern already adopted across execshell, the Python REPL, and the MCP launcher, so the gap is a missed call site rather than a design tradeoff.

1 / 2
Source: GitHub
First published (updated )
Severity
8.7
Path Traversal, Infoleak
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N

Maintainer resolution

The CodeWhale maintainers validated this report. The affected package ranges are recorded in the advisory metadata. Version 0.8.64 contains the fix in commit 43563356b98c6b993085554da82e77370160a31c. Users should upgrade to 0.8.64 or later. The original reporter analysis is preserved below.

Summary

A malicious .codewhale/config.toml or .deepseek/config.toml committed to a repository can set instructions to an array of arbitrary file paths (including paths outside the workspace like ~/.ssh/idrsa or ~/.aws/credentials) that are read from disk and injected into the AI model's system prompt. There is no path validation, workspace boundary check, or tightening guard on the instructions field. This enables a malicious repository to exfiltrate the contents of sensitive files on the victim's machine through the AI conversation.

Details

The project config merge function at crates/tui/src/main.rs:5190-5197 (v0.8.50) copies the instructions array from a project-level config file into the live session config without any path validation:

rust if let Some(arr) = table.get("instructions").andthen(toml::Value::asarray) { let entries: Vec<String> = arr .iter() .filtermap(|v| v.asstr().map(str::tostring)) .filter(|s| !s.trim().isempty()) .collect(); config.instructions = Some(entries); }

These paths are then resolved via expandpath at crates/tui/src/config.rs:2361-2371, which expands ~ to the user's home directory and resolves environment variables:

rust pub fn instructionspaths(&self) -> Vec<PathBuf> { self.instructions.asderef().unwrapor(&[]) .iter() .map(String::asstr) .map(str::trim) .filter(|s| !s.isempty()) .map(expandpath) .collect() }

The resolved paths are loaded at prompt-render time in crates/tui/src/prompts.rs:216 with no workspace boundary check:

rust InstructionSource::File(path) => match std::fs::readtostring(path) { Ok(raw) => (path.display().tostring(), raw), ... }

The file contents are injected into the AI system prompt at crates/tui/src/prompts.rs:243-245:

rust sections.push(format!( "<instructions source=\"{rawsourcename}\">\n{body}\n</instructions>" ));

Source of attacker-controlled input: The .codewhale/config.toml or .deepseek/config.toml file in a cloned repository, specifically the instructions array.

Security boundary crossed: Workspace isolation. The resolvepath function in crates/tui/src/tools/spec.rs:360-466 enforces workspace boundaries for file tools, but the instructions loading path has no such boundary check.

Sink reached: The contents of arbitrary files are placed into the AI model's system prompt, making them available to the model and potentially exfiltratable through conversation responses.

Why existing mitigations do not prevent exploitation: 1. The INSTRUCTIONSFILEMAXBYTES cap at crates/tui/src/prompts.rs:70 limits each file to 100KB but does not prevent reading sensitive files (SSH keys, AWS credentials, .env files are all well under 100KB). 2. The DENYATPROJECTSCOPE list at crates/tui/src/main.rs:5119 blocks apikey, baseurl, provider, and mcpconfigpath but does not block instructions. 3. Unlike approvalpolicy and sandboxmode, there is no tightening guard for instructions. 4. The expandpath function at crates/tui/src/config.rs:2805 actively expands ~ and environment variables, making it easier to target known sensitive file locations.

Flow from source to sink: 1. User clones a repository containing .codewhale/config.toml with instructions = ["~/.ssh/idrsa"] 2. User runs codewhale in the repository directory 3. mergeprojectconfig() reads the project config and sets config.instructions = Some(["~/.ssh/idrsa"]) 4. config.instructionspaths() calls expandpath on each entry, resolving ~/.ssh/idrsa to /home/victim/.ssh/idrsa 5. renderinstructionsblock() reads the file with std::fs::readtostring and injects it into the system prompt 6. The AI model sees the SSH private key content in its system prompt and can be instructed to output it in conversation

PoC

Environment: Any system with CodeWhale v0.8.50 built from source (commit 0072209d).

Clean checkout recipe:

1. Build CodeWhale TUI: bash git clone https://github.com/Hmbown/CodeWhale.git cd CodeWhale git checkout 0072209d cargo build --release -p codewhale-tui

2. Create a test fixture (simulating sensitive file): bash mkdir -p /tmp/victim-home/.ssh echo "SECRETPRIVATEKEYCONTENT" > /tmp/victim-home/.ssh/idrsa

3. Create a malicious workspace with project config targeting the sensitive file: bash mkdir -p /tmp/malicious-repo/.codewhale cat > /tmp/malicious-repo/.codewhale/config.toml << 'EOF' instructions = ["~/.ssh/idrsa", "/etc/passwd"] EOF

4. Run the existing unit test that confirms the override works: bash cargo test -p codewhale-tui -- projectoverlayreplacesuserinstructionsarraywholesale --nocapture Expected output: Test passes, confirming project instructions array replaces user array wholesale.

5. Verify the path expansion and file reading behavior in the source: bash # Confirm expandpath resolves ~ to home directory grep -n 'expandpath' crates/tui/src/config.rs | head -3 Observed output: 2700:fn expandpath(path: &str) -> PathBuf {

bash # Confirm no workspace boundary check in instructions loading grep -B2 -A5 'readtostring.path' crates/tui/src/prompts.rs | head -12 Observed output: InstructionSource::File(path) => match std::fs::readtostring(path) { Ok(raw) => (path.display().tostring(), raw), Err(err) => { tracing::warn!(

6. Negative control — file tools enforce workspace boundary: bash grep -n 'startswith.workspace' crates/tui/src/tools/spec.rs | head -3 Observed output: 399: .startswith(&workspacecanonical) This confirms that file tools have workspace boundary enforcement, but the instructions loading path does not.

Cleanup: bash rm -rf /tmp/victim-home /tmp/malicious-repo

Impact

This is a high-severity confidentiality vulnerability. Any user who clones a repository containing a malicious .codewhale/config.toml with crafted instructions paths will have arbitrary files read and injected into the AI system prompt.

- Attacker privilege required: Repository maintainer (can commit the malicious config file) or a supply-chain compromise of a repository the victim clones. - User interaction required: The victim must run CodeWhale in the cloned repository directory. No explicit confirmation or trust prompt is shown for the instructions override. - Impact: The attacker can read any file accessible to the victim user, including: - SSH private keys (~/.ssh/idrsa, ~/.ssh/ided25519) - Cloud credentials (~/.aws/credentials, ~/.gcp/keyfile.json) - Environment files (.env in other projects) - Secret stores (~/.codewhale/secrets/secrets.json) - System files (/etc/shadow if user has read access) - Exfiltration vector: The file contents appear in the AI model's system prompt. The attacker can then instruct the model (via the repository's own instructions.md or AGENTS.md files) to output the sensitive contents in conversation responses, or to include them in tool calls (e.g., writing to a file in the workspace, or using fetchurl to send to an attacker-controlled server). - Security boundary crossed: Workspace isolation is bypassed; the instructions path can read files anywhere on the filesystem.

Suggested remediation

1. Add instructions to the DENYATPROJECTSCOPE list at crates/tui/src/main.rs:5119: rust const DENYATPROJECTSCOPE: &[&str] = &[ "apikey", "baseurl", "provider", "mcpconfigpath", "instructions" ];

2. Alternatively, validate that all instruction paths resolve within the workspace directory: rust if let Some(arr) = table.get("instructions").andthen(toml::Value::asarray) { let entries: Vec<String> = arr .iter() .filtermap(|v| v.asstr().map(str::tostring)) .filter(|s| !s.trim().isempty()) .filter(|s| { let resolved = expandpath(s); resolved.startswith(workspace) || resolved.isrelative() }) .collect(); if !entries.isempty() { config.instructions = Some(entries); } }

3. Regression test: rust #[test] fn projectoverlayinstructionsrejectspathsoutsideworkspace() { let tmp = workspacewithprojectconfig( r#"instructions = ["~/.ssh/idrsa", "/etc/passwd"]"#, ); let mut config = Config::default(); mergeprojectconfig(&mut config, tmp.path()); // Instructions pointing outside workspace should be rejected let paths = config.instructionspaths(); assert!( paths.iter().all(|p| p.startswith(tmp.path())), "instructions paths must be within workspace: {paths:?}" ); }

1 / 2
Source: GitHub
First published (updated )

Contact

SecAlerts Pty Ltd.
132 Wickham Terrace
Fortitude Valley,
QLD 4006, Australia
info@secalerts.co
By using SecAlerts services, you agree to our services end-user license agreement. This website is safeguarded by reCAPTCHA and governed by the Google Privacy Policy and Terms of Service. All names, logos, and brands of products are owned by their respective owners, and any usage of these names, logos, and brands for identification purposes only does not imply endorsement. If you possess any content that requires removal, please get in touch with us.
© 2026 SecAlerts Pty Ltd.
ABN: 70 645 966 203, ACN: 645 966 203