filleokus

Either me or you are misunderstanding the situation. A comment from the GP link: https://news.ycombinator.com/item?id=47633867

This is slightly different from what OpenCode was banned from doing; they were a separate harness grabbing a user’s Claude Code session and pretending to be Claude Code.

OpenClaw was still using Claude Code as the harness (via claude -p)[0]. I understand why Anthropic is doing this (and they’ve made it clear that building products around claude -p is disallowed) but I fear Conductor will be next.

But... Even when running it in mode 2 ("claude -p") they at certain points tried to detect OpenClaw-usage based prompts made, and blocked them [0]. Now OpenClaw says that Antrophic sanctions this as allowable again.

I agree with GP that this is hard to take seriously.

[0] https://x.com/steipete/status/2040811558427648357

Neat! Pricing wise it might not always make sense though to use the commercial blob storages, especially for solo usage.

1 TB is roughly 20-30 USD per month at AWS/GCP only in storage, plus traffic and operations. R2 is slightly cheaper and includes traffic.

Compared to e.g a Google AI plan where you get 5 TB storage for the same price (25 USD/month) + Gemini Pro thrown in.

Totally agree.

Also, considering how prevalent TPM/Secure Enclaves are on modern devices, I would guess most package maintainers already have hardware capable of generating/using signing keys that never leave hardware.

I think it is mostly a devex/workflow question.

Considering the recent ci/cd-pipeline compromises, I think it would make sense to make a two phase commit process required for popular packages. Build and upload to the registry from a pipeline, but require a signature from a hardware resident key before making the package available.

I suspect nradov argues that this type of geofencing + allow-listing is not typically what people mean when they talk about "export control", which I agree with.

And while geofencing + allow-listing for sure provide value in e.g the Ukrainian conflict, it's a weak protection compared to goods that are actually under strict export control (e.g ITAR), and will always have to be done after the fact. Russia could for example put Starlink on drones launched from the Baltic Ocean targeting Poland or whatever.

Someone was using Xray, proxying to my employer, and it was detected in our attack surface management tool (Censys). I had some quite stressful few minutes before I realised what was going on, "how the hell have our TLS cert leaked to some random VPS hoster in Vietnam!?".

Thankfully for my blood pressure, whoever had set it up had left some kind of management portal accessible on a random high port number and it contained some strings which led me back to the Xray project.

Yes!

Any many CRDT implantations have already solved this for the styled text domain (e.g bold and cursive can be additive but color not etc).

But something user definable would be really useful

I agree, this seems like straight up bad design from a security perspective.

But at the same time, me as a customer of Github, would prefer if Github made it harder for vendors like CodeRabbit to make misstakes like this.

If you have an app with access to more than 1M repos, it would make sense for Github to require a short lived token to access a given repository and only allow the "master" private key to update the app info or whatever.

And/or maybe design mechanisms that only allow minting of these tokens for the repo whenever a certain action is run (i.e not arbitrarily).

But at the end of the day, yes, it's impossible for Github to both allow users to grant full access to whatever app and at the same time ensure stuff like this doesn't happen.

Spivak is saying that the DNS method is superior (i.e you are agreeing - and I do too).

One reason I can think of for HTTP-01 / TLS-ALPN-01 is on-demand issuance, issuing the certificate when you get the request. Which might seem insane (and kinda is), but can be useful for e.g crazy web-migration projects. If you have an enormous, deeply levelled, domain sprawl that are almost never used but you need it up for some reason it can be quite handy.

(Another reason, soon, is that HTTP-01 will be able to issue certs for IP addresses: https://letsencrypt.org/2025/07/01/issuing-our-first-ip-addr...)

I ride rental scooters almost 10k minutes per year and would really like to get my hands on my own ride data to plug it into something like this (or simpler) to find the optimal routes for my regular trips.

Google Maps (or others) works good to find a resonable route, but I can do better on my own. One-way streets where bikes are allowed to go do opposite way is sometimes missing, short desire paths connecting bike ways, crossings where it's safe to do an (illegal) right-on-red etc.

Tried a GDPR data claim from Voi but got nothing back :( But I hope the data is somehow available for urban planners, think it would be a great source of truth to use in tools like this.

I guess it depends a lot on your situation, but for OP's method to be effective you need to out-compete other breeding grounds in not only your backyard but also X feet/meters away (whatever distance mosquitoes typically fly to "hunt").

If there's a nice shallow pond on the property line 100 feet from your porch (or water filled tires at the sloppy neighbour or whatever it might be), I seriously doubt the efficacy of the method in the article.

This thing would lure in any mosquitoes (and unfortunately other things, as per sibling comment) that fly in your backyard, wherever they come from.

For electricity: That also of course depends, but around here it's not uncommon to have an outlet on the outside of some garage or outbuilding or something. The product I linked have a 50 feet cord as well. The fan noise has not been noticeable at all when I've seen it.

Many people with mosquito issues around here (Sweden) uses something like https://www.clasohlson.com/se/Mosquito-Magnet/p/31-7190 which burns propane to produce Co2 to lure in mosquitoes and then sucks them in with a fan towards a metal grid to zap them with electricity.

Non-poisonous and from what I've heard fairly effective. Not sure if these exists in the US?

I've been occasionally using Microsoft's RDP Client [0] on my iPhone with external keyboard + mouse with a usb-c cable into my external monitor (with a Logitech RF dongle connected to the back of it).

It worked okay, the mouse support is somewhat of a hack, but keyboard works awesome.

The biggest annoyance was actually getting RDP to work satisfactory on a linux box with no external monitor plugged in to it (hetzner box).

I thought someone would have created an app to run browser on the external screen in full resolution, so I could skip RDP and use vscode server via the browser. But the only option seems to be infinitex2p which is not available in the EU :(.

[0]: Which in typical Microsoft idiotic fashion semi recently got renamed to "Windows app"... [1]: https://x.com/infinitex2p

Allianz have more than 150k employees with offices in 50+ countries. Not all of them need access to the CRM of course, but I think going back to on-prem is just asking for different kind of trouble.

We don't have any details now, but I wouldn't be surprised if the cloud-based CRM provider didn't have a very technical interesting weakness, but rather that some kind of social engineeringy method was used.

If global companies like this instead had stuff running on-prem all around the world the likelihood of more technical vulnerabilities seems MORE likely to me.

(Air gapping is of course possible, but in my experience, outside of the most security sensitive areas the downsides are simply not acceptable. Or the "air gapping" is just the old "hard shell" / permitter based access-model...)

It’s pretty clear if you check github that Azure’s services and documentation are written by distributed teams with little coordination.

I've come to the same conclusion after dealing (and reporting) jankyness in both the Azure (ARM) API and especially the CLI. [0] is a nice issue I look at every once in a while. I think an installed az cli is now 700 MB+ of Python code and different bundled python versions...

[0] https://github.com/Azure/azure-cli/issues/7387

As mentioned in the thread and expanded on the blog [0] moxie is also against the whole idea of federation and multiple clients.

I think my perception has changed in the last ≈ 10 years, to be more leaning in moxie's direction. It's hard enough to design something secure and usable, having to try and support all different implementations under the sun makes most federated approaches never reach any mass adoption.

Even though it's not a one-to-one analog I also think e.g the lack of crypto agility in Wireshark was a very good decision, the same with QUIC having explicit anti-ossification (e.g encrypted headers). Giving enterprise middle boxes the chance to meddle in things is just setting things to hurt for everyone else.

https://signal.org/blog/the-ecosystem-is-moving/

Something similar again is my little tool hemlis [0]

It uses Shamir's secret sharing algorithm to generate shares where the private key is split in n shares with k needed to reconstruct it. The bytes are encoded as word on a PDF (either 'burnt in' or written manually with pen to minimise the risk of storing them on printers etc).

That way you can spread the risk of loosing the physical key, while still maintaining some assurance that e.g your friends can run away with the key (or be compelled to hand it over to some threat actor).

[0] https://github.com/filleokus/hemlis

Looks cool! In the short demo [0] they mention "within a few hundred milliseconds" as VM boot time (I assume?). I wonder how much tweaking they had to do, because this is using the Virtualization.framework, which has been around a while and used by Docker dekstop / Colima / UTM (as an option).

I wonder what the memory overhead is, especially if running multiple containers - as that would spin up multiple VM's.

[0] https://developer.apple.com/videos/play/wwdc2025/346 10:10 and forwards

Surprised to see no discussion of other data structures like dicts/maps, or arrays of arbitrary type. Hopefully they'd be a straightforward extension. IME, apps need collaborative data structures more often than they need pure collaborative text editing.

Totally agree. I guess an array of "atomic" objects, where the properties of the objects can't be changed can be done just by replacing the string with your own type. Changes inside of the object is probably trickier, but maybe it's just about efficiently storing/traversing the tree?

I've also always thoguth it should be possible to create something where the consumer of the helper library (per OP terminology) can hook in their own lightweight "semantic model" logic, to prevent/manage invalid states. A todo item can't both have isDone: true and state: inProgress at the same time. Similar to rich text formatting semantics mentioned in the linked article.

Every year or so I've been toying with the idea of a thin client dev environment. Smallest possible device that can run Linux (or a RDP client) and support being plugged in to a single USB-C dock cable (display, usb for keyboard/mouse and power).

Maybe this is the answer? Even though I don't need the screen, the footprint of a smartphone is smaller than almost all SBC supporting the above requirements.

I haven't seen any hint that the Critical Alerts entitlement would use any special infra compared to regular push notifications.

It's just metadata in the notification body indicating to the device to ignore silent mode etc.

It's e.g used by Pagerduty [0]. It's just a way to override notification settings.

The software for the systems you mention have this entitlement (or some equivalent), but are otherwise completely unrelated to this.

[0] https://support.pagerduty.com/main/docs/mobile-app-settings#...

Agreed, and I would argue that it's even worse on the browser side. We have Chrome and Safari on iOS, the rest is essentially irrelevant. With regards to web standards, Edge is just another Chrome-reskin. When Apple sooner or later looses the WebKit monopoly on iOS, it will all be Chrome...

My "fear" has always been that Meta/Alphabet would slowly but surely migrate their apps over to their own third-party App Store to get past the pesky IDFA limitations[0] and other tracking hurdles.

So far nothing seems to indicate that it's happening. The question is if it's due to Apple's "measures" or just because it is not worthwhile for Meta/Alphabet. I think it's a combination of. But if it was as easy to "side-load" an app on iOS as on macOS - per your suggestion, I'm confident Meta would have done the switch in a heartbeat.

Just imagine if Apple provided nice API's for auto-updating, essentially no limitations on what binaries can be attested, API's/mechanisms for easy migration between AppStore apps and side loaded ones, no scary screens etc. Essentially implementing the DMA to the fullest extent, really honouring the intent of the law. Why wouldn't all the mega apps just move over? And what consequences would it have?

I think it would be awesome to e.g lift the JIT blocking and allow more strange niche things in alternative app stores. But getting all regular people on a wild-west third party app stores for the (ad financed) apps the use every day is just begging for a huge _actual_ loss in privacy.

[0] https://en.wikipedia.org/wiki/Identifier_for_Advertisers#App...

Hmm. I'm not a WebRTC pro but looked into it recently for a hobby project and felt that the typical WebRTC TURN implementation still leaves the TURN server in a quite trusted position. My rough understanding:

- (1) Each client generates a key pair

- (2) The fingerprint of the public key is part of the SDP message each client generates

- (3) The SDP message is somehow exchanged between the clients, out of band, and the session is started. The client's verify the remote peer using the public key from the SDP message.

The problem is that it's not really feasible in most circumstances to exchange the full SDP message out of band, so instead the service provide some mechanism to map a shorter ID (typically in a URL) to a centrally stored copy of the SDP. I think this might be where it happens for filepizza [0].

This means that a malicious file sharing operator, being in control of both the TURN service and the out-of-band signalling mechanism, could just MITM the DTLS connection and snoop on all the data going by. The peer's think they have each others public keys but they just have two keys owned by the server.

[0] https://github.com/kern/filepizza/blob/main/src/channel.ts

Yeah sorry, I'm too focused on backend services.

In other comments to this link people are describing GPS according to my mental model, which is hard to combine with cryptography making it un-spoofable.

If someone can re-broadcast the keystream and control the latency I perceive as a receiver, how would me checking that the MAC is correct help?

"Modern" .NET (previously ".NET Core" v1, v2, v3 - but now just ".NET" v6, v7, v8, v9) works really well on Linux and in containers etc. "Legacy" .NET, .NET Framework, version 4.X, does not.

If you build something new today in .NET land you are using a version that is compatible out of the box with linux, but there's gazillions of LOC .NET Framework out in enterprises that have yet not been migrated/rewritten.

But I don't actually know if Mono is stable enough to run Framework services on Linux?

I don't know how (if at all) Kudu is related to Mono, but on Azure you can run .NET Framework in e.g App Services (which uses Kudo under the hood). It's probably the only way to host a Framework service outside of IIS on a Windows VM. And Kudo contains references to Mono, and looks really linuxy when I've used it.

as if no amount of solar and wind power generation capacity could be an adequate substitute for any amount of geothermal power, because you don't have solar power at night, for example. But actually that's just a question of how much it costs to store the energy until it's needed or transmit it from where it's still being produced.

I guess this depends on the region, at least to some extent. In Northern Europe we've had these periods during fall/winter in recent years where it's cold, essentially dark, and (worst) no wind. It's not really feasible to store ≈multiple days of consumption for tens of millions of people.

In three of the four Swedish price regions I think we are essentially in a situation now where wind power is "worthless" and can't be built out any more, at least not without major changes to consumption patterns. When the wind is blowing there is such high production that prices go almost to 0, and the operators earn ish nothing, and when prices go up there is no wind so no-one can produce.

This phenomenon is something I would like to learn more about. Of course there is an element of frequency illusion mixed in, but this happens every now and again. Some random subject is all of sudden talked / written about by unrelated actors.

It doesn't necessarily have to be anything nefarious about it, papers and YouTubers need stuff to write and talk about after all. But at the same time that can be very beneficial for e.g Quaise in this case. How does it work, I'm guessing a "publicist" is involved somehow? How much does it cost? Has anyone here done something similar?

For Windows signing, use Azure Trusted Signing

I recently checked it out as an alternative to renewing our signing cert, but it doesn't support issuing EV certs.

I've understood it as having an EV code signing cert on Windows is required for drivers, but somehow also gives you better SmartScreen reputation making it useful even for user space apps in enterprisey settings?

Not sure if this is FUD spread by the EV CA's or not though?