public virtual void DoTest6()
{
byte[] salt = Hex.Decode("61DF870C4890FE85D6E3DD87C3DCE3723F91DB49");
RsaKeyParameters pubParameters = new RsaKeyParameters(false, mod6, pub6);
RsaKeyParameters privParameters = new RsaKeyParameters(true, mod6, pri6);
ParametersWithSalt sigParameters = new ParametersWithSalt(privParameters, salt);
RsaEngine rsa = new RsaEngine();
byte[] data;
//
// ISO 9796-2 - PSS Signing
//
Iso9796d2PssSigner eng = new Iso9796d2PssSigner(rsa, new RipeMD160Digest(), 20, true);
eng.Init(true, sigParameters);
data = eng.GenerateSignature();
eng.Init(false, pubParameters);
if (!IsSameAs(sig6, 1, data))
{
Fail("failed ISO9796-2 generation Test 6");
}
if (!eng.VerifySignature(data))
{
Fail("failed ISO9796-2 verify Test 6");
}
}
public virtual void Init(bool forSigning, ICipherParameters parameters)
{
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
RsaKeyParameters rsaKeyParameters;
if (parameters is ParametersWithRandom)
{
ParametersWithRandom parametersWithRandom = (ParametersWithRandom)parameters;
rsaKeyParameters = (RsaKeyParameters)parametersWithRandom.Parameters;
if (forSigning)
{
random = parametersWithRandom.Random;
}
}
else if (parameters is ParametersWithSalt)
{
if (!forSigning)
{
throw new ArgumentException("ParametersWithSalt only valid for signing", "parameters");
}
ParametersWithSalt parametersWithSalt = (ParametersWithSalt)parameters;
rsaKeyParameters = (RsaKeyParameters)parametersWithSalt.Parameters;
standardSalt = parametersWithSalt.GetSalt();
if (standardSalt.Length != saltLength)
{
throw new ArgumentException("Fixed salt is of wrong length");
}
}
else
{
rsaKeyParameters = (RsaKeyParameters)parameters;
if (forSigning)
{
random = new SecureRandom();
}
}
cipher.Init(forSigning, rsaKeyParameters);
keyBits = rsaKeyParameters.Modulus.BitLength;
block = new byte[(keyBits + 7) / 8];
if (trailer == 188)
{
mBuf = new byte[block.Length - digest.GetDigestSize() - saltLength - 1 - 1];
}
else
{
mBuf = new byte[block.Length - digest.GetDigestSize() - saltLength - 1 - 2];
}
Reset();
}
/// <summary> Initialise the signer.
///
/// </summary>
/// <param name="forSigning">true if for signing, false if for verification.
/// </param>
/// <param name="param">parameters for signature generation/verification. If the
/// parameters are for generation they should be a ParametersWithRandom,
/// a ParametersWithSalt, or just an RsaKeyParameters object. If RsaKeyParameters
/// are passed in a SecureRandom will be created.
/// </param>
/// <exception cref=""> ArgumentException if wrong parameter type or a fixed
/// salt is passed in which is the wrong length.
/// </exception>
public virtual void Init(
bool forSigning,
ICipherParameters parameters)
{
int lengthOfSalt = saltLength;
RsaKeyParameters kParam;
if (parameters is ParametersWithRandom)
{
ParametersWithRandom p = (ParametersWithRandom)parameters;
kParam = (RsaKeyParameters)p.Parameters;
random = p.Random;
}
else if (parameters is ParametersWithSalt)
{
ParametersWithSalt p = (ParametersWithSalt)parameters;
kParam = (RsaKeyParameters)p.Parameters;
standardSalt = p.GetSalt();
lengthOfSalt = standardSalt.Length;
}
else
{
kParam = (RsaKeyParameters)parameters;
if (forSigning)
{
random = new SecureRandom();
}
}
cipher.Init(forSigning, kParam);
keyBits = kParam.Modulus.BitLength;
block = new byte[(keyBits + 7) / 8];
if (trailer == TrailerImplicit)
{
mBuf = new byte[block.Length - digest.GetDigestSize() - lengthOfSalt - 1 - 1];
}
else
{
mBuf = new byte[block.Length - digest.GetDigestSize() - lengthOfSalt - 1 - 2];
}
Reset();
}
public virtual void Init(bool forSigning, ICipherParameters parameters)
{
RsaKeyParameters rsaKeyParameters;
if (parameters is ParametersWithRandom)
{
ParametersWithRandom parametersWithRandom = (ParametersWithRandom)parameters;
rsaKeyParameters = (RsaKeyParameters)parametersWithRandom.Parameters;
if (forSigning)
{
this.random = parametersWithRandom.Random;
}
}
else if (parameters is ParametersWithSalt)
{
if (!forSigning)
{
throw new ArgumentException("ParametersWithSalt only valid for signing", "parameters");
}
ParametersWithSalt parametersWithSalt = (ParametersWithSalt)parameters;
rsaKeyParameters = (RsaKeyParameters)parametersWithSalt.Parameters;
this.standardSalt = parametersWithSalt.GetSalt();
if (this.standardSalt.Length != this.saltLength)
{
throw new ArgumentException("Fixed salt is of wrong length");
}
}
else
{
rsaKeyParameters = (RsaKeyParameters)parameters;
if (forSigning)
{
this.random = new SecureRandom();
}
}
this.cipher.Init(forSigning, rsaKeyParameters);
this.keyBits = rsaKeyParameters.Modulus.BitLength;
this.block = new byte[(this.keyBits + 7) / 8];
if (this.trailer == 188)
{
this.mBuf = new byte[this.block.Length - this.digest.GetDigestSize() - this.saltLength - 1 - 1];
}
else
{
this.mBuf = new byte[this.block.Length - this.digest.GetDigestSize() - this.saltLength - 1 - 2];
}
this.Reset();
}
/// <summary> Initialise the signer.
///
/// </summary>
/// <param name="forSigning">true if for signing, false if for verification.
/// </param>
/// <param name="param">parameters for signature generation/verification. If the
/// parameters are for generation they should be a ParametersWithRandom,
/// a ParametersWithSalt, or just an RSAKeyParameters object. If RSAKeyParameters
/// are passed in a SecureRandom will be created.
/// </param>
/// <exception cref="ArgumentException"> IllegalArgumentException if wrong parameter type or a fixed
/// salt is passed in which is the wrong length.
/// </exception>
public virtual void init(bool forSigning, CipherParameters param)
{
RSAKeyParameters kParam = null;
int lengthOfSalt = saltLength;
if (param is ParametersWithRandom)
{
ParametersWithRandom p = (ParametersWithRandom)param;
kParam = (RSAKeyParameters)p.getParameters();
random = p.getRandom();
}
else if (param is ParametersWithSalt)
{
ParametersWithSalt p = (ParametersWithSalt)param;
kParam = (RSAKeyParameters)p.getParameters();
standardSalt = p.getSalt();
lengthOfSalt = standardSalt.Length;
}
else
{
kParam = (RSAKeyParameters)param;
if (forSigning)
{
random = new SecureRandom();
}
}
cipher.init(forSigning, kParam);
keyBits = kParam.getModulus().bitLength();
block = new byte[(keyBits + 7) / 8];
if (trailer == TRAILER_IMPLICIT)
{
mBuf = new byte[block.Length - digest.getDigestSize() - lengthOfSalt - 1 - 1];
}
else
{
mBuf = new byte[block.Length - digest.getDigestSize() - lengthOfSalt - 1 - 2];
}
reset();
}
public virtual void DoTest7()
{
byte[] salt = new byte[0];
RsaKeyParameters pubParameters = new RsaKeyParameters(false, mod6, pub6);
RsaKeyParameters privParameters = new RsaKeyParameters(true, mod6, pri6);
ParametersWithSalt sigParameters = new ParametersWithSalt(privParameters, salt);
RsaEngine rsa = new RsaEngine();
byte[] data;
//
// ISO 9796-2 - PSS Signing
//
Iso9796d2PssSigner eng = new Iso9796d2PssSigner(rsa, new Sha1Digest(), 0, false);
eng.Init(true, sigParameters);
eng.Update(msg7[0]);
eng.BlockUpdate(msg7, 1, msg7.Length - 1);
data = eng.GenerateSignature();
eng.Init(false, pubParameters);
if (!IsSameAs(sig7, 0, data))
{
Fail("failed ISO9796-2 generation Test 7");
}
eng.Update(msg7[0]);
eng.BlockUpdate(msg7, 1, msg7.Length - 1);
if (!eng.VerifySignature(data))
{
Fail("failed ISO9796-2 verify Test 7");
}
if (!IsSameAs(msg7, 0, eng.GetRecoveredMessage()))
{
Fail("failed ISO9796-2 recovery Test 7");
}
}
public virtual void DoTest8()
{
byte[] salt = Hex.Decode("78E293203CBA1B7F92F05F4D171FF8CA3E738FF8");
RsaKeyParameters pubParameters = new RsaKeyParameters(false, mod6, pub6);
RsaKeyParameters privParameters = new RsaKeyParameters(true, mod6, pri6);
ParametersWithSalt sigParameters = new ParametersWithSalt(privParameters, salt);
RsaEngine rsa = new RsaEngine();
byte[] data;
//
// ISO 9796-2 - PSS Signing
//
Iso9796d2PssSigner eng = new Iso9796d2PssSigner(rsa, new RipeMD160Digest(), 20, false);
eng.Init(true, sigParameters);
eng.Update(msg8[0]);
eng.BlockUpdate(msg8, 1, msg8.Length - 1);
data = eng.GenerateSignature();
eng.Init(false, pubParameters);
if (!IsSameAs(sig8, 0, data))
{
Fail("failed ISO9796-2 generation Test 8");
}
eng.Update(msg8[0]);
eng.BlockUpdate(msg8, 1, msg8.Length - 1);
if (!eng.VerifySignature(data))
{
Fail("failed ISO9796-2 verify Test 8");
}
}
/// <summary>Initialise the signer.</summary>
/// <param name="forSigning">true if for signing, false if for verification.</param>
/// <param name="parameters">parameters for signature generation/verification. If the
/// parameters are for generation they should be a ParametersWithRandom,
/// a ParametersWithSalt, or just an RsaKeyParameters object. If RsaKeyParameters
/// are passed in a SecureRandom will be created.
/// </param>
/// <exception cref="ArgumentException">if wrong parameter type or a fixed
/// salt is passed in which is the wrong length.
/// </exception>
public virtual void Init(
bool forSigning,
ICipherParameters parameters)
{
RsaKeyParameters kParam;
if (parameters is ParametersWithRandom)
{
ParametersWithRandom p = (ParametersWithRandom)parameters;
kParam = (RsaKeyParameters)p.Parameters;
if (forSigning)
{
random = p.Random;
}
}
else if (parameters is ParametersWithSalt)
{
if (!forSigning)
{
throw new ArgumentException("ParametersWithSalt only valid for signing", "parameters");
}
ParametersWithSalt p = (ParametersWithSalt)parameters;
kParam = (RsaKeyParameters)p.Parameters;
standardSalt = p.GetSalt();
if (standardSalt.Length != saltLength)
{
throw new ArgumentException("Fixed salt is of wrong length");
}
}
else
{
kParam = (RsaKeyParameters)parameters;
if (forSigning)
{
random = new SecureRandom();
}
}
cipher.Init(forSigning, kParam);
keyBits = kParam.Modulus.BitLength;
block = new byte[(keyBits + 7) / 8];
if (trailer == IsoTrailers.TRAILER_IMPLICIT)
{
mBuf = new byte[block.Length - digest.GetDigestSize() - saltLength - 1 - 1];
}
else
{
mBuf = new byte[block.Length - digest.GetDigestSize() - saltLength - 1 - 2];
}
Reset();
}
