public bool IsPassValid(byte[] pass)
{
if (OnlyPublic)
{
throw new ArgumentException(
this.MyNameOfProperty(e => e.OnlyPublic)
);
}
try
{
if (SignType != (int)ELightCertificateSignType.None)
{
PrivateSignParameters.GetOriginData(pass);
}
if (EncryptType != (int)ELightCertificateEncryptType.None)
{
PrivateEncryptParameters.GetOriginData(pass);
}
return(true);
}
catch
{
return(false);
}
}
public void ChangePass(byte[] oldPass, byte[] newPass)
{
if (oldPass == null || oldPass.Length == 0)
{
throw new ArgumentNullException(
MyNameof.GetLocalVarName(() => oldPass)
);
}
if (newPass == null || newPass.Length == 0)
{
throw new ArgumentNullException(
MyNameof.GetLocalVarName(() => newPass)
);
}
if (OnlyPublic)
{
throw new InvalidOperationException(
this.MyNameOfProperty(e => e.OnlyPublic)
);
}
if (!IsPassValid(oldPass))
{
throw new ArgumentException(
MyNameof.GetLocalVarName(() => oldPass)
);
}
if (SignType != (int)ELightCertificateSignType.None)
{
var curSignPrivateData = PrivateSignParameters.GetOriginData(
oldPass
);
PrivateSignParameters = new PassEncryptedData(
curSignPrivateData,
(EPrivateKeysKeyDerivationFunction)
PrivateSignParameters.KeyDerivationFunctionType,
newPass
);
}
if (EncryptType != (int)ELightCertificateEncryptType.None)
{
var curEncryptPrivateData
= PrivateEncryptParameters.GetOriginData(
oldPass
);
PrivateEncryptParameters = new PassEncryptedData(
curEncryptPrivateData,
(EPrivateKeysKeyDerivationFunction)
PrivateEncryptParameters.KeyDerivationFunctionType,
newPass
);
}
}
public byte[] DecryptData(
byte[] encryptedData,
byte[] pass
)
{
if (encryptedData == null)
{
throw new ArgumentNullException(
MyNameof.GetLocalVarName(() => encryptedData)
);
}
if (encryptedData.Length == 0)
{
throw new ArgumentOutOfRangeException(
"encryptedData.Length == 0"
);
}
if (pass == null)
{
throw new ArgumentNullException(
MyNameof.GetLocalVarName(() => pass)
);
}
if (
EncryptType
== (int)ELightCertificateEncryptType.Rsa
)
{
var privateRsaParameters = ReadRsaParameters(
PrivateEncryptParameters.GetOriginData(
pass
),
true
);
using (var csp = GetRsaCsp())
{
csp.ImportParameters(privateRsaParameters);
return(csp.Decrypt(encryptedData, true));
}
}
throw new ArgumentOutOfRangeException(
this.MyNameOfProperty(e => e.EncryptType)
);
}
/**/
if (readPrivate)
{
result.P = reader.ReadBytesOrThrow(reader.ReadInt32());
result.Q = reader.ReadBytesOrThrow(reader.ReadInt32());
result.DP = reader.ReadBytesOrThrow(reader.ReadInt32());
result.DQ = reader.ReadBytesOrThrow(reader.ReadInt32());
result.InverseQ = reader.ReadBytesOrThrow(reader.ReadInt32());
result.D = reader.ReadBytesOrThrow(reader.ReadInt32());
}
}
//_rng.GetBytes(ms.GetBuffer());
}
return(result);
}
private static readonly LittleEndianBitConverter _littleConverter
= new LittleEndianBitConverter();
/**/
public void CheckMe(
bool checkPrivateKeys = false,
byte[] privateKeysPass = null
)
{
if (OnlyPublic && checkPrivateKeys)
{
throw new ArgumentException(
MyNameof.GetLocalVarName(() => checkPrivateKeys)
);
}
if (Id == Guid.Empty)
{
throw new ArgumentException(
this.MyNameOfProperty(e => e.Id)
);
}
if (AdditionalData == null)
{
throw new ArgumentNullException(
this.MyNameOfProperty(e => e.AdditionalData)
);
}
if (Signatures == null)
{
throw new ArgumentNullException(
this.MyNameOfProperty(e => e.Signatures)
);
}
if (
checkPrivateKeys &&
privateKeysPass == null
)
{
throw new ArgumentNullException(
MyNameof.GetLocalVarName(() => privateKeysPass)
);
}
if (SignType != (int)ELightCertificateSignType.None)
{
if (SignType == (int)ELightCertificateSignType.Rsa)
{
if (SignKeySize <= 0)
{
throw new ArgumentOutOfRangeException(
this.MyNameOfProperty(e => e.SignKeySize)
);
}
if (
PublicSignParameters == null
)
{
throw new ArgumentNullException(
this.MyNameOfProperty(e => e.PublicSignParameters)
);
}
var publicRsaParameters = ReadRsaParameters(
PublicSignParameters,
false
);
using (var csp = GetRsaCsp())
{
csp.ImportParameters(
publicRsaParameters
);
if (csp.KeySize != SignKeySize)
{
throw new ArgumentException(
this.MyNameOfProperty(e => e.PublicSignParameters)
);
}
}
if (checkPrivateKeys)
{
if (PrivateSignParameters == null)
{
throw new ArgumentNullException(
this.MyNameOfProperty(e => e.PrivateSignParameters)
);
}
PrivateSignParameters.CheckMe();
var privateRsaParameters = ReadRsaParameters(
PrivateSignParameters.GetOriginData(
privateKeysPass
),
true
);
if (
!privateRsaParameters.Exponent.SequenceEqual(
publicRsaParameters.Exponent
)
||
!privateRsaParameters.Modulus.SequenceEqual(
publicRsaParameters.Modulus
)
)
{
throw new ArgumentException(
this.MyNameOfProperty(e => e.PrivateSignParameters)
);
}
using (var csp = GetRsaCsp())
{
csp.ImportParameters(
privateRsaParameters
);
if (csp.KeySize != SignKeySize)
{
throw new ArgumentException(
this.MyNameOfProperty(e => e.PrivateSignParameters)
);
}
}
}
}
else
{
throw new ArgumentOutOfRangeException(
this.MyNameOfProperty(e => e.SignType)
);
}
}
if (EncryptType != (int)ELightCertificateEncryptType.None)
{
if (EncryptType == (int)ELightCertificateEncryptType.Rsa)
{
if (EncryptKeySize <= 0)
{
throw new ArgumentOutOfRangeException(
this.MyNameOfProperty(e => e.EncryptKeySize)
);
}
if (
PublicEncryptParameters == null
)
{
throw new ArgumentNullException(
this.MyNameOfProperty(e => e.PublicEncryptParameters)
);
}
var publicRsaParameters = ReadRsaParameters(
PublicEncryptParameters,
false
);
using (var csp = GetRsaCsp())
{
csp.ImportParameters(
publicRsaParameters
);
if (csp.KeySize != SignKeySize)
{
throw new ArgumentException(
this.MyNameOfProperty(e => e.PublicEncryptParameters)
);
}
}
if (checkPrivateKeys)
{
if (PrivateEncryptParameters == null)
{
throw new ArgumentNullException(
this.MyNameOfProperty(e => e.PrivateEncryptParameters)
);
}
PrivateEncryptParameters.CheckMe();
var privateRsaParameters = ReadRsaParameters(
PrivateEncryptParameters.GetOriginData(
privateKeysPass
),
true
);
if (
!privateRsaParameters.Exponent.SequenceEqual(
publicRsaParameters.Exponent
)
||
!privateRsaParameters.Modulus.SequenceEqual(
publicRsaParameters.Modulus
)
)
{
throw new ArgumentException(
this.MyNameOfProperty(e => e.PrivateEncryptParameters)
);
}
using (var csp = GetRsaCsp())
{
csp.ImportParameters(
privateRsaParameters
);
if (csp.KeySize != SignKeySize)
{
throw new ArgumentException(
this.MyNameOfProperty(e => e.PrivateEncryptParameters)
);
}
}
}
}
else
{
throw new ArgumentOutOfRangeException(
this.MyNameOfProperty(e => e.EncryptType)
);
}
}
if (Signatures.Any(_ => _.SignerCertificateId == this.Id))
{
Assert.True(
LightCertificatesHelper.CheckCertificateSignature(
this,
this
)
);
}
}
