Score:4

Do you know protocols, where it is necessary to obtain several "independent" points on the same elliptic curve?

id flag

Consider an elliptic curve $E$ defined over a finite field $\mathbb{F}_{\!q}$ with a fixed non-zero $\mathbb{F}_{\!q}$-point $P$. For simplicity, let the order of the $\mathbb{F}_{\!q}$-point group $E(\mathbb{F}_{\!q})$ be prime and hence the group is generated by $P$. For the sake of security, in numerous protocols of elliptic cryptography (e.g., in a safe version of Dual_EC_DRBG) we need to generate yet another "independent" $\mathbb{F}_{\!q}$-point $Q$ on $E$.

Please answer the question. Do you know protocols, where it is necessary to obtain more "independent" $\mathbb{F}_{\!q}$-points on the same curve ? In other words, a party deals with "independent" $\mathbb{F}_{\!q}$-points $Q_1$, $Q_2$, $\ldots$, $Q_n$ in addition to $P$. By "independent" I mean such points that no one knows the discrete logarithms relative to each other.

I ask you, because for some $E$ and $n$ I know how to produce simultaneously several $Q_i$ faster than separate generation of them. I would like to understand whether my approach is worthy of publication in a good scientific journal. Or maybe it even has something to do with real world cryptography.

eckes avatar
us flag
Maybe some multi-party ECDH based key agreements?
Dimitri Koshelev avatar
id flag
@eckes, could you precise your comment ?
Score:8
my flag

Do you know protocols where it is necessary to obtain several "independent" points on the same elliptic curve?

One obvious place where this occurs if you are implementing a Pedersen commitment of a vector of values; you commit to a vector $(x_1, x_2, ..., x_n)$ by publishing the value $rH + x_1G_1 + x_2G_2 + ... + x_nG_n$; for this to work, you obviously need $n+1$ independent points $H, G_1, G_2, ..., G_n$

While this is a tad obscure, this does come up; a quick Google finds this paper, and so there is some applicability; certainly more than some papers I have seen...

Dimitri Koshelev avatar
id flag
thank you! I don't know much about commitment schemes. Why is not it sufficient to take $n = 1$ ? Does $n > 1$ occur in real world crypto ?
poncho avatar
my flag
@DimitriKoshelev: $n=1$ might not be sufficient if you're trying to take advantage of the homomorphic properties of Pedersen commitments; e.g. given a commitment of $(x_1, x_2)$ and $(y_1, y_2)$ generate a ZKP that $2(x_1, x_2) - 5(y_1, y_2) = (3, 7)$
Dimitri Koshelev avatar
id flag
I forgot to say that my generation method gives $\approx q$ tuples $(Q_i)_{i=1}^n$ among $E^n(\mathbb{F}_{\!q}) \approx q^n$. Isn't this important for security ?
poncho avatar
my flag
@DimitriKoshelev: what's critical (at least, for vector Pedersen commitments) is that no one knows a nontrivial solution for $x_1G_1 + x_2G_2 + ... + x_nG_n = 0$ (where the trivial solution is $x_1 \equiv x_2 \equiv ... \equiv x_n \equiv 0$). Does your idea provide that?
Dimitri Koshelev avatar
id flag
It provides that, but the distribution is far from uniform on $E^n(\mathbb{F}_{\!q})$ (it covers only $\approx q$ tuples). I have the impression that this is not important, because $q$ is big in cryptography and we can change often independent points. What do you think ?
poncho avatar
my flag
@DimitriKoshelev: the hardness assumption I referred to is both necessary and sufficient for the binding property of vector Pedersen; it doesn't really care how many tuples would be possible. Of course, other use cases may make other hardness assumptions on the generated points...
Dimitri Koshelev avatar
id flag
how large is $n$ in practice ?
Geoffroy Couteau avatar
cn flag
"Generalized Pedersen commitments" (that's their name) are now widely used, especially in the context of [Bulletproof](https://eprint.iacr.org/2017/1066.pdf). Bulletproof is implemented and used in Monero, so that counts as "real life" I guess :) Here, $n$ will be typically $32$ or $64$.
Score:2
es flag

There is a "hash-to-point" function used in several schemes, where it is necessary to generate an EC point where the discrete log w.r.t. any other EC point is unknown. In particular:

  1. A linkable ring signature. A 'key image' needs to be generated, where the correctness of the 'key image' declared with a signature is verifiable, and where if the same signer (using the same private key) were to create a ring signature again (even with different other ring member public key participants), it would be clear that they have used the same private key to sign again. See here for details.

  2. An oblivious psuedo-random function uses hash-to-point to encode the PRF input values as EC points. here.

  3. Oblivious transfer uses hash-to-point, and EC El Gamal can use hash-to-point if you only need the encoding of messages into points to go in one direction. See an example of both here.

  4. This non-membership proof uses hash-to-point for a variation on Pedersen commitments where the commitment needs to be blinded, but does not need to be additively homomorphic.

Dimitri Koshelev avatar
id flag
thank you, but I cannot compute a "hash-to-point" function in several arguments faster than separately. My problem is different. I can generate several independent points (depending in only one argument) faster than separately.
knaccc avatar
es flag
@DimitriKoshelev can you clarify what you mean by "depending in only one argument"? And does your technique work when there is a co-factor, and you need to ensure that the point is within the same large subgroup as the large subgroup generated by a particular well-known base point? You might be interested that there was some optimization work done for the Monero cryptocurrency to ensure that an arbitrary byte sequence can be quickly mapped to an Ed25519 point: https://github.com/monero-project/research-lab/blob/master/whitepaper/ge_fromfe_writeup/ge_fromfe.pdf
knaccc avatar
es flag
This is the C and Python code for mapping quickly to valid EC points, based on the paper I linked in the comment above: https://github.com/monero-project/monero/blob/b4e1dc83d275f8ee9a8c12615cf952f05161c7a3/src/crypto/crypto-ops.c#L2210 https://github.com/monero-project/mininero/blob/c5fcee9d8ec8c302bca7fda8ce79b68e20d31c34/mininero.py#L238
Dimitri Koshelev avatar
id flag
Me technique returns a tuple $(Q_i)_{i=1}^n$ depending on a given element of the basic field $\mathbb{F}_{\!q}$. It works when there is a co-factor, because we can always clear it.
knaccc avatar
es flag
@DimitriKoshelev In the examples I've given above, let's say you are doing some kind of private set intersection and the numbers being sent to the OPRF are small integers lower than, say, 100. Depending on how much faster it might be to create a tuple of 100 elements using your technique, perhaps it would be preferable to use your technique than to individually do a hash-to-point operation on each integer input.
Dimitri Koshelev avatar
id flag
my technique does not work in constant time. Hence its applications are restricted to protocols, where arguments of the hash function are not secret.
Score:1
sa flag

Your question is essentially: Is it useful to be able to sample a tuple $(Q_1, Q_2, \dots, Q_n) \in E(F)^n$ such that no relation is known among the points, but the tuple is not sampled from the uniform distribution.

From a practical point of view, there are two issues:

  • Often, these points are sampled during the generation of system parameters, which does not happen very often and is not time critical.
  • Many schemes seem secure even if the points have not been sampled from the uniform distribution.

That is, practically it is often not very useful, but also often not insecure, seemingly at least.

The main objection would be that the security proofs of these schemes sometimes rely on being able to sample the tuple $(Q_1, \dots, Q_n)$ with some trapdoor embedded, and this is often hard to do if you need a non-uniform distribution on the tuple. This would then ruin the security proof. (Example: Suppose I want to be able to equivocate openings of Pedersen multi-commitments.)

Some people may not care about that, but I think most cryptographers would be very reluctant to accept this without any clear benefit to be had.

In other words, I would expect the algorithm you have to be mostly not useful and sometimes unusable.

That said, the algorithm you have come up with may be interesting to some people for some reason, regardless of these obstacles. Or it may have other interesting properties. So it may be worthwhile publishing anyway.

Dimitri Koshelev avatar
id flag
thank you. You write "Often, these points are sampled during the generation of system parameters, which does not happen very often and is not time critical." However, if we don't change often the points, then there is a risk that an attacker can find a dependency between them, especially if $n$ is big. Am I right ?
Dimitri Koshelev avatar
id flag
I didn't understand your paragraph starting from "The main objection ...". Could you clarify ?
sa flag
These points might appear in system parameters, public keys and standards. Long-term objects, in other words. What in particular is it you do not understand?
Dimitri Koshelev avatar
id flag
in fact, I can refine the method to make it uniform. Even then, it works much more efficiently in average than the successive calls of a constant-time map to a curve.
mangohost

Post an answer

Most people don’t grasp that asking a lot of questions unlocks learning and improves interpersonal bonding. In Alison’s studies, for example, though people could accurately recall how many questions had been asked in their conversations, they didn’t intuit the link between questions and liking. Across four studies, in which participants were engaged in conversations themselves or read transcripts of others’ conversations, people tended not to realize that question asking would influence—or had influenced—the level of amity between the conversationalists.