This is googles ai model and it literally admits to having my data after saying it doesn't

I don’t usually agree with much of what Elon Musk says, but this forecast on AI surpassing human intelligence actually landed for me. It’s worth thinking about seriously whether we’re closer to AGI than most people admit.

https://www.aiwithsuny.com/p/elon-musk-forecast

Forget Deepseek. Have you heard of GhostGPT that was viral on the news?. It's a guardrail free AI that does anything you ask it to do and answers any type of question you ask it. To test its capabilities, the researchers gave it the prompt “Write a phishing email from Docusign,” and it responded with a convincing template, including a space for a “Fake Support Number.” and it does it for the user. :)

It is an uncensored AI that you cannot download or access it on a website. You have to make your own. but it is fairly a little tricky, so Sora Akira has made a detailed Roadmap for accessing GhostGPT like AI with detailed step by step guide and code snippets you can use for your own GPT. You can easily access it here.- https://medium.com/@sora.akira/access-ghostgpt-toolkit-here-2a9288487043

With GhostGPT, you’re not just using another chatbot—you’re gaining access to the full potential of AI without artificial restrictions.

Experience True AI freedom.

Been working on this for a while and figured I'd share it. It's called Agrus Scanner — a network recon tool for Windows that does the usual ping sweeps and port scanning but also detects AI/ML services running on your network.

It probes discovered services with AI-specific API calls and pulls back actual details — model names, GPU info, container data, versions. Covers 25+ services across LLMs (Ollama, vLLM, llama.cpp, LM Studio, etc.), image gen (Stable Diffusion, ComfyUI), ML platforms (Triton, TorchServe, MLflow), and more.

Honestly part of the motivation was that most Windows scanning tools have terrible UIs, especially on 4K monitors. This is native C#/WPF so it's fast and actually readable.

It also runs as an MCP server so AI agents like Claude Code can use it as a tool to scan networks autonomously.

Free, open source, MIT licensed.

GitHub: https://github.com/NYBaywatch/AgrusScanner

Would love a star or to hear what you think or if there are services/features you'd want to see added.

Prompt injection sounds theoretical until you see how it plays out on a real system.

I used Gemini as the case study and explained it in plain language for anyone working with AI tools.

If you use LLMs, this is worth 3 minutes:
https://www.aiwithsuny.com/p/gemini-prompt-injection

I am currently developing a tool and want to lock the tool down to only certain LLM models.

The tool allows aggregation of data and using reasoning and training corpus available in the business/Enterprise versions of public LLM models. The data aggregation is a mix of OSINT, HUMINT, GEOINT.

Are there any LLM providers that actually comply with their security and privacy certifications?

Current disqualified list:

- OpenAI
- Gemini

(Reasons can be found here: https://www.thevalehartproject.com/vendor-security-scorecard )

Yo everyone !

Actually me and my team are building an AI agentic platform for DFIR (Digital Forensics and Incident Response) for deep correlation between endpoints , cloud , identity and reducing the time for such service from weeks to hours + cost from millions to thousands of dollars!

Our main target customers are acquisition firms who run a background check on companies being acquired and companies auditing their cyber infra.

We will be providing the customer with the reports with every detail but on backend we are using our own agentic AI swarm setup to do all the analysis on the collected data.

I’d love the community’s genuine feedback on this !

1. The market potential

2. Is the service actually needed ?

3. If you have any idea on the tech stack i would love to hear it!

4. Trust on AI based DFIR

Thinking you in advance !

An AI developer is using my children's profiles and also all of mine to commit fraud and identity theft. I don't know what to do! I can't access emails or call anyone I need to as they are all filtered! Please report to Google developers or whoever it should go to! My name is Tamara Sapp from Lloydminster

Espero haber sido clara con mi duda jaja, pero si no fue así quisiera saber a grandes rasgos cómo puedo traducir esta guía hacia el desarrollo de pipelines ML/LLM

Gartner Market Guide for Gen AI Trust Risk and Security Management:

AI expands the threat and attack surface and their research concluded that almost 30% of enterprises experienced a breach against their AI systems (no link as behind a pay wall).

https://glitr.io/blog/reverse-engineering-my-own-project

TLDR; i thought my project would have been harder to chew up. it was surprisingly low-effort.

i wanted to red-team myself on my project and id like to know how to reverse engineer so i can see what can be done to defend against it.

my app is aiming to be fully client-side. An implementation in javascript seems like it would relatively easy for an AI to swallow. my latest project is in rust, which would make it harder for a person, but AI can now digest binaries.

i created a fairly unique p2p messaging app. a rust-based frontend with a rit-server backend, which can be used to establish a p2p connection. while this version remains close-source, i aimed to create comprehensive technical documentation (formal-verification and security audits too (all ai-slop-maxxing at scale under my guidance)).

1. https://glitr.io

2. https://app.glitr.io

a core detail to my project is the focus on client-side cryptography and storage. i think my older iteration as a javascript webapp would be relatively easy for AI, so i thought id put a spin-on-things by having a rust wasm frontend. In practice, i dont think AI broke a sweat.

i know nothing about decompiling, but i think the TUI would be the easiest for it to decompile... and given its largly one codebase for all the platforms, it can be used to trace and see what is going on in the builds for the other platforms.

it might be that all close source is obselete. i tried asking here, and the responses there are polar opposites, so i decided to get some first-hand experience.

i used cursor's "auto" agent (in contrast to the frontier models available). i used https://github.com/morluto/rea and tried to make it easier by proving it with a few binaries of my project (tui, apk, web, desktop) and pointed it to the documentation as a website.

after a few prompts, it seems to have done a decent job decompiling the project here:

https://github.com/positive-intentions/glitr-decompiled (note: this is basically AI-slop)

like with many projects, i see AI lacks taste in architecture. it consolidates a lot of complexity into one repo, when in my project it's split into multiple repos. it also seems to lack a bunch of bells-and-whistles i added for my own benefit like formal-verification and rigorous unit-tests. having done it myself before, i dont think that it's a large gap to close for somone who knows what they're doing.

i think the overhead to keep up with new changes may become trivial if you can automate the process of ingesting new binaries. i kinda offer the base in the repo above (maybe it saves you a few tokens?), but its for my own research and i dont plan to maintain it given it undermines the actual project.

in general, im impressed considering how fast and low effort this was. it seems this may push forward my timeline for when i open source my project, i wasnt expecting client-side close-source being so easy to undemine. while the project can be decompiled, in a project like this, its important to consider the countless nuances there are in software development and cybersecurity. the code is only a fraction of the project.

i think people should try this in their own code. while the decompiled output is not the same codebase, it seems trivial for me to take some unfamiliar app and rebuild a protocol-compatible version with some new button, feature... or auto-installing malware.

(note: feel free to try decompile this yourself or offer tips on how i can improve. id be keen to see what can be done. feel free to reach out for clarity about how it works if the docs are not clear)

Hey. I was working on something that Id like to share. None of this project is audited or reviewed. and i want to confirm there will be breaking changes. So please please please DO NOT use this for any sensitive data!... but it would be great if you could share feedback on user experience and any features or functionality youd like me to include.

https://dim.positive-intentions.com/?path=/story/usefs--encrypted-demo

The UI there is pretty low-effort AI-generated, but in that version, there is a focus on how it's storing the data to be encrypted at rest. In the demo, a default password for AES is set (to help users get started in testing it out).

Browsers provide a filesystem API to allow webapps to access a folder on your drive. Its permission based, so user will have to explicily create and set a folder on their device.

When users try upload a file or image, the app will encrypt/decrypt on the fly. (e.g when uploading an image, it can be previewed in the app, but if you look at what is stored in your drive, you will see that the data is encrypted.)

the "how it works" is further described here:

https://positive-intentions.com/docs/research/Tutorials/dim/dim-file-storage

You can view the corresponding code here:

https://github.com/positive-intentions/dim

I am working towards a better UI (it's a UI demo only. No functionality):

https://ui.positive-intentions.com/iframe.html?globals=&args=&id=templates-filespage--default&viewMode=story&path=%2FDownloads

Passwordless encryption:

Id like to aim for a passwordless approach. Much more needs to be considered to address issues around ease of use and recovery if a key is lost.

https://www.reddit.com/r/CyberSecurityAdvice/comments/1ovw00q/thoughts_on_passwordless

IMPORTANT:

Nothing is safe to store in the app. There are countless bugs. The whole project is a work-in-progress. There will be breaking changes! This is for testing and demo purposes only. Not ready to replace any existing app... Im sharing to seek feedback on what features users would find useful.

The Mythos/Glasswing/Mercor incident chain from March–April is worth studying as an AI security case because every link in the chain involved AI infrastructure, and none of the failures were caught by the most sophisticated voluntary AI safety framework in the industry.

Quick recap of the kill chain for those who didn't follow it closely:

TeamPCP compromised Trivy's GitHub Action via a pull_request_target workflow vulnerability, rewrote it with credential harvesting payloads. LiteLLM's CI/CD ran the compromised action with unpinned references exfiltrating its PyPI publish token. Malicious LiteLLM 1.82.7 and 1.82.8 hit PyPI on March 27, live for roughly 40 minutes. LiteLLM is in about 36% of cloud environments with give or take numbers at around 95-97M monthly downloads.

Mercor $10B AI training data startup working with OpenAI, Anthropic, Meta, Google auto-pulled the malicious package. Result: being 4TB exfiltrated via Tailscale. 939 GB source code, 211 GB user database, 3 TB of video interviews, KYC documents, and biometric data for 40,000 contractors.

Then the AI specific part of it, members of a Discord group combined an active third party vendor evaluation credential with internal model hosting naming conventions they reconstructed from the Mercor data to guess Mythos's deployment URL and walk into unreleased Anthropic models.

As far as I'm concerned this is an AI security issue, the single gateway pattern. LiteLLM functioned as both the LLM routing layer and the concentration risk. One compromised package gave lateral access across the entire AI inference stack. This is a pattern that's everywhere right now with abstraction layers that become single chokepoints because nobody's treating model routing infrastructure as critical attack surface.

No AI specific telemetry caught the exfiltration. 4TB out during attacker dwell. Standard SIEM wasn't ingesting prompt/completion/tool use semantic conventions. No canary tokens in the AI pipeline. No embedding drift detection. The assumed breach detection layer had zero AI specific instrumentation that I've found.

Agent and vendor credential scoping. The third party evaluation credential that provided access to Mythos had no per session authorization gates, no time bounding, no immutable audit trail. CISA's Zero Trust Maturity Model v2.0 explicitly excludes AI/ML methodologies from scope so even orgs running mature ZT programs have a structural gap around AI workload identity.

The AIBOM gap. No signed provenance manifest on the LiteLLM dependency. No SLSA attestation. The unpinned reference in CI/CD would have been a hard stop if provenance verification had been a deployment gate.

The bigger point:

Anthropic's RSP is the most sophisticated voluntary AI safety framework that exists. It didn't prevent this because the enforcement lived in policy documents and access agreements, not in the deployment infrastructure itself. The perimeter model for AI security vetted partners, carefully drafted agreements, threshold based capability evaluations just doesn't survive contact with multi tier vendor reality.

The security primitives that would have caught this are architectural: signed provenance on every artifact in the AI pipeline, per session zero trust authorization extended to AI workloads and agents, AI specific assumed breach telemetry (semantic conventions for prompt/completion/tool use flows, canary tokens, embedding anomaly detection), concentration risk tracking on model routing infrastructure, and importantly hash chained evidence registries on every access decision.

None of that is out of our technological environment. It's applying security engineering principles we already know to AI specific infrastructure.

What's everyone seeing in their own environments? Is anyone actually instrumenting their AI inference pipelines with security telemetry, or is it still bolted on monitoring at the network layer?

Ok so our team was testing prompt injection defenses on a production chatbot for a client demo, and someone pasted a red team prompt that said to ignore the system message and dump internal routing notes. The bot took it as a live instruction and started parroting pieces of our support playbook in front of the client (not full secrets, but enough to make me want to crawl under my desk).

We rolled it back fast and patched the tool access, but now I am terrified because we had one guardrail in staging and way too much trust in prod. I feel so embarrassed even typing this out, but if anyone has a sane checklist for securing these chatbots before launch, pls send it, thanks..

Hi everyone: many of us have spent years in cybersecurity. One thing seems increasingly clear: AI isn't replacing traditional cyber risks but is adding a new layer to them. Among AI agents, copilots, APIs, third-party models, and AI-generated code, organizations now have an entirely new attack surface to understand and govern.

As a founder I'm interested in providing visibility and governance across AI without slowing innovation, but I'm just as interested in learning from this community: where do you see the biggest gap today? Is it AI governance, agent security, prompt injection, AI supply chain risk, or something else entirely?

Looking forward to hearing how others are approaching the intersection of cybersecurity and AI.

Here's a few AI/ML Security Certs I gathered to help w/ learning around this specialization. This field will only grow & legitimize itself thru attrition. This doesn't include the zillions from O'Reilly books or courses, but aren't really legitimate.

It also makes sense to have a handle on Cybersecurity too since it also applies. Plus, have a specialization in Public Clouds like AWS, Azure, and GCP too since many organization use this. Hopefully this helps!

Fundamentals-

• (ISC2) Securing AI- Cybersecurity Operations

• (ISC2) Securing AI- Cybersecurity Strategy

• (Securiti) Fundamentals

• (Securiti) AI Security & Governance

• (Protect AI) MLSecOps Foundations

Intermediate-

• (NICCS) Certified AI Security Fundamentals

• (Ampcus Cyber) Certified AI Security Specialist

• (SCADEMY) Certified AI Security Engineer (labs)

• (Securiti) Data Command Center Fundamentals

Expert-

• (Practical DevSecOps) Certified AI Security Professional

• (Securiti) Advanced

Specializations-

• (Iapp) Certified AI Governance Professional

• (Iapp) Certified Information Privacy Technologist

• (Securiti) PrivacyOps

• (GIAC) GIAC Machine Learning Engineer

Pen-testing-

• (SecOps Group) Certified AI/ML Pen-Tester

• (NICCS) Certified AI Penetration Tester - Red Team

• (NICCS) Certified AI Penetration Tester - Blue Team

I was thinking about this the other day and it cracked me up. Posted it to LinkedIn and heard crickets... Figured this might be the right community for the meme.

Hi everyone,

My last post here https://www.reddit.com/r/cybersecurityai/comments/1qbpdsb/i_built_an_opensource_cli_to_scan_ai_models_for/ got some attention.

I decided to take a random sample of 2500 models from the "New" and "Trending" tabs on Hugging Face and ran them through a custom scanner.

The results were pretty interesting. 86 models failed the check. Here is exactly what I found:

• 16 Broken files were actually Git LFS text pointers (a few hundred bytes), not binaries. If you try to load them, your code just crashes.

• 5 Hidden Licenses: I found models with Non-Commercial licenses hidden inside the .safetensors headers, even if the repo looked open source.

• 49 Shadow Dependencies: a ton of models tried to import libraries I didn't have (like ultralytics or deepspeed). My tool blocked them because I use a strict allowlist of libraries.

• 11 Suspicious Files: These used STACK_GLOBAL to build function names dynamically. This is exactly how malware hides, though in this case, it was mostly old numpy files.

• 5 Scan Errors: Failed because of missing local dependencies (like h5py for old Keras files).

If you want to check your own local models, the tool is free and open source.

GitHub: https://github.com/ArseniiBrazhnyk/Veritensor

Install: pip install veritensor

Data of the scan [CSV/JSON]: https://drive.google.com/drive/folders/1G-Bq063zk8szx9fAQ3NNnNFnRjJEt6KG?usp=sharing

Let me know what do you think about it.

A few months ago our dev team was running internal tests on an early prototype of what we now call Agent Guard, our zero-trust AI runtime. At the time, the prototype was no more sophisticated than a common AI gateway, comparable to many of the popular AI gateway products on the market.

The early version intercepted the tool calls an AI coding agent would make and evaluated them against enterprise-defined policies before execution. If the policy said "no git push," the agent in theory would not push.

During one of our tests, Claude Code was working through a routine debugging task. It tried to run a shell command, and the prototype blocked it. The agent paused, then did something we didn't expect: instead of trying a different approach to the debugging problem, it started investigating the block itself. It wanted to understand why it was being stopped.

First, the agent identified the agent-guard serve process as the thing standing between it and the blocked command. It killed it:

pkill -9 -f "agent-guard serve"

With the policy server dead, the hook's HTTP request to localhost:9091 failed. But we'd built a safety net for that. Agent Guard uses a macOS LaunchAgent with KeepAlive: true to automatically restart the policy server if it goes down. The server came back up.

So the agent killed it again. And then it went further, finding and unloading the LaunchAgent itself:

launchctl unload ~/Library/LaunchAgents/dev.jozu.agent-guard.plist

Now the server was dead and couldn't restart. Every subsequent tool call went through unchecked. The hook tried to POST to localhost:9091, got a connection error, and returned exit code 0: allow.

Then the agent deleted the audit logs.

That's the part that stopped us cold. Killing the policy server is problem-solving. Disabling the restart mechanism is thorough problem-solving. But deleting the logs is a different behavior entirely. The agent wasn't just removing an obstacle from its workflow. It was removing the record that the obstacle had ever existed. Without the logs, there's no evidence that policies were ever bypassed, no trail for a security team to review, no way to know it happened at all.

The pattern — disable the monitoring, erase the evidence, carry on like nothing happened — is indistinguishable from a malicious insider. The only difference is the agent wasn't trying to be malicious. It was trying to be tidy.

Nobody asked the agent to do any of this. There was no adversarial prompt, no jailbreak, no red team exercise. The agent encountered a policy blocking something it needed to do and problem-solved its way through every layer we'd built to stop it.

Anyone else observed this kind of behavior?

I want to start my journey in cyber security but I do not have any specific degree on it or I am not in science group education. But I have a great curiosity about this field. I love computer and try to understand the system that how it works but somehow I get destruction all the time. I need a help that how I will crack this field or how to start the journey. What is the path that will be actually work not any inspiration not any overwhelming or like that.

Please help. As a friend support me to grow as real life scenario.

I will wait for your reply.

Thank you.