1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
using System;
using Org.BouncyCastle.Utilities.Encoders;
namespace Org.BouncyCastle.Math.EC.Custom.Sec
{
internal class SecT163R2Curve
: AbstractF2mCurve
{
private const int SecT163R2_DEFAULT_COORDS = COORD_LAMBDA_PROJECTIVE;
protected readonly SecT163R2Point m_infinity;
public SecT163R2Curve()
: base(163, 3, 6, 7)
{
this.m_infinity = new SecT163R2Point(this, null, null);
this.m_a = FromBigInteger(BigInteger.One);
this.m_b = FromBigInteger(new BigInteger(1, Hex.Decode("020A601907B8C953CA1481EB10512F78744A3205FD")));
this.m_order = new BigInteger(1, Hex.Decode("040000000000000000000292FE77E70C12A4234C33"));
this.m_cofactor = BigInteger.Two;
this.m_coord = SecT163R2_DEFAULT_COORDS;
}
protected override ECCurve CloneCurve()
{
return new SecT163R2Curve();
}
public override bool SupportsCoordinateSystem(int coord)
{
switch (coord)
{
case COORD_LAMBDA_PROJECTIVE:
return true;
default:
return false;
}
}
public override ECPoint Infinity
{
get { return m_infinity; }
}
public override int FieldSize
{
get { return 163; }
}
public override ECFieldElement FromBigInteger(BigInteger x)
{
return new SecT163FieldElement(x);
}
protected internal override ECPoint CreateRawPoint(ECFieldElement x, ECFieldElement y, bool withCompression)
{
return new SecT163R2Point(this, x, y, withCompression);
}
protected internal override ECPoint CreateRawPoint(ECFieldElement x, ECFieldElement y, ECFieldElement[] zs, bool withCompression)
{
return new SecT163R2Point(this, x, y, zs, withCompression);
}
public override bool IsKoblitz
{
get { return false; }
}
/**
* Decompresses a compressed point P = (xp, yp) (X9.62 s 4.2.2).
*
* @param yTilde
* ~yp, an indication bit for the decompression of yp.
* @param X1
* The field element xp.
* @return the decompressed point.
*/
protected override ECPoint DecompressPoint(int yTilde, BigInteger X1)
{
ECFieldElement x = FromBigInteger(X1), y = null;
if (x.IsZero)
{
y = B.Sqrt();
}
else
{
ECFieldElement beta = x.Square().Invert().Multiply(B).Add(A).Add(x);
ECFieldElement z = SolveQuadraticEquation(beta);
if (z != null)
{
if (z.TestBitZero() != (yTilde == 1))
{
z = z.AddOne();
}
switch (this.CoordinateSystem)
{
case COORD_LAMBDA_AFFINE:
case COORD_LAMBDA_PROJECTIVE:
{
y = z.Add(x);
break;
}
default:
{
y = z.Multiply(x);
break;
}
}
}
}
if (y == null)
throw new ArgumentException("Invalid point compression");
return this.CreateRawPoint(x, y, true);
}
/**
* Solves a quadratic equation <code>z<sup>2</sup> + z = beta</code>(X9.62
* D.1.6) The other solution is <code>z + 1</code>.
*
* @param beta
* The value to solve the quadratic equation for.
* @return the solution for <code>z<sup>2</sup> + z = beta</code> or
* <code>null</code> if no solution exists.
*/
private ECFieldElement SolveQuadraticEquation(ECFieldElement beta)
{
if (beta.IsZero)
return beta;
ECFieldElement zeroElement = FromBigInteger(BigInteger.Zero);
ECFieldElement z = null;
ECFieldElement gamma = null;
Random rand = new Random();
do
{
ECFieldElement t = FromBigInteger(new BigInteger(163, rand));
z = zeroElement;
ECFieldElement w = beta;
for (int i = 1; i < 163; i++)
{
ECFieldElement w2 = w.Square();
z = z.Square().Add(w2.Multiply(t));
w = w2.Add(beta);
}
if (!w.IsZero)
return null;
gamma = z.Square().Add(z);
}
while (gamma.IsZero);
return z;
}
public virtual int M
{
get { return 163; }
}
public virtual bool IsTrinomial
{
get { return false; }
}
public virtual int K1
{
get { return 3; }
}
public virtual int K2
{
get { return 6; }
}
public virtual int K3
{
get { return 7; }
}
}
}
|
