< Summary

Information
Class: Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECAlgorithms
Assembly: Renci.SshNet
File(s): \home\appveyor\projects\ssh-net\src\Renci.SshNet\Security\BouncyCastle\math\ec\ECAlgorithms.cs
Line coverage
13%
Covered lines: 43
Uncovered lines: 275
Coverable lines: 318
Total lines: 496
Line coverage: 13.5%
Branch coverage
7%
Covered branches: 9
Total branches: 116
Branch coverage: 7.7%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity Line coverage
IsF2mCurve(...)100%10%
IsF2mField(...)0%40%
IsFpCurve(...)100%1100%
IsFpField(...)100%1100%
SumOfMultiplies(...)0%160%
SumOfTwoMultiplies(...)0%60%
ShamirsTrick(...)100%10%
ImportPoint(...)50%283.33%
MontgomeryTrick(...)100%10%
MontgomeryTrick(...)100%6100%
ReferenceMultiply(...)0%100%
ValidatePoint(...)0%20%
CleanPoint(...)50%283.33%
ImplCheckResult(...)50%280%
ImplShamirsTrickJsf(...)0%20%
ImplShamirsTrickWNaf(...)0%80%
ImplShamirsTrickWNaf(...)0%80%
ImplShamirsTrickWNaf(...)0%200%
ImplSumOfMultiplies(...)0%20%
ImplSumOfMultipliesGlv(...)0%60%
ImplSumOfMultiplies(...)0%20%
ImplSumOfMultiplies(...)0%180%

File(s)

\home\appveyor\projects\ssh-net\src\Renci.SshNet\Security\BouncyCastle\math\ec\ECAlgorithms.cs

#LineLine coverage
 1using System;
 2
 3using Renci.SshNet.Security.Org.BouncyCastle.Math.EC.Endo;
 4using Renci.SshNet.Security.Org.BouncyCastle.Math.EC.Multiplier;
 5using Renci.SshNet.Security.Org.BouncyCastle.Math.Field;
 6
 7namespace Renci.SshNet.Security.Org.BouncyCastle.Math.EC
 8{
 9    internal class ECAlgorithms
 10    {
 11        public static bool IsF2mCurve(ECCurve c)
 012        {
 013            return IsF2mField(c.Field);
 014        }
 15
 16        public static bool IsF2mField(IFiniteField field)
 017        {
 018            return field.Dimension > 1 && field.Characteristic.Equals(BigInteger.Two)
 019                && field is IPolynomialExtensionField;
 020        }
 21
 22        public static bool IsFpCurve(ECCurve c)
 923        {
 924            return IsFpField(c.Field);
 925        }
 26
 27        public static bool IsFpField(IFiniteField field)
 928        {
 929            return field.Dimension == 1;
 930        }
 31
 32        public static ECPoint SumOfMultiplies(ECPoint[] ps, BigInteger[] ks)
 033        {
 034            if (ps == null || ks == null || ps.Length != ks.Length || ps.Length < 1)
 035                throw new ArgumentException("point and scalar arrays should be non-null, and of equal, non-zero, length"
 36
 037            int count = ps.Length;
 038            switch (count)
 39            {
 40                case 1:
 041                    return ps[0].Multiply(ks[0]);
 42                case 2:
 043                    return SumOfTwoMultiplies(ps[0], ks[0], ps[1], ks[1]);
 44                default:
 045                    break;
 46            }
 47
 048            ECPoint p = ps[0];
 049            ECCurve c = p.Curve;
 50
 051            ECPoint[] imported = new ECPoint[count];
 052            imported[0] = p;
 053            for (int i = 1; i < count; ++i)
 054            {
 055                imported[i] = ImportPoint(c, ps[i]);
 056            }
 57
 058            GlvEndomorphism glvEndomorphism = c.GetEndomorphism() as GlvEndomorphism;
 059            if (glvEndomorphism != null)
 060            {
 061                return ImplCheckResult(ImplSumOfMultipliesGlv(imported, ks, glvEndomorphism));
 62            }
 63
 064            return ImplCheckResult(ImplSumOfMultiplies(imported, ks));
 065        }
 66
 67        public static ECPoint SumOfTwoMultiplies(ECPoint P, BigInteger a, ECPoint Q, BigInteger b)
 068        {
 069            ECCurve cp = P.Curve;
 070            Q = ImportPoint(cp, Q);
 71
 72            // Point multiplication for Koblitz curves (using WTNAF) beats Shamir's trick
 073            {
 074                AbstractF2mCurve f2mCurve = cp as AbstractF2mCurve;
 075                if (f2mCurve != null && f2mCurve.IsKoblitz)
 076                {
 077                    return ImplCheckResult(P.Multiply(a).Add(Q.Multiply(b)));
 78                }
 079            }
 80
 081            GlvEndomorphism glvEndomorphism = cp.GetEndomorphism() as GlvEndomorphism;
 082            if (glvEndomorphism != null)
 083            {
 084                return ImplCheckResult(
 085                    ImplSumOfMultipliesGlv(new ECPoint[] { P, Q }, new BigInteger[] { a, b }, glvEndomorphism));
 86            }
 87
 088            return ImplCheckResult(ImplShamirsTrickWNaf(P, a, Q, b));
 089        }
 90
 91        /*
 92        * "Shamir's Trick", originally due to E. G. Straus
 93        * (Addition chains of vectors. American Mathematical Monthly,
 94        * 71(7):806-808, Aug./Sept. 1964)
 95        *
 96        * Input: The points P, Q, scalar k = (km?, ... , k1, k0)
 97        * and scalar l = (lm?, ... , l1, l0).
 98        * Output: R = k * P + l * Q.
 99        * 1: Z <- P + Q
 100        * 2: R <- O
 101        * 3: for i from m-1 down to 0 do
 102        * 4:        R <- R + R        {point doubling}
 103        * 5:        if (ki = 1) and (li = 0) then R <- R + P end if
 104        * 6:        if (ki = 0) and (li = 1) then R <- R + Q end if
 105        * 7:        if (ki = 1) and (li = 1) then R <- R + Z end if
 106        * 8: end for
 107        * 9: return R
 108        */
 109        public static ECPoint ShamirsTrick(ECPoint P, BigInteger k, ECPoint Q, BigInteger l)
 0110        {
 0111            ECCurve cp = P.Curve;
 0112            Q = ImportPoint(cp, Q);
 113
 0114            return ImplCheckResult(ImplShamirsTrickJsf(P, k, Q, l));
 0115        }
 116
 117        public static ECPoint ImportPoint(ECCurve c, ECPoint p)
 27118        {
 27119            ECCurve cp = p.Curve;
 27120            if (!c.Equals(cp))
 0121                throw new ArgumentException("Point must be on the same curve");
 122
 27123            return c.ImportPoint(p);
 27124        }
 125
 126        public static void MontgomeryTrick(ECFieldElement[] zs, int off, int len)
 0127        {
 0128            MontgomeryTrick(zs, off, len, null);
 0129        }
 130
 131        public static void MontgomeryTrick(ECFieldElement[] zs, int off, int len, ECFieldElement scale)
 15132        {
 133            /*
 134             * Uses the "Montgomery Trick" to invert many field elements, with only a single actual
 135             * field inversion. See e.g. the paper:
 136             * "Fast Multi-scalar Multiplication Methods on Elliptic Curves with Precomputation Strategy Using Montgomer
 137             * by Katsuyuki Okeya, Kouichi Sakurai.
 138             */
 139
 15140            ECFieldElement[] c = new ECFieldElement[len];
 15141            c[0] = zs[off];
 142
 15143            int i = 0;
 327144            while (++i < len)
 312145            {
 312146                c[i] = c[i - 1].Multiply(zs[off + i]);
 312147            }
 148
 15149            --i;
 150
 15151            if (scale != null)
 9152            {
 9153                c[i] = c[i].Multiply(scale);
 9154            }
 155
 15156            ECFieldElement u = c[i].Invert();
 157
 327158            while (i > 0)
 312159            {
 312160                int j = off + i--;
 312161                ECFieldElement tmp = zs[j];
 312162                zs[j] = c[i].Multiply(u);
 312163                u = u.Multiply(tmp);
 312164            }
 165
 15166            zs[off] = u;
 15167        }
 168
 169        /**
 170         * Simple shift-and-add multiplication. Serves as reference implementation
 171         * to verify (possibly faster) implementations, and for very small scalars.
 172         *
 173         * @param p
 174         *            The point to multiply.
 175         * @param k
 176         *            The multiplier.
 177         * @return The result of the point multiplication <code>kP</code>.
 178         */
 179        public static ECPoint ReferenceMultiply(ECPoint p, BigInteger k)
 0180        {
 0181            BigInteger x = k.Abs();
 0182            ECPoint q = p.Curve.Infinity;
 0183            int t = x.BitLength;
 0184            if (t > 0)
 0185            {
 0186                if (x.TestBit(0))
 0187                {
 0188                    q = p;
 0189                }
 0190                for (int i = 1; i < t; i++)
 0191                {
 0192                    p = p.Twice();
 0193                    if (x.TestBit(i))
 0194                    {
 0195                        q = q.Add(p);
 0196                    }
 0197                }
 0198            }
 0199            return k.SignValue < 0 ? q.Negate() : q;
 0200        }
 201
 202        public static ECPoint ValidatePoint(ECPoint p)
 0203        {
 0204            if (!p.IsValid())
 0205                throw new InvalidOperationException("Invalid point");
 206
 0207            return p;
 0208        }
 209
 210        public static ECPoint CleanPoint(ECCurve c, ECPoint p)
 9211        {
 9212            ECCurve cp = p.Curve;
 9213            if (!c.Equals(cp))
 0214                throw new ArgumentException("Point must be on the same curve", "p");
 215
 9216            return c.DecodePoint(p.GetEncoded(false));
 9217        }
 218
 219        internal static ECPoint ImplCheckResult(ECPoint p)
 18220        {
 18221            if (!p.IsValidPartial())
 0222                throw new InvalidOperationException("Invalid result");
 223
 18224            return p;
 18225        }
 226
 227        internal static ECPoint ImplShamirsTrickJsf(ECPoint P, BigInteger k, ECPoint Q, BigInteger l)
 0228        {
 0229            ECCurve curve = P.Curve;
 0230            ECPoint infinity = curve.Infinity;
 231
 232            // TODO conjugate co-Z addition (ZADDC) can return both of these
 0233            ECPoint PaddQ = P.Add(Q);
 0234            ECPoint PsubQ = P.Subtract(Q);
 235
 0236            ECPoint[] points = new ECPoint[] { Q, PsubQ, P, PaddQ };
 0237            curve.NormalizeAll(points);
 238
 0239            ECPoint[] table = new ECPoint[] {
 0240            points[3].Negate(), points[2].Negate(), points[1].Negate(),
 0241            points[0].Negate(), infinity, points[0],
 0242            points[1], points[2], points[3] };
 243
 0244            byte[] jsf = WNafUtilities.GenerateJsf(k, l);
 245
 0246            ECPoint R = infinity;
 247
 0248            int i = jsf.Length;
 0249            while (--i >= 0)
 0250            {
 0251                int jsfi = jsf[i];
 252
 253                // NOTE: The shifting ensures the sign is extended correctly
 0254                int kDigit = ((jsfi << 24) >> 28), lDigit = ((jsfi << 28) >> 28);
 255
 0256                int index = 4 + (kDigit * 3) + lDigit;
 0257                R = R.TwicePlus(table[index]);
 0258            }
 259
 0260            return R;
 0261        }
 262
 263        internal static ECPoint ImplShamirsTrickWNaf(ECPoint P, BigInteger k,
 264            ECPoint Q, BigInteger l)
 0265        {
 0266            bool negK = k.SignValue < 0, negL = l.SignValue < 0;
 267
 0268            k = k.Abs();
 0269            l = l.Abs();
 270
 0271            int widthP = System.Math.Max(2, System.Math.Min(16, WNafUtilities.GetWindowSize(k.BitLength)));
 0272            int widthQ = System.Math.Max(2, System.Math.Min(16, WNafUtilities.GetWindowSize(l.BitLength)));
 273
 0274            WNafPreCompInfo infoP = WNafUtilities.Precompute(P, widthP, true);
 0275            WNafPreCompInfo infoQ = WNafUtilities.Precompute(Q, widthQ, true);
 276
 0277            ECPoint[] preCompP = negK ? infoP.PreCompNeg : infoP.PreComp;
 0278            ECPoint[] preCompQ = negL ? infoQ.PreCompNeg : infoQ.PreComp;
 0279            ECPoint[] preCompNegP = negK ? infoP.PreComp : infoP.PreCompNeg;
 0280            ECPoint[] preCompNegQ = negL ? infoQ.PreComp : infoQ.PreCompNeg;
 281
 0282            byte[] wnafP = WNafUtilities.GenerateWindowNaf(widthP, k);
 0283            byte[] wnafQ = WNafUtilities.GenerateWindowNaf(widthQ, l);
 284
 0285            return ImplShamirsTrickWNaf(preCompP, preCompNegP, wnafP, preCompQ, preCompNegQ, wnafQ);
 0286        }
 287
 288        internal static ECPoint ImplShamirsTrickWNaf(ECPoint P, BigInteger k, ECPointMap pointMapQ, BigInteger l)
 0289        {
 0290            bool negK = k.SignValue < 0, negL = l.SignValue < 0;
 291
 0292            k = k.Abs();
 0293            l = l.Abs();
 294
 0295            int width = System.Math.Max(2, System.Math.Min(16, WNafUtilities.GetWindowSize(System.Math.Max(k.BitLength, 
 296
 0297            ECPoint Q = WNafUtilities.MapPointWithPrecomp(P, width, true, pointMapQ);
 0298            WNafPreCompInfo infoP = WNafUtilities.GetWNafPreCompInfo(P);
 0299            WNafPreCompInfo infoQ = WNafUtilities.GetWNafPreCompInfo(Q);
 300
 0301            ECPoint[] preCompP = negK ? infoP.PreCompNeg : infoP.PreComp;
 0302            ECPoint[] preCompQ = negL ? infoQ.PreCompNeg : infoQ.PreComp;
 0303            ECPoint[] preCompNegP = negK ? infoP.PreComp : infoP.PreCompNeg;
 0304            ECPoint[] preCompNegQ = negL ? infoQ.PreComp : infoQ.PreCompNeg;
 305
 0306            byte[] wnafP = WNafUtilities.GenerateWindowNaf(width, k);
 0307            byte[] wnafQ = WNafUtilities.GenerateWindowNaf(width, l);
 308
 0309            return ImplShamirsTrickWNaf(preCompP, preCompNegP, wnafP, preCompQ, preCompNegQ, wnafQ);
 0310        }
 311
 312        private static ECPoint ImplShamirsTrickWNaf(ECPoint[] preCompP, ECPoint[] preCompNegP, byte[] wnafP,
 313            ECPoint[] preCompQ, ECPoint[] preCompNegQ, byte[] wnafQ)
 0314        {
 0315            int len = System.Math.Max(wnafP.Length, wnafQ.Length);
 316
 0317            ECCurve curve = preCompP[0].Curve;
 0318            ECPoint infinity = curve.Infinity;
 319
 0320            ECPoint R = infinity;
 0321            int zeroes = 0;
 322
 0323            for (int i = len - 1; i >= 0; --i)
 0324            {
 0325                int wiP = i < wnafP.Length ? (int)(sbyte)wnafP[i] : 0;
 0326                int wiQ = i < wnafQ.Length ? (int)(sbyte)wnafQ[i] : 0;
 327
 0328                if ((wiP | wiQ) == 0)
 0329                {
 0330                    ++zeroes;
 0331                    continue;
 332                }
 333
 0334                ECPoint r = infinity;
 0335                if (wiP != 0)
 0336                {
 0337                    int nP = System.Math.Abs(wiP);
 0338                    ECPoint[] tableP = wiP < 0 ? preCompNegP : preCompP;
 0339                    r = r.Add(tableP[nP >> 1]);
 0340                }
 0341                if (wiQ != 0)
 0342                {
 0343                    int nQ = System.Math.Abs(wiQ);
 0344                    ECPoint[] tableQ = wiQ < 0 ? preCompNegQ : preCompQ;
 0345                    r = r.Add(tableQ[nQ >> 1]);
 0346                }
 347
 0348                if (zeroes > 0)
 0349                {
 0350                    R = R.TimesPow2(zeroes);
 0351                    zeroes = 0;
 0352                }
 353
 0354                R = R.TwicePlus(r);
 0355            }
 356
 0357            if (zeroes > 0)
 0358            {
 0359                R = R.TimesPow2(zeroes);
 0360            }
 361
 0362            return R;
 0363        }
 364
 365        internal static ECPoint ImplSumOfMultiplies(ECPoint[] ps, BigInteger[] ks)
 0366        {
 0367            int count = ps.Length;
 0368            bool[] negs = new bool[count];
 0369            WNafPreCompInfo[] infos = new WNafPreCompInfo[count];
 0370            byte[][] wnafs = new byte[count][];
 371
 0372            for (int i = 0; i < count; ++i)
 0373            {
 0374                BigInteger ki = ks[i]; negs[i] = ki.SignValue < 0; ki = ki.Abs();
 375
 0376                int width = System.Math.Max(2, System.Math.Min(16, WNafUtilities.GetWindowSize(ki.BitLength)));
 0377                infos[i] = WNafUtilities.Precompute(ps[i], width, true);
 0378                wnafs[i] = WNafUtilities.GenerateWindowNaf(width, ki);
 0379            }
 380
 0381            return ImplSumOfMultiplies(negs, infos, wnafs);
 0382        }
 383
 384        internal static ECPoint ImplSumOfMultipliesGlv(ECPoint[] ps, BigInteger[] ks, GlvEndomorphism glvEndomorphism)
 0385        {
 0386            BigInteger n = ps[0].Curve.Order;
 387
 0388            int len = ps.Length;
 389
 0390            BigInteger[] abs = new BigInteger[len << 1];
 0391            for (int i = 0, j = 0; i < len; ++i)
 0392            {
 0393                BigInteger[] ab = glvEndomorphism.DecomposeScalar(ks[i].Mod(n));
 0394                abs[j++] = ab[0];
 0395                abs[j++] = ab[1];
 0396            }
 397
 0398            ECPointMap pointMap = glvEndomorphism.PointMap;
 0399            if (glvEndomorphism.HasEfficientPointMap)
 0400            {
 0401                return ECAlgorithms.ImplSumOfMultiplies(ps, pointMap, abs);
 402            }
 403
 0404            ECPoint[] pqs = new ECPoint[len << 1];
 0405            for (int i = 0, j = 0; i < len; ++i)
 0406            {
 0407                ECPoint p = ps[i], q = pointMap.Map(p);
 0408                pqs[j++] = p;
 0409                pqs[j++] = q;
 0410            }
 411
 0412            return ECAlgorithms.ImplSumOfMultiplies(pqs, abs);
 0413        }
 414
 415        internal static ECPoint ImplSumOfMultiplies(ECPoint[] ps, ECPointMap pointMap, BigInteger[] ks)
 0416        {
 0417            int halfCount = ps.Length, fullCount = halfCount << 1;
 418
 0419            bool[] negs = new bool[fullCount];
 0420            WNafPreCompInfo[] infos = new WNafPreCompInfo[fullCount];
 0421            byte[][] wnafs = new byte[fullCount][];
 422
 0423            for (int i = 0; i < halfCount; ++i)
 0424            {
 0425                int j0 = i << 1, j1 = j0 + 1;
 426
 0427                BigInteger kj0 = ks[j0]; negs[j0] = kj0.SignValue < 0; kj0 = kj0.Abs();
 0428                BigInteger kj1 = ks[j1]; negs[j1] = kj1.SignValue < 0; kj1 = kj1.Abs();
 429
 0430                int width = System.Math.Max(2, System.Math.Min(16, WNafUtilities.GetWindowSize(System.Math.Max(kj0.BitLe
 431
 0432                ECPoint P = ps[i], Q = WNafUtilities.MapPointWithPrecomp(P, width, true, pointMap);
 0433                infos[j0] = WNafUtilities.GetWNafPreCompInfo(P);
 0434                infos[j1] = WNafUtilities.GetWNafPreCompInfo(Q);
 0435                wnafs[j0] = WNafUtilities.GenerateWindowNaf(width, kj0);
 0436                wnafs[j1] = WNafUtilities.GenerateWindowNaf(width, kj1);
 0437            }
 438
 0439            return ImplSumOfMultiplies(negs, infos, wnafs);
 0440        }
 441
 442        private static ECPoint ImplSumOfMultiplies(bool[] negs, WNafPreCompInfo[] infos, byte[][] wnafs)
 0443        {
 0444            int len = 0, count = wnafs.Length;
 0445            for (int i = 0; i < count; ++i)
 0446            {
 0447                len = System.Math.Max(len, wnafs[i].Length);
 0448            }
 449
 0450            ECCurve curve = infos[0].PreComp[0].Curve;
 0451            ECPoint infinity = curve.Infinity;
 452
 0453            ECPoint R = infinity;
 0454            int zeroes = 0;
 455
 0456            for (int i = len - 1; i >= 0; --i)
 0457            {
 0458                ECPoint r = infinity;
 459
 0460                for (int j = 0; j < count; ++j)
 0461                {
 0462                    byte[] wnaf = wnafs[j];
 0463                    int wi = i < wnaf.Length ? (int)(sbyte)wnaf[i] : 0;
 0464                    if (wi != 0)
 0465                    {
 0466                        int n = System.Math.Abs(wi);
 0467                        WNafPreCompInfo info = infos[j];
 0468                        ECPoint[] table = (wi < 0 == negs[j]) ? info.PreComp : info.PreCompNeg;
 0469                        r = r.Add(table[n >> 1]);
 0470                    }
 0471                }
 472
 0473                if (r == infinity)
 0474                {
 0475                    ++zeroes;
 0476                    continue;
 477                }
 478
 0479                if (zeroes > 0)
 0480                {
 0481                    R = R.TimesPow2(zeroes);
 0482                    zeroes = 0;
 0483                }
 484
 0485                R = R.TwicePlus(r);
 0486            }
 487
 0488            if (zeroes > 0)
 0489            {
 0490                R = R.TimesPow2(zeroes);
 0491            }
 492
 0493            return R;
 0494        }
 495    }
 496}
Generated by: ReportGenerator 5.2.0.0
11/29/2023 - 11:22:39 AM
GitHub | reportgenerator.io

Methods/Properties

IsF2mCurve(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECCurve)
IsF2mField(Renci.SshNet.Security.Org.BouncyCastle.Math.Field.IFiniteField)
IsFpCurve(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECCurve)
IsFpField(Renci.SshNet.Security.Org.BouncyCastle.Math.Field.IFiniteField)
SumOfMultiplies(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint[],Renci.SshNet.Security.Org.BouncyCastle.Math.BigInteger[])
SumOfTwoMultiplies(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint,Renci.SshNet.Security.Org.BouncyCastle.Math.BigInteger,Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint,Renci.SshNet.Security.Org.BouncyCastle.Math.BigInteger)
ShamirsTrick(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint,Renci.SshNet.Security.Org.BouncyCastle.Math.BigInteger,Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint,Renci.SshNet.Security.Org.BouncyCastle.Math.BigInteger)
ImportPoint(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECCurve,Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint)
MontgomeryTrick(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECFieldElement[],System.Int32,System.Int32)
MontgomeryTrick(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECFieldElement[],System.Int32,System.Int32,Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECFieldElement)
ReferenceMultiply(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint,Renci.SshNet.Security.Org.BouncyCastle.Math.BigInteger)
ValidatePoint(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint)
CleanPoint(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECCurve,Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint)
ImplCheckResult(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint)
ImplShamirsTrickJsf(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint,Renci.SshNet.Security.Org.BouncyCastle.Math.BigInteger,Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint,Renci.SshNet.Security.Org.BouncyCastle.Math.BigInteger)
ImplShamirsTrickWNaf(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint,Renci.SshNet.Security.Org.BouncyCastle.Math.BigInteger,Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint,Renci.SshNet.Security.Org.BouncyCastle.Math.BigInteger)
ImplShamirsTrickWNaf(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint,Renci.SshNet.Security.Org.BouncyCastle.Math.BigInteger,Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPointMap,Renci.SshNet.Security.Org.BouncyCastle.Math.BigInteger)
ImplShamirsTrickWNaf(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint[],Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint[],System.Byte[],Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint[],Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint[],System.Byte[])
ImplSumOfMultiplies(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint[],Renci.SshNet.Security.Org.BouncyCastle.Math.BigInteger[])
ImplSumOfMultipliesGlv(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint[],Renci.SshNet.Security.Org.BouncyCastle.Math.BigInteger[],Renci.SshNet.Security.Org.BouncyCastle.Math.EC.Endo.GlvEndomorphism)
ImplSumOfMultiplies(Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPoint[],Renci.SshNet.Security.Org.BouncyCastle.Math.EC.ECPointMap,Renci.SshNet.Security.Org.BouncyCastle.Math.BigInteger[])
ImplSumOfMultiplies(System.Boolean[],Renci.SshNet.Security.Org.BouncyCastle.Math.EC.Multiplier.WNafPreCompInfo[],System.Byte[][])