ecp_8cpp-source.html

来自「Crypto++是一个非常强大的密码学库,主要是功能全」· HTML 代码 · 共 484 行 · 第 1/3 页

00318                 S = mr.Multiply(fourY2, P.x);
00319                 aZ4 = mr.Multiply(aZ4, sixteenY4);
00320                 M = mr.Square(P.x);
00321                 M = mr.Add(mr.Add(mr.Double(M), M), aZ4);
00322                 P.x = mr.Square(M);
00323                 mr.Reduce(P.x, S);
00324                 mr.Reduce(P.x, S);
00325                 mr.Reduce(S, P.x);
00326                 P.y = mr.Multiply(M, S);
00327                 sixteenY4 = mr.Square(fourY2);
00328                 mr.Reduce(P.y, mr.Half(sixteenY4));
00329         }
00330 
00331         <span class="keyword">const</span> <a class="code" href="class_modular_arithmetic.html">ModularArithmetic</a> &amp;mr;
00332         ProjectivePoint P;
00333         <span class="keywordtype">bool</span> firstDoubling, negated;
00334         <a class="code" href="class_integer.html">Integer</a> sixteenY4, aZ4, twoY, fourY2, S, M;
00335 };
00336 
00337 <span class="keyword">struct </span>ZIterator
00338 {
00339         ZIterator() {}
00340         ZIterator(std::vector&lt;ProjectivePoint&gt;::iterator it) : it(it) {}
00341         <a class="code" href="class_integer.html">Integer</a>&amp; operator*() {<span class="keywordflow">return</span> it-&gt;z;}
00342         <span class="keywordtype">int</span> operator-(ZIterator it2) {<span class="keywordflow">return</span> it-it2.it;}
00343         ZIterator operator+(<span class="keywordtype">int</span> i) {<span class="keywordflow">return</span> ZIterator(it+i);}
00344         ZIterator&amp; operator+=(<span class="keywordtype">int</span> i) {it+=i; <span class="keywordflow">return</span> *<span class="keyword">this</span>;}
00345         std::vector&lt;ProjectivePoint&gt;::iterator it;
00346 };
00347 
00348 <a class="code" href="struct_e_c_p_point.html">ECP::Point</a> ECP::ScalarMultiply(<span class="keyword">const</span> Point &amp;P, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &amp;k)<span class="keyword"> const</span>
00349 <span class="keyword"></span>{
00350         Element result;
00351         <span class="keywordflow">if</span> (k.<a class="code" href="class_integer.html#_integerz41_2">BitCount</a>() &lt;= 5)
00352                 <a class="code" href="class_abstract_group.html">AbstractGroup&lt;ECPPoint&gt;::SimultaneousMultiply</a>(&amp;result, P, &amp;k, 1);
00353         <span class="keywordflow">else</span>
00354                 ECP::SimultaneousMultiply(&amp;result, P, &amp;k, 1);
00355         <span class="keywordflow">return</span> result;
00356 }
00357 
00358 <span class="keywordtype">void</span> ECP::SimultaneousMultiply(<a class="code" href="struct_e_c_p_point.html">ECP::Point</a> *results, <span class="keyword">const</span> <a class="code" href="struct_e_c_p_point.html">ECP::Point</a> &amp;P, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> *expBegin, <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> expCount)<span class="keyword"> const</span>
00359 <span class="keyword"></span>{
00360         <span class="keywordflow">if</span> (!GetField().IsMontgomeryRepresentation())
00361         {
00362                 <a class="code" href="class_e_c_p.html">ECP</a> ecpmr(*<span class="keyword">this</span>, <span class="keyword">true</span>);
00363                 <span class="keyword">const</span> <a class="code" href="class_modular_arithmetic.html">ModularArithmetic</a> &amp;mr = ecpmr.<a class="code" href="class_e_c_p.html#_e_c_pa26">GetField</a>();
00364                 ecpmr.<a class="code" href="class_e_c_p.html#_e_c_pa13">SimultaneousMultiply</a>(results, ToMontgomery(mr, P), expBegin, expCount);
00365                 <span class="keywordflow">for</span> (<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i=0; i&lt;expCount; i++)
00366                         results[i] = FromMontgomery(mr, results[i]);
00367                 <span class="keywordflow">return</span>;
00368         }
00369 
00370         ProjectiveDoubling rd(GetField(), m_a, m_b, P);
00371         std::vector&lt;ProjectivePoint&gt; bases;
00372         std::vector&lt;WindowSlider&gt; exponents;
00373         exponents.reserve(expCount);
00374         std::vector&lt;std::vector&lt;unsigned int&gt; &gt; baseIndices(expCount);
00375         std::vector&lt;std::vector&lt;bool&gt; &gt; negateBase(expCount);
00376         std::vector&lt;std::vector&lt;unsigned int&gt; &gt; exponentWindows(expCount);
00377         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> i;
00378 
00379         <span class="keywordflow">for</span> (i=0; i&lt;expCount; i++)
00380         {
00381                 assert(expBegin-&gt;<a class="code" href="class_integer.html#_integerz41_11">NotNegative</a>());
00382                 exponents.push_back(WindowSlider(*expBegin++, InversionIsFast(), 5));
00383                 exponents[i].FindNextWindow();
00384         }
00385 
00386         <span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> expBitPosition = 0;
00387         <span class="keywordtype">bool</span> notDone = <span class="keyword">true</span>;
00388 
00389         <span class="keywordflow">while</span> (notDone)
00390         {
00391                 notDone = <span class="keyword">false</span>;
00392                 <span class="keywordtype">bool</span> baseAdded = <span class="keyword">false</span>;
00393                 <span class="keywordflow">for</span> (i=0; i&lt;expCount; i++)
00394                 {
00395                         <span class="keywordflow">if</span> (!exponents[i].finished &amp;&amp; expBitPosition == exponents[i].windowBegin)
00396                         {
00397                                 <span class="keywordflow">if</span> (!baseAdded)
00398                                 {
00399                                         bases.push_back(rd.P);
00400                                         baseAdded =<span class="keyword">true</span>;
00401                                 }
00402 
00403                                 exponentWindows[i].push_back(exponents[i].expWindow);
00404                                 baseIndices[i].push_back(bases.size()-1);
00405                                 negateBase[i].push_back(exponents[i].negateNext);
00406 
00407                                 exponents[i].FindNextWindow();
00408                         }
00409                         notDone = notDone || !exponents[i].finished;
00410                 }
00411 
00412                 <span class="keywordflow">if</span> (notDone)
00413                 {
00414                         rd.Double();
00415                         expBitPosition++;
00416                 }
00417         }
00418 
00419         <span class="comment">// convert from projective to affine coordinates</span>
00420         ParallelInvert(GetField(), ZIterator(bases.begin()), ZIterator(bases.end()));
00421         <span class="keywordflow">for</span> (i=0; i&lt;bases.size(); i++)
00422         {
00423                 <span class="keywordflow">if</span> (bases[i].z.NotZero())
00424                 {
00425                         bases[i].y = GetField().Multiply(bases[i].y, bases[i].z);
00426                         bases[i].z = GetField().Square(bases[i].z);
00427                         bases[i].x = GetField().Multiply(bases[i].x, bases[i].z);
00428                         bases[i].y = GetField().Multiply(bases[i].y, bases[i].z);
00429                 }
00430         }
00431 
00432         std::vector&lt;BaseAndExponent&lt;Point, word&gt; &gt; finalCascade;
00433         <span class="keywordflow">for</span> (i=0; i&lt;expCount; i++)
00434         {
00435                 finalCascade.resize(baseIndices[i].size());
00436                 <span class="keywordflow">for</span> (<span class="keywordtype">unsigned</span> <span class="keywordtype">int</span> j=0; j&lt;baseIndices[i].size(); j++)
00437                 {
00438                         ProjectivePoint &amp;base = bases[baseIndices[i][j]];
00439                         <span class="keywordflow">if</span> (base.z.IsZero())
00440                                 finalCascade[j].base.identity = <span class="keyword">true</span>;
00441                         <span class="keywordflow">else</span>
00442                         {
00443                                 finalCascade[j].base.identity = <span class="keyword">false</span>;
00444                                 finalCascade[j].base.x = base.x;
00445                                 <span class="keywordflow">if</span> (negateBase[i][j])
00446                                         finalCascade[j].base.y = GetField().Inverse(base.y);
00447                                 <span class="keywordflow">else</span>
00448                                         finalCascade[j].base.y = base.y;
00449                         }
00450                         finalCascade[j].exponent = exponentWindows[i][j];
00451                 }
00452                 results[i] = GeneralCascadeMultiplication(*<span class="keyword">this</span>, finalCascade.begin(), finalCascade.end());
00453         }
00454 }
00455 
00456 <a class="code" href="struct_e_c_p_point.html">ECP::Point</a> ECP::CascadeScalarMultiply(<span class="keyword">const</span> Point &amp;P, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &amp;k1, <span class="keyword">const</span> Point &amp;Q, <span class="keyword">const</span> <a class="code" href="class_integer.html">Integer</a> &amp;k2)<span class="keyword"> const</span>
00457 <span class="keyword"></span>{
00458         <span class="keywordflow">if</span> (!GetField().IsMontgomeryRepresentation())
00459         {
00460                 <a class="code" href="class_e_c_p.html">ECP</a> ecpmr(*<span class="keyword">this</span>, <span class="keyword">true</span>);
00461                 <span class="keyword">const</span> <a class="code" href="class_modular_arithmetic.html">ModularArithmetic</a> &amp;mr = ecpmr.<a class="code" href="class_e_c_p.html#_e_c_pa26">GetField</a>();
00462                 <span class="keywordflow">return</span> FromMontgomery(mr, ecpmr.<a class="code" href="class_e_c_p.html#_e_c_pa12">CascadeScalarMultiply</a>(ToMontgomery(mr, P), k1, ToMontgomery(mr, Q), k2));
00463         }
00464         <span class="keywordflow">else</span>
00465                 <span class="keywordflow">return</span> <a class="code" href="class_abstract_group.html">AbstractGroup&lt;Point&gt;::CascadeScalarMultiply</a>(P, k1, Q, k2);
00466 }
00467 
00468 NAMESPACE_END
00469 
00470 <span class="preprocessor">#endif</span>
</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue Jul 8 23:34:13 2003 for Crypto++ by
<a href="http://www.doxygen.org/index.html">
<img src="doxygen.png" alt="doxygen" align="middle" border=0 > 
</a>1.3.2 </small></address>
</body>
</html>