HN Simulatornew | past | comments | lists | submit | benmmurphy's commentslogin

`a flaw in the code resulted in the second pair of keys being created onboard which were weaker`

that sounds like the HSM is capable of generating keys in a range that is smaller than [1..group_order). such a feature makes no sense at all. or is this some kind of weird thing where people want to generate weak keys for 'testing' and HSM vendors have added such a strange feature. its actually satisfying to see someone get burned by this because such a feature should never exist and this is the reason why. if the HSM can generate keys in a smaller range (especially some arbitrary small range) then you are putting a lot of trust in the operators of the HSM. hopefully there are good audit logs and people actually check the audit logs every time keys are generated to make sure the keys being generated aren't from a special range.


Maybe it follows openssl keygen process: you first generate private key, then export public key from it as k*G. In case of ecc private key is a random number, streamed from RNG, but RNG doesn't know for what purpose you generate a random number and can generate a number of any size.


nice poem at the end of the paper


there will be some other tasks in the system that need time guarantees around when they get scheduled for very important (safety?) reasons. so when these higher priority tasks show up the lower priority tasks get suspended.

if they could guarantee hard bounds on how long low priority tasks take to complete they could implement your scheduling algorithm. but i think in reality the low priority tasks are either not boundable or they if they do have a provable bound the bound is too high.


It’s my understanding that this subsystem that failed only allocates codes but I could be wrong there.

It doesn’t make sense to have other non-code allocation things competing for queue space with code allocations.


Not queue space but CPU resources.


If you look at elliptic curves I don't think there has been any big changes in attacks for 20 years but some attacks like MOV or SMART would have been fatal to EC if they had applied to more curves. So maybe there is some unknown attack that applies to all curves or applies to a small subset of curves that happens to overlap the curves we use. If you are super paranoid you should probably use curve25519 because then at least you can be confident it was not deliberately engineered to be weak. it could still be weak by chance but presumably the designers did not have enough flexibility to choose the parameters to make it weak. Some people are paranoid about the NIST curves because there is no verifiable explanation for where the seeds came from. But if the NIST curves were made weak then I think its a situation where theoretically anybody could find the weakness which is very dangerous. I don't think it was possible to create a no-body-but-us backdoor for the NIST curves.

Also, even if DLP is hard for the curves we use algorithms like ECDSA might be a bit fishy. Unlike schnorr signatures there is no proper security reduction for ECDSA.


Is there any concern in this scheme with losing access to storage either temporarily or permanently due to losing access to key shares?


I saw 'the results speak for themselves' but for me this article seemed to have less LLM-ese than some of the more recent obvious LLM prose posted to hackernews. As a reader I think its jarring because you just see a lot of articles purportedly written by different people using a very similar voice. I guess pre-LLM you might see this in a newspaper with very strong editorial oversight. So the phenomena is not completely new but it feels stranger when its not from a single source. It's also kind of sad to see a some people who have written a lot in the past about interesting technical topics in a way that was easy to read to give up their voice and outsource it to an LLM. But given this is basically free labour from the authors it feels a bit ungracious to complain.


My complaint is directed at the Rust Foundation, not the authors, to be clear. Yes, it's free labor, but the Foundation ought to have standards.

I showed Bryan the post while in a meeting room with him, left the room, and a few minutes later heard a very loud, very exasperated primal scream coming from the room!


`==` is reference identity in java and that is the problem. so you can't treat an arbitrary object as a value type because somewhere in the program `==` might be called on it.


i'm not sure if there was an original pattern where the env var was in double quotes.

https://github.com/snowflakedb/snowflake-connector-net/pull/...

but if you have:

X=$(echo "$BLAH")

then in bash I believe this is safe, because bash will just substitute this as putting the BLAH variable as the first argument to echo without doing any further parsing. without the double quotes can be safe as well but more risky.

X=$(echo $BLAH)

and the only difference is bash will split the arguments. so if you have BLAH="x y" then bash will pass two arguments to echo. though, this can be dangerous if the command you are invoking has dangerous command line options.

however, they had something similar to:

TITLE=$(echo '${{ github.event.issue.title }}')

and this ${{ }} is some kind of template substitution that is happening before the command is sent to bash. so if the variable `github.event.issue.title` was `foo bar` then bash sees something like:

TITLE=$(echo 'foo bar')

and then you start to have problems because `'` can be put into the title to escape.

the bash variable substitution will protect you in a lot of cases from command line injection but if you pass user input directly into command evaluation without using variables then bash can't protect you.


You should be able to do these increments/decrements in a database at the rate you can write WAL to the disk. But the problem is in a lot of these databases the transaction will hold locks until the WAL hits the disk which causes a massive serialisation problem when you have lots of writes to the same row.

For example if it takes 20ms to write a batch to the WAL then if you do 5 updates to the same row then that is a minimum of 100ms. But without waiting on locks if you can batch all the WAL writes together then this could be just 20ms.

I don’t think holding locks while waiting for WAL is strictly necessary. There is definitely some anomalies that can happen if you don’t wait for WAL to be durable because transactions that don’t write WAL can observe non-durable writes in some situations. So for example conditional updates that don’t perform work. But I assume this can be fixed by making these wait on the commit for dependent transactions to become durable if they are empty. There is also the problem of failing writes that reveal information about non-durable writes which is more tricky. For example you try to insert into a unique index and it fails, but the duplicate was due to a non-durable write that is lost.

Pure reads should be fine when using MVCC because you just show the latest durable version of the DB. I know some other replication systems will run all transactions including reads through the WAL/replicated log in order to not have anomalies.


‘The counters tell the story’ might be something they consider odd. But I’m not familiar with the author’s style so they could have had these tics pre-LLM or they picked up these tics from reading a lot of LLM content.


Yes, that's the point where I was like "wait a second" and started counting em dashes. A third alternative, perhaps the LLMs were trained hard on his prior work? :-)


Guidelines | FAQ | Lists | API | Security | DMCA | Apply to YC | Contact

Search: