public static bool Check()
{
Int256[] numbers_local = new Int256[K];
for (int k = 0; k < K; k++)
{
Int256 no_local = 0;
for (int d = 0; d < N; d++)
{
no_local = no_local * 10 + Numbers[k][d];
}
numbers_local[k] = no_local;
}
Int256 sum = 0;
for (int k = 0; k < K; k++)
{
sum += numbers_local[k];
}
Int256[] resLocal = new Int256[N + 1];
int t = N + 1;
while (sum > 0)
{
resLocal[--t] = sum % 10;
sum /= 10;
}
Console.WriteLine($"Local {String.Join("", resLocal)}");
Console.WriteLine($"Global {String.Join("", Result)}");
if (!String.Join("", Result).Equals(String.Join("", resLocal)))
{
return(false);
}
return(true);
}
public override (object, int) Decode(byte[] data, int position, bool packed)
{
(BigInteger nominator, int newPosition) = Int256.DecodeInt(data, position, packed);
BigRational rational = BigRational.FromBigInt(nominator) * BigRational.Reciprocal(BigRational.Pow(BigRational.FromInt(10), Precision));
return(rational, newPosition);
}
private bool CheckNewNonceHash(Int256 newNonce, Int128 newNonceHash)
{
byte[] hash = ComputeSHA1(newNonce.ToBytes());
Int128 nonceHash = hash.ToInt128();
return(nonceHash == newNonceHash);
}
private List <Solution> SearchFile(string fileName)
{
#if DEBUG
checked {
#endif
List <Solution> solutionsFound = new List <Solution>();
foreach (string line in File.ReadAllLines(fileName)) //For each line
{
string[] number = line.Split("\t");
foreach (string numberString in number) //For each prime
{
long prime = long.Parse(numberString);
primeCounter += 1;
primeSum += (Int256)((Int128)prime * prime);
if (primeSum % primeCounter == 0)
{
solutionsFound.Add(new Solution()
{
numberOfPrimes = primeCounter,
sum = primeSum,
lastPrime = prime
});
}
}
}
return(solutionsFound);
#if DEBUG
}
#endif
}
void Simplify()
{
if (Value >= 1.0)
{
Int256 newExp = Exp;
double newValue = Value;
while (newValue >= 1.0)
{
newValue /= 10.0;
newExp++;
}
Value = newValue;
Exp = newExp;
}
else if (Value < 0.1 && Value >= 0.0)
{
Int256 newExp = Exp;
double newValue = Value;
while (newValue < 0.1)
{
newValue *= 10.0;
newExp--;
}
Value = newValue;
Exp = newExp;
}
}
void Verify256Value(Int256 x, ulong a, ulong b, ulong c, ulong d)
{
Assert.AreEqual(a, x.A);
Assert.AreEqual(b, x.B);
Assert.AreEqual(c, x.C);
Assert.AreEqual(d, x.D);
}
public void TestCompare()
{
Assert.AreEqual(0, new Int256(1).CompareTo(new Int256(1)));
Assert.AreEqual(-1, new Int256(1).CompareTo(new Int256(2)));
Assert.AreEqual(1, new Int256(2).CompareTo(new Int256(1)));
Assert.AreEqual(0, new Int256(0x123456789ABCDEF0, 0xA2A4A6A8D1D2D3D4, 0xB2B4B6B8C1C2C3C4, 0xC2C4C6C8B1B2B3B4).CompareTo(new Int256(0x123456789ABCDEF0, 0xA2A4A6A8D1D2D3D4, 0xB2B4B6B8C1C2C3C4, 0xC2C4C6C8B1B2B3B4)));
//public ulong[] ToUIn64Array()
//public uint[] ToUIn32Array()
var t1 = new Int256(0x123456789ABCDEF0, 0xA2A4A6A8D1D2D3D4, 0xB2B4B6B8C1C2C3C4, 0xC2C4C6C8B1B2B3B4);
ulong[] t2 = t1.ToUIn64Array();
Assert.AreEqual(t2[0], 0xC2C4C6C8B1B2B3B4u);
Assert.AreEqual(t2[1], 0xB2B4B6B8C1C2C3C4u);
Assert.AreEqual(t2[2], 0xA2A4A6A8D1D2D3D4u);
Assert.AreEqual(t2[3], 0x123456789ABCDEF0u);
uint[] t3 = t1.ToUIn32Array();
Assert.AreEqual(t3[0], 0xB1B2B3B4u);
Assert.AreEqual(t3[1], 0xC2C4C6C8u);
Assert.AreEqual(t3[2], 0xC1C2C3C4u);
Assert.AreEqual(t3[3], 0xB2B4B6B8u);
Assert.AreEqual(t3[4], 0xD1D2D3D4u);
Assert.AreEqual(t3[5], 0xA2A4A6A8u);
Assert.AreEqual(t3[6], 0x9ABCDEF0u);
Assert.AreEqual(t3[7], 0x12345678u);
//public static bool operator >(Int256 left, Int256 right)
//public static bool operator <(Int256 left, Int256 right)
//public static bool operator >=(Int256 left, Int256 right)
//public static bool operator <=(Int256 left, Int256 right)
//public static bool operator !=(Int256 left, Int256 right)
//public static bool operator ==(Int256 left, Int256 right)
Assert.AreEqual(true, new Int256(1) == new Int256(1));
Assert.AreEqual(true, new Int256(10) == 10);
Assert.AreEqual(true, new Int256(9) < 10);
Assert.AreEqual(true, new Int256(11) > 10);
Assert.AreEqual(true, new Int256(1) != new Int256(2));
Assert.AreEqual(true, new Int256(0x123456789ABCDEFA) == 0x123456789ABCDEFA);
var small1 = new Int256(0x123456789ABCDEF0, 0xA2A4A6A8D1D2D3D4, 0xB2B4B6B8C1C2C3C4, 0xC2C4C6C8B1B2B3B4);
var big1 = new Int256(0x223456789ABCDEF0, 0xA2A4A6A8D1D2D3D4, 0xB2B4B6B8C1C2C3C4, 0xC2C4C6C8B1B2B3B4);
var big1b = new Int256(0x223456789ABCDEF0, 0xA2A4A6A8D1D2D3D4, 0xB2B4B6B8C1C2C3C4, 0xC2C4C6C8B1B2B3B4);
var small2 = new Int256(0x123456789ABCDEF0, 0xA2A4A6A8D1D2D3D4, 0xB2B4B6B8C1C2C3C4, 0xC2C4C6C8B1B2B3B4);
var big2 = new Int256(0x123456789ABCDEF0, 0xA2A4A6A8D1D2D3D4, 0xB2B4B6B8C1C2C3C4, 0xC2C4C6C8B1B2B3B5);
Assert.AreEqual(true, small1 < big1);
Assert.AreEqual(true, small2 < big2);
Assert.AreEqual(true, small1 <= big1);
Assert.AreEqual(true, small2 <= big2);
Assert.AreEqual(true, big1 > small1);
Assert.AreEqual(true, big2 > small2);
Assert.AreEqual(true, big1 >= small1);
Assert.AreEqual(true, big2 >= small2);
Assert.AreEqual(true, big1 >= big1b);
Assert.AreEqual(true, big1 <= big1b);
}
/// <summary>
/// Converts an <see cref="Int256" /> value to an array of bytes.
/// </summary>
/// <param name="value">Value.</param>
/// <param name="buffer">An array of bytes.</param>
/// <param name="offset">The starting position within <paramref name="buffer" />.</param>
/// <param name="asLittleEndian">Convert from little endian.</param>
public static void ToBytes(this Int256 value, byte[] buffer, int offset = 0, bool?asLittleEndian = null)
{
bool ale = GetIsLittleEndian(asLittleEndian);
value.D.ToBytes(buffer, ale ? offset : offset + 24, ale);
value.C.ToBytes(buffer, ale ? offset + 8 : offset + 16, ale);
value.B.ToBytes(buffer, ale ? offset + 16 : offset + 8, ale);
value.A.ToBytes(buffer, ale ? offset + 24 : offset, ale);
}
public Solver(SolverState state, FilePath FilePath, SaveStrategy Save)
{
this.FilePath = FilePath;
this.Save = Save;
primeSum = state.primeSum;
primeCounter = state.primeCounter;
groupIndex = state.groupIndex;
part = state.part;
}
public void Should_substruct_big_numbers_correctly(string x, string y, string z)
{
var i1 = Int256.Parse(x);
var i2 = Int256.Parse(y);
var i3 = i1 - i2;
("0x" + i3.ToString("X32")).Should().Be(z);
}
public void Should_multiply_big_numbers_correctly(string x, string y, string z)
{
var i1 = Int256.Parse(x);
var i2 = Int256.Parse(y);
var i3 = i1 * i2;
("0x" + i3.ToString("X")).Should().Be(z);
}
public void Should_sum_big_numbers_correctly(string x, string y, string z)
{
Int256 i1 = Int256.Parse(x);
Int256 i2 = Int256.Parse(y);
Int256 i3 = i1 + i2;
("0x" + i3.ToString("X32")).Should().Be(z);
}
public static async Task <Step3Res> Do(
Some <ServerDhParams.OkTag> someServerDhParams,
Int256 newNonce,
Some <MtProtoPlainTransport> transport
)
{
var dhParams = someServerDhParams.Value;
var key = Aes.GenerateKeyDataFromNonces(dhParams.ServerNonce.ToBytes(true), newNonce.ToBytes(true));
var plaintextAnswer = Aes.DecryptAES(key, dhParams.EncryptedAnswer.ToArrayUnsafe());
var dh = plaintextAnswer.Apply(Deserialize(WithHashSumCheck(ServerDhInnerData.Deserialize)));
Helpers.Assert(dh.Nonce == dhParams.Nonce, "auth step3: invalid nonce in encrypted answer");
Helpers.Assert(dh.ServerNonce == dhParams.ServerNonce, "auth step3: invalid server nonce in encrypted answer");
var currentEpochTime = Helpers.GetCurrentEpochTime();
var timeOffset = dh.ServerTime - currentEpochTime;
var g = dh.G;
var dhPrime = new BigInteger(1, dh.DhPrime.ToArrayUnsafe());
var ga = new BigInteger(1, dh.Ga.ToArrayUnsafe());
var b = new BigInteger(Rnd.NextBytes(2048));
var gb = BigInteger.ValueOf(g).ModPow(b, dhPrime);
var gab = ga.ModPow(b, dhPrime);
var dhInnerData = new ClientDhInnerData(
nonce: dh.Nonce,
serverNonce: dh.ServerNonce,
retryId: 0,
gb: gb.ToByteArrayUnsigned().ToBytesUnsafe()
);
var dhInnerDataBts = Serialize(dhInnerData);
var dhInnerDataHashedBts = WithHashAndPadding(dhInnerDataBts);
var dhInnerDataHashedEncryptedBytes = Aes.EncryptAES(key, dhInnerDataHashedBts);
var resp = await transport.Value.Call(new SetClientDhParams(
nonce : dh.Nonce,
serverNonce : dh.ServerNonce,
encryptedData : dhInnerDataHashedEncryptedBytes.ToBytesUnsafe()
));
var res = resp.Match(
dhGenOkTag: identity,
dhGenFailTag: _ => throw Helpers.FailedAssertion("auth step3: dh_gen_fail"),
dhGenRetryTag: _ => throw Helpers.FailedAssertion("auth step3: dh_gen_retry")
);
var authKey = AuthKey.FromGab(gab);
var newNonceHash = authKey.CalcNewNonceHash(newNonce.ToBytes(true), 1).ToInt128();
Helpers.Assert(res.Nonce == dh.Nonce, "auth step3: invalid nonce");
Helpers.Assert(res.ServerNonce == dh.ServerNonce, "auth step3: invalid server nonce");
Helpers.Assert(res.NewNonceHash1 == newNonceHash, "auth step3: invalid new nonce hash");
return(new Step3Res(authKey, timeOffset));
}
public override void DeserializeBody(BinaryReader br)
{
pq = StringUtil.Deserialize(br);
p = StringUtil.Deserialize(br);
q = StringUtil.Deserialize(br);
nonce = (Int128)ObjectUtils.DeserializeObject(br);
server_nonce = (Int128)ObjectUtils.DeserializeObject(br);
new_nonce = (Int256)ObjectUtils.DeserializeObject(br);
Type = TLAbsP_Q_inner_dataTypes.TLP_q_inner_data;
}
public void Should_multiply_correctly(int x, int y, int z)
{
var i1 = (Int256)x;
var i2 = (Int256)y;
Int256 i3 = i1 * i2;
((int)i3).Should().Be(z);
i3.ToString().Should().Be(z.ToString(CultureInfo.InvariantCulture));
}
private ReqDHParamsArgs CreateReqDhParamsArgs(ResPQ resPQ, out PQInnerData pqInnerData)
{
Int256 pq = resPQ.Pq.ToInt256(asLittleEndian: false);
Int256 p, q;
pq.GetPrimeMultipliers(out p, out q);
Int256 newNonce = _nonceGenerator.GetNonce(32).ToInt256();
pqInnerData = new PQInnerData
{
Pq = resPQ.Pq,
P = p.ToBytes(false, true),
Q = q.ToBytes(false, true),
Nonce = resPQ.Nonce,
ServerNonce = resPQ.ServerNonce,
NewNonce = newNonce
};
byte[] data = _tlRig.Serialize(pqInnerData);
byte[] dataHash = ComputeSHA1(data);
Debug.Assert((dataHash.Length + data.Length) <= 255);
// data_with_hash := SHA1(data) + data + (any random bytes); such that the length equal 255 bytes;
var dataWithHash = new byte[255];
using (var streamer = new TLStreamer(dataWithHash))
{
streamer.Write(dataHash);
streamer.Write(data);
streamer.WriteRandomDataTillEnd();
}
PublicKey publicKey = _keyChain.GetFirst(resPQ.ServerPublicKeyFingerprints);
if (publicKey == null)
{
throw new PublicKeyNotFoundException(resPQ.ServerPublicKeyFingerprints);
}
byte[] encryptedData = _encryptionServices.RSAEncrypt(dataWithHash, publicKey);
var reqDhParamsArgs = new ReqDHParamsArgs
{
Nonce = pqInnerData.Nonce,
ServerNonce = pqInnerData.ServerNonce,
P = pqInnerData.P,
Q = pqInnerData.Q,
PublicKeyFingerprint = publicKey.Fingerprint,
EncryptedData = encryptedData
};
return(reqDhParamsArgs);
}
public void TestPlusMinusOps()
{
//public static Int256 operator +(Int256 value)
//public static Int256 operator -(Int256 value)
//public static Int256 operator +(Int256 left, Int256 right)
//public static Int256 operator -(Int256 left, Int256 right)
Verify256Value(new Int256(1) + new Int256(1), 0, 0, 0, 2);
var t1 = new Int256(1);
t1++;
Verify256Value(t1, 0, 0, 0, 2);
Verify256Value(new Int256(5) - new Int256(3), 0, 0, 0, 2);
var t2 = new Int256(3);
t2--;
Verify256Value(t2, 0, 0, 0, 2);
var big1 = new Int256(0x223456789ABCDEF0, 0xA2A4A6A8D1D2D3D4, 0xB2B4B6B8C1C2C3C4, 0xC2C4C6C8B1B2B3B4);
Verify256Value(big1 + new Int256(1), 0x223456789ABCDEF0, 0xA2A4A6A8D1D2D3D4, 0xB2B4B6B8C1C2C3C4, 0xC2C4C6C8B1B2B3B5);
Verify256Value(big1 + new Int256(1, 0, 0, 0), 0x223456789ABCDEF1, 0xA2A4A6A8D1D2D3D4, 0xB2B4B6B8C1C2C3C4, 0xC2C4C6C8B1B2B3B4);
Verify256Value(big1 - new Int256(1), 0x223456789ABCDEF0, 0xA2A4A6A8D1D2D3D4, 0xB2B4B6B8C1C2C3C4, 0xC2C4C6C8B1B2B3B3);
Verify256Value(big1 - new Int256(1, 0, 0, 0), 0x223456789ABCDEEF, 0xA2A4A6A8D1D2D3D4, 0xB2B4B6B8C1C2C3C4, 0xC2C4C6C8B1B2B3B4);
var bigWrap1a = new Int256(0xFFFFFFFFFFFFFFFF, 0, 0, 0);
var bigWrap1b = new Int256(0, 0xFFFFFFFFFFFFFFFF, 0, 0);
var bigWrap1c = new Int256(0, 0, 0xFFFFFFFFFFFFFFFF, 0);
var bigWrap1d = new Int256(0, 0, 0, 0xFFFFFFFFFFFFFFFF);
Verify256Value(bigWrap1a + new Int256(1, 0, 0, 0), 0, 0, 0, 0);
Verify256Value(bigWrap1b + new Int256(0, 1, 0, 0), 1, 0, 0, 0);
Verify256Value(bigWrap1c + new Int256(0, 0, 1, 0), 0, 1, 0, 0);
Verify256Value(bigWrap1d + new Int256(1), 0, 0, 1, 0);
var bigWrap2a = new Int256(1, 0, 0, 0);
var bigWrap2b = new Int256(0, 1, 0, 0);
var bigWrap2c = new Int256(0, 0, 1, 0);
var bigWrap2d = new Int256(0, 0, 0, 0);
Verify256Value(bigWrap2a - new Int256(1), 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF);
Verify256Value(bigWrap2b - new Int256(1), 0, 0, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF);
Verify256Value(bigWrap2c - new Int256(1), 0, 0, 0, 0xFFFFFFFFFFFFFFFF);
Verify256Value(bigWrap2d - new Int256(1), 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF);
//public static Int256 operator ++(Int256 value)
//public static Int256 operator --(Int256 value)
bigWrap2d--;
Assert.AreEqual(true, bigWrap2d == -1);
bigWrap2d++;
Assert.AreEqual(true, bigWrap2d == 0);
bigWrap2d++;
Assert.AreEqual(true, bigWrap2d == 1);
}
public void Should_rightShift_correctly(string x, string y, string z)
{
//
// X >> Y should = z
//
var i1 = Int256.Parse(x);
var shifthBy = int.Parse(y);
var i3 = i1 >> shifthBy;
("0x" + i3.ToString("X32")).Should().Be(z);
}
public void Should_leftShift_correctly(string x, string y, string z)
{
//
// X >> Y should = z
//
Int256 i1 = Int256.Parse(x);
int shifthBy = int.Parse(y);
Int256 i3 = i1 << shifthBy;
("0x" + i3.ToString("X32")).Should().Be(z);
}
public static void GetPrimeMultipliers(this Int256 pq, out Int256 p, out Int256 q)
{
p = PollardRho(pq);
q = pq / p;
if (p > q)
{
Int256 t = p;
p = q;
q = t;
}
}
//[TestCase("2852213850458175921094913949697", "51539607551", "55340232221128654847")]
//[TestCase("2253601067072664030639173111353", "2932031007403", "768614336404564651")]
//[TestCase("154866286100907105216716400854538488352313", "768614336404564651", "201487636602438195784363")]
//[TestCase("170277282318432095373149951383568233665261047797485113", "201487636602438195784363", "845100400152152934331135470251")]
//[TestCase("47928794074934470746074693488053803551576675688093033978263006055993", "845100400152152934331135470251", "56713727820156410577229101238628035243")]
public void Should_get_prime_multipliers_for_Int256(string pqS, string expectedPs, string expectedQs)
{
Int256 pq = Int256.Parse(pqS);
Int256 expectedP = Int256.Parse(expectedPs);
Int256 expectedQ = Int256.Parse(expectedQs);
Int256 p, q;
pq.GetPrimeMultipliers(out p, out q);
p.Should().Be(expectedP);
q.Should().Be(expectedQ);
}
public void TestMathOps()
{
//public static Int256 operator /(Int256 dividend, Int256 divisor)
//public static Int256 operator *(Int256 left, Int256 right)
var m1 = new Int256(0, 0, 0, 2);
m1 /= 2;
Verify256Value(m1, 0, 0, 0, 1);
var m2 = new Int256(0, 0, 1, 0);
m2 /= 2;
Verify256Value(m2, 0, 0, 0, 0x8000000000000000);
m2 /= 2;
Verify256Value(m2, 0, 0, 0, 0x4000000000000000);
m2 *= 2;
Verify256Value(m2, 0, 0, 0, 0x8000000000000000);
m2 *= 2;
Verify256Value(m2, 0, 0, 1, 0);
m2 *= 2;
Verify256Value(m2, 0, 0, 2, 0);
//public static Int256 operator %(Int256 dividend, Int256 divisor)
var m3 = new Int256(0, 0, 0, 13);
Assert.AreEqual(3, m3 % 10);
//public static Int256 operator >>(Int256 value, int shift)
//public static Int256 operator <<(Int256 value, int shift)
var m4 = new Int256(0, 0, 1, 0);
m4 >>= 2;
Verify256Value(m4, 0, 0, 0, 0x4000000000000000);
m4 <<= 3;
Verify256Value(m4, 0, 0, 2, 0);
//public static Int256 operator |(Int256 left, Int256 right)
//public static Int256 operator &(Int256 left, Int256 right)
var m5a = new Int256(0, 0, 1, 0);
var m5b = new Int256(2, 2, 2, 2);
m5a |= m5b;
Verify256Value(m5a, 2, 2, 3, 2);
var m6a = new Int256(0, 0, 1, 0);
var m6b = new Int256(2, 2, 3, 2);
m6a &= m6b;
Verify256Value(m6a, 0, 0, 1, 0);
//public static Int256 operator ~(Int256 value)
}
/// <summary>
/// Converts an <see cref="Int256" /> value to a byte array.
/// </summary>
/// <param name="value">Value.</param>
/// <param name="asLittleEndian">Convert from little endian.</param>
/// <param name="trimZeros">Trim zero bytes from left or right, depending on endian.</param>
/// <returns>Array of bytes.</returns>
public static byte[] ToBytes(this Int256 value, bool?asLittleEndian = null, bool trimZeros = false)
{
var buffer = new byte[32];
value.ToBytes(buffer, 0, asLittleEndian);
if (trimZeros)
{
buffer = buffer.TrimZeros(asLittleEndian);
}
return(buffer);
}
public static Int256 GCD(this Int256 a, Int256 b)
{
while (true)
{
if (b == 0)
{
return(a);
}
Int256 a1 = a;
a = b;
b = a1 % b;
}
}
void ConvertFromDouble(double d)
{
Int256 newExp = 0;
double newValue = d;
while (newValue >= 1.0)
{
newValue /= 10.0;
newExp++;
}
Value = newValue;
Exp = newExp;
}
public void Should_compare_big_numbers_correctly(string x, string y, bool?z)
{
// z == null means that numbers are equal.
Int256 i1 = Int256.Parse(x);
Int256 i2 = Int256.Parse(y);
bool value = z.HasValue && z.Value;
(i1 > i2).Should().Be(value);
(i1 < i2).Should().Be(z.HasValue && !value);
(i1 == i2).Should().Be(!z.HasValue);
(i1 != i2).Should().Be(z.HasValue);
}
public override byte[] Encode(object arg, bool packed)
{
if (arg is BigRational input)
{
if (_denominator != input.Denominator)
{
throw new AbiException(AbiEncodingExceptionMessage);
}
return(Int256.Encode(input.Numerator, packed));
}
throw new AbiException(AbiEncodingExceptionMessage);
}
static void Main(string[] args)
{
string[] values = File.ReadAllLines(@"/Users/alexandraneamtu/Documents/An3-sem1/crypto/Lab2/Lab2Crypto/test.txt");
string[] results = new string[100];
foreach (var line in values)
{
string[] s = line.Split(',');
/*
* long a, b;
*
* bool aResult = Int64.TryParse(s[0], out a);
* bool bResult = Int64.TryParse(s[1], out b);
*
* if (aResult && bResult)
* {
*
* Console.WriteLine("a: " + a + " b: " + b);
* var time1 = Stopwatch.StartNew();
* var result1 = GCDAlgorithms.Alg1(a, b);
* time1.Stop();
* Console.WriteLine("Alg1 Result: " + result1);
* Console.WriteLine(time1.Elapsed.TotalMilliseconds * 1000000 + " nanoseconds\n");
*
*
* Console.WriteLine("a: " + a + " b: " + b);
* var time2 = Stopwatch.StartNew();
* var result2 = GCDAlgorithms.Alg2(a, b);
* time2.Stop();
* Console.WriteLine("Alg2 Result: " + result2);
* Console.WriteLine(time2.Elapsed.TotalMilliseconds * 1000000 + " nanoseconds\n");
* }
*/
Int256 aBig, bBig;
bool aBigResult = Int256.TryParse(s[0], out aBig);
bool bBigResult = Int256.TryParse(s[1], out bBig);
if (aBigResult && bBigResult)
{
Console.WriteLine("a: " + aBig + " b: " + bBig);
var time3 = Stopwatch.StartNew();
var result3 = GCDAlgorithms.Alg3(aBig, bBig);
time3.Stop();
Console.WriteLine("Alg3 Result: " + result3);
Console.WriteLine(time3.Elapsed.TotalMilliseconds * 1000000
+ " nanoseconds\n");
}
}
Console.ReadLine();
}
public static Int256 PollardRho(Int256 number)
{
var func = new Func <Int256, Int256, Int256>((param, mod) => ((param * param + 1) % mod));
Int256 x = 2, y = 2, z;
do
{
x = func(x, number);
y = func(func(y, number), number);
z = GCD(x > y ? x - y : y - x, number);
} while (z <= 1);
return(z);
}
private Int128 ComputeNewNonceHash(Int256 newNonce, byte num, byte[] authKeyAuxHash)
{
var arr = new byte[33 + authKeyAuxHash.Length];
using (var streamer = new TLStreamer(arr))
{
streamer.WriteInt256(newNonce);
streamer.WriteByte(num);
streamer.Write(authKeyAuxHash);
}
byte[] hash = ComputeSHA1(arr);
Int128 result = hash.ToInt128(HashLength - 16);
return(result);
}
public override void WriteInt256(Int256 value)
{
lock (_streamer)
_streamer.WriteInt256(value);
}
public static void GetPrimeMultipliers(this Int256 pq, out Int256 p, out Int256 q)
{
p = PollardRho(pq);
q = pq/p;
if (p > q)
{
Int256 t = p;
p = q;
q = t;
}
}
/// <summary>
/// Writes a 256-bit signed integer.
/// </summary>
public virtual void WriteInt256(Int256 value)
{
value.ToBytes(_buffer, 0, _streamAsLittleEndianInternal);
Write(_buffer, 0, 32);
}
private Int128 ComputeNewNonceHash(Int256 newNonce, byte num, byte[] authKeyAuxHash)
{
var arr = new byte[33 + authKeyAuxHash.Length];
using (var streamer = new TLStreamer(arr))
{
streamer.WriteInt256(newNonce);
streamer.WriteByte(num);
streamer.Write(authKeyAuxHash);
}
byte[] hash = ComputeSHA1(arr);
Int128 result = hash.ToInt128(HashLength - 16);
return result;
}
public static void Serialize(Int256 src, BinaryWriter writer)
{
writer.Write(src.ToBytes(true));
}
public static Int256 GCD(this Int256 a, Int256 b)
{
while (true)
{
if (b == 0)
{
return a;
}
Int256 a1 = a;
a = b;
b = a1%b;
}
}
private bool CheckNewNonceHash(Int256 newNonce, Int128 newNonceHash)
{
byte[] hash = ComputeSHA1(newNonce.ToBytes());
Int128 nonceHash = hash.ToInt128();
return nonceHash == newNonceHash;
}
public static void GetPrimeMultipliers(this Int256 pq, out Int256 p, out Int256 q)
{
// new prime generation algorithm.
ulong what = (ulong)pq.ToType(typeof(ulong), null, false);
int it = 0, i, j;
ulong g = 0;
for (i = 0; i < 3 || it < 1000; i++)
{
ulong t = ((GenerateLongRand() & 15) + 17) % what;
ulong x = GenerateLongRand() % (what - 1) + 1, y = x;
int lim = 1 << (i + 18);
for (j = 1; j < lim; j++)
{
++it;
ulong a = x, b = x, c = t;
while (b != 0)
{
if ((b & 1) != 0)
{
c += a;
if (c >= what)
{
c -= what;
}
}
a += a;
if (a >= what)
{
a -= what;
}
b >>= 1;
}
x = c;
ulong z = x < y ? what + x - y : x - y;
g = GCD(z, what);
if (g != 1)
{
break;
}
if ((j & (j - 1)) == 0)
{
y = x;
}
}
if (g > 1 && g < what)
{
break;
}
}
if (g > 1 && g < what)
{
p = g;
q = what / g;
if (p > q)
{
var tmp = p;
p = q;
q = tmp;
}
}
else
{
p = 0;
q = 0;
}
// Old algorithm, can be removed in later versions
//p = PollardRho(pq);
//q = pq / p;
//if (p > q)
//{
// Int256 t = p;
// p = q;
// q = t;
//}
Console.WriteLine("p {0} q {1}", p, q);
}
public static Int256 PollardRho(Int256 number)
{
var func = new Func<Int256, Int256, Int256>((param, mod) => ((param*param + 1)%mod));
Int256 x = 2, y = 2, z;
do
{
x = func(x, number);
y = func(func(y, number), number);
z = GCD(x > y ? x - y : y - x, number);
} while (z <= 1);
return z;
}
