HNHacker News
TopNewBestAskShowJobs

kbolino

2,446 karma · joined August 29, 2011

submissionscomments
kbolino··on Let's Encrypt is adding two additional remote perspectives for domain validation
Most apps don't need access to all web sites, they just need access to specific services. If the developer of the app controls some or all of those services, then the app can be coded to require the use of OV/EV certificates. With that rule in place, the app can then also inspect the subject DNs and check for the presence of its own organization details. The end result would be kind of like certificate pinning, except a little more flexible.

For documents, yes this includes things like DocuSign, but also signed PDFs, signed XML, etc. Any situation where a business, nonprofit, government agency, etc., is corporately attesting to something, like the signing of a contract or the public release of a statement, can use an OV/EV certificate.

kbolino··on Let's Encrypt is adding two additional remote perspectives for domain validation
I've looked at this question a bit more closely, and it seems that the Baseline Requirements for WebPKI do not require key rotation unless key compromise is known to have occurred. In other words, while you must get new certificates regularly, you can continue to use the same keypair for them, as long as it continues to meet the security requirements and you don't think it's been stolen. It seems they have judged certificate mis-issuance to be a much more likely threat than key theft. I'm not sure if that same premise would still apply to e-mail, but I wanted to make this correction.
kbolino··on Let's Encrypt is adding two additional remote perspectives for domain validation
Outside of regulatory requirements, they're useful for code signing (the extra hoops frustrate malicious actors, the legal identity behind the cert can be targeted for banning/suing/prosecuting), apps connecting to their own home services, and document signing, off the top of my head.
kbolino··on 2026 is an exciting year for the Rust compiler (and me)
This is a bit of a tangent, but Go generics aren't monomorphized. Each instantiation is "stenciled" down to its GC shape and then the differences among types with the same shape are handled using a "dictionary" which is kind of like Swift's witness tables or Go's own interface vtables. See this description for details: https://github.com/golang/proposal/blob/master/design/generi...

The typical end result sits somewhere between monomorphization and type erasure in terms of generated code and runtime indirection.

kbolino··on Let's Encrypt is adding two additional remote perspectives for domain validation
That only applies when you're replying to someone. It doesn't apply to new conversations or adding someone new to an existing conversation.
kbolino··on Let's Encrypt is adding two additional remote perspectives for domain validation
Certificate revocation applies to all uses of PKI, not just web browsers. In fact, it is an even bigger problem with email, because there are so many more email addresses than web sites.
kbolino··on Let's Encrypt is adding two additional remote perspectives for domain validation
But you can't re-use the private key, and you can't keep the same one around for very long. In a thread about "why can't we do Let's Encrypt but for email", surely we must start by accepting one of the most important lessons of the modern WebPKI era, which is that CRLs and OCSP do not work at the scale involved here, which has led to keys and thus certificates being constantly rotated.

Somebody else already said "key management is the hardest problem" and I wholeheartedly agree.

kbolino··on Let's Encrypt is adding two additional remote perspectives for domain validation
You wouldn't. Let's Encrypt doesn't verify anything more than that the requestor of the HTTPS certificate currently has control over the domain. The equivalent would verify nothing more than that the requestor of the S/MIME certificate currently has control over the email address. This part is actually a fairly standard procedure already, as a lot of websites will send verification emails to fully activate new account signups.
kbolino··on Let's Encrypt is adding two additional remote perspectives for domain validation
Why such a long lifetime?

If you could actually solve the deeper problem of the sender being able to find the correct certificate to use for the recipient(s), then the lifetime could and should be as short as possible, as in days not years. The recipient can decrypt the message forever, as long as they continue to possess the private key, even if the associated certificate expires. Short-lived certificates are the only effective mechanism for dealing with key theft and mis-issuance that works at scale.

kbolino··on Let's Encrypt is adding two additional remote perspectives for domain validation
Without major cross-national legal changes, OV/EV certificates on the open web are pointless at best and misleading to the point of being dangerous at worst. They remain quite useful in specific scenarios outside of normal web browsing, but that's not the issue at hand.
kbolino··on Java sealed classes and exhaustive pattern matching
SQL parameter bindings solve only one part of the problem, that of putting variables into value positions. They don't solve the problem of putting variables into name positions (you cannot "SELECT FROM ?" or anything like it), and they certainly don't solve the problem of dynamic SQL. This is somewhat orthogonal to the topic at hand, but the mentality should be that the problem space is still quite open, with the existing solution being a starting point, not an ending point.
kbolino··on Namecheap just seized and disabled all my domains
It's not a threat.

Most websites don't use CAA records at all. The records can only narrow what CAs are acceptable down from the end user's root trust store, they can't add new CAs to it. And CloudFlare is typically in charge of managing its customers' certificates, so they add CAA records for their own CAs.

If you don't trust CF to manage your certs, you are not in their target market and generally should not use their products.

https://developers.cloudflare.com/ssl/reference/certificate-...

kbolino··on Keyboard differences between Windows and Macs
I'm responding to both your comments to me in one place. My memory here is fuzzy, especially of 16-bit Windows (which I did use, but I was a child at the time). But, from what I can gather, there is an important difference between 16-bit and 32-bit Windows programs.

In 16-bit land, WinMain is an application entrypoint, and launching an already-open application again causes its WinMain to be invoked with hPrevInstance set to a non-NULL value. Here, the distinction between "process" and "application" was nonexistent/irrelevant.

In 32-bit land, WinMain is a process entrypoint, hPrevInstance is always NULL, and launching an already-open application again causes a new process to be spawned by the O/S. If the application wasn't coded for explicit coordination (using O/S-level mutexes or IPC mechanisms), then two or more running copies of the same application are not aware of each other, do not share any resources, and for a long time were not treated as a single "application" by the operating system.

kbolino··on I love software rendering
A lot of the fuzziness of TVs vs. PC monitors was down to the poor signaling (RF modulators, composite video). Some lucky/picky folks had TVs with component video (YPbPr) which produced images about as good as VGA monitors (RGB).

However, CRTs do not have fixed pixel geometries, and even when they produced relatively sharp images, they would seem fuzzier or softer in a side-by-side comparison with an LCD of the same size and resolution.

kbolino··on Apple/macOS silently removed from official Unix registry
They don't make any money on macOS anymore. You get it preinstalled on their computers, you can't buy it separately, you can't install it on other computers, and major upgrades are free.
kbolino··on Keyboard differences between Windows and Macs
This is good detail, but I wasn't comparing to mobile, I was comparing to Macintosh. A native app on Windows has always been more of a loose collection of related files, whereas it is a single file on Macs and is presented as a cohesive unit throughout the operating system. Thus, Cmd+Q was more feasible than a similar shortcut could have been on Windows, and Alt+F4 really was its closest equivalent because Windows didn't organize things the way Mac did.
kbolino··on Keyboard differences between Windows and Macs
> Alt+F4 in Windows has always been "close window", not close app.

Well, if we're talking about traditional Windows behavior, there's no such thing as an app in the first place.

Some programs allowed multiple windows to be open at the same time (e.g. Notepad), and some didn't (e.g. Paint), but for those that did, they spawned each window as its own process. Closing the window closed the process. That two processes shared the same executable had no deeper meaning until Windows XP added taskbar grouping.

kbolino··on Turn off Apple Intelligence on macOS 27 and get its disk space back
I'm not saying it was ever necessary for any of the computers (except maybe the passively-cooled MacBook Air), but that it was necessary for the phones, and so that design was carried over to the computers. There was a considerable gap (18 months) between the release of the M1 Mac Mini, the first Apple Silicon computer, and the release of the M1 Mac Studio, the first Apple Silicon computer with replaceable storage. I'm sure that time wasn't all spent on developing the storage socket, but much of it probably was spent on adapting to and utilizing the larger power and thermal budgets more generally.
kbolino··on Example.com just launched the biggest redesign in decades
It's not as easy to remember, but you can also do:

  data:text/html,<body%20bgcolor="white">
kbolino··on Turn off Apple Intelligence on macOS 27 and get its disk space back
Longer traces and contact connectors require more power and generate more heat to maintain the same level of signal integrity as shorter traces and soldered connections. All modern Apple hardware is downstream of its phone division. They don't make a specialty PC that runs a very different O/S (macOS instead of Windows) anymore, they make a scaled-up phone that runs a slightly different O/S (macOS instead of iOS) now.
kbolino··on Several vulnerabilities have been discovered in the Linux kernel
You may never have dug that deep into their respective documentation, and you may never have even heard of libcurl, but their superficial overlap in ability to download a single file from an HTTP server does not make them "trivially replaceable" with each other (in either direction).

Regardless, even if hypothetical product X could do everything cURL and libcurl do for most people, that wouldn't make cURL/libcurl much less load-bearing, any more than the existence of FreeBSD or Illumos make Linux less load-bearing.

kbolino··on Turn off Apple Intelligence on macOS 27 and get its disk space back
App bundles (what's inside most DMGs) and Windows executables are signed, have been for a long time, and are required to be, by the O/S, in order to execute "normally". Apple uses centralized PKI (the developer's key must be signed by Apple) while Microsoft uses distributed PKI (the developer's key must be signed by a code-signing CA who in turn is approved by Microsoft).
kbolino··on Several vulnerabilities have been discovered in the Linux kernel
> cURL developers just have NIH syndrome.

What does this even mean? cURL is one of the most load-bearing pieces of software in existence. It, and the Linux kernel, which takes a similarly dim view of the CVE system, are the inventors. "Not Invented Here" seems to imply that there is a vast body of peer work for them to draw on to resolve this problem, but who are their peers? As far as I can tell, the answer is something like "Microsoft and Apple", on the one hand, who exist in a totally different, mostly closed-source or at least closed-development, ecosystem, or something like "glibc and OpenSSL" on the other hand, which have their own storied CVE history.

kbolino··on Git 3.0's upcoming SHA-256 default will be a costly mistake
There's a lot of lingering "SSL is just for your bank" sentiment out there. There are other ways to achieve integrity protection than using TLS, and there are even ways to use TLS without WebPKI, but nobody is putting any effort into any of them, and so TLS+WebPKI is the solution, and no website is exempt, because it is fundamentally an infrastructure problem.
kbolino··on Git 3.0's upcoming SHA-256 default will be a costly mistake
The point I'm making is that "backwards compatibility" cannot rely on SHA-1 support being around forever. At some point, all uses of SHA-1 must go. This includes not only the interfaces between Git and external tools, but also Git's internal data structures. Past a certain point in the near future, there cannot be a two-tier Merkle tree system anymore; the SHA-1 tier has to be removed before long.
kbolino··on Git 3.0's upcoming SHA-256 default will be a costly mistake
Allowing both hash algorithms is, from a security standpoint, equivalent to just using the less-secure hash algorithm.

All repos need to end up using SHA-2 exclusively by the end. All tools that speak only SHA-1 need to be made incompatible intentionally. If the SHA-1/SHA-2 hybrid approach could allow that to happen, then it would be useful. If not, then it would just be a waste of time.

kbolino··on Git 3.0's upcoming SHA-256 default will be a costly mistake
I don't particularly like the terminology but, still, the attitude that TLS is just for "sensitive" websites, actions, or data is quite wrong. Even if you don't care about surveillance or ISP ad injection, you should care about infrastructure compromises and exploit injection. It sounds exotic and high effort but it's not. Unless you're personally auditing the coffee shop, airport, library, hotel, etc. Wi-Fi hardware and network before you connect, it could affect you easily. It's not even a choice that reasonably belongs in the hands of website owners, because they don't control all the paths from users back to them. And even residential and municipal ISP networks can get compromised, too, along with data centers and everything in between.
kbolino··on When oil prices spike, where does the money go?
> Do farmers triple or 5x the price of food during droughts?

Yes, actually. The price of 1 pint of real vanilla extract is currently $9.59 at Costco. I have seen it as high as $42.99. That is a nearly 5x spread, and it largely depends on the weather and politics in Madagascar.

kbolino··on Platform-independent SIMD in Go
The exact equivalences between the two languages are not the point, and anyway, Go arrays are fixed-size and have no Java equivalent.

The point is that Java does not have this problem in the language or the standard library. Of course, you should not write racy Go code; the language provides ample ways to avoid the race, such as channels; and the race detector will generally find such racy code, provided you turn it on. However, the issue is that this race leads to memory-safety violations; it can occur especially in code written by novice Go programmers, and it's well acknowledged by the language authors [1].

[1]: https://research.swtch.com/gorace

kbolino··on Platform-independent SIMD in Go
Java arrays are thin pointers to Array objects, which contain the length and data in the same place (on the far side of the pointer). Since thin pointers cannot tear and Array objects cannot be resized, Arrays themselves are always memory-safe in safe code.

Go slices are fat pointers to undecorated memory. The slice itself is a 3-tuple of pointer, length, and capacity. If you append to a slice that's already at capacity, the Go runtime will allocate new memory for you and return a new 3-tuple. If you assign that result to a variable that's also being accessed by another goroutine, the latter can observe the slice in an inconsistent state. It can, for example, see the old pointer but with the new length, allowing out-of-bounds access. None of this requires unsafe code.

The same issue applies to string and interface variables, which are also fat pointers.

← PreviousPage 2 of 34Next →