/// <summary> /// Creates the key exchange data. /// </summary> /// <returns>The key exchange data to be sent to the intended recipient.</returns> public override byte[] CreateKeyExchange() { BigInteger y = m_G.ModPow(m_X, m_P); byte[] ret = y.GetBytes(); y.Clear(); return(ret); }
public override byte[] CreateKeyExchange() { BigInteger bigInteger = this.m_G.ModPow(this.m_X, this.m_P); byte[] bytes = bigInteger.GetBytes(); bigInteger.Clear(); return(bytes); }
public override byte[] DecryptKeyExchange(byte[] keyEx) { BigInteger bigInteger = new BigInteger(keyEx).ModPow(this.m_X, this.m_P); byte[] bytes = bigInteger.GetBytes(); bigInteger.Clear(); return(bytes); }
private void Dispose() { if (!_disposed) { _p.Clear(); _g.Clear(); _x.Clear(); } _disposed = true; }
/// <summary> /// Extracts secret information from the key exchange data. /// </summary> /// <param name="keyEx">The key exchange data within which the shared key is hidden.</param> /// <returns>The shared key derived from the key exchange data.</returns> public override byte[] DecryptKeyExchange(byte[] keyEx) { var pvr = new BigInteger(keyEx); BigInteger z = pvr.ModPow(m_X, m_P); byte[] ret = z.GetBytes(); z.Clear(); return(ret); }
/// <summary> /// Releases the unmanaged resources used by the SymmetricAlgorithm and optionally releases the managed resources. /// </summary> /// <param name="disposing"> /// <b>true</b> to release both managed and unmanaged resources; <b>false</b> to release only /// unmanaged resources. /// </param> protected override void Dispose(bool disposing) { if (!m_Disposed) { m_P.Clear(); m_G.Clear(); m_X.Clear(); } m_Disposed = true; }
protected override void Dispose(bool disposing) { if (!m_disposed) { // Always zeroize private key if (d != null) { d.Clear(); d = null; } if (p != null) { p.Clear(); p = null; } if (q != null) { q.Clear(); q = null; } if (dp != null) { dp.Clear(); dp = null; } if (dq != null) { dq.Clear(); dq = null; } if (qInv != null) { qInv.Clear(); qInv = null; } if (disposing) { // clear public key if (e != null) { e.Clear(); e = null; } if (n != null) { n.Clear(); n = null; } } } // call base class // no need as they all are abstract before us m_disposed = true; }
public override byte[] DecryptValue(byte[] rgb) { if (this.m_disposed) { throw new ObjectDisposedException("private key"); } if (!this.keypairGenerated) { this.GenerateKeyPair(); } BigInteger bigInteger1 = new BigInteger(rgb); BigInteger bigInteger2 = (BigInteger)null; if (this.keyBlinding) { bigInteger2 = BigInteger.GenerateRandom(this.n.BitCount()); bigInteger1 = bigInteger2.ModPow(this.e, this.n) * bigInteger1 % this.n; } BigInteger bigInteger3; if (this.isCRTpossible) { BigInteger bigInteger4 = bigInteger1.ModPow(this.dp, this.p); BigInteger bigInteger5 = bigInteger1.ModPow(this.dq, this.q); if (bigInteger5 > bigInteger4) { BigInteger bigInteger6 = this.p - (bigInteger5 - bigInteger4) * this.qInv % this.p; bigInteger3 = bigInteger5 + this.q * bigInteger6; } else { BigInteger bigInteger6 = (bigInteger4 - bigInteger5) * this.qInv % this.p; bigInteger3 = bigInteger5 + this.q * bigInteger6; } } else { if (this.PublicOnly) { throw new CryptographicException(Locale.GetText("Missing private key to decrypt value.")); } bigInteger3 = bigInteger1.ModPow(this.d, this.n); } if (this.keyBlinding) { bigInteger3 = bigInteger3 * bigInteger2.ModInverse(this.n) % this.n; bigInteger2.Clear(); } byte[] paddedValue = this.GetPaddedValue(bigInteger3, this.KeySize >> 3); bigInteger1.Clear(); bigInteger3.Clear(); return(paddedValue); }
public override byte[] DecryptValue(byte[] rgb) { if (m_disposed) { throw new ObjectDisposedException("private key"); } if (!keypairGenerated) { GenerateKeyPair(); } BigInteger bigInteger = new BigInteger(rgb); BigInteger bigInteger2 = null; if (keyBlinding) { bigInteger2 = BigInteger.GenerateRandom(n.BitCount()); bigInteger = bigInteger2.ModPow(e, n) * bigInteger % n; } BigInteger bigInteger5; if (isCRTpossible) { BigInteger bigInteger3 = bigInteger.ModPow(dp, p); BigInteger bigInteger4 = bigInteger.ModPow(dq, q); if (bigInteger4 > bigInteger3) { BigInteger bi = p - (bigInteger4 - bigInteger3) * qInv % p; bigInteger5 = bigInteger4 + q * bi; } else { BigInteger bi = (bigInteger3 - bigInteger4) * qInv % p; bigInteger5 = bigInteger4 + q * bi; } } else { if (PublicOnly) { throw new CryptographicException(Locale.GetText("Missing private key to decrypt value.")); } bigInteger5 = bigInteger.ModPow(d, n); } if (keyBlinding) { bigInteger5 = bigInteger5 * bigInteger2.ModInverse(n) % n; bigInteger2.Clear(); } byte[] paddedValue = GetPaddedValue(bigInteger5, KeySize >> 3); bigInteger.Clear(); bigInteger5.Clear(); return(paddedValue); }
protected override void Dispose(bool disposing) { if (!m_disposed) { // Always zeroize private key if (x != null) { x.Clear(); x = null; } if (disposing) { // clear group if (p != null) { p.Clear(); p = null; } if (q != null) { q.Clear(); q = null; } if (g != null) { g.Clear(); g = null; } if (j != null) { j.Clear(); j = null; } if (seed != null) { seed.Clear(); seed = null; } // clear public key if (y != null) { y.Clear(); y = null; } } } // call base class // no need as they all are abstract before us m_disposed = true; }
protected override void Dispose(bool disposing) { if (!m_disposed) { if (d != null) { d.Clear(); d = null; } if (p != null) { p.Clear(); p = null; } if (q != null) { q.Clear(); q = null; } if (dp != null) { dp.Clear(); dp = null; } if (dq != null) { dq.Clear(); dq = null; } if (qInv != null) { qInv.Clear(); qInv = null; } if (disposing) { if (e != null) { e.Clear(); e = null; } if (n != null) { n.Clear(); n = null; } } } m_disposed = true; }
public override byte[] DecryptValue(byte[] rgb) { if (m_disposed) { throw new ObjectDisposedException("private key"); } // decrypt operation is used for signature if (!keypairGenerated) { GenerateKeyPair(); } BigInteger input = new BigInteger(rgb); BigInteger output; // decrypt (which uses the private key) can be // optimized by using CRT (Chinese Remainder Theorem) if (isCRTpossible) { // m1 = c^dp mod p BigInteger m1 = input.ModPow(dp, p); // m2 = c^dq mod q BigInteger m2 = input.ModPow(dq, q); BigInteger h; if (m2 > m1) { // thanks to benm! h = p - ((m2 - m1) * qInv % p); output = m2 + q * h; } else { // h = (m1 - m2) * qInv mod p h = (m1 - m2) * qInv % p; // m = m2 + q * h; output = m2 + q * h; } } else { // m = c^d mod n output = input.ModPow(d, n); } byte[] result = output.GetBytes(); // zeroize value input.Clear(); output.Clear(); return(result); }
/// <summary> /// Releases the unmanaged resources used by the SymmetricAlgorithm and optionally releases the managed resources. /// </summary> /// <param name="disposing"><b>true</b> to release both managed and unmanaged resources; <b>false</b> to release only unmanaged resources.</param> protected override void Dispose(bool disposing) { if (disposing) { if (!m_Disposed) { m_P.Clear(); m_G.Clear(); m_X.Clear(); } m_Disposed = true; } GC.SuppressFinalize(this); }
public override byte[] EncryptValue(byte[] rgb) { if (m_disposed) { throw new ObjectDisposedException("public key"); } if (!keypairGenerated) { GenerateKeyPair(); } BigInteger bigInteger = new BigInteger(rgb); BigInteger bigInteger2 = bigInteger.ModPow(e, n); byte[] paddedValue = GetPaddedValue(bigInteger2, KeySize >> 3); bigInteger.Clear(); bigInteger2.Clear(); return(paddedValue); }
public override byte[] EncryptValue(byte[] rgb) { if (this.m_disposed) { throw new ObjectDisposedException("public key"); } if (!this.keypairGenerated) { this.GenerateKeyPair(); } BigInteger bigInteger1 = new BigInteger(rgb); BigInteger bigInteger2 = bigInteger1.ModPow(this.e, this.n); byte[] paddedValue = this.GetPaddedValue(bigInteger2, this.KeySize >> 3); bigInteger1.Clear(); bigInteger2.Clear(); return(paddedValue); }
public override byte[] EncryptValue(byte[] rgb) { if (m_disposed) { throw new ObjectDisposedException("public key"); } if (!keypairGenerated) { GenerateKeyPair(); } BigInteger input = new BigInteger(rgb); BigInteger output = input.ModPow(e, n); byte[] result = output.GetBytes(); // zeroize value input.Clear(); output.Clear(); return(result); }
public override byte[] EncryptValue(byte[] rgb) { if (m_disposed) { throw new ObjectDisposedException("public key"); } if (!keypairGenerated) { GenerateKeyPair(); } BigInteger input = new BigInteger(rgb); BigInteger output = input.ModPow(e, n); // it's sometimes possible for the results to be a byte short // and this can break some software (see #79502) so we 0x00 pad the result byte[] result = GetPaddedValue(output, (KeySize >> 3)); // zeroize value input.Clear(); output.Clear(); return(result); }
public override byte[] DecryptValue(byte[] rgb) { if (m_disposed) { throw new ObjectDisposedException("private key"); } // decrypt operation is used for signature if (!keypairGenerated) { GenerateKeyPair(); } BigInteger input = new BigInteger(rgb); BigInteger r = null; // we use key blinding (by default) against timing attacks if (keyBlinding) { // x = (r^e * g) mod n // *new* random number (so it's timing is also random) r = BigInteger.GenerateRandom(n.BitCount()); input = r.ModPow(e, n) * input % n; } BigInteger output; // decrypt (which uses the private key) can be // optimized by using CRT (Chinese Remainder Theorem) if (isCRTpossible) { // m1 = c^dp mod p BigInteger m1 = input.ModPow(dp, p); // m2 = c^dq mod q BigInteger m2 = input.ModPow(dq, q); BigInteger h; if (m2 > m1) { // thanks to benm! h = p - ((m2 - m1) * qInv % p); output = m2 + q * h; } else { // h = (m1 - m2) * qInv mod p h = (m1 - m2) * qInv % p; // m = m2 + q * h; output = m2 + q * h; } } else { // m = c^d mod n output = input.ModPow(d, n); } if (keyBlinding) { // Complete blinding // x^e / r mod n output = output * r.ModInverse(n) % n; r.Clear(); } byte[] result = output.GetBytes(); // zeroize values input.Clear(); output.Clear(); return(result); }
public override byte[] DecryptValue(byte[] rgb) { if (m_disposed) { throw new ObjectDisposedException("private key"); } // decrypt operation is used for signature if (!keypairGenerated) { GenerateKeyPair(); } BigInteger input = new BigInteger(rgb); BigInteger r = null; // we use key blinding (by default) against timing attacks if (keyBlinding) { // x = (r^e * g) mod n // *new* random number (so it's timing is also random) r = BigInteger.GenerateRandom(n.BitCount()); input = r.ModPow(e, n) * input % n; } BigInteger output; // decrypt (which uses the private key) can be // optimized by using CRT (Chinese Remainder Theorem) if (isCRTpossible) { // m1 = c^dp mod p BigInteger m1 = input.ModPow(dp, p); // m2 = c^dq mod q BigInteger m2 = input.ModPow(dq, q); BigInteger h; if (m2 > m1) { // thanks to benm! h = p - ((m2 - m1) * qInv % p); output = m2 + q * h; } else { // h = (m1 - m2) * qInv mod p h = (m1 - m2) * qInv % p; // m = m2 + q * h; output = m2 + q * h; } } else if (!PublicOnly) { // m = c^d mod n output = input.ModPow(d, n); } else { throw new CryptographicException(Locale.GetText("Missing private key to decrypt value.")); } if (keyBlinding) { // Complete blinding // x^e / r mod n output = output * r.ModInverse(n) % n; r.Clear(); } // it's sometimes possible for the results to be a byte short // and this can break some software (see #79502) so we 0x00 pad the result byte[] result = GetPaddedValue(output, (KeySize >> 3)); // zeroize values input.Clear(); output.Clear(); return(result); }