bigramx/libraries-tivadar-besthttp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Initial commit

Browse Source
This commit is contained in:
Timur Kozanov
2026-07-03 05:02:26 +03:00
commit 374ff1e689
4080 changed files with 388870 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/AbstractECMultiplier.cs vendored Normal file
View File

@ -0,0 +1,33 @@
#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
#pragma warning disable
namespace Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Multiplier
{
public abstract class AbstractECMultiplier
: ECMultiplier
{
public virtual ECPoint Multiply(ECPoint p, BigInteger k)
{
int sign = k.SignValue;
if (sign == 0 || p.IsInfinity)
return p.Curve.Infinity;
ECPoint positive = MultiplyPositive(p, k.Abs());
ECPoint result = sign > 0 ? positive : positive.Negate();
/*
* Although the various multipliers ought not to produce invalid output under normal
* circumstances, a final check here is advised to guard against fault attacks.
*/
return CheckResult(result);
}
protected abstract ECPoint MultiplyPositive(ECPoint p, BigInteger k);
protected virtual ECPoint CheckResult(ECPoint p)
{
return ECAlgorithms.ImplCheckResult(p);
}
}
}
#pragma warning restore
#endif

18
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/AbstractECMultiplier.cs.meta vendored Normal file
View File

@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 1a02407f48267dc41b4c1ad5125b5462
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 267636
packageName: Best HTTP
packageVersion: 3.0.17
assetPath: Packages/com.tivadar.best.http/Runtime/3rdParty/BouncyCastle/math/ec/multiplier/AbstractECMultiplier.cs
uploadId: 783279

22
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/ECMultiplier.cs vendored Normal file
View File

@ -0,0 +1,22 @@
#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
#pragma warning disable
namespace Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Multiplier
{
/**
* Interface for classes encapsulating a point multiplication algorithm
* for <code>ECPoint</code>s.
*/
public interface ECMultiplier
{
/**
* Multiplies the <code>ECPoint p</code> by <code>k</code>, i.e.
* <code>p</code> is added <code>k</code> times to itself.
* @param p The <code>ECPoint</code> to be multiplied.
* @param k The factor by which <code>p</code> is multiplied.
* @return <code>p</code> multiplied by <code>k</code>.
*/
ECPoint Multiply(ECPoint p, BigInteger k);
}
}
#pragma warning restore
#endif

18
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/ECMultiplier.cs.meta vendored Normal file
View File

@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: f1d6c36605e51984fb5c9c08696690b6
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 267636
packageName: Best HTTP
packageVersion: 3.0.17
assetPath: Packages/com.tivadar.best.http/Runtime/3rdParty/BouncyCastle/math/ec/multiplier/ECMultiplier.cs
uploadId: 783279

69
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/FixedPointCombMultiplier.cs vendored Normal file
View File

@ -0,0 +1,69 @@
#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
#pragma warning disable
using System;
using Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.Raw;
namespace Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Multiplier
{
public class FixedPointCombMultiplier
: AbstractECMultiplier
{
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
ECCurve c = p.Curve;
int size = FixedPointUtilities.GetCombSize(c);
if (k.BitLength > size)
{
/*
* TODO The comb works best when the scalars are less than the (possibly unknown) order.
* Still, if we want to handle larger scalars, we could allow customization of the comb
* size, or alternatively we could deal with the 'extra' bits either by running the comb
* multiple times as necessary, or by using an alternative multiplier as prelude.
*/
throw new InvalidOperationException("fixed-point comb doesn't support scalars larger than the curve order");
}
FixedPointPreCompInfo info = FixedPointUtilities.Precompute(p);
ECLookupTable lookupTable = info.LookupTable;
int width = info.Width;
int d = (size + width - 1) / width;
int fullComb = d * width;
ECPoint R = c.Infinity;
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER || UNITY_2021_2_OR_NEWER
int KLen = Nat.GetLengthForBits(fullComb);
Span<uint> K = KLen <= 32
? stackalloc uint[KLen]
: new uint[KLen];
Nat.FromBigInteger(fullComb, k, K);
#else
uint[] K = Nat.FromBigInteger(fullComb, k);
#endif
for (int i = 1; i <= d; ++i)
{
uint secretIndex = 0;
for (int j = fullComb - i; j >= 0; j -= d)
{
uint secretBit = K[j >> 5] >> (j & 0x1F);
secretIndex ^= secretBit >> 1;
secretIndex <<= 1;
secretIndex ^= secretBit;
}
ECPoint add = lookupTable.Lookup((int)secretIndex);
R = R.TwicePlus(add);
}
return R.Add(info.Offset);
}
}
}
#pragma warning restore
#endif

18
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/FixedPointCombMultiplier.cs.meta vendored Normal file
View File

@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: eda4bde80961d4c48b13132930eafde5
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 267636
packageName: Best HTTP
packageVersion: 3.0.17
assetPath: Packages/com.tivadar.best.http/Runtime/3rdParty/BouncyCastle/math/ec/multiplier/FixedPointCombMultiplier.cs
uploadId: 783279

47
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/FixedPointPreCompInfo.cs vendored Normal file
View File

@ -0,0 +1,47 @@
#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
#pragma warning disable
using System;
namespace Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Multiplier
{
/**
* Class holding precomputation data for fixed-point multiplications.
*/
public class FixedPointPreCompInfo
: PreCompInfo
{
protected ECPoint m_offset = null;
/**
* Lookup table for the precomputed <code>ECPoint</code>s used for a fixed point multiplication.
*/
protected ECLookupTable m_lookupTable = null;
/**
* The width used for the precomputation. If a larger width precomputation
* is already available this may be larger than was requested, so calling
* code should refer to the actual width.
*/
protected int m_width = -1;
public virtual ECLookupTable LookupTable
{
get { return m_lookupTable; }
set { this.m_lookupTable = value; }
}
public virtual ECPoint Offset
{
get { return m_offset; }
set { this.m_offset = value; }
}
public virtual int Width
{
get { return m_width; }
set { this.m_width = value; }
}
}
}
#pragma warning restore
#endif

18
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/FixedPointPreCompInfo.cs.meta vendored Normal file
View File

@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: e78d035a66c7a454b99842dc4f0d6e6b
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 267636
packageName: Best HTTP
packageVersion: 3.0.17
assetPath: Packages/com.tivadar.best.http/Runtime/3rdParty/BouncyCastle/math/ec/multiplier/FixedPointPreCompInfo.cs
uploadId: 783279

99
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/FixedPointUtilities.cs vendored Normal file
View File

@ -0,0 +1,99 @@
#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
#pragma warning disable
using System;
namespace Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Multiplier
{
public class FixedPointUtilities
{
public static readonly string PRECOMP_NAME = "bc_fixed_point";
public static int GetCombSize(ECCurve c)
{
BigInteger order = c.Order;
return order == null ? c.FieldSize + 1 : order.BitLength;
}
public static FixedPointPreCompInfo GetFixedPointPreCompInfo(PreCompInfo preCompInfo)
{
return preCompInfo as FixedPointPreCompInfo;
}
public static FixedPointPreCompInfo Precompute(ECPoint p)
{
return (FixedPointPreCompInfo)p.Curve.Precompute(p, PRECOMP_NAME, new FixedPointCallback(p));
}
private class FixedPointCallback
: IPreCompCallback
{
private readonly ECPoint m_p;
internal FixedPointCallback(ECPoint p)
{
this.m_p = p;
}
public PreCompInfo Precompute(PreCompInfo existing)
{
FixedPointPreCompInfo existingFP = existing as FixedPointPreCompInfo;
ECCurve c = m_p.Curve;
int bits = FixedPointUtilities.GetCombSize(c);
int minWidth = bits > 250 ? 6 : 5;
int n = 1 << minWidth;
if (CheckExisting(existingFP, n))
return existingFP;
int d = (bits + minWidth - 1) / minWidth;
ECPoint[] pow2Table = new ECPoint[minWidth + 1];
pow2Table[0] = m_p;
for (int i = 1; i < minWidth; ++i)
{
pow2Table[i] = pow2Table[i - 1].TimesPow2(d);
}
// This will be the 'offset' value
pow2Table[minWidth] = pow2Table[0].Subtract(pow2Table[1]);
c.NormalizeAll(pow2Table);
ECPoint[] lookupTable = new ECPoint[n];
lookupTable[0] = pow2Table[0];
for (int bit = minWidth - 1; bit >= 0; --bit)
{
ECPoint pow2 = pow2Table[bit];
int step = 1 << bit;
for (int i = step; i < n; i += (step << 1))
{
lookupTable[i] = lookupTable[i - step].Add(pow2);
}
}
c.NormalizeAll(lookupTable);
FixedPointPreCompInfo result = new FixedPointPreCompInfo();
result.LookupTable = c.CreateCacheSafeLookupTable(lookupTable, 0, lookupTable.Length);
result.Offset = pow2Table[minWidth];
result.Width = minWidth;
return result;
}
private bool CheckExisting(FixedPointPreCompInfo existingFP, int n)
{
return existingFP != null && CheckTable(existingFP.LookupTable, n);
}
private bool CheckTable(ECLookupTable table, int n)
{
return table != null && table.Size >= n;
}
}
}
}
#pragma warning restore
#endif

18
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/FixedPointUtilities.cs.meta vendored Normal file
View File

@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 0f1e170e17e148a4c9464bdb52be01ff
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 267636
packageName: Best HTTP
packageVersion: 3.0.17
assetPath: Packages/com.tivadar.best.http/Runtime/3rdParty/BouncyCastle/math/ec/multiplier/FixedPointUtilities.cs
uploadId: 783279

45
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/GlvMultiplier.cs vendored Normal file
View File

@ -0,0 +1,45 @@
#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
#pragma warning disable
using System;
using Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Endo;
namespace Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Multiplier
{
public class GlvMultiplier
: AbstractECMultiplier
{
protected readonly ECCurve curve;
protected readonly GlvEndomorphism glvEndomorphism;
public GlvMultiplier(ECCurve curve, GlvEndomorphism glvEndomorphism)
{
if (curve == null || curve.Order == null)
throw new ArgumentException("Need curve with known group order", "curve");
this.curve = curve;
this.glvEndomorphism = glvEndomorphism;
}
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
if (!curve.Equals(p.Curve))
throw new InvalidOperationException();
BigInteger n = p.Curve.Order;
BigInteger[] ab = glvEndomorphism.DecomposeScalar(k.Mod(n));
BigInteger a = ab[0], b = ab[1];
if (glvEndomorphism.HasEfficientPointMap)
{
return ECAlgorithms.ImplShamirsTrickWNaf(glvEndomorphism, p, a, b);
}
ECPoint q = EndoUtilities.MapPoint(glvEndomorphism, p);
return ECAlgorithms.ImplShamirsTrickWNaf(p, a, q, b);
}
}
}
#pragma warning restore
#endif

18
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/GlvMultiplier.cs.meta vendored Normal file
View File

@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: c4c7314cd6d2f06418c78274c5ef2e62
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 267636
packageName: Best HTTP
packageVersion: 3.0.17
assetPath: Packages/com.tivadar.best.http/Runtime/3rdParty/BouncyCastle/math/ec/multiplier/GlvMultiplier.cs
uploadId: 783279

13
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/IPreCompCallback.cs vendored Normal file
View File

@ -0,0 +1,13 @@
#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
#pragma warning disable
using System;
namespace Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Multiplier
{
public interface IPreCompCallback
{
PreCompInfo Precompute(PreCompInfo existing);
}
}
#pragma warning restore
#endif

18
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/IPreCompCallback.cs.meta vendored Normal file
View File

@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 5d91b3dbf45e2b54783119024704938b
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 267636
packageName: Best HTTP
packageVersion: 3.0.17
assetPath: Packages/com.tivadar.best.http/Runtime/3rdParty/BouncyCastle/math/ec/multiplier/IPreCompCallback.cs
uploadId: 783279

15
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/PreCompInfo.cs vendored Normal file
View File

@ -0,0 +1,15 @@
#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
#pragma warning disable
namespace Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Multiplier
{
/**
* Interface for classes storing precomputation data for multiplication
* algorithms. Used as a Memento (see GOF patterns) for
* <code>WNafMultiplier</code>.
*/
public interface PreCompInfo
{
}
}
#pragma warning restore
#endif

18
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/PreCompInfo.cs.meta vendored Normal file
View File

@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 2d8ee340411030e48bd15afc18fb58f5
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 267636
packageName: Best HTTP
packageVersion: 3.0.17
assetPath: Packages/com.tivadar.best.http/Runtime/3rdParty/BouncyCastle/math/ec/multiplier/PreCompInfo.cs
uploadId: 783279

48
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/ValidityPreCompInfo.cs vendored Normal file
View File

@ -0,0 +1,48 @@
#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
#pragma warning disable
using System;
namespace Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Multiplier
{
internal class ValidityPreCompInfo
: PreCompInfo
{
internal static readonly string PRECOMP_NAME = "bc_validity";
private bool failed = false;
private bool curveEquationPassed = false;
private bool orderPassed = false;
internal bool HasFailed()
{
return failed;
}
internal void ReportFailed()
{
failed = true;
}
internal bool HasCurveEquationPassed()
{
return curveEquationPassed;
}
internal void ReportCurveEquationPassed()
{
curveEquationPassed = true;
}
internal bool HasOrderPassed()
{
return orderPassed;
}
internal void ReportOrderPassed()
{
orderPassed = true;
}
}
}
#pragma warning restore
#endif

18
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/ValidityPreCompInfo.cs.meta vendored Normal file
View File

@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: d3df916ac2529814bb129cca39b3243c
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 267636
packageName: Best HTTP
packageVersion: 3.0.17
assetPath: Packages/com.tivadar.best.http/Runtime/3rdParty/BouncyCastle/math/ec/multiplier/ValidityPreCompInfo.cs
uploadId: 783279

93
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/WNafL2RMultiplier.cs vendored Normal file
View File

@ -0,0 +1,93 @@
#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
#pragma warning disable
using System;
using Best.HTTP.SecureProtocol.Org.BouncyCastle.Utilities;
namespace Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Multiplier
{
/**
* Class implementing the WNAF (Window Non-Adjacent Form) multiplication
* algorithm.
*/
public class WNafL2RMultiplier
: AbstractECMultiplier
{
/**
* Multiplies <code>this</code> by an integer <code>k</code> using the
* Window NAF method.
* @param k The integer by which <code>this</code> is multiplied.
* @return A new <code>ECPoint</code> which equals <code>this</code>
* multiplied by <code>k</code>.
*/
protected override ECPoint MultiplyPositive(ECPoint p, BigInteger k)
{
int minWidth = WNafUtilities.GetWindowSize(k.BitLength);
WNafPreCompInfo info = WNafUtilities.Precompute(p, minWidth, true);
ECPoint[] preComp = info.PreComp;
ECPoint[] preCompNeg = info.PreCompNeg;
int width = info.Width;
int[] wnaf = WNafUtilities.GenerateCompactWindowNaf(width, k);
ECPoint R = p.Curve.Infinity;
int i = wnaf.Length;
/*
* NOTE: We try to optimize the first window using the precomputed points to substitute an
* addition for 2 or more doublings.
*/
if (i > 1)
{
int wi = wnaf[--i];
int digit = wi >> 16, zeroes = wi & 0xFFFF;
int n = System.Math.Abs(digit);
ECPoint[] table = digit < 0 ? preCompNeg : preComp;
// Optimization can only be used for values in the lower half of the table
if ((n << 2) < (1 << width))
{
int highest = 32 - Integers.NumberOfLeadingZeros(n);
// TODO Get addition/doubling cost ratio from curve and compare to 'scale' to see if worth substituting?
int scale = width - highest;
int lowBits = n ^ (1 << (highest - 1));
int i1 = ((1 << (width - 1)) - 1);
int i2 = (lowBits << scale) + 1;
R = table[i1 >> 1].Add(table[i2 >> 1]);
zeroes -= scale;
//Console.WriteLine("Optimized: 2^" + scale + " * " + n + " = " + i1 + " + " + i2);
}
else
{
R = table[n >> 1];
}
R = R.TimesPow2(zeroes);
}
while (i > 0)
{
int wi = wnaf[--i];
int digit = wi >> 16, zeroes = wi & 0xFFFF;
int n = System.Math.Abs(digit);
ECPoint[] table = digit < 0 ? preCompNeg : preComp;
ECPoint r = table[n >> 1];
R = R.TwicePlus(r);
R = R.TimesPow2(zeroes);
}
return R;
}
}
}
#pragma warning restore
#endif

18
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/WNafL2RMultiplier.cs.meta vendored Normal file
View File

@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 3107b79ddf993944ca337671fb2ac54d
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 267636
packageName: Best HTTP
packageVersion: 3.0.17
assetPath: Packages/com.tivadar.best.http/Runtime/3rdParty/BouncyCastle/math/ec/multiplier/WNafL2RMultiplier.cs
uploadId: 783279

89
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/WNafPreCompInfo.cs vendored Normal file
View File

@ -0,0 +1,89 @@
#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
#pragma warning disable
namespace Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Multiplier
{
/**
* Class holding precomputation data for the WNAF (Window Non-Adjacent Form)
* algorithm.
*/
public class WNafPreCompInfo
: PreCompInfo
{
internal volatile int m_promotionCountdown = 4;
protected int m_confWidth = -1;
/**
* Array holding the precomputed <code>ECPoint</code>s used for a Window
* NAF multiplication.
*/
protected ECPoint[] m_preComp = null;
/**
* Array holding the negations of the precomputed <code>ECPoint</code>s used
* for a Window NAF multiplication.
*/
protected ECPoint[] m_preCompNeg = null;
/**
* Holds an <code>ECPoint</code> representing Twice(this). Used for the
* Window NAF multiplication to create or extend the precomputed values.
*/
protected ECPoint m_twice = null;
protected int m_width = -1;
internal int DecrementPromotionCountdown()
{
int t = m_promotionCountdown;
if (t > 0)
{
m_promotionCountdown = --t;
}
return t;
}
internal int PromotionCountdown
{
get { return m_promotionCountdown; }
set { this.m_promotionCountdown = value; }
}
public virtual bool IsPromoted
{
get { return m_promotionCountdown <= 0; }
}
public virtual int ConfWidth
{
get { return m_confWidth; }
set { this.m_confWidth = value; }
}
public virtual ECPoint[] PreComp
{
get { return m_preComp; }
set { this.m_preComp = value; }
}
public virtual ECPoint[] PreCompNeg
{
get { return m_preCompNeg; }
set { this.m_preCompNeg = value; }
}
public virtual ECPoint Twice
{
get { return m_twice; }
set { this.m_twice = value; }
}
public virtual int Width
{
get { return m_width; }
set { this.m_width = value; }
}
}
}
#pragma warning restore
#endif

18
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/WNafPreCompInfo.cs.meta vendored Normal file
View File

@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 7672118dc77b50543998724995fa50b1
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 267636
packageName: Best HTTP
packageVersion: 3.0.17
assetPath: Packages/com.tivadar.best.http/Runtime/3rdParty/BouncyCastle/math/ec/multiplier/WNafPreCompInfo.cs
uploadId: 783279

759
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/WNafUtilities.cs vendored Normal file
View File

@ -0,0 +1,759 @@
#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
#pragma warning disable
using System;
using Best.HTTP.SecureProtocol.Org.BouncyCastle.Utilities;
namespace Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Multiplier
{
public abstract class WNafUtilities
{
public static readonly string PRECOMP_NAME = "bc_wnaf";
private static readonly int[] DEFAULT_WINDOW_SIZE_CUTOFFS = new int[]{ 13, 41, 121, 337, 897, 2305 };
private static readonly int MAX_WIDTH = 16;
private static readonly ECPoint[] EMPTY_POINTS = new ECPoint[0];
public static void ConfigureBasepoint(ECPoint p)
{
ECCurve c = p.Curve;
if (null == c)
return;
BigInteger n = c.Order;
int bits = (null == n) ? c.FieldSize + 1 : n.BitLength;
int confWidth = System.Math.Min(MAX_WIDTH, GetWindowSize(bits) + 3);
c.Precompute(p, PRECOMP_NAME, new ConfigureBasepointCallback(c, confWidth));
}
public static int[] GenerateCompactNaf(BigInteger k)
{
if ((k.BitLength >> 16) != 0)
throw new ArgumentException("must have bitlength < 2^16", "k");
if (k.SignValue == 0)
return Arrays.EmptyInts;
BigInteger _3k = k.ShiftLeft(1).Add(k);
int bits = _3k.BitLength;
int[] naf = new int[bits >> 1];
BigInteger diff = _3k.Xor(k);
int highBit = bits - 1, length = 0, zeroes = 0;
for (int i = 1; i < highBit; ++i)
{
if (!diff.TestBit(i))
{
++zeroes;
continue;
}
int digit = k.TestBit(i) ? -1 : 1;
naf[length++] = (digit << 16) | zeroes;
zeroes = 1;
++i;
}
naf[length++] = (1 << 16) | zeroes;
if (naf.Length > length)
{
naf = Trim(naf, length);
}
return naf;
}
public static int[] GenerateCompactWindowNaf(int width, BigInteger k)
{
if (width == 2)
{
return GenerateCompactNaf(k);
}
if (width < 2 || width > 16)
throw new ArgumentException("must be in the range [2, 16]", "width");
if ((k.BitLength >> 16) != 0)
throw new ArgumentException("must have bitlength < 2^16", "k");
if (k.SignValue == 0)
return Arrays.EmptyInts;
int[] wnaf = new int[k.BitLength / width + 1];
// 2^width and a mask and sign bit set accordingly
int pow2 = 1 << width;
int mask = pow2 - 1;
int sign = pow2 >> 1;
bool carry = false;
int length = 0, pos = 0;
while (pos <= k.BitLength)
{
if (k.TestBit(pos) == carry)
{
++pos;
continue;
}
k = k.ShiftRight(pos);
int digit = k.IntValue & mask;
if (carry)
{
++digit;
}
carry = (digit & sign) != 0;
if (carry)
{
digit -= pow2;
}
int zeroes = length > 0 ? pos - 1 : pos;
wnaf[length++] = (digit << 16) | zeroes;
pos = width;
}
// Reduce the WNAF array to its actual length
if (wnaf.Length > length)
{
wnaf = Trim(wnaf, length);
}
return wnaf;
}
public static byte[] GenerateJsf(BigInteger g, BigInteger h)
{
int digits = System.Math.Max(g.BitLength, h.BitLength) + 1;
byte[] jsf = new byte[digits];
BigInteger k0 = g, k1 = h;
int j = 0, d0 = 0, d1 = 0;
int offset = 0;
while ((d0 | d1) != 0 || k0.BitLength > offset || k1.BitLength > offset)
{
int n0 = ((int)((uint)k0.IntValue >> offset) + d0) & 7;
int n1 = ((int)((uint)k1.IntValue >> offset) + d1) & 7;
int u0 = n0 & 1;
if (u0 != 0)
{
u0 -= (n0 & 2);
if ((n0 + u0) == 4 && (n1 & 3) == 2)
{
u0 = -u0;
}
}
int u1 = n1 & 1;
if (u1 != 0)
{
u1 -= (n1 & 2);
if ((n1 + u1) == 4 && (n0 & 3) == 2)
{
u1 = -u1;
}
}
if ((d0 << 1) == 1 + u0)
{
d0 ^= 1;
}
if ((d1 << 1) == 1 + u1)
{
d1 ^= 1;
}
if (++offset == 30)
{
offset = 0;
k0 = k0.ShiftRight(30);
k1 = k1.ShiftRight(30);
}
jsf[j++] = (byte)((u0 << 4) | (u1 & 0xF));
}
// Reduce the JSF array to its actual length
if (jsf.Length > j)
{
jsf = Trim(jsf, j);
}
return jsf;
}
public static byte[] GenerateNaf(BigInteger k)
{
if (k.SignValue == 0)
return Arrays.EmptyBytes;
BigInteger _3k = k.ShiftLeft(1).Add(k);
int digits = _3k.BitLength - 1;
byte[] naf = new byte[digits];
BigInteger diff = _3k.Xor(k);
for (int i = 1; i < digits; ++i)
{
if (diff.TestBit(i))
{
naf[i - 1] = (byte)(k.TestBit(i) ? -1 : 1);
++i;
}
}
naf[digits - 1] = 1;
return naf;
}
/**
* Computes the Window NAF (non-adjacent Form) of an integer.
* @param width The width <code>w</code> of the Window NAF. The width is
* defined as the minimal number <code>w</code>, such that for any
* <code>w</code> consecutive digits in the resulting representation, at
* most one is non-zero.
* @param k The integer of which the Window NAF is computed.
* @return The Window NAF of the given width, such that the following holds:
* <code>k = &amp;sum;<sub>i=0</sub><sup>l-1</sup> k<sub>i</sub>2<sup>i</sup>
* </code>, where the <code>k<sub>i</sub></code> denote the elements of the
* returned <code>byte[]</code>.
*/
public static byte[] GenerateWindowNaf(int width, BigInteger k)
{
if (width == 2)
{
return GenerateNaf(k);
}
if (width < 2 || width > 8)
throw new ArgumentException("must be in the range [2, 8]", "width");
if (k.SignValue == 0)
return Arrays.EmptyBytes;
byte[] wnaf = new byte[k.BitLength + 1];
// 2^width and a mask and sign bit set accordingly
int pow2 = 1 << width;
int mask = pow2 - 1;
int sign = pow2 >> 1;
bool carry = false;
int length = 0, pos = 0;
while (pos <= k.BitLength)
{
if (k.TestBit(pos) == carry)
{
++pos;
continue;
}
k = k.ShiftRight(pos);
int digit = k.IntValue & mask;
if (carry)
{
++digit;
}
carry = (digit & sign) != 0;
if (carry)
{
digit -= pow2;
}
length += (length > 0) ? pos - 1 : pos;
wnaf[length++] = (byte)digit;
pos = width;
}
// Reduce the WNAF array to its actual length
if (wnaf.Length > length)
{
wnaf = Trim(wnaf, length);
}
return wnaf;
}
public static int GetNafWeight(BigInteger k)
{
if (k.SignValue == 0)
return 0;
BigInteger _3k = k.ShiftLeft(1).Add(k);
BigInteger diff = _3k.Xor(k);
return diff.BitCount;
}
public static WNafPreCompInfo GetWNafPreCompInfo(ECPoint p)
{
return GetWNafPreCompInfo(p.Curve.GetPreCompInfo(p, PRECOMP_NAME));
}
public static WNafPreCompInfo GetWNafPreCompInfo(PreCompInfo preCompInfo)
{
return preCompInfo as WNafPreCompInfo;
}
/**
* Determine window width to use for a scalar multiplication of the given size.
*
* @param bits the bit-length of the scalar to multiply by
* @return the window size to use
*/
public static int GetWindowSize(int bits)
{
return GetWindowSize(bits, DEFAULT_WINDOW_SIZE_CUTOFFS, MAX_WIDTH);
}
/**
* Determine window width to use for a scalar multiplication of the given size.
*
* @param bits the bit-length of the scalar to multiply by
* @param maxWidth the maximum window width to return
* @return the window size to use
*/
public static int GetWindowSize(int bits, int maxWidth)
{
return GetWindowSize(bits, DEFAULT_WINDOW_SIZE_CUTOFFS, maxWidth);
}
/**
* Determine window width to use for a scalar multiplication of the given size.
*
* @param bits the bit-length of the scalar to multiply by
* @param windowSizeCutoffs a monotonically increasing list of bit sizes at which to increment the window width
* @return the window size to use
*/
public static int GetWindowSize(int bits, int[] windowSizeCutoffs)
{
return GetWindowSize(bits, windowSizeCutoffs, MAX_WIDTH);
}
/**
* Determine window width to use for a scalar multiplication of the given size.
*
* @param bits the bit-length of the scalar to multiply by
* @param windowSizeCutoffs a monotonically increasing list of bit sizes at which to increment the window width
* @param maxWidth the maximum window width to return
* @return the window size to use
*/
public static int GetWindowSize(int bits, int[] windowSizeCutoffs, int maxWidth)
{
int w = 0;
for (; w < windowSizeCutoffs.Length; ++w)
{
if (bits < windowSizeCutoffs[w])
{
break;
}
}
return System.Math.Max(2, System.Math.Min(maxWidth, w + 2));
}
public static WNafPreCompInfo Precompute(ECPoint p, int minWidth, bool includeNegated)
{
return (WNafPreCompInfo)p.Curve.Precompute(p, PRECOMP_NAME,
new PrecomputeCallback(p, minWidth, includeNegated));
}
public static WNafPreCompInfo PrecomputeWithPointMap(ECPoint p, ECPointMap pointMap, WNafPreCompInfo fromWNaf,
bool includeNegated)
{
return (WNafPreCompInfo)p.Curve.Precompute(p, PRECOMP_NAME,
new PrecomputeWithPointMapCallback(p, pointMap, fromWNaf, includeNegated));
}
private static byte[] Trim(byte[] a, int length)
{
byte[] result = new byte[length];
Array.Copy(a, 0, result, 0, result.Length);
return result;
}
private static int[] Trim(int[] a, int length)
{
int[] result = new int[length];
Array.Copy(a, 0, result, 0, result.Length);
return result;
}
private static ECPoint[] ResizeTable(ECPoint[] a, int length)
{
ECPoint[] result = new ECPoint[length];
Array.Copy(a, 0, result, 0, a.Length);
return result;
}
private class ConfigureBasepointCallback
: IPreCompCallback
{
private readonly ECCurve m_curve;
private readonly int m_confWidth;
internal ConfigureBasepointCallback(ECCurve curve, int confWidth)
{
this.m_curve = curve;
this.m_confWidth = confWidth;
}
public PreCompInfo Precompute(PreCompInfo existing)
{
WNafPreCompInfo existingWNaf = existing as WNafPreCompInfo;
if (null != existingWNaf && existingWNaf.ConfWidth == m_confWidth)
{
existingWNaf.PromotionCountdown = 0;
return existingWNaf;
}
WNafPreCompInfo result = new WNafPreCompInfo();
result.PromotionCountdown = 0;
result.ConfWidth = m_confWidth;
if (null != existingWNaf)
{
result.PreComp = existingWNaf.PreComp;
result.PreCompNeg = existingWNaf.PreCompNeg;
result.Twice = existingWNaf.Twice;
result.Width = existingWNaf.Width;
}
return result;
}
}
private class MapPointCallback
: IPreCompCallback
{
private readonly WNafPreCompInfo m_infoP;
private readonly bool m_includeNegated;
private readonly ECPointMap m_pointMap;
internal MapPointCallback(WNafPreCompInfo infoP, bool includeNegated, ECPointMap pointMap)
{
this.m_infoP = infoP;
this.m_includeNegated = includeNegated;
this.m_pointMap = pointMap;
}
public PreCompInfo Precompute(PreCompInfo existing)
{
WNafPreCompInfo result = new WNafPreCompInfo();
result.ConfWidth = m_infoP.ConfWidth;
ECPoint twiceP = m_infoP.Twice;
if (null != twiceP)
{
ECPoint twiceQ = m_pointMap.Map(twiceP);
result.Twice = twiceQ;
}
ECPoint[] preCompP = m_infoP.PreComp;
ECPoint[] preCompQ = new ECPoint[preCompP.Length];
for (int i = 0; i < preCompP.Length; ++i)
{
preCompQ[i] = m_pointMap.Map(preCompP[i]);
}
result.PreComp = preCompQ;
result.Width = m_infoP.Width;
if (m_includeNegated)
{
ECPoint[] preCompNegQ = new ECPoint[preCompQ.Length];
for (int i = 0; i < preCompNegQ.Length; ++i)
{
preCompNegQ[i] = preCompQ[i].Negate();
}
result.PreCompNeg = preCompNegQ;
}
return result;
}
}
private class PrecomputeCallback
: IPreCompCallback
{
private readonly ECPoint m_p;
private readonly int m_minWidth;
private readonly bool m_includeNegated;
internal PrecomputeCallback(ECPoint p, int minWidth, bool includeNegated)
{
this.m_p = p;
this.m_minWidth = minWidth;
this.m_includeNegated = includeNegated;
}
public PreCompInfo Precompute(PreCompInfo existing)
{
WNafPreCompInfo existingWNaf = existing as WNafPreCompInfo;
int width = System.Math.Max(2, System.Math.Min(MAX_WIDTH, m_minWidth));
int reqPreCompLen = 1 << (width - 2);
if (CheckExisting(existingWNaf, width, reqPreCompLen, m_includeNegated))
{
existingWNaf.DecrementPromotionCountdown();
return existingWNaf;
}
WNafPreCompInfo result = new WNafPreCompInfo();
ECCurve c = m_p.Curve;
ECPoint[] preComp = null, preCompNeg = null;
ECPoint twiceP = null;
if (null != existingWNaf)
{
int promotionCountdown = existingWNaf.DecrementPromotionCountdown();
result.PromotionCountdown = promotionCountdown;
int confWidth = existingWNaf.ConfWidth;
result.ConfWidth = confWidth;
preComp = existingWNaf.PreComp;
preCompNeg = existingWNaf.PreCompNeg;
twiceP = existingWNaf.Twice;
}
width = System.Math.Min(MAX_WIDTH, System.Math.Max(result.ConfWidth, width));
reqPreCompLen = 1 << (width - 2);
int iniPreCompLen = 0;
if (null == preComp)
{
preComp = EMPTY_POINTS;
}
else
{
iniPreCompLen = preComp.Length;
}
if (iniPreCompLen < reqPreCompLen)
{
preComp = WNafUtilities.ResizeTable(preComp, reqPreCompLen);
if (reqPreCompLen == 1)
{
preComp[0] = m_p.Normalize();
}
else
{
int curPreCompLen = iniPreCompLen;
if (curPreCompLen == 0)
{
preComp[0] = m_p;
curPreCompLen = 1;
}
ECFieldElement iso = null;
if (reqPreCompLen == 2)
{
preComp[1] = m_p.ThreeTimes();
}
else
{
ECPoint isoTwiceP = twiceP, last = preComp[curPreCompLen - 1];
if (null == isoTwiceP)
{
isoTwiceP = preComp[0].Twice();
twiceP = isoTwiceP;
/*
* For Fp curves with Jacobian projective coordinates, use a (quasi-)isomorphism
* where 'twiceP' is "affine", so that the subsequent additions are cheaper. This
* also requires scaling the initial point's X, Y coordinates, and reversing the
* isomorphism as part of the subsequent normalization.
*
* NOTE: The correctness of this optimization depends on:
* 1) additions do not use the curve's A, B coefficients.
* 2) no special cases (i.e. Q +/- Q) when calculating 1P, 3P, 5P, ...
*/
if (!twiceP.IsInfinity && ECAlgorithms.IsFpCurve(c) && c.FieldSize >= 64)
{
switch (c.CoordinateSystem)
{
case ECCurve.COORD_JACOBIAN:
case ECCurve.COORD_JACOBIAN_CHUDNOVSKY:
case ECCurve.COORD_JACOBIAN_MODIFIED:
{
iso = twiceP.GetZCoord(0);
isoTwiceP = c.CreatePoint(twiceP.XCoord.ToBigInteger(),
twiceP.YCoord.ToBigInteger());
ECFieldElement iso2 = iso.Square(), iso3 = iso2.Multiply(iso);
last = last.ScaleX(iso2).ScaleY(iso3);
if (iniPreCompLen == 0)
{
preComp[0] = last;
}
break;
}
}
}
}
while (curPreCompLen < reqPreCompLen)
{
/*
* Compute the new ECPoints for the precomputation array. The values 1, 3,
* 5, ..., 2^(width-1)-1 times p are computed
*/
preComp[curPreCompLen++] = last = last.Add(isoTwiceP);
}
}
/*
* Having oft-used operands in affine form makes operations faster.
*/
c.NormalizeAll(preComp, iniPreCompLen, reqPreCompLen - iniPreCompLen, iso);
}
}
if (m_includeNegated)
{
int pos;
if (null == preCompNeg)
{
pos = 0;
preCompNeg = new ECPoint[reqPreCompLen];
}
else
{
pos = preCompNeg.Length;
if (pos < reqPreCompLen)
{
preCompNeg = WNafUtilities.ResizeTable(preCompNeg, reqPreCompLen);
}
}
while (pos < reqPreCompLen)
{
preCompNeg[pos] = preComp[pos].Negate();
++pos;
}
}
result.PreComp = preComp;
result.PreCompNeg = preCompNeg;
result.Twice = twiceP;
result.Width = width;
return result;
}
private bool CheckExisting(WNafPreCompInfo existingWNaf, int width, int reqPreCompLen, bool includeNegated)
{
return null != existingWNaf
&& existingWNaf.Width >= System.Math.Max(existingWNaf.ConfWidth, width)
&& CheckTable(existingWNaf.PreComp, reqPreCompLen)
&& (!includeNegated || CheckTable(existingWNaf.PreCompNeg, reqPreCompLen));
}
private bool CheckTable(ECPoint[] table, int reqLen)
{
return null != table && table.Length >= reqLen;
}
}
private class PrecomputeWithPointMapCallback
: IPreCompCallback
{
private readonly ECPoint m_point;
private readonly ECPointMap m_pointMap;
private readonly WNafPreCompInfo m_fromWNaf;
private readonly bool m_includeNegated;
internal PrecomputeWithPointMapCallback(ECPoint point, ECPointMap pointMap, WNafPreCompInfo fromWNaf,
bool includeNegated)
{
this.m_point = point;
this.m_pointMap = pointMap;
this.m_fromWNaf = fromWNaf;
this.m_includeNegated = includeNegated;
}
public PreCompInfo Precompute(PreCompInfo existing)
{
WNafPreCompInfo existingWNaf = existing as WNafPreCompInfo;
int width = m_fromWNaf.Width;
int reqPreCompLen = m_fromWNaf.PreComp.Length;
if (CheckExisting(existingWNaf, width, reqPreCompLen, m_includeNegated))
{
existingWNaf.DecrementPromotionCountdown();
return existingWNaf;
}
/*
* TODO Ideally this method would support incremental calculation, but given the
* existing use-cases it would be of little-to-no benefit.
*/
WNafPreCompInfo result = new WNafPreCompInfo();
result.PromotionCountdown = m_fromWNaf.PromotionCountdown;
ECPoint twiceFrom = m_fromWNaf.Twice;
if (null != twiceFrom)
{
ECPoint twice = m_pointMap.Map(twiceFrom);
result.Twice = twice;
}
ECPoint[] preCompFrom = m_fromWNaf.PreComp;
ECPoint[] preComp = new ECPoint[preCompFrom.Length];
for (int i = 0; i < preCompFrom.Length; ++i)
{
preComp[i] = m_pointMap.Map(preCompFrom[i]);
}
result.PreComp = preComp;
result.Width = width;
if (m_includeNegated)
{
ECPoint[] preCompNeg = new ECPoint[preComp.Length];
for (int i = 0; i < preCompNeg.Length; ++i)
{
preCompNeg[i] = preComp[i].Negate();
}
result.PreCompNeg = preCompNeg;
}
return result;
}
private bool CheckExisting(WNafPreCompInfo existingWNaf, int width, int reqPreCompLen, bool includeNegated)
{
return null != existingWNaf
&& existingWNaf.Width >= width
&& CheckTable(existingWNaf.PreComp, reqPreCompLen)
&& (!includeNegated || CheckTable(existingWNaf.PreCompNeg, reqPreCompLen));
}
private bool CheckTable(ECPoint[] table, int reqLen)
{
return null != table && table.Length >= reqLen;
}
}
}
}
#pragma warning restore
#endif

18
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/WNafUtilities.cs.meta vendored Normal file
View File

@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 176b8fc813ad1a542bb4cfe1d0afd8ea
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 267636
packageName: Best HTTP
packageVersion: 3.0.17
assetPath: Packages/com.tivadar.best.http/Runtime/3rdParty/BouncyCastle/math/ec/multiplier/WNafUtilities.cs
uploadId: 783279

142
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/WTauNafMultiplier.cs vendored Normal file
View File

@ -0,0 +1,142 @@
#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
#pragma warning disable
using System;
using Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Abc;
namespace Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Multiplier
{
/**
* Class implementing the WTNAF (Window
* <code>&#964;</code>-adic Non-Adjacent Form) algorithm.
*/
public class WTauNafMultiplier
: AbstractECMultiplier
{
// TODO Create WTauNafUtilities class and move various functionality into it
internal static readonly string PRECOMP_NAME = "bc_wtnaf";
/**
* Multiplies a {@link org.bouncycastle.math.ec.AbstractF2mPoint AbstractF2mPoint}
* by <code>k</code> using the reduced <code>&#964;</code>-adic NAF (RTNAF)
* method.
* @param p The AbstractF2mPoint to multiply.
* @param k The integer by which to multiply <code>k</code>.
* @return <code>p</code> multiplied by <code>k</code>.
*/
protected override ECPoint MultiplyPositive(ECPoint point, BigInteger k)
{
AbstractF2mPoint p = point as AbstractF2mPoint;
if (p == null)
throw new ArgumentException("Only AbstractF2mPoint can be used in WTauNafMultiplier");
AbstractF2mCurve curve = (AbstractF2mCurve)p.Curve;
int m = curve.FieldSize;
sbyte a = (sbyte)curve.A.ToBigInteger().IntValue;
sbyte mu = Tnaf.GetMu(a);
BigInteger[] s = curve.GetSi();
ZTauElement rho = Tnaf.PartModReduction(k, m, a, s, mu, (sbyte)10);
return MultiplyWTnaf(p, rho, a, mu);
}
/**
* Multiplies a {@link org.bouncycastle.math.ec.AbstractF2mPoint AbstractF2mPoint}
* by an element <code>&#955;</code> of <code><b>Z</b>[&#964;]</code> using
* the <code>&#964;</code>-adic NAF (TNAF) method.
* @param p The AbstractF2mPoint to multiply.
* @param lambda The element <code>&#955;</code> of
* <code><b>Z</b>[&#964;]</code> of which to compute the
* <code>[&#964;]</code>-adic NAF.
* @return <code>p</code> multiplied by <code>&#955;</code>.
*/
private AbstractF2mPoint MultiplyWTnaf(AbstractF2mPoint p, ZTauElement lambda,
sbyte a, sbyte mu)
{
ZTauElement[] alpha = (a == 0) ? Tnaf.Alpha0 : Tnaf.Alpha1;
BigInteger tw = Tnaf.GetTw(mu, Tnaf.Width);
sbyte[]u = Tnaf.TauAdicWNaf(mu, lambda, Tnaf.Width,
BigInteger.ValueOf(Tnaf.Pow2Width), tw, alpha);
return MultiplyFromWTnaf(p, u);
}
/**
* Multiplies a {@link org.bouncycastle.math.ec.AbstractF2mPoint AbstractF2mPoint}
* by an element <code>&#955;</code> of <code><b>Z</b>[&#964;]</code>
* using the window <code>&#964;</code>-adic NAF (TNAF) method, given the
* WTNAF of <code>&#955;</code>.
* @param p The AbstractF2mPoint to multiply.
* @param u The the WTNAF of <code>&#955;</code>..
* @return <code>&#955; * p</code>
*/
private static AbstractF2mPoint MultiplyFromWTnaf(AbstractF2mPoint p, sbyte[] u)
{
AbstractF2mCurve curve = (AbstractF2mCurve)p.Curve;
sbyte a = (sbyte)curve.A.ToBigInteger().IntValue;
WTauNafCallback callback = new WTauNafCallback(p, a);
WTauNafPreCompInfo preCompInfo = (WTauNafPreCompInfo)curve.Precompute(p, PRECOMP_NAME, callback);
AbstractF2mPoint[] pu = preCompInfo.PreComp;
// TODO Include negations in precomp (optionally) and use from here
AbstractF2mPoint[] puNeg = new AbstractF2mPoint[pu.Length];
for (int i = 0; i < pu.Length; ++i)
{
puNeg[i] = (AbstractF2mPoint)pu[i].Negate();
}
// q = infinity
AbstractF2mPoint q = (AbstractF2mPoint) p.Curve.Infinity;
int tauCount = 0;
for (int i = u.Length - 1; i >= 0; i--)
{
++tauCount;
int ui = u[i];
if (ui != 0)
{
q = q.TauPow(tauCount);
tauCount = 0;
ECPoint x = ui > 0 ? pu[ui >> 1] : puNeg[(-ui) >> 1];
q = (AbstractF2mPoint)q.Add(x);
}
}
if (tauCount > 0)
{
q = q.TauPow(tauCount);
}
return q;
}
private class WTauNafCallback
: IPreCompCallback
{
private readonly AbstractF2mPoint m_p;
private readonly sbyte m_a;
internal WTauNafCallback(AbstractF2mPoint p, sbyte a)
{
this.m_p = p;
this.m_a = a;
}
public PreCompInfo Precompute(PreCompInfo existing)
{
if (existing is WTauNafPreCompInfo)
return existing;
WTauNafPreCompInfo result = new WTauNafPreCompInfo();
result.PreComp = Tnaf.GetPreComp(m_p, m_a);
return result;
}
}
}
}
#pragma warning restore
#endif

18
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/WTauNafMultiplier.cs.meta vendored Normal file
View File

@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: 5facf8f0e9c80c94c806d2befb73db5f
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 267636
packageName: Best HTTP
packageVersion: 3.0.17
assetPath: Packages/com.tivadar.best.http/Runtime/3rdParty/BouncyCastle/math/ec/multiplier/WTauNafMultiplier.cs
uploadId: 783279

28
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/WTauNafPreCompInfo.cs vendored Normal file
View File

@ -0,0 +1,28 @@
#if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
#pragma warning disable
namespace Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Multiplier
{
/**
* Class holding precomputation data for the WTNAF (Window
* <code>&#964;</code>-adic Non-Adjacent Form) algorithm.
*/
public class WTauNafPreCompInfo
: PreCompInfo
{
/**
* Array holding the precomputed <code>AbstractF2mPoint</code>s used for the
* WTNAF multiplication in <code>
* {@link org.bouncycastle.math.ec.multiplier.WTauNafMultiplier.multiply()
* WTauNafMultiplier.multiply()}</code>.
*/
protected AbstractF2mPoint[] m_preComp;
public virtual AbstractF2mPoint[] PreComp
{
get { return m_preComp; }
set { this.m_preComp = value; }
}
}
}
#pragma warning restore
#endif

18
Runtime/3rdParty/BouncyCastle/math/ec/multiplier/WTauNafPreCompInfo.cs.meta vendored Normal file
View File

@ -0,0 +1,18 @@
fileFormatVersion: 2
guid: f14b38c7241eb4a4193c1afa7bb942f9
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
AssetOrigin:
serializedVersion: 1
productId: 267636
packageName: Best HTTP
packageVersion: 3.0.17
assetPath: Packages/com.tivadar.best.http/Runtime/3rdParty/BouncyCastle/math/ec/multiplier/WTauNafPreCompInfo.cs
uploadId: 783279