niko
525 lines
14 KiB
C#
525 lines
14 KiB
C#
using System;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using Mono.Math;
|
|
|
|
namespace Mono.Security.Cryptography
|
|
{
|
|
// Token: 0x020000AD RID: 173
|
|
internal class RSAManaged : RSA
|
|
{
|
|
// Token: 0x06000969 RID: 2409 RVA: 0x00025D5C File Offset: 0x00023F5C
|
|
public RSAManaged()
|
|
: this(1024)
|
|
{
|
|
}
|
|
|
|
// Token: 0x0600096A RID: 2410 RVA: 0x00025D6C File Offset: 0x00023F6C
|
|
public RSAManaged(int keySize)
|
|
{
|
|
this.LegalKeySizesValue = new KeySizes[1];
|
|
this.LegalKeySizesValue[0] = new KeySizes(384, 16384, 8);
|
|
base.KeySize = keySize;
|
|
}
|
|
|
|
// Token: 0x14000002 RID: 2
|
|
// (add) Token: 0x0600096B RID: 2411 RVA: 0x00025DB4 File Offset: 0x00023FB4
|
|
// (remove) Token: 0x0600096C RID: 2412 RVA: 0x00025DD0 File Offset: 0x00023FD0
|
|
public event RSAManaged.KeyGeneratedEventHandler KeyGenerated;
|
|
|
|
// Token: 0x0600096D RID: 2413 RVA: 0x00025DEC File Offset: 0x00023FEC
|
|
~RSAManaged()
|
|
{
|
|
this.Dispose(false);
|
|
}
|
|
|
|
// Token: 0x0600096E RID: 2414 RVA: 0x00025E28 File Offset: 0x00024028
|
|
private void GenerateKeyPair()
|
|
{
|
|
int num = this.KeySize + 1 >> 1;
|
|
int num2 = this.KeySize - num;
|
|
this.e = 17U;
|
|
do
|
|
{
|
|
this.p = BigInteger.GeneratePseudoPrime(num);
|
|
}
|
|
while (this.p % 17U == 1U);
|
|
for (;;)
|
|
{
|
|
do
|
|
{
|
|
this.q = BigInteger.GeneratePseudoPrime(num2);
|
|
}
|
|
while (this.q % 17U == 1U || !(this.p != this.q));
|
|
this.n = this.p * this.q;
|
|
if (this.n.BitCount() == this.KeySize)
|
|
{
|
|
break;
|
|
}
|
|
if (this.p < this.q)
|
|
{
|
|
this.p = this.q;
|
|
}
|
|
}
|
|
BigInteger bigInteger = this.p - 1;
|
|
BigInteger bigInteger2 = this.q - 1;
|
|
BigInteger bigInteger3 = bigInteger * bigInteger2;
|
|
this.d = this.e.ModInverse(bigInteger3);
|
|
this.dp = this.d % bigInteger;
|
|
this.dq = this.d % bigInteger2;
|
|
this.qInv = this.q.ModInverse(this.p);
|
|
this.keypairGenerated = true;
|
|
this.isCRTpossible = true;
|
|
if (this.KeyGenerated != null)
|
|
{
|
|
this.KeyGenerated(this, null);
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700010B RID: 267
|
|
// (get) Token: 0x0600096F RID: 2415 RVA: 0x00025FCC File Offset: 0x000241CC
|
|
public override int KeySize
|
|
{
|
|
get
|
|
{
|
|
if (this.keypairGenerated)
|
|
{
|
|
int num = this.n.BitCount();
|
|
if ((num & 7) != 0)
|
|
{
|
|
num += 8 - (num & 7);
|
|
}
|
|
return num;
|
|
}
|
|
return base.KeySize;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700010C RID: 268
|
|
// (get) Token: 0x06000970 RID: 2416 RVA: 0x00026008 File Offset: 0x00024208
|
|
public override string KeyExchangeAlgorithm
|
|
{
|
|
get
|
|
{
|
|
return "RSA-PKCS1-KeyEx";
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700010D RID: 269
|
|
// (get) Token: 0x06000971 RID: 2417 RVA: 0x00026010 File Offset: 0x00024210
|
|
public bool PublicOnly
|
|
{
|
|
get
|
|
{
|
|
return this.keypairGenerated && (this.d == null || this.n == null);
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700010E RID: 270
|
|
// (get) Token: 0x06000972 RID: 2418 RVA: 0x0002604C File Offset: 0x0002424C
|
|
public override string SignatureAlgorithm
|
|
{
|
|
get
|
|
{
|
|
return "http://www.w3.org/2000/09/xmldsig#rsa-sha1";
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000973 RID: 2419 RVA: 0x00026054 File Offset: 0x00024254
|
|
public override byte[] DecryptValue(byte[] rgb)
|
|
{
|
|
if (this.m_disposed)
|
|
{
|
|
throw new ObjectDisposedException("private key");
|
|
}
|
|
if (!this.keypairGenerated)
|
|
{
|
|
this.GenerateKeyPair();
|
|
}
|
|
BigInteger bigInteger = new BigInteger(rgb);
|
|
BigInteger bigInteger2 = null;
|
|
if (this.keyBlinding)
|
|
{
|
|
bigInteger2 = BigInteger.GenerateRandom(this.n.BitCount());
|
|
bigInteger = bigInteger2.ModPow(this.e, this.n) * bigInteger % this.n;
|
|
}
|
|
BigInteger bigInteger6;
|
|
if (this.isCRTpossible)
|
|
{
|
|
BigInteger bigInteger3 = bigInteger.ModPow(this.dp, this.p);
|
|
BigInteger bigInteger4 = bigInteger.ModPow(this.dq, this.q);
|
|
if (bigInteger4 > bigInteger3)
|
|
{
|
|
BigInteger bigInteger5 = this.p - (bigInteger4 - bigInteger3) * this.qInv % this.p;
|
|
bigInteger6 = bigInteger4 + this.q * bigInteger5;
|
|
}
|
|
else
|
|
{
|
|
BigInteger bigInteger5 = (bigInteger3 - bigInteger4) * this.qInv % this.p;
|
|
bigInteger6 = bigInteger4 + this.q * bigInteger5;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (this.PublicOnly)
|
|
{
|
|
throw new CryptographicException(Locale.GetText("Missing private key to decrypt value."));
|
|
}
|
|
bigInteger6 = bigInteger.ModPow(this.d, this.n);
|
|
}
|
|
if (this.keyBlinding)
|
|
{
|
|
bigInteger6 = bigInteger6 * bigInteger2.ModInverse(this.n) % this.n;
|
|
bigInteger2.Clear();
|
|
}
|
|
byte[] paddedValue = this.GetPaddedValue(bigInteger6, this.KeySize >> 3);
|
|
bigInteger.Clear();
|
|
bigInteger6.Clear();
|
|
return paddedValue;
|
|
}
|
|
|
|
// Token: 0x06000974 RID: 2420 RVA: 0x00026210 File Offset: 0x00024410
|
|
public override byte[] EncryptValue(byte[] rgb)
|
|
{
|
|
if (this.m_disposed)
|
|
{
|
|
throw new ObjectDisposedException("public key");
|
|
}
|
|
if (!this.keypairGenerated)
|
|
{
|
|
this.GenerateKeyPair();
|
|
}
|
|
BigInteger bigInteger = new BigInteger(rgb);
|
|
BigInteger bigInteger2 = bigInteger.ModPow(this.e, this.n);
|
|
byte[] paddedValue = this.GetPaddedValue(bigInteger2, this.KeySize >> 3);
|
|
bigInteger.Clear();
|
|
bigInteger2.Clear();
|
|
return paddedValue;
|
|
}
|
|
|
|
// Token: 0x06000975 RID: 2421 RVA: 0x0002627C File Offset: 0x0002447C
|
|
public override RSAParameters ExportParameters(bool includePrivateParameters)
|
|
{
|
|
if (this.m_disposed)
|
|
{
|
|
throw new ObjectDisposedException(Locale.GetText("Keypair was disposed"));
|
|
}
|
|
if (!this.keypairGenerated)
|
|
{
|
|
this.GenerateKeyPair();
|
|
}
|
|
RSAParameters rsaparameters = default(RSAParameters);
|
|
rsaparameters.Exponent = this.e.GetBytes();
|
|
rsaparameters.Modulus = this.n.GetBytes();
|
|
if (includePrivateParameters)
|
|
{
|
|
if (this.d == null)
|
|
{
|
|
throw new CryptographicException("Missing private key");
|
|
}
|
|
rsaparameters.D = this.d.GetBytes();
|
|
if (rsaparameters.D.Length != rsaparameters.Modulus.Length)
|
|
{
|
|
byte[] array = new byte[rsaparameters.Modulus.Length];
|
|
Buffer.BlockCopy(rsaparameters.D, 0, array, array.Length - rsaparameters.D.Length, rsaparameters.D.Length);
|
|
rsaparameters.D = array;
|
|
}
|
|
if (this.p != null && this.q != null && this.dp != null && this.dq != null && this.qInv != null)
|
|
{
|
|
int num = this.KeySize >> 4;
|
|
rsaparameters.P = this.GetPaddedValue(this.p, num);
|
|
rsaparameters.Q = this.GetPaddedValue(this.q, num);
|
|
rsaparameters.DP = this.GetPaddedValue(this.dp, num);
|
|
rsaparameters.DQ = this.GetPaddedValue(this.dq, num);
|
|
rsaparameters.InverseQ = this.GetPaddedValue(this.qInv, num);
|
|
}
|
|
}
|
|
return rsaparameters;
|
|
}
|
|
|
|
// Token: 0x06000976 RID: 2422 RVA: 0x0002642C File Offset: 0x0002462C
|
|
public override void ImportParameters(RSAParameters parameters)
|
|
{
|
|
if (this.m_disposed)
|
|
{
|
|
throw new ObjectDisposedException(Locale.GetText("Keypair was disposed"));
|
|
}
|
|
if (parameters.Exponent == null)
|
|
{
|
|
throw new CryptographicException(Locale.GetText("Missing Exponent"));
|
|
}
|
|
if (parameters.Modulus == null)
|
|
{
|
|
throw new CryptographicException(Locale.GetText("Missing Modulus"));
|
|
}
|
|
this.e = new BigInteger(parameters.Exponent);
|
|
this.n = new BigInteger(parameters.Modulus);
|
|
if (parameters.D != null)
|
|
{
|
|
this.d = new BigInteger(parameters.D);
|
|
}
|
|
if (parameters.DP != null)
|
|
{
|
|
this.dp = new BigInteger(parameters.DP);
|
|
}
|
|
if (parameters.DQ != null)
|
|
{
|
|
this.dq = new BigInteger(parameters.DQ);
|
|
}
|
|
if (parameters.InverseQ != null)
|
|
{
|
|
this.qInv = new BigInteger(parameters.InverseQ);
|
|
}
|
|
if (parameters.P != null)
|
|
{
|
|
this.p = new BigInteger(parameters.P);
|
|
}
|
|
if (parameters.Q != null)
|
|
{
|
|
this.q = new BigInteger(parameters.Q);
|
|
}
|
|
this.keypairGenerated = true;
|
|
bool flag = this.p != null && this.q != null && this.dp != null;
|
|
this.isCRTpossible = flag && this.dq != null && this.qInv != null;
|
|
if (!flag)
|
|
{
|
|
return;
|
|
}
|
|
bool flag2 = this.n == this.p * this.q;
|
|
if (flag2)
|
|
{
|
|
BigInteger bigInteger = this.p - 1;
|
|
BigInteger bigInteger2 = this.q - 1;
|
|
BigInteger bigInteger3 = bigInteger * bigInteger2;
|
|
BigInteger bigInteger4 = this.e.ModInverse(bigInteger3);
|
|
flag2 = this.d == bigInteger4;
|
|
if (!flag2 && this.isCRTpossible)
|
|
{
|
|
flag2 = this.dp == bigInteger4 % bigInteger && this.dq == bigInteger4 % bigInteger2 && this.qInv == this.q.ModInverse(this.p);
|
|
}
|
|
}
|
|
if (!flag2)
|
|
{
|
|
throw new CryptographicException(Locale.GetText("Private/public key mismatch"));
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000977 RID: 2423 RVA: 0x000266B4 File Offset: 0x000248B4
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if (!this.m_disposed)
|
|
{
|
|
if (this.d != null)
|
|
{
|
|
this.d.Clear();
|
|
this.d = null;
|
|
}
|
|
if (this.p != null)
|
|
{
|
|
this.p.Clear();
|
|
this.p = null;
|
|
}
|
|
if (this.q != null)
|
|
{
|
|
this.q.Clear();
|
|
this.q = null;
|
|
}
|
|
if (this.dp != null)
|
|
{
|
|
this.dp.Clear();
|
|
this.dp = null;
|
|
}
|
|
if (this.dq != null)
|
|
{
|
|
this.dq.Clear();
|
|
this.dq = null;
|
|
}
|
|
if (this.qInv != null)
|
|
{
|
|
this.qInv.Clear();
|
|
this.qInv = null;
|
|
}
|
|
if (disposing)
|
|
{
|
|
if (this.e != null)
|
|
{
|
|
this.e.Clear();
|
|
this.e = null;
|
|
}
|
|
if (this.n != null)
|
|
{
|
|
this.n.Clear();
|
|
this.n = null;
|
|
}
|
|
}
|
|
}
|
|
this.m_disposed = true;
|
|
}
|
|
|
|
// Token: 0x06000978 RID: 2424 RVA: 0x000267F4 File Offset: 0x000249F4
|
|
public override string ToXmlString(bool includePrivateParameters)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
RSAParameters rsaparameters = this.ExportParameters(includePrivateParameters);
|
|
try
|
|
{
|
|
stringBuilder.Append("<RSAKeyValue>");
|
|
stringBuilder.Append("<Modulus>");
|
|
stringBuilder.Append(Convert.ToBase64String(rsaparameters.Modulus));
|
|
stringBuilder.Append("</Modulus>");
|
|
stringBuilder.Append("<Exponent>");
|
|
stringBuilder.Append(Convert.ToBase64String(rsaparameters.Exponent));
|
|
stringBuilder.Append("</Exponent>");
|
|
if (includePrivateParameters)
|
|
{
|
|
if (rsaparameters.P != null)
|
|
{
|
|
stringBuilder.Append("<P>");
|
|
stringBuilder.Append(Convert.ToBase64String(rsaparameters.P));
|
|
stringBuilder.Append("</P>");
|
|
}
|
|
if (rsaparameters.Q != null)
|
|
{
|
|
stringBuilder.Append("<Q>");
|
|
stringBuilder.Append(Convert.ToBase64String(rsaparameters.Q));
|
|
stringBuilder.Append("</Q>");
|
|
}
|
|
if (rsaparameters.DP != null)
|
|
{
|
|
stringBuilder.Append("<DP>");
|
|
stringBuilder.Append(Convert.ToBase64String(rsaparameters.DP));
|
|
stringBuilder.Append("</DP>");
|
|
}
|
|
if (rsaparameters.DQ != null)
|
|
{
|
|
stringBuilder.Append("<DQ>");
|
|
stringBuilder.Append(Convert.ToBase64String(rsaparameters.DQ));
|
|
stringBuilder.Append("</DQ>");
|
|
}
|
|
if (rsaparameters.InverseQ != null)
|
|
{
|
|
stringBuilder.Append("<InverseQ>");
|
|
stringBuilder.Append(Convert.ToBase64String(rsaparameters.InverseQ));
|
|
stringBuilder.Append("</InverseQ>");
|
|
}
|
|
stringBuilder.Append("<D>");
|
|
stringBuilder.Append(Convert.ToBase64String(rsaparameters.D));
|
|
stringBuilder.Append("</D>");
|
|
}
|
|
stringBuilder.Append("</RSAKeyValue>");
|
|
}
|
|
catch
|
|
{
|
|
if (rsaparameters.P != null)
|
|
{
|
|
Array.Clear(rsaparameters.P, 0, rsaparameters.P.Length);
|
|
}
|
|
if (rsaparameters.Q != null)
|
|
{
|
|
Array.Clear(rsaparameters.Q, 0, rsaparameters.Q.Length);
|
|
}
|
|
if (rsaparameters.DP != null)
|
|
{
|
|
Array.Clear(rsaparameters.DP, 0, rsaparameters.DP.Length);
|
|
}
|
|
if (rsaparameters.DQ != null)
|
|
{
|
|
Array.Clear(rsaparameters.DQ, 0, rsaparameters.DQ.Length);
|
|
}
|
|
if (rsaparameters.InverseQ != null)
|
|
{
|
|
Array.Clear(rsaparameters.InverseQ, 0, rsaparameters.InverseQ.Length);
|
|
}
|
|
if (rsaparameters.D != null)
|
|
{
|
|
Array.Clear(rsaparameters.D, 0, rsaparameters.D.Length);
|
|
}
|
|
throw;
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
// Token: 0x1700010F RID: 271
|
|
// (get) Token: 0x06000979 RID: 2425 RVA: 0x00026ABC File Offset: 0x00024CBC
|
|
// (set) Token: 0x0600097A RID: 2426 RVA: 0x00026AC4 File Offset: 0x00024CC4
|
|
public bool UseKeyBlinding
|
|
{
|
|
get
|
|
{
|
|
return this.keyBlinding;
|
|
}
|
|
set
|
|
{
|
|
this.keyBlinding = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000110 RID: 272
|
|
// (get) Token: 0x0600097B RID: 2427 RVA: 0x00026AD0 File Offset: 0x00024CD0
|
|
public bool IsCrtPossible
|
|
{
|
|
get
|
|
{
|
|
return !this.keypairGenerated || this.isCRTpossible;
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600097C RID: 2428 RVA: 0x00026AE8 File Offset: 0x00024CE8
|
|
private byte[] GetPaddedValue(BigInteger value, int length)
|
|
{
|
|
byte[] bytes = value.GetBytes();
|
|
if (bytes.Length >= length)
|
|
{
|
|
return bytes;
|
|
}
|
|
byte[] array = new byte[length];
|
|
Buffer.BlockCopy(bytes, 0, array, length - bytes.Length, bytes.Length);
|
|
Array.Clear(bytes, 0, bytes.Length);
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x04000210 RID: 528
|
|
private const int defaultKeySize = 1024;
|
|
|
|
// Token: 0x04000211 RID: 529
|
|
private bool isCRTpossible;
|
|
|
|
// Token: 0x04000212 RID: 530
|
|
private bool keyBlinding = true;
|
|
|
|
// Token: 0x04000213 RID: 531
|
|
private bool keypairGenerated;
|
|
|
|
// Token: 0x04000214 RID: 532
|
|
private bool m_disposed;
|
|
|
|
// Token: 0x04000215 RID: 533
|
|
private BigInteger d;
|
|
|
|
// Token: 0x04000216 RID: 534
|
|
private BigInteger p;
|
|
|
|
// Token: 0x04000217 RID: 535
|
|
private BigInteger q;
|
|
|
|
// Token: 0x04000218 RID: 536
|
|
private BigInteger dp;
|
|
|
|
// Token: 0x04000219 RID: 537
|
|
private BigInteger dq;
|
|
|
|
// Token: 0x0400021A RID: 538
|
|
private BigInteger qInv;
|
|
|
|
// Token: 0x0400021B RID: 539
|
|
private BigInteger n;
|
|
|
|
// Token: 0x0400021C RID: 540
|
|
private BigInteger e;
|
|
|
|
// Token: 0x020006C5 RID: 1733
|
|
// (Invoke) Token: 0x0600419C RID: 16796
|
|
public delegate void KeyGeneratedEventHandler(object sender, EventArgs e);
|
|
}
|
|
}
|