Skip to content

Certificate revocation #11

Open
Open

Description

@jprenken

Unfortunately, this service's design is incompatible with the Let's Encrypt Subscriber Agreement, which does not permit sharing private keys. All publicly trusted Certificate Authorities forbid this type of design; see Section 9.6.3 of the CA/B Forum Baseline Requirements.

Let's Encrypt is obligated to revoke any compromised private keys they become aware of. Accordingly, the certificates corresponding to the private keys leaked via this project have been revoked. Although Let's Encrypt can't offer specific guidance about a redesign, take a look at acme-dns for an example of "middleware" that helps with DNS. The Let's Encrypt community forum may have more detailed suggestions and feedback if you need help.

Activity

  1. perki commented on Aug 2, 2026

    @perki
    Owner

    @jprenken Understood - that's too bad, I was very pleased to share this tool. I'll keep it just for me then, and unpublished it in the upcoming days to continue using it privately.

  2. Nouvborne commented on Aug 9, 2026

    @Nouvborne

    @perki It was a good run, mind if i host it? Many big projects like Feather was relying on it making Feather not work.

  3. jakub-antos commented on Aug 13, 2026

    @jakub-antos

    He is the problem with Feather and the Ryuksign fork is an untrusted SSL certificate for backloop.dev. The whole iOS sideloading scene is now trapped. 🫨

  4. perki commented on Aug 13, 2026

    @perki
    Owner

    @Nouvborne I recommend that you use the same logic with a domain you own.

    I was thinking of doing a proxy server to automatize individual certificate generation on a per hostname, but then it will quickly hit the 50 certificates per domain limit.

  5. Nouvborne commented on Aug 18, 2026

    @Nouvborne

    He is the problem with Feather and the Ryuksign fork is an untrusted SSL certificate for backloop.dev. The whole iOS sideloading scene is now trapped. 🫨

    go to settings > Installation and pick server, Semi Local and switch on Only use localhost address.

  6. perki commented on Sep 4, 2026

    @perki
    Owner
  7. jprenken commented on Sep 4, 2026

    @jprenken
    Author

    @jprenken maybe let's encrypt could bypass the rule ;) - https://medium.com/p/688f9dbac5c2/edit

    Hi, @perki, it looks like that isn't a publicly accessible link.

  8. perki commented on Sep 4, 2026

    @perki
    Owner

    Hi @jprenken Indeed! Posts on Medium are not public anymore. Once again trapped being a product.

    Here is the content of the article .. many Bla Bla .. still there is a gap to fill
    The message for Let's encrypt is at the end ;)

    The certificate everyone could share

    Nine hours.

    That is how long the last certificate lasted. Issued at 10:20 UTC on 31 July 2026, revoked
    at 19:01 the same day, reason keyCompromise. The one before it had lasted weeks. The one
    before that, weeks. For about two years I published a real, browser-trusted wildcard
    certificate for *.backloop.dev, a domain whose every subdomain resolves to 127.0.0.1.
    Anyone could download it and have HTTPS on localhost with nothing installed into any trust
    store. Roughly 350 certificates over the life of it.

    It is over. Not because it stopped being useful, but because it turns out the thing it did
    cannot be done. I want to write down why, because it is the kind of conclusion that is much
    cheaper to read than to reach.

    There is also a way this could still be done properly, and a message for the Let's Encrypt
    team, at the end.

    Why it worked at all

    The pitch was narrow and, I still think, correct. Browsers will not let an HTTPS page talk
    to an HTTP API, or the reverse. On localhost that leaves you choosing between switching off
    security warnings while you develop, or a self-signed certificate that every browser and
    every teammate has to be told to trust. backloop.dev sidestepped both: a real domain
    pointing at loopback, and a real certificate for it, published openly so everyone could
    share the same one.

    The reasoning behind publishing it was that the certificate only ever secures traffic that
    never leaves your machine. Nobody is harmed. Nothing is at risk. I still believe every word
    of that. It is also completely beside the point, which took me two years to understand
    properly.

    Why it ended

    Publishing a certificate for other people to use means publishing its private key. A
    certificate is useless without one. But a publicly trusted certificate whose private key
    has been published is, by definition, a compromised certificate.

    CA/Browser Forum Baseline Requirements §4.9.1.1 obliges a certificate authority to revoke
    within 24 hours of obtaining evidence that a private key is compromised. Not "may". Not
    "should consider". A key sitting on a public web page is exactly that evidence, and it is
    not a judgement the authority is free to make differently: its own place in the trust store
    depends on it not making exceptions.

    So every certificate I published was on a countdown from the moment it went up. What
    changed in 2026 was not the rule. It was the speed of the scanners.

    When What happened
    31 Jul 2026, 10:20 Certificate issued
    31 Jul 2026, 19:01 Revoked, keyCompromise. About nine hours.
    1 Aug 2026 The authority blocklists the domain outright: "The ACME server refuses to issue a certificate for this domain name, because it is forbidden by policy." No practical appeal.
    6 Aug 2026 A commercial wildcard bought from a different authority
    8 Aug 2026, 14:57 Revoked, same reason. About two days.
    4 Sep 2026 Discontinued

    Note the second line of that table. The blocklist is on the domain, not the
    certificate. That is the part that ends the project rather than merely inconveniencing it:
    there is no key rotation, no cleanup, no "this time I'll be careful" that lifts it.

    Three things that do not work around it

    Splitting the key. From December 2024 I published the private key as two files to be
    concatenated. This is the closest thing to a clever idea I had, and I want to be clear
    about the result: it bought time against naive scanners and nothing else. Both 2026
    revocations happened with the split in place. It is a speed bump on a road that goes to the
    same place.

    Changing authority. The two involved shared nothing but the Baseline Requirements, and
    the Baseline Requirements are the constraint. Any authority that learns of a published key
    must revoke, and every authority eventually learns. That is what Certificate Transparency
    is for, and CT is not optional.

    Paying. The commercial certificate lasted two days instead of nine hours. Money buys
    support, not an exemption.

    The general form

    A shared, publicly trusted certificate for localhost cannot be built and kept working.

    This is not a gap in anyone's tooling, and not something a sufficiently clever workaround
    gets around. It is the revocation rule functioning exactly as designed, and that rule is
    the reason every other certificate on the web means anything at all. The uncomfortable part
    of this whole exercise is that the thing which killed my project is a thing I want working
    properly.

    Anyone setting out to build this arrives here. Better to know on the first day than after
    five weeks.

    The gap it leaves, which is real

    The honest advice is to use a local certificate authority: mkcert, Caddy's
    internal CA
    , or vite-plugin-mkcert if you are on Vite. They work, they are
    well made, and you should use them.

    They are not the same thing, and I would rather say so than pretend the replacement is
    seamless. All of them install a root certificate into a trust store. That root can sign for
    any hostname, so its key is now something you have to care about. And every machine that
    must trust your dev server needs its own setup: a teammate's laptop, a CI runner, the phone
    on your desk you use to check the mobile layout, the tablet in the meeting room.

    Devices you do not administer were exactly backloop.dev's use case. Nothing replaces that,
    and nothing can. That is the point of this whole article: a certificate that works on a
    device you do not administer is a publicly trusted one, and a publicly trusted one cannot
    be shared.

    What I would actually do today

    Two things survive, and they are free.

    The DNS is still live. Every subdomain of backloop.dev still resolves to 127.0.0.1 and
    ::1, and a local authority will sign whatever name you ask it to. So:

    mkcert -install
    mkcert '*.backloop.dev' backloop.dev

    gives you a locally trusted wildcard for a domain that already points at your own machine.
    As many clean hostnames as you like (api.backloop.dev, app.backloop.dev,
    auth.backloop.dev), with no /etc/hosts editing and no public certificate anywhere in
    it. That is most of what the project gave you, minus the part that was never sustainable.

    The multi-host gateway from the second article still runs too. It just takes a certificate
    you supply instead of downloading one. The repository has the details.

    If you are thinking of trying this yourself

    If you are reading this thinking it would work if you did it more carefully: it is worse
    now than when I started. The scanners that took weeks in 2024 took nine hours in 2026, and
    what you lose is not a certificate you can reissue. It is the domain.

    What could actually work

    There is a version of this that breaks no rules at all, and I spent a while trying to
    build it before I shut the project down.

    Instead of one certificate shared by everyone, each developer gets their own. You ask for
    alice.backloop.dev, a certificate is issued for that name alone, and the private key is
    generated on your machine and never leaves it. Nothing is published. Nothing is shared.
    There is no compromised key, so there is nothing for an authority to revoke, and §4.9.1.1
    never comes into it. The whole problem described in this article disappears, because the
    problem was never the domain. It was the sharing.

    What stopped me was arithmetic. Let's Encrypt allows 50 certificates per registered domain
    every seven days, counted globally across every account. For backloop.dev that is 50
    certificates a week for every developer in the world put together. It is a sensible limit,
    it exists to prevent exactly the sort of pattern I would have looked like from the outside,
    and it makes an on-demand service on a shared domain impossible to run.

    The mechanism that would fix it already exists. Let's Encrypt uses the Public Suffix
    List
    to decide what counts as a registered domain, and a domain on that list has each
    of its subdomains counted as a registered domain in its own right. That is how services
    like github.io work. On the list, alice.backloop.dev and bob.backloop.dev would each
    have their own budget instead of sharing one, and on-demand issuance becomes ordinary
    rather than abusive. It is not free of side effects, since browsers use the same list and a
    domain on it cannot set apex cookies across its subdomains, but for a local development
    domain that seems a fair price.

    An open note to Let's Encrypt

    If anyone from Let's Encrypt happens to read this, two things.

    First: thank you. Not politely, but specifically. You made TLS free and automatic for
    everyone, you have run it at enormous scale for a decade without drama, and the reason my
    project could exist at all for two years is that issuing a certificate cost nothing and
    took seconds. When you revoked mine you were doing exactly what the rules require, and the
    fact that you enforce them without exception is precisely what makes your certificates
    worth having. I have no complaint. I built something the rules do not allow, and the rules
    were right.

    Second, an offer. I would be glad to hand you backloop.dev. Not to license or to
    share, but to transfer, so that you own and control it outright.

    Every hostname under it resolves to 127.0.0.1 and ::1 and nothing else. A certificate
    issued for anything.backloop.dev can only ever secure a connection that a developer makes
    to their own machine. There is no server to attack, no third party to impersonate, and no
    traffic that leaves the laptop it started on. Put the domain on the Public Suffix List,
    where it belongs, and issue on demand to anyone who asks, with each requester holding their
    own key. Every developer on earth gets real HTTPS on localhost with nothing installed in
    any trust store, and no rule anywhere is bent to do it.

    I have no idea whether that fits anything you want to run, and it is entirely reasonable if
    it does not. But the domain is sitting here, the DNS is already correct, and the offer is
    open and unconditional.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions