benmmurphy
benmmurphy on Hacker News
`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.
nice poem at the end of the paper
White didn't use engine assistance in this game, Black may have used engine assistance but I don't think its clear from the moves. Black's moves are theory up to some point so could have been played by someone who was booked up. However, black had very odd move timing which might indicate engine assistance or their game may have been interrupted by real life. Black spent 4 mins out of 15 mins on Qxf2+. Which I think is strange because black has very few serious candidate moves and Bxf2+ has an obvious refutation and otherwise the Black Queen needs to move because its threatened to be captured with check and g7, and c7 are hanging and the Queen can't defend both squares and losing either would be disastrous for Black. However, since White's reply is forced there is an argument that Black should spend time on Qxf2+ calculating variations beyond Kd1 rather than spending time after Kd1 just in case Qxf2+ is not good.
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.
this is interesting. i uploaded a game where white had only 1 legal move, and then this move was flagged as 'highly suspicious' because white made the same move the engine would have made. i think the complexity estimation should take into account the number of legal moves.
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.
`==` 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.
In the UK you can make an order of information to compel directors of a company that is in debt to answer questions about company assets, accounts and records under oath. This can be done in County Court and my understanding it is inexpensive. I'm not sure how useful this is for carrying out an audit because I think its meant to be used for seeing if the debtor has the ability to pay. I think generally incorrect trading during an insolvency is meant to be discovered by the receivers during the insolvency process. Also, I'm not sure if there is an equivalent to an order of information in the US system.
I think if the consignor has not taken the correct steps then there is a risk the receiver would be able to pay other secured creditors using the consignors assets. For example if there are other creditors with liens on the inventory then you are meant to take steps to notify them of your claims on the consigned goods because otherwise the consigned goods could look like inventory to the secured creditor (
https://www.lowenstein.com/news-insights/publications/articl...)
hackernews capitalising Int makes this question kind of confusing. Because the question is meant to be about c++ behaviour but `Int` is not a standard c++ type. But Int is not java because java uses Integer and `Int` is not c# because c# has uses the explicit IntBitsize types. I think maybe the only languages where the title makes sense in is Scala or Swift.
I think the original commenter confused taking the CUBIC implementation from the kernel and rewriting that in Rust for use in their QUIC implementation or they just jumbled their wording. It does make sense to use an existing battle tested implementation of a congestion algorithm because there are potential many real world failure modes that you might not anticipate if you try and write an implementation from scratch.
I think UUIDv7 could make sense but I suspect the recommendations in the spec predate UUIDv7. Also, if you want sorted schemes then there are slightly more efficient schemes than UUIDv7. With UUID you are always sacrificing some bits to distinguish between the UUID types which I guess does not really matter in practice but it seems unnecessary.
Generating 16 random bytes is simpler than generating a random UUID
you know things are bad when lemire.me feels he needs to post an AI slop image :(
wasn't there some meme that 30u30 was some kind of predictor for fraud
The problem with Apache 2 is it might not be completely clear how this works with a Saas product. Of course if you are distributing binaries or source to customers then you are going to run into issues with Apache Licensing. But if you are just running code on your servers then its not so straight forward. However, I guess its likely they were distributing javascript code so that could be a problem for them. Also, I guess regardless of the licensing issues not being honest with your customers when you are a compliance company is not going to be great for business.
it seems like if these statements that were part of the grants were 1FA protected then they should not have been part of the grants in the first place. since having 1FA protected statements in the grants allows the government to compel speech by favouring grants that make approved statements in the same way they can suppress speech by targeting grants that include disfavoured statements. people were previously claiming certain buzzwords needed to be included in order to hurdle the grant process. of course this is probably completely unworkable in practice since you need some kind of description of the grant and almost anything could be seen as some kind of speech that might be favored or punished for political reasons.
The games are on github (
https://github.com/kennethpayne01/project_kahn_public/blob/m...) which might give better context as to how the simulation was run. Based on the code the LLMs only have a rough idea of the rules of the game. For example you can use 'Strategic Nuclear War' in order to force a draw as long as the opponent cannot win on the same turn. So as long as on your first turn you do 'Limited Nuclear Use' then presumably its impossible to actually lose a game unless you are so handicapped that your opponent can force a win with the same strategy. I suspect with knowledge of the internal mechanics of the game you can play in a risk free way where you try to make progress towards a win but if your opponent threatens to move into a winning position then you can just execute the 'Strategic Nuclear War' action.
From the article:
> They also made mistakes in the fog of war: accidents happened in 86 per cent of the conflicts, with an action escalating higher than the AI intended to, based on its reasoning.
Which I guess is technically true but also seems a bit misleading because it seems to imply the AI made these mistakes but these mistakes are just part of the simulation. The AI chooses an action then there is some chance that a different action will actually be selected instead.
i think the use case for setHTML is for user content that contains rich text and to display that safely. so this is not an alternative for escaping text or inserting text into the DOM but rather a method for displaying rich text. for example maybe you have an editor that produces em, and strong tags so now you can just whitelist those tags and use setHTML to safely put that rich text into the DOM without worrying about all the possible HTML parsing edge cases.
i'm not sure if Dtrace interpreter was safer than EBPF. I guess in theory it should be because a JIT is just extra surface area but I'm not sure in practice. Both EBPF and DTrace had bugs. Also, I always thought EBPF JIT was just a translation to machine code and it didn't do any kind of optimization pass so should be very similar to how DTrace works. They both ship byte code to the kernel. But I guess the big difference is EBPF relies more on a verification pass while I think most of DTrace safety verification was performed while executing the bytecode. I remember there was a lot of stuff in EBPF where the verifier was meant to be able statically determine you were only accessing memory you were able to. I think there was a lot of bugs around this because the verifier would assume slightly different behaviour than what the runtime was producing. But this is also not necessarily a JIT problem you could have an interpreter that relied on a static safety pass as well.
There might be health problems associated with these drugs but they need to be compared to the next best option. I think for a lot of people on these drugs the next best option is continuing the status quo which has a lot of negative health outcomes as well.
I can't imagine what would happen if federal agents killed someones son, wife and dog in a firefight when executing a warrant based on a crime that looked like entrapment while a Democrat was in office.
for phones its a bit difficult because i don't think you can egress out ip traffic without root or jailbreak on iphone and iOS. but i guess on desktop this should be possible