Monero Research Lab Meeting - Wed 03 July 2024, 17:00 UTC

Logs:

< rucknium:monero.social > Meeting time! https://github.com/monero-project/meta/issues/1034

< kayabanerve:monero.social > 👋

< rucknium:monero.social > 1) Greetings

< jberman > waves

< rbrunner > Hello

< chaser:monero.social > hello

< vtnerd:monero.social > Hi

< jeffro256:monero.social > Howdy

< rucknium:monero.social > 2) Updates. What is everyone working on?

< kayabanerve:matrix.org > Organizing research/audits, as usual.

< rucknium:monero.social > me: Helping with stressnet. Successfully (I think) ran the Dulmage-Mendelsohn Decomposition on a simulated set of transactions that have been flooded by black marbles. Running some stats on the mainnet p2p transaction logs to see if they have evidence of the black marble flooding.

< jeffro256:monero.social > me: polishing fix PR for subaddress-related temporary scanning misses

< jberman > me: grow_tree and trim_tree are approaching production-grade ready, continuing on trim_tree this week

< vtnerd:monero.social > I worked on LWS frontend API.

< rucknium:monero.social > 3) Stress testing monerod https://github.com/monero-project/monero/issues/9348

< rucknium:monero.social > Maybe rbrunner can explain what he found in "Daemons processing big blocks may bump against serializer sanity checks and fail to sync" https://github.com/monero-project/monero/issues/9388

< rbrunner > It's mostly described in the issue.

< rbrunner > The short version: Sanity checks, put in place a few years ago, trigger if daemons asks other daemons for 20 very large blocks

< rbrunner > because asking for 20 blocks is what they do per default

< rbrunner > The immediate "band aid" measure on stressnet was syncing single blocks, before the root issue was known, which works

< rbrunner > I submitted a PR to stressnet to go higher with the sanity checks

< rbrunner > Durable and sensible solution might be to go dynamic with that number of blocks requested, depending on average blocksize

< jeffro256:monero.social > Is that PR on spackle's repo?

< rbrunner > Yes. 3 constants redefined bigger.

< rucknium:monero.social > Here's rbrunner's that set sanity checks higher: https://github.com/spackle-xmr/monero/pull/12

< rbrunner > The behavior is acutally quite funny: The daemon starts to disconnect every other daemon because it thinks they all send it corrupt data :)

< rucknium:monero.social > Here's mine that just set default sync chunk to 1: https://github.com/spackle-xmr/monero/pull/8

< jeffro256:monero.social > Damn 16K bytes per string is a really tiny limit lol

< rbrunner > I think it's 16'000 strings.

< jeffro256:monero.social > Ah I see, that makes more sense

< rucknium:monero.social > We are at about 4MB block size now on stressnet. No one falls behind permanently, but there is some temporary fall-behind and re-org/orphaning at this block size: https://monitor.stressnet.net/

< rbrunner > moneromooo mentioned that they just chose the limits more or less according to gut feeling, not as the result of some testing, or even simulation

< rbrunner > So we probably should not give too much weight to their actual current values

< rucknium:monero.social > ofrnxmr set up a stressnet block explorer at (onion hidden service): http://stressgguj7ugyxtqe7czeoelobeb3cnyhltooueuae2t3avd5ynepid.onion

< jeffro256:monero.social > So blocks could have 820 txs per block, and if there's 20 blocks, then that would go over the string limit?

< rbrunner > It seems so, yes. I saw it in the debugger go over the limit.

< rbrunner > After getting around 30 MB of data

< rbrunner > Although I could not find out where exactly, because that complicated templated serialization code was beyond my debugging fu

< jeffro256:monero.social > Well another issue at hand is why the serializer doesn't check those limits while it is writing out

< rbrunner > Well, duh, yes

< rbrunner > I think it's protection about doctored data that blows up to gigabytes and brings down Monero daemons. Was a thing once as a possible attack, if I remember correctly

< rbrunner > *protection against

< rbrunner > Maybe vtnerd knows more

< rbrunner > I don't plan to work more on this, I think somebody with better knowledge should find a good solution here

< rbrunner > Going dynamic might not be trivial

< vtnerd:monero.social > The current limit was chosen somewhat arbitrarily by moo. My new serializer often does limits based on wire size - a string is frequently required to be of minimum length, etc, instead of a max count. Unfortunately there are still some max counts in a few places that I didn't completely remove

< rucknium:monero.social > Do any devs have requests for what spamming "configuration" to set up on stressnet? Right now we are spamming 1in/2out with 4MB blocks and a small txpool. We can increase the txpool, lower/raise block sizes, maybe try many-input txs to analyze "A lot of 150/2 transactions in the txpool causes memory spike / OOM" https://github.com/monero-project/monero/issues/9317

< jeffro256:monero.social > Doing 1in/16out will let you create the highest number of transactions as quick as possible

< jeffro256:monero.social > Maybe having 150 1-input txs will also cause the issue?

< rucknium:monero.social > We are at about 20 txs/second being confirmed with 4MB blocks

< rbrunner > I think there is nothing special with having 150 1-input transactions? Maybe I misunderstand.

< rbrunner > We have hundreds of transactions going into a single block on stressnet now ...

< kayabanerve:matrix.org > For byte spam, inputs is the way to go.

< rucknium:monero.social > 150 1-input txs is sort of what we are doing now...over and over again

< rbrunner > Without OOM problems, as far as I am aware

< kayabanerve:matrix.org > (except you consume inputs faster than you make them)

< jeffro256:monero.social > And you haven't run into the OOM issue at all?

< rucknium:monero.social > Per byte of data, inputs also take longer to verify than outputs according to my tx performance tests

< rbrunner > Seems so, yes

< rucknium:monero.social > jeffro256: Low-RAM stressnet machines OOM if they have too many connections. On my 4GB node I've set connections to 4in/4out IIRC

< rbrunner > All kinds of problems, but I did not hear about daemons running out of memory. Not on machines with "reasonable" amount of memory to start with

< rucknium:monero.social > You can check the monitor node's RAM use, connections, CPU, etc on https://monitor.stressnet.net/

< rucknium:monero.social > Or did the data collection go down?

< jeffro256:monero.social > nice website ;)

< rucknium:monero.social > I'll check that after the meeting

< rucknium:monero.social > 4) Potential measures against a black marble attack. https://github.com/monero-project/research-lab/issues/119

< rucknium:monero.social > I made progress on two topics.

< rucknium:monero.social > A paper Vijayakumaran, S. 2023, "Analysis of Cryptonote transaction graphs using the Dulmage-Mendelsohn decomposition." Paper presented at 5th Conference on Advances in Financial Technologies (AFT 2023). https://moneroresearch.info/index.php?action=resource_RESOURCEVIEW_CORE&id=39

< rucknium:monero.social > was released with a DM decomposition program written in Rust. I took the transactions that occurred during the suspected black marble flooding and eliminated the "black marbles" and removed black marble ring members from "real" txs. Then I ran the DM decomposition to see if even more ring members could be eliminated.

< rucknium:monero.social > For more info on this attack, see Section 4 "Chain reaction graph attacks" of my https://github.com/Rucknium/misc-research/blob/main/Monero-Black-Marble-Flood/pdf/monero-black-marble-flood.pdf

< rucknium:monero.social > According to my initial calculations, the suspected black marble flooding could reduce 0.5% of rings to effective ring size one (i.e. the real spend could be deduced) without trying any chain reaction graph attacks. In preliminary results, the Dulmage-Mendelsohn Decomposition can double that percentage to 1%. That number is within what I expected.

< rucknium:monero.social > The other topic is analyzing p2p tx broadcast logs. I have two questions.

< rucknium:monero.social > How is the time of queue set in src/cryptonote_protocol/levin_notify.cpp for fluff txs? I think nodes wait for some random time before sending a gossip message with the txs it has accumulated. How is that set?

< rucknium:monero.social > The other question is whether Dandelion++ starts broadcasting at the "top of the minute", e.g. 17:31:00. In the data the gossip message arrival times are not uniformly distributed across the seconds of a minute. It almost looks like D++ does start broadcast at the top of the minute. I see higher probability of receiving a tx gossip message in the first 15 seconds of a minute. Then<clipped message

< rucknium:monero.social > there is a smaller bump at about :40, which is the D++ embargo timeout time.

< rucknium:monero.social > Another explanation is that some entity is broadcasting lots of txs at the top of the minute...like a spammer

< vtnerd:monero.social > I don't see how the code waits until the top of a minute, that sounds like something custom

< rucknium:monero.social > Thanks. Then it's a possible fingerprint

< rucknium:monero.social > If the gossip messages were uniformly distributed across a minute, then each second would have 1.667% of the messages. But what I am seeing is that the 10th second has 1.8%.

< rucknium:monero.social > This is with about 15 million gossip messages. It cannot be random variation

< rucknium:monero.social > Thanks to people who submitted monerod logs :)

< rucknium:monero.social > I asked my first question because I noticed that txs were 'clumped" in gossip messages more than I expected.

< rbrunner > Hmm, I wonder why you would care about minutes if you spam.

< rucknium:monero.social > I mean, I want to understand the process of clumping

< rbrunner > Ah, maybe some primitive throttle that results in this?

< rucknium:monero.social > I don't think the spam script was set to maximum of what it was capable of.

< rucknium:monero.social > 5) Research Pre-Seraphis Full-Chain Membership Proofs. Discuss hiring Cypher Stack for 4 days of work (38 XMR) reviewing Veridise's proofs of the divisor technique. https://www.getmonero.org/2024/04/27/fcmps.html https://repo.getmonero.org/monero-project/ccs-proposals/-/merge_requests/449#note_25181

< rucknium:monero.social > kayabanerve: You wanted to discuss this

< kayabanerve:matrix.org > Yep

< kayabanerve:matrix.org > So the divisor proofs are complete, with ~3-4 hours to spare which is now moving to the R1CS circuit review as available.

< kayabanerve:matrix.org > That means we need to

< kayabanerve:matrix.org > 1) Have the proofs reviewed (which is arguable tertiary since Eagen originally proposed the technique)

< kayabanerve:matrix.org > 2) Potentially be fine extending Veridise's contract 2-3 hours for the full R1CS review which should be less than a grand?

< vtnerd:monero.social > Oh that it is expected if I'm understanding you correctly. There's a fluff delay so txes will be grouped somewhat

< kayabanerve:matrix.org > I solicited two quotes and received one from Cypher Stack on the proof review. It was 38 XMR @ 4 days (I believe 4 days of work, not 4 days of turnaround). cc Diego Salazar to confirm the quote if they're around.

< vtnerd:monero.social > But I wouldn't expect it to happen specifically at the top of a minute

< diego:cypherstack.com > ye

< kayabanerve:matrix.org > So that'd be my endorsement, and now subject to jberman 's co-endorsement (prior solicited yet needing an on-the-record version) and then MRL's.

< rucknium:monero.social > vtnerd: Thanks. I skimmed the code with my non-C++ eyes and I couldn't find how the fluff timer is set. Every X seconds, with a random component?

< kayabanerve:matrix.org > And then, I forgot to bring this up prior, but yes, I'd also like to confirm it's fine if we contract Veridise a few more hours as necessary to complete the R1CS review. It was projected at 5 hours and we're a bit short of that much time remaining. It's all reasonable to me.

< vtnerd:monero.social > I'm skimming the code to remind myself hold on

< jberman > +1 for Cyper Stack divisor proof review, +1 for Veridise contract extension for R1CS review. Both sound solid to me

< rucknium:monero.social > kayabanerve: Thanks. You said you solicited two quotes for the divisor proof review. Any info on the second one?

< kayabanerve:matrix.org > I also have a tertiary topic I'd like to solicit MRL's opinion on, if we have a few minutes after the this Veridise discussion. It should be relatively brief, and is vaguely related to FCMPs, but I apologize if I should've brought it up prior and gotten it officially on the agenda. I only thought of it a couple days ago.

< kayabanerve:matrix.org > I solicited two and received one.

< kayabanerve:matrix.org > Because we didn't actually receive the other quote in a timely fashion (solicited over a week ago), we decided to move on with the proposal from CS which is reasonable and from the very trusted Aaron.

< rucknium:monero.social > "Cyper Stack divisor proof review" and "Veridise contract extension for R1CS review" sound good to me.

< rbrunner > From the little I can really judge this, good for me as well ...

< kayabanerve:matrix.org > I will note we did not solicit a full spread as we originally did. Given the prior prices we've been quoted, I'm definitely preferring working with boutique firms (which is leading to not sending out as many emails and doing as many calls for results probably not worthwhile).

< kayabanerve:matrix.org > rbrunner: Progress :D Exciting things :D Sign over more money and get more progress :D

< rbrunner > Suuure :)

< kayabanerve:matrix.org > On a much more legitimate and descriptive note, the divisor technique is a way to efficiently prove in-circuit a scalar multiplication.

< kayabanerve:matrix.org > We use it to add (and remove) terms to Pedersen Commitments

< kayabanerve:matrix.org > The divisor technique makes the cost 7 multiplicative constraints. Otherwise, it'd be 512.

< kayabanerve:matrix.org > So it's 72x faster than prior state of the art.

< vtnerd:monero.social > The randomized timer is set per connection - slightly longer timeout for in connections. It gets set when there are no txes in the connection queue and gets flushed entirely when it expires. So you should see batches of txes sent

< kayabanerve:matrix.org > The technique was posited by Eagen in 2022. Eagen's divisor work is largely subject to a lot of the same criticism as faced BP++. Aaron Feickert may be a more accurate person to comment as an individual who actually does review.

< kayabanerve:matrix.org > Veridise was prior contracted to do a proper set of proofs for the technique, expanding on the rather sparse notes of Eagen on safety (~ half a page).

< rucknium:monero.social > vtnerd: Thank you!

< aaron:cypherstack.com > I haven't done a thorough review of the divisor preprint, so I can't provide meaningful conclusions on that yet

< kayabanerve:matrix.org > We now have a 12 page document establishing the background and security. While that's arguably already secondary review, Eagen being the primary source, tertiary review of the idea/secondary review of the proofs is reasonable.

< aaron:cypherstack.com > My very initial reading suggested that there could be similar issues as in BP++ (at least the initial version of BP++)

< kayabanerve:matrix.org > So that's all this is. Hiring Cypher Stack/Aaron to do review and ensure we actually get such great performance safely :)

< rucknium:monero.social > IMHO, giving the task of review to a skeptical reviewer is a good move. That's what is proposed AFAIK.

< kayabanerve:matrix.org > By the numbers, I'll also note Veridise (with extension to complete the R1CS review) + this review by Cypher Stack is cheaper than both the Cypher Stack and Goodell quotes to do the proofs AFAICR.

< kayabanerve:matrix.org > If no one has any objections, and the above summary provides sufficient clarity, I'd like to bring up my semi-adjacent topic. Would that be fine with you, Rucknium?

< kayabanerve:matrix.org > (i ask as you execute our agenda)

< rucknium:monero.social > Sounds great. I think we have loose consensus in favor of your two proposals today.

< kayabanerve:matrix.org > 👍

< kayabanerve:matrix.org > My other topic is simply how I want to contract review of the unreviewed hash function in Monero which we rely on for security.

< kayabanerve:matrix.org > This is out of scope of the FCMP work, and the FCMP research budget, but I don't want to throw a researcher into submitting a CCS/MAGIC fundraise without a MRL endorsement.

< kayabanerve:matrix.org > And I'd like to get this review done before the FCMP hard fork so if our unreviewed hash function is found unsafe, we can replace it at that time.

< rbrunner > You mean the CryptoNight "slow hash"?

< kayabanerve:matrix.org > I'm specifically referring to the bespoke hash to point within the Monero codebase, which has been documented yet not reviewed, and I would not be surprised if it had bias.

< kayabanerve:matrix.org > If we're argue it as targeting 126 bits of security, and it has 110, it's fine yet should be deprecated and replaced (and we can replace it any time. Right now, the FCMP++ proposal has the key image generator a variable in the tree. It can be calculated however we want, including fixed to some constant if we had a proposal there)

< kayabanerve:matrix.org > Hm. That's an interesting thought for its own line of research :D

< kayabanerve:matrix.org > Yet to go back to my original point: bespoke hash to point probably not great. We don't know if it's great or acceptably bad or very bad. We should have this reviewed. If not great, FCMP++ should replace it with Elligator or similar.

< kayabanerve:matrix.org > I'd just like to ask MRL that sounds reasonable and if I get a researcher to submit a CCS/MAGIC fund raise, they have backing on the premise being worthwhile.

< aaron:cypherstack.com > Any reason not to simply go with Elligator, as it's well studied?

< aaron:cypherstack.com > Or is that "simply" carrying too much weight

< kayabanerve:matrix.org > Performance, political capital, we still have to do this research to ensure supply hasn't been violated historically.

< kayabanerve:matrix.org > Elligator (at least as used, which may be some variant) does two hash to points and sums them to create a non-biased point AFAIK.

< kayabanerve:matrix.org > A lot of the hash to points discussed for standardization do so from my brief experience with them (which may be incomplete).

< kayabanerve:matrix.org > So I don't want to propose a 50% perf drop without justification. We get the justification it's 'standard' but now we have two hash algos and the old is tech debt still needing impl/maintenance. Even if we said the security alone was sufficient, we still need to understand the security of the old one.

< kayabanerve:matrix.org > And if the old one ends up secure, why move off?

< aaron:cypherstack.com > Yep, basically

< kayabanerve:matrix.org > Considering its keccak256 with some method of determining a y coordinate which is valid, and recovering the x, my expectation/hope is that it's a bn254-esque issue.

< kayabanerve:matrix.org > Deprecate, don't use, still out of human feasibility as understood today.

< rucknium:monero.social > 50% perf drop on this operation means what percent drop on verifying a whole tx?

< kayabanerve:matrix.org > Which means if we replace it, we're fine and can move on.

< rucknium:monero.social > i.e. how important is it?

< kayabanerve:matrix.org > Uhhhh right now or FCMP++s?

< rucknium:monero.social > If you can give an answer on both

< kayabanerve:matrix.org > Right now, we don't cache the key image generator. Every ring signature loads the output and re-runs the hash to point AFAIK.

< kayabanerve:matrix.org > So input verification would decrease... 10-20%? Off-hand estimate?

< kayabanerve:matrix.org > That hash to point will be 1/3 hash functions done by the CLSAG which is dominated by its hashes IIRC.

< aaron:cypherstack.com > Well, presumably you could use a faster hash function with Elligator, no?

< aaron:cypherstack.com > If you'd already be migrating

< kayabanerve:matrix.org > Under FCMP++s, input verification doesn't do a hash to point. We calculate it once per output and save it to the tree.

< kayabanerve:matrix.org > Like honestly, we may even be able to do a static point there now that I think about it.

< aaron:cypherstack.com > e.g. one of the BLAKEs

< kayabanerve:matrix.org > Eh. No. We rely on the explicit hash to point to achieve a binding property in the linking tag and prevent using a view key to burn other outputs.

< kayabanerve:matrix.org > So we'd need to at least solve that problem, and then also redo the considerations on related key attacks.

< kayabanerve:matrix.org > And then even if it wasn't for those issues/necessities, we just had the composition reviewed and I can't sign off on that much time/effort when it's an optimization/protocol simplification at best.

< kayabanerve:matrix.org > Anyways. Should be marginal under FCMP++s, off-hand I'd guess 10-20% worse CLSAG verification due to lack of caching.

< kayabanerve:matrix.org > Aaron Feickert: I'd argue the end hash would need to be 20+% faster to be justified, and likely under the FCMP++ design (which determines and saves the key image). We can make the current CLSAG verify use a variable hash to point yet we'd have to track ring member age with the ring member which is a mess.

< kayabanerve:matrix.org > (if we were picking a new function and justifying it based on performance. A 5% faster algorithm isn't worth complicating the specification)

< aaron:cypherstack.com > Could be interesting to time that out... Elligator-upon-some-BLAKE vs. CN

< kayabanerve:matrix.org > Interesting to time out, I agree :D

< aaron:cypherstack.com > I've seen solid throughput numbers for the BLAKEs, but don't recall what that means for small inputs where "throughput" probably isn't really the measurement you want

< kayabanerve:matrix.org > But again, historical review is necessary to ensure current integrity so I'd just like MRL's endorsement on an effort to find someone to review the current fn for bias/determine how much bias it has.

< rucknium:monero.social > kayabanerve: Can you say if you have a candidate to attempt this?

< kayabanerve:matrix.org > Worst case, it's not collision resistant and we need to start arguing the security of CryptoNote ring signatures? Does CLSAG's soundness hold even if the dynamic generator is non-uniform Aaron Feickert ?

< kayabanerve:matrix.org > Rucknium: No, I asked one person and they deferred believing there to be better candidates. I don't want to cold email the Elligator people before knowing MRL endorses this research.

< kayabanerve:matrix.org > Because I can cold email and organize a CCS, but then CCS will ask for MRL's opinion and we'll be in a MRL meeting a month from now (after I used a bunch of people's time) discussing the premise of this research as we are now :p

< kayabanerve:matrix.org > I'd like to confirm the premise is agreed upon, find a candidate, and then have MRL solely review the specific proposal (not the premise of the proposal, which has become a stated goal)

< rucknium:monero.social > I don't fully understand this specific issue, but I am in favor of funding research on potential vulnerabilities. It sounds like this is that.

< kayabanerve:matrix.org > So don't worry, not going to ask to raise 100k ahead of time as a slush fund for this research :p

< aaron:cypherstack.com > It assumes the hash-to-point function can be modeled as a random oracle

< kayabanerve:matrix.org > Yes but does it have to be a good random oracle for soundness

< kayabanerve:matrix.org > (I can follow up in DMs later, don't worry :) )

< aaron:cypherstack.com > Yeah, probably a little off topic for this meeting

< aaron:cypherstack.com > (basic answer... consequences of "bad" RO unclear)

< rucknium:monero.social > I have a question: If it isn't as secure as we want, can the issue be eliminated on the blockchain by prohibiting new txs with that operation (e.g. use Elligator instead), or do the unspent outputs on the chain need to use the old operation? So it would be harder to stop a vulnerability from being exploited later

< kayabanerve:matrix.org > Yeah, so worst case (<110 bits of security), we'd do follow up work on the CN ring sigs/MLSAG/CLSAG to investigate impact.

< kayabanerve:matrix.org > This effects the key image.

< rucknium:monero.social > Can we get the opinion of tevador about this topic? Or jeffro256 ?

< kayabanerve:matrix.org > Hm. Both affects and effects are arguable as valid there. I meant to type affects but I'm not sure I'm wrong for not doing so...

< kayabanerve:matrix.org > But yeah, we can't move to Elligator universally without enabling double spending all historical outputs.

< rucknium:monero.social > By the way, https://monitor.stressnet.net is back. The data collector script had died.

< kayabanerve:matrix.org > The exact implications of it being bad are unclear.

< kayabanerve:matrix.org > I'd want to say under FCMP++, it'd only break unlinkability? I don't believe we argue soundness at all as premised on the hash to point?

< aaron:cypherstack.com > IIRC soundness would not be directly affected

< kayabanerve:matrix.org > We output I' = I + r_i V and a commitment to r_i. The membership circuit asserts the r_i is consistent. Even if you found a relationship of I to V, it doesn't matter as we computationally bind to the V randomness.

< kayabanerve:matrix.org > Right. So even if the existing points are biased, and you can find relationships for existing points, it shouldn't be an issue.

< aaron:cypherstack.com > At no point do things like commitment binding depend on any particular relationship between the hash output and other generators

< kayabanerve:matrix.org > And we'd stop the ability to produce new unbiased points, so you could only work off what's already on-chain.

< aaron:cypherstack.com > (this was specifically checked)

< kayabanerve:matrix.org > The larger concern is the existing ring signatures, MLSAG historically, and CLSAG. CLSAG very strongly transcripts and I hope its soundness to be fine. Ring signatures... may have some short Schnorr argument? MLSAG, I'd hope to follow CLSAG.

< kayabanerve:matrix.org > But ring signatures' use of hash to point is incredibly load bearing, to a horrific degree.

< kayabanerve:matrix.org > That's its own nightmare. Thankfully, FCMP++s mean we can finally deny TXs with ring signatures (they're still allowed today for migratory purposes).

< kayabanerve:matrix.org > Anyways. Whole thing. Investigating the bias would be the first step to any discussion.

< aaron:cypherstack.com > FWIW I can take a closer look at the CLSAG security proofs later to investigate this more thoroughly

< aaron:cypherstack.com > It's a good question

< aaron:cypherstack.com > (anyone else is of course welcome to do this too)

< kayabanerve:matrix.org > Part of me doesn't want you to waste your time before we determine bias, yet I'd explicitly be curious if MLSAG/CLSAG soundness holds upon a bad ROM here.

< rucknium:monero.social > kayabanerve: A decision on this can wait until next meeting, right? Maybe get more opinions and discuss next time.

< kayabanerve:matrix.org > it can? It just delays my contacting people. I have yet to hear any objections into this research which is obviously ambiguous, and in the worst case, enables forging key images/proofs.

< aaron:cypherstack.com > Eh, I'm curious :D

< kayabanerve:matrix.org > So if you want the official position to be until next meeting, sure, yet I personally think the premise has been well received enough I'm fine moving forward.

< aaron:cypherstack.com > "Do random oracles actually exist" is a major load-bearing question for a lot of cryptography...

< kayabanerve:matrix.org > But also yes, I'd love tevador's opinion.

< kayabanerve:matrix.org > (And if I'm fine moving forward, I get it's not yet officially MRL backed and promise to not so represent it ;) )

< kayabanerve:matrix.org > If MLSAG/CLSAG holds, the absolute worst case is we migrate all existing RCT outputs yet not all historical CN outputs. Then we turnstile those so it goes from inflation to theft.

< kayabanerve:matrix.org > (migrate into FCMP++)

< kayabanerve:matrix.org > I have nothing else to say immediately on this (and apologies it took much longer than expected), other than the above comment being why this review should complete before the FCMP++ PR is finalized. We can finish discussions next week for any official endorsement of the research topic (though yes, I'll probably start reaching out prior to the official endorsement). I have not<clipped message

< kayabanerve:matrix.org > hing else to say on FCMPs other than congrats to CS for the new work.

< rucknium:monero.social > --- END MEETING ---

< rucknium:monero.social > Thanks, everyone.

_< sgp:monero.social >__ thank you

< midipoet > Is the 'hash to point' function the only one in the current protocol that doesn't already have a formal review conducted (and one assumes published)?

< kayabanerve:matrix.org > There are two hash to point functions, technically. Informally, decompress(keccak256()), which has a failure rate, and map(keccak256()), used for key image generators and without a failure rate.

< kayabanerve:matrix.org > The former is only used for the generator H. The latter is used for key image generators and BP generators.

< kayabanerve:matrix.org > Aaron Feickert: should be able to comment that the former is fine? They may decline to as the exact security properties may be difficult to define exactly, yet I've never heard it implied to be significantly faulty.

< aaron:cypherstack.com > The former should be fine, yes

< kayabanerve:matrix.org > I'll also note Shen notated the function a bit, and cited other hash to points at the time (noting how this construction was distinct). Unfortunately, they didn't work on positing it as comparable/secure. My points of contact will presumably be the people who proposed the hash to points being standardized, some modern researchers, and potentially one or two who have similar constructions.

< kayabanerve:matrix.org > (if anyone are similar)

< midipoet > Excuse my ignorance, but why would the former be fine, and not the latter?

< kayabanerve:matrix.org > Because decompression effectively forces rejection sampling until it finds a valid y.

< kayabanerve:matrix.org > The map function does coercion which may produce a non-uniform y.

< UkoeHB > The cryptonote hash-to-point originates in this paper: https://arxiv.org/pdf/0706.1448. And is informally described by Shen Noether in https://web.getmonero.org/resources/research-lab/pubs/ge_fromfe.pdf

< midipoet > kayabanerve: i really appreciate that explanation. I actually think i understand it!

< midipoet > UkoeHB: nice, thanks.

< kayabanerve:matrix.org > UkoeHB: Shen described it as novel. TIL there is a citation for it.

< kayabanerve:matrix.org > Do you have further background on where/when that was found? I'm pulling it up ro compare now

< kayabanerve:matrix.org > *to

< kayabanerve:matrix.org > Not to say the theory isn't related, yet the formula Shen notated do not appear present in the former paper.

< kayabanerve:matrix.org > That could be notational, I won't claim to know either algorithm expertly after 10m, or could be a lack of equivalence.

< kayabanerve:matrix.org > Or it could be how the former isn't for hashing to twisted edwards and the latter would have to embed the map from the Weierstrass curve in order to hash to a twisted edwards point.

< kayabanerve:matrix.org > Pulled up ZtM. It cites the CryptoNote WP for that claim.

< kayabanerve:matrix.org > Found the relevant citation in the CN WP. I'd have to ping Aaron Feickert on if the former actually lines up with the latter, assuming some Weierstrass map was crammed in?

< UkoeHB > I never looked into the math of it, so not sure if the citation is accurate.

monero-project / meta

Monero Research Lab Meeting - Wed 03 July 2024, 17:00 UTC #1034

1030