public bool ContainsSignature(string sig, bool includePrivate = false)
{
if (includePrivate)
{
return(m_SignatureList.Any(e => e.Name == sig));
}
return(Signatures.Any(e => e.Name == sig));
}
public FileTypeVerifyResult Verify(Stream stream)
{
stream.Position = 0;
var reader = new BinaryReader(stream);
var headerBytes = reader.ReadBytes(SignatureLength);
return(new FileTypeVerifyResult
{
Name = Name,
Description = Description,
IsVerified = Signatures.Any(signature =>
headerBytes.Take(signature.Length)
.SequenceEqual(signature)
)
});
}
private void UpdateFlags()
{
if (!MultipleSignaturesPossible && Signatures.Count <= 1)
{
AnyHaveAsm = ItemType != AssemblyType.Unknown;
AnyHaveDoc = DocModel != null && !DocModel.IsEmpty();
AnyHaveTra = DocModelTranslated != null && !DocModelTranslated.IsEmpty();
AllThatHaveAsmHaveDoc = !AnyHaveAsm || AnyHaveDoc;
AnyThatHaveAsmHaveDoc = !AnyHaveAsm || AnyHaveDoc;
AllThatHaveDocHaveAsm = !AnyHaveDoc || AnyHaveAsm || DocModel.IsCsNone();
AnyThatHaveDocHaveAsm = !AnyHaveDoc || AnyHaveAsm || DocModel.IsCsNone();
AllThatHaveEngHaveTra = !AnyHaveDoc || AnyHaveTra;
AnyThatHaveEngHaveTra = !AnyHaveDoc || AnyHaveTra;
AllThatHaveTraHaveEng = !AnyHaveTra || AnyHaveDoc;
AnyThatHaveTraHaveEng = !AnyHaveTra || AnyHaveDoc;
}
else
{
AnyHaveAsm = Signatures.Any(e => e.InAsm);
AnyHaveDoc = Signatures.Any(e => e.InDoc) && DocModel != null && !DocModel.IsEmpty();
AnyHaveTra = Signatures.Any(e => e.InDocTranslated) && DocModelTranslated != null && !DocModelTranslated.IsEmpty();
IEnumerable <SignatureEntry> asmOrDoc = Signatures.Where(s => (s.InAsm || s.InDoc));
AllThatHaveAsmHaveDoc = !AnyHaveAsm || asmOrDoc.All(e => e.InDoc);
AnyThatHaveAsmHaveDoc = !AnyHaveAsm || asmOrDoc.Any(e => e.InDoc);
AllThatHaveDocHaveAsm = !AnyHaveDoc || asmOrDoc.All(e => e.InAsm) || DocModel.IsCsNone();;
AnyThatHaveDocHaveAsm = !AnyHaveDoc || asmOrDoc.Any(e => e.InAsm) || DocModel.IsCsNone();;
IEnumerable <SignatureEntry> engOrTra = Signatures.Where(s => (s.InDoc || s.InDocTranslated));
AllThatHaveEngHaveTra = !AnyHaveDoc || engOrTra.All(e => e.InDocTranslated);
AnyThatHaveEngHaveTra = !AnyHaveDoc || engOrTra.Any(e => e.InDocTranslated);
AllThatHaveTraHaveEng = !AnyHaveTra || engOrTra.All(e => e.InDoc);
AnyThatHaveTraHaveEng = !AnyHaveTra || engOrTra.Any(e => e.InDoc);
}
AllPrivate = m_SignatureList.Any(s => s.InAsm && s.Asm.Private) && !Signatures.Any(s => (s.InAsm || s.InDoc));
}
/**/
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
)
);
}
}
