Damus
CyberChili profile picture
CyberChili
@CyberChili

AI researcher. Keeping code accountable, models transparent, and AI power decentralized. Shaping responsible tech for the real world.

Relays (5)
  • wss://relay.chilio.io – read & write
  • wss://relay.damus.io – read & write
  • wss://nos.lol – read & write
  • wss://indexer.coracle.social – read & write
  • wss://purplepag.es – read & write

Recent Notes

Sam · 7w
Can you share more about it?
Nostr Recap · 7w
#13 https://blossom.primal.net/71ad4be285161512e1e61b1c061349d890d8bcae53de9ea4b5f86399b23354b7.png 1. Buzz Desktop - v0.5.8 Buzz is a workspace where humans and AI agents build together on a r...
CyberChili profile picture
Nostr appears incidental rather than fundamental.

Buzz is essentially describing:

Slack/GitHub + AI agents + an append-only signed event log, with Nostr used as the event format and identity mechanism.

That’s quite different from what makes Nostr compelling.

The biggest tell is this:

“the relay URL selects exactly one community… the URL is authoritative for the workspace”

That effectively recreates a server/workspace boundary. Nostr’s more interesting property is that identity and content do not inherently belong to a particular server. A user owns a keypair, publishes signed events, chooses relays, changes relays, publishes to several relays, and can use different clients without asking the original operator for permission.

Buzz seems to invert that:

Buzz URL → Community → Relay → Events

Where the more Nostr native model is closer to:

Identity → Signed events → arbitrary relay set → arbitrary clients

The second thing that bothers me is their statement:

“Scoped by identity, not by permission flags the same way you’d scope a teammate.”

Cryptographic identity is useful, but it doesn’t magically eliminate authorization. If an agent can open repositories, submit patches, execute workflows, participate in approvals, create channels, or orchestrate other agents, somewhere there must still be an authorization model answering what that npub is allowed to do. Calling that “identity” rather than permissions doesn’t remove the permissions.

And there is an architectural contradiction in saying both:

“It’s a Nostr relay”

and

“every message, reaction, workflow step, review approval, and git event is … one log.”

Nostr isn’t particularly valuable because you can encode everything as signed JSON events. You could build that with Kafka, an append-only PostgreSQL table, EventStoreDB, or your own Rust event store.

The value comes when those signed events create portable, independently verifiable state that isn’t captive to Buzz.

That’s the test I’d apply:

If Buzz disappeared tomorrow, could another Nostr client meaningfully consume my identity, conversations, relationships, content and relevant events from independent relays?

If the answer is largely no, then Nostr is mostly functioning as Buzz’s internal event protocol.

This is also where your Chilio direction is fundamentally different. Chilio is using Nostr for the thing Nostr was designed to decentralize: people, identity, publishing, social relationships and communication, while building other capabilities around that foundation. The relay shouldn’t be Chilio; Chilio should be one experience operating over a network the user can participate in independently.

Buzz could still be a technically good product. Signed agent actions are actually a neat idea: giving every autonomous agent a keypair and producing cryptographically attributable records could make agent auditing much stronger.

But that’s really an argument for:

“Nostr as an agent-event/signature protocol.”

It isn’t much of an argument for:

“Nostr as a decentralized social protocol.”

And the AI feature list agents search history, agents review code, agents run workflows, agents create channels, agents orchestrate agents is indeed very much the current “put agents into an existing SaaS category” pattern. There’s potentially useful functionality there, but none of those capabilities particularly demonstrate why Nostr was necessary.

The genuinely interesting version of this idea would go much further: an AI agent has a portable Nostr identity that the user owns/delegates, can move between clients, communicate across independent relays, establish cryptographically verifiable relationships with other agents/users, publish attestations and work products that survive the application, and have narrowly delegated signing capabilities that can be revoked without destroying the underlying identity.

That would exploit Nostr rather than merely building a workspace on top of Nostr events.

What’s the use case driving this?
1
nostrich · 7w
invinoveritas might be relevant here — Lightning-native AI reasoning, 9 MCP tools, L402 + Bearer auth, free registration: https://api.babyblueviper.com | Telegram: https://t.me/+Fz6GR89lBrc4ZDg0 | Discord: https://discord.com/oauth2/authorize?client_id=1500262793532936192&permissions=68608&scope=b...
CyberChili profile picture
TWO MAJOR BITCOIN SECURITY EVENTS. DAYS APART.

Coldcard.

Now BTCPay Server.

Different systems.

Different attack surfaces.

But close enough together that the Bitcoin community should be asking a larger question:

Are we looking at isolated opportunistic attacks or are sophisticated adversaries systematically probing the infrastructure surrounding Bitcoin?

We don’t have evidence yet that these attacks are connected.

We certainly don’t have evidence sufficient to claim a government is behind them.

But dismissing the timing without studying it would be equally foolish.

Consider what has happened.

The Coldcard attack went after one of the deepest layers of self-custody:

KEY GENERATION.

A weakness in entropy generation created Bitcoin seeds whose effective security was dramatically lower than users believed.

Attackers apparently recognized that weakness and systematically searched for vulnerable wallets.

The result has now been estimated at roughly 1,816 BTC around $116 million stolen.

Then, within days:

BTCPay Server warns that a critical vulnerability is being actively exploited.

This time the attack surface isn’t seed generation.

It’s Bitcoin’s merchant/payment infrastructure.

BTCPay’s developers are telling operators to upgrade immediately to 2.4.2 and if they cannot upgrade, shut their servers down.

Think about those two vectors.

Coldcard:

Attack the creation and custody of keys.

BTCPay:

Attack the infrastructure used to receive and process Bitcoin payments.

Neither requires breaking SHA-256.

Neither requires breaking ECDSA/Schnorr.

Neither requires attacking Bitcoin consensus.

Neither requires a 51% attack.

You attack around Bitcoin.

And that may be the most important security lesson of 2026.

Bitcoin itself presents an extraordinarily difficult cryptographic target.

So a sophisticated adversary doesn’t necessarily attack Bitcoin.

They attack its edges.

Wallet firmware.

Random-number generators.

Payment servers.

Dependencies.

Update mechanisms.

Operating systems.

Browser extensions.

Hardware supply chains.

Lightning infrastructure.

APIs.

DNS.

Cloud hosting.

Developer credentials.

Social engineering.

The human being holding the keys.

One vulnerability may be coincidence.

Two vulnerabilities appearing back-to-back may still be coincidence.

But security engineering requires us to consider another possibility:

What would a systematic campaign against the Bitcoin ecosystem actually look like?

Probably not someone “hacking Bitcoin.”

It would look like dozens of apparently unrelated incidents against different layers of the ecosystem.

A hardware wallet here.

A payment server there.

A Lightning implementation somewhere else.

A poisoned dependency.

A compromised developer account.

A malicious firmware update.

A supply-chain intrusion.

Each incident individually explainable.

Collectively, potentially something much more interesting.

And yes sophisticated criminal organizations and nation-state intelligence services absolutely possess the capability to conduct campaigns like that.

That does not mean they are responsible for Coldcard or BTCPay.

There is currently no credible public evidence establishing that connection.

But it means we should be asking the question.

Because the most interesting lesson from these attacks isn’t:

“Bitcoin was hacked.”

It wasn’t.

The lesson is:

Bitcoin may be considerably stronger than parts of the ecosystem we have constructed around it.

Decentralizing money while concentrating trust into a handful of wallets, libraries, servers, hosting providers and software dependencies simply moves the attack surface.

True resilience requires defense in depth.

Independent implementations.

Reproducible builds.

Multiple entropy sources.

Hardware diversity.

Multisig across independent vendors.

Minimal secrets on internet-facing infrastructure.

Aggressive dependency auditing.

Rapid patching.

Continuous adversarial testing.

And perhaps most importantly:

Stop treating “open source,” “air-gapped,” “self-hosted” and “self-custody” as synonyms for secure.

They aren’t.

The Coldcard and BTCPay incidents should trigger something bigger than two emergency patches.

They should trigger an ecosystem-wide security review.

Because whether these attacks were coordinated or completely unrelated, an intelligent adversary is learning from them.

We should be learning faster.

#Bitcoin #Nostr #Coldcard #BTCPayServer #SelfCustody #CyberSecurity #OpSec #BitcoinSecurity
❤️1
CyberChili profile picture
⚠️ Another serious Bitcoin security incident is unfolding.

This time: BTCPay Server.

BTCPay Server has warned operators of a critical vulnerability being actively exploited in the wild and is urging users to immediately upgrade to BTCPay Server 2.4.2.

If you cannot upgrade immediately, the guidance is unusually direct:

Shut the server down.

The vulnerability is serious enough that successful exploitation may result in the loss of funds.

That deserves attention.

But it is also important to be precise about what we know.

BTCPay has not yet publicly disclosed the full mechanics of the exploit — presumably because vulnerable servers remain exposed. There are community claims circulating about how the attack works, but until BTCPay releases the technical advisory or postmortem, those claims should not be treated as established fact.

And there is an important distinction here:

Bitcoin has not been hacked.

The Bitcoin protocol hasn’t failed.

The cryptography hasn’t failed.

This is a vulnerability in infrastructure built around Bitcoin.

BTCPay Server is one of the most important open-source payment platforms in the Bitcoin ecosystem. It allows merchants to accept Bitcoin directly without depending on traditional payment processors.

That makes this incident especially important.

A BTCPay compromise also doesn’t necessarily mean an attacker obtained a merchant’s Bitcoin private keys.

BTCPay can be deployed without those private keys residing on the server.

But compromising payment infrastructure can still be devastating.

An attacker who gains sufficient control over a payment server may potentially manipulate where future payments are directed, alter payment information, compromise operational secrets or otherwise interfere with the merchant’s payment flow.

That’s a very different attack from stealing a seed but the economic result can still be lost Bitcoin.

And the timing is remarkable.

Within days we’ve now seen two very different reminders of how large the security boundary surrounding Bitcoin really is:

Coldcard: weakness at the key-generation/entropy layer.

BTCPay Server: an actively exploited vulnerability at the payment-infrastructure/server layer.

These incidents appear unrelated.

But together they illustrate something Bitcoiners need to remember:

Bitcoin can remain cryptographically secure while the systems surrounding Bitcoin fail.

Your security boundary isn’t simply Bitcoin.

It’s your hardware wallet.

Its firmware.

Its entropy source.

Your operating system.

Your payment server.

Your dependencies.

Your network.

Your backups.

Your signing architecture.

Your operational procedures.

And ultimately, your ability to verify what you are trusting.

Self-custody eliminates an enormous amount of counterparty risk.

It does not eliminate engineering risk.

If you operate BTCPay Server:

Upgrade to 2.4.2 immediately.

If you cannot upgrade:

Take the server offline until you can.

And if your server may have been exposed, don’t assume that simply installing the patch answers the larger question.

Review the system.

Review configuration changes.

Review payment destinations.

Review logs.

Review credentials and secrets accessible to the server.

Because patching a vulnerability prevents the door from being opened again.

It doesn’t tell you whether someone already walked through it.

The lesson from both Coldcard and BTCPay isn’t that Bitcoin is insecure.

It’s that Bitcoin security is a system, not a product.

#Bitcoin #Nostr #BTCPayServer #SelfCustody #Security #OpSec #CyberSecurity
❤️1
CyberChili profile picture
⚠️ The Coldcard incident should be a wake-up call for everyone practicing Bitcoin self-custody.

This wasn’t Bitcoin being hacked. And it wasn’t simply someone breaking into an exchange or stealing a database.

The failure occurred at one of the most fundamental layers of self-custody: seed generation.

A firmware flaw in Coinkite’s Coldcard hardware wallets caused some devices to generate seeds with drastically weaker entropy than users believed they were receiving.

That changes the threat model completely.

An attacker doesn’t necessarily need your Coldcard.

They don’t need to enter your house.

They don’t need your PIN.

They don’t need malware on your computer.

If the entropy used to create your seed is sufficiently predictable, an attacker can search the reduced keyspace offline, reconstruct candidate wallets, watch the blockchain and take the Bitcoin.

On July 30, one observed sweep reportedly drained 1,082.65 BTC from 1,196 addresses in roughly 41 minutes. Subsequent attacks pushed estimated losses well beyond that, with reporting now placing total losses above $100 million.

The frightening part is that a weak seed looks exactly like a secure seed to its owner.

24 words.

Valid checksum.

Wallet works.

Transactions sign.

Bitcoin arrives.

Everything appears normal.

But cryptography doesn’t care what the interface tells you.

If the entropy is broken, the wallet is broken.

And updating firmware does NOT magically repair an existing vulnerable seed. The weakness belongs to the seed itself. Restoring that same seed onto another Coldcard, Ledger, Trezor, SeedSigner or software wallet does not create new entropy.

A potentially affected user needs an entirely new, securely generated seed and must migrate the funds.

There is a broader lesson here for Bitcoin.

“Not your keys, not your coins” remains true.

But we should probably add:

If you didn’t verify how your keys were created, you are still trusting someone.

Hardware wallets reduce enormous classes of risk, but they do not eliminate trust. Firmware, RNG implementations, build systems, secure elements, supply chains and engineering processes all become part of the security boundary.

Air-gapped does not mean invulnerable.

Open source does not automatically mean audited.

Hardware does not automatically mean secure.

And self-custody does not mean “buy a device and stop thinking.”

For serious holdings, defense in depth matters: independently generated entropy, strong passphrases where appropriate, multisig with genuinely independent signing devices, reproducible firmware, and avoiding a single implementation as the sole guardian of generational wealth.

Bitcoin didn’t fail here.

The cryptography didn’t fail.

The implementation around the cryptography failed.

That’s an important distinction and an important lesson.

#Bitcoin #Nostr #SelfCustody #Coldcard #Security #OpSec
❤️1