Here, the generator is fixed as part of the configuration of the group.
One natural question is whether or not allowing the adversary
to choose the generator helps them.
This variant with a chosen generator could be described as follows:
[!note] Note:
It is convenient to assume that the adversary cannot send a P
equal to the identity point, which makes the rest of the proofs smoother.
Sending the identity point also forces the adversary to guess randomly,
so it's not a good strategy anyhow.
Now, clearly DLog≤CLog.
The question is, if DLog is hard, what can we say about CLog?
Does being able to choose the generator help?
A little bit, at least with the techniques I've managed to gather together.
In particular, we can show that:
CLog≤DLog
If anyone knows how to get a tighter bound, I'm all ears!
[!note] Note:
I'm assuming that we're working in a group of prime order q,
and thus that all points besides the identity are generators.
Reduction from Multi-CLog
Instead of reducing directly from CLog, we instead reduce
from a variant where the adversary needs to solve multiple challenges
on their provided generator:
In this section, we show that CLog2≤DLog,
which gives us the aforementioned result that CLog≤DLog, combining the two reductions.
Lemma:CLog2≤DLog
The basic idea is that two queries are enough to learn
the discrete logarithm of G with respect to P, and some point
X with respect to P.
We combine these two pieces of information to learn the discrete
logarithm of X with respect to G.
First, note that the adversary's perspective is the same.
They see two uniformly random group elements (thanks to our obligation
that P is a generator).
So, it boils down to whether or not our check is equivalent
First, note that the check we're supposed to be doing is that:
r^⋅Px^⋅P=r⋅G=x⋅G
Or, considering P to have discrete logarithm p, that:
r^⋅px^⋅p=r=x
Note that we manually check the first equation, and so if that's
false, we behave in the same way, by rejecting.
So, assume that r^p=r.
In this case, p=r^r,
and so applying that to the second equation gives us
x^r^r=?x,
and so our discrete logarithm game will tell us that correctly.
■
Reducing CLog to Multi-CLog
In this section, we prove that CLog≤nCLogn.
The idea is simple, although unfortunately not a straight line reduction.
(I should encapsulate this into one of "my" "state-separable proof gadgets")
The idea is that given an adversary A for CLog,
you create an adversary B for CLogn by repeatedly rewinding
the adversary back to the point after sending P, you then feed them
a different Xi each time, getting back x^1,…,x^n
across the different forks.
Because each Xi has the same distribution as in CLog,
the probability of succeeding is bounded below by CLogn,
since we have n forked instances which need to succeed.
This gives us our result.
Putting everything together
To recap, we have:
CLogCLog2≤CLog2≤DLog
which implies:
CLog≤DLog
I have a hunch that the square root loss in security is essential,
but getting this tighter would be quite interesting, imo.