public VerifyResult VerifyMany(IDictionary <string, object> keyValueCollections, bool withGlobalRules, string withGlobalProviderName = "")
{
if (ValidationHandler is null)
{
return(VerifyResult.Success);
}
var master = ValidationHandler.VerifyMany(_visitor.SourceType, keyValueCollections);
var slave = withGlobalRules
? ValidationMe.Resolve <T>(withGlobalProviderName).VerifyMany(_visitor.SourceType, keyValueCollections)
: VerifyResult.Success;
return(VerifyResult.Merge(master, slave));
}
private static JObject GetRelayResult(VerifyResult reason, UInt256 hash)
{
if (reason == VerifyResult.Succeed)
{
var ret = new JObject();
ret["hash"] = hash.ToString();
return(ret);
}
else
{
throw new RpcException(-500, reason.ToString());
}
}
public VerifyResult VerifyOne(string memberName, object value, bool withGlobalRules, string withGlobalProviderName = "")
{
if (ValidationHandler is null)
{
return(VerifyResult.Success);
}
var master = ValidationHandler.VerifyOne(_visitor.SourceType, value, memberName);
var slave = withGlobalRules
? ValidationMe.Resolve <T>(withGlobalProviderName).VerifyOne(value, memberName)
: VerifyResult.Success;
return(VerifyResult.Merge(master, slave));
}
public VerifyResult Verify(bool withGlobalRules, string withGlobalProviderName = "")
{
if (ValidationHandler is null)
{
return(VerifyResult.Success);
}
var master = ValidationHandler.Verify(_visitor.SourceType, _visitor.Instance);
var slave = withGlobalRules
? ValidationMe.Resolve <T>(withGlobalProviderName).Verify(_visitor.Instance)
: VerifyResult.Success;
return(VerifyResult.Merge(master, slave));
}
public VerifyResult Refund()
{
var result = new VerifyResult {
Status = "-30000"
};
result.Description = GetDescription(1006, int.Parse(result.Status));
if (ReturningParams.Length > 0)
{
var decryptedRequest = "";
var aes = new AES(Key, Iv);
var aesDecrypt = aes.Decrypt(ReturningParams, out decryptedRequest);
if (aesDecrypt)
{
var arry = decryptedRequest.Split(Convert.ToChar(","));
result.Amount = int.Parse(arry[0]);
result.OrderId = int.Parse(arry[1]);
//result.RefId = arry[2];
result.Status = arry[3];
result.Description = arry[4];
var payGateTranId = arry[5];
result.RefrenceNumber = arry[6];
result.CustomerCardNumber = arry[4] + "***" + arry[7];
result.Description = GetDescription(1006, int.Parse(result.Status));
if (int.Parse(result.Status) == 0)
{
result.Status = "-30001";
result.Description = GetDescription(1006, int.Parse(result.Status));
var userpassEncrypt = "";
aes.Encrypt(Username + "," + Password, out userpassEncrypt);
var ap = new AsanPardakhtService.merchantservicesSoapClient();
var verify = ap.RequestVerification(MerchantId, userpassEncrypt, uint.Parse(payGateTranId));
result.Status = verify;
result.Description = GetDescription(1006, int.Parse(result.Status));
if (int.Parse(verify) == 500)
{
result.Status = "-30002";
result.Description = GetDescription(1006, int.Parse(result.Status));
var recon = ap.RequestReconciliation(MerchantId, userpassEncrypt, uint.Parse(payGateTranId));
result.Status = recon;
result.Description = GetDescription(1006, int.Parse(result.Status));
}
}
}
}
return(result);
}
public virtual VerifyResult VerifyOne(string memberName, bool withGlobalRules, string withGlobalProviderName = "")
{
if (ValidationHandler is null)
{
return(VerifyResult.Success);
}
var value = _visitor.ExposeLazyMemberHandler().Value.GetValueObject(memberName);
var master = ValidationHandler.VerifyOne(_visitor.SourceType, value, memberName);
var slave = withGlobalRules
? ValidationMe.Resolve(_visitor.SourceType, withGlobalProviderName).Verify(_visitor.SourceType, _visitor.Instance)
: VerifyResult.Success;
return(VerifyResult.Merge(master, slave));
}
/// <summary>
/// Проверить поступил ли чек в ФНС
/// </summary>
/// <param name="fiscalNumber">Фискальный номер, также известный как ФН. Номер состоит из 16 цифр.</param>
/// <param name="fiscalDocument">Номер фискального документа, также известный как ФД. Состоит максимум из 10 цифр.</param>
/// <param name="fiscalSign">Фискальный признак документа, также известный как ФП, ФПД. Состоит максимум из 10 цифр.</param>
/// <param name="date">Дата, указанная в чеке. Секунды не обязательные.</param>
/// <param name="sum">Сумма, указанная в чеке. Включая копейки.</param>
/// <returns></returns>
public static async Task <VerifyResult> VerifyAsync(string fiscalNumber, string fiscalDocument, string fiscalSign, DateTime date, double sum)
{
var response = await client.GetAsync(Urls.GetCheckUrl(fiscalNumber, fiscalDocument, fiscalSign, date, sum));
var result = new VerifyResult
{
IsSuccess = response.IsSuccessStatusCode,
Message = await response.Content.ReadAsStringAsync(),
ReceiptExists = response.IsSuccessStatusCode,
StatusCode = response.StatusCode
};
return(result);
}
private static async void VerifyFace(object s, EventArgs e)
{
if (Paused)
{
return;
}
var frame = GetCameraImage();
var recognizedFace = await faceClient.DetectAsync(frame.ToMemoryStream(".jpg"), returnFaceId : true);
recognizedFaceID = recognizedFace.Length > 0 ? recognizedFace[0].FaceId : (Guid?)null;
VerifyResult result = new VerifyResult()
{
Confidence = 0
};
if (recognizedFaceID != null)
{
result = await faceClient.VerifyAsync(myFaceID, (Guid)recognizedFaceID);
}
if (result.Confidence < 0.5)
{
lockTimer++;
if (lockTimer == 1)
{
await Task.Run(() => MessageBox.Show(new Form()
{
TopMost = true
}, "...", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning));
}
if (lockTimer > maxFailures)
{
LockWorkStation();
Paused = true;
lockTimer = 0;
}
}
else
{
lockTimer = 0;
}
TrayMenu.MenuItems[1].Text = $"Result ({iteration}): {result.Confidence}";
iteration++;
}
/// <summary>
/// 获取request对象
/// </summary>
/// <param name="requestStr"></param>
/// <param name="bizCode"></param>
/// <param name="baseRequest"></param>
/// <returns></returns>
protected VerifyResult GetRequest(string requestStr, string bizCode, out BaseRequest baseRequest)
{
baseRequest = null;
switch (bizCode)
{
case "1006":
baseRequest = JsonUtils.Deserialize <BaseRequest>(requestStr);
break;
default:
return(VerifyResult.CreateVerifyResult(false, EnumPlatform.EResponseCode.无效交易类型));
}
return(ModelVerify(baseRequest));
}
/// <summary>
/// Verify a member of the entity. <br />
/// 成员验证入口
/// </summary>
/// <param name="expression"></param>
/// <param name="memberValue"></param>
/// <param name="keyValueCollection"></param>
/// <typeparam name="TVal"></typeparam>
/// <returns></returns>
public virtual VerifyResult VerifyOneWithDictionary <TVal>(Expression <Func <T, TVal> > expression, TVal memberValue, IDictionary <string, object> keyValueCollection)
{
var parentContract = VerifiableObjectContractManager.Resolve <T>();
var memberName = PropertySelector.GetPropertyName(expression);
var memberContract = parentContract?.GetMemberContract(memberName);
if (memberContract is null)
{
return(VerifyResult.MemberIsNotExists(memberName));
}
var memberContext = VerifiableMemberContext.Create(memberValue, memberContract, parentContract.WithDictionary(keyValueCollection));
return(VerifyOneImpl(memberContext));
}
/// <summary>
/// Verify a member of the entity. <br />
/// 成员验证入口
/// </summary>
/// <param name="declaringType"></param>
/// <param name="memberValue"></param>
/// <param name="memberName"></param>
/// <returns></returns>
VerifyResult IValidator.VerifyOne(Type declaringType, object memberValue, string memberName)
{
if (memberValue is null)
{
return(_options.ReturnNullReferenceOrSuccess());
}
var memberContract = VerifiableObjectContractManager.Resolve(declaringType)?.GetMemberContract(memberName);
if (memberContract is null)
{
return(VerifyResult.MemberIsNotExists(memberName));
}
return(VerifyOneInternal(VerifiableMemberContext.Create(memberValue, memberContract)));
}
public static async Task <double> Compare(string path1, string path2)
{
var faces = await UploadAndDetectFaces(path1);
var faceid1 = faces[0].FaceId;
var faces2 = await UploadAndDetectFaces(path2);
var faceid2 = faces2[0].FaceId;
VerifyResult result = await faceServiceClient.VerifyAsync(faceid1, faceid2);
return(result.Confidence);
}
public void VerifyUserquake_InvalidDataSignature_Another()
{
string dataSignature = "bgU4UOzGjfRKQZLq4Bzr4cShdBsCDnK/UBd5RbCqJ0I0dU97mFLLaNLAKscgN8iX";
string dataExpire = "2018/02/27 03-29-32";
string publicKey = "MEowDQYJKoZIhvcNAQEBBQADOQAwNgIxAOhqFvL7N/G2RlrluixV6efWsAaAA+9albM86Ltv9MJjwLBiJYAXZPI9UJY++COYOwIBEQ==";
string keySignature = "SMCL2D6mR+3LWCa3A5a+j5m3+6G1Utt0zcvVMQTiBhI657RG0n008rNAEuAF02YhA12cNhT6Rji9op7dmPNQhRGDvLCeYQPJuA482Q42Ld4iH9CPNUDDxOJMKN/hJC8LSb0cL+Q7RaCml/+J07cI9VG4nHC9f0X2dhQ5790RkKM=";
string keyExpire = "2018/02/27 04-17-21";
string data = "1638_270328,525";
VerifyResult result = Verifier.VerifyUserquake(data, dataExpire, dataSignature, publicKey, keySignature, keyExpire, DateTime.Parse("2018/02/27 03:29:32"));
Assert.IsFalse(result.isExpired);
Assert.IsFalse(result.isValidSignature);
}
public void VerifyUserquake_InvalidKeySignature_Another()
{
string dataSignature = "0C/bVWbyqNRCbOijje6ihB/Xk+gcaBiBj8oN13kpP8n9CbesxIidbLp1EzcVAa/C";
string dataExpire = "2018/02/27 03-29-32";
string publicKey = "MEowDQYJKoZIhvcNAQEBBQADOQAwNgIxAOhqFvL7N/G2RlrluixV6efWsAaAA+9albM86Ltv9MJjwLBiJYAXZPI9UJY++COYOwIBEQ==";
string keySignature = "c834gslXCfQLEv7iNnvkwJgyliQBHEJWGQhRmOOLuGF/YPo47ar4mB4TILm1MnIPNBRGHo2SsNh1GzdxPoILStB4Tbg9r7x3s40YDdZzo/3dW6HAnEtwQeponMSy1zsYr1AP3LKIwRaRxvCuwltOhfCfkde0Bqf2BoCHrC++wvc=";
string keyExpire = "2018/02/27 09-32-17";
string data = "1638_270328,525";
VerifyResult result = Verifier.VerifyUserquake(data, dataExpire, dataSignature, publicKey, keySignature, keyExpire, DateTime.Parse("2018/02/27 03:29:32"));
Assert.IsFalse(result.isExpired);
Assert.IsFalse(result.isValidSignature);
}
public void VerifyUserquake_CorruptedPublicKey()
{
string dataSignature = "0C/bVWbyqNRCbOijje6ihB/Xk+gcaBiBj8oN13kpP8n9CbesxIidbLp1EzcVAa/C";
string dataExpire = "2018/02/27 03-29-32";
string publicKey = "KEY_CORRUPTED";
string keySignature = "SMCL2D6mR+3LWCa3A5a+j5m3+6G1Utt0zcvVMQTiBhI657RG0n008rNAEuAF02YhA12cNhT6Rji9op7dmPNQhRGDvLCeYQPJuA482Q42Ld4iH9CPNUDDxOJMKN/hJC8LSb0cL+Q7RaCml/+J07cI9VG4nHC9f0X2dhQ5790RkKM=";
string keyExpire = "2018/02/27 04-17-21";
string data = "1638_270328,525";
VerifyResult result = Verifier.VerifyUserquake(data, dataExpire, dataSignature, publicKey, keySignature, keyExpire, DateTime.Parse("2018/02/27 03:29:32"));
Assert.IsFalse(result.isExpired);
Assert.IsFalse(result.isValidSignature);
}
public void VerifyUserquake_AnotherPublicKey()
{
string dataSignature = "0C/bVWbyqNRCbOijje6ihB/Xk+gcaBiBj8oN13kpP8n9CbesxIidbLp1EzcVAa/C";
string dataExpire = "2018/02/27 03-29-32";
string publicKey = "MEwwDQYJKoZIhvcNAQEBBQADOwAwOAIxAIMdh5rapUc4iT43bdU5ZsegZ0FR2K7/ESoB8xLl963CLzW+rspHr+eyiHNDfAMdbwIDAQAB";
string keySignature = "Dt2GPh6kq+rP+44lS6UQZtc23XlM/nSwNWOdykACiRQ64j1FSTYYYugzJk5pMIJjFmqc9qAAgStD8mdpYx3p2Xkt8P9YdFA/f0UNkeCfvK/XYQ0MJfN0p4YmaZqKbJCmeLf4R1iL+4Qf+TA6DjtHn+8vEum/A4yWs4aiZLHD7zk=";
string keyExpire = "2018/02/27 10-01-28";
string data = "1638_270328,525";
VerifyResult result = Verifier.VerifyUserquake(data, dataExpire, dataSignature, publicKey, keySignature, keyExpire, DateTime.Parse("2018/02/27 03:29:32"));
Assert.IsFalse(result.isExpired);
Assert.IsFalse(result.isValidSignature);
}
public void VerifyUserquake_CorruptedKeySignature()
{
string dataSignature = "0C/bVWbyqNRCbOijje6ihB/Xk+gcaBiBj8oN13kpP8n9CbesxIidbLp1EzcVAa/C";
string dataExpire = "2018/02/27 03-29-32";
string publicKey = "MEowDQYJKoZIhvcNAQEBBQADOQAwNgIxAOhqFvL7N/G2RlrluixV6efWsAaAA+9albM86Ltv9MJjwLBiJYAXZPI9UJY++COYOwIBEQ==";
string keySignature = "SIGNATURE_CORRUPTED";
string keyExpire = "2018/02/27 04-17-21";
string data = "1638_270328,525";
VerifyResult result = Verifier.VerifyUserquake(data, dataExpire, dataSignature, publicKey, keySignature, keyExpire, DateTime.Parse("2018/02/27 03:29:32"));
Assert.IsFalse(result.isExpired);
Assert.IsFalse(result.isValidSignature);
}
public void VerifyUserquake_CorruptedKeyExpire()
{
string dataSignature = "0C/bVWbyqNRCbOijje6ihB/Xk+gcaBiBj8oN13kpP8n9CbesxIidbLp1EzcVAa/C";
string dataExpire = "2018/02/27 03-29-32";
string publicKey = "MEowDQYJKoZIhvcNAQEBBQADOQAwNgIxAOhqFvL7N/G2RlrluixV6efWsAaAA+9albM86Ltv9MJjwLBiJYAXZPI9UJY++COYOwIBEQ==";
string keySignature = "SMCL2D6mR+3LWCa3A5a+j5m3+6G1Utt0zcvVMQTiBhI657RG0n008rNAEuAF02YhA12cNhT6Rji9op7dmPNQhRGDvLCeYQPJuA482Q42Ld4iH9CPNUDDxOJMKN/hJC8LSb0cL+Q7RaCml/+J07cI9VG4nHC9f0X2dhQ5790RkKM=";
string keyExpire = "EXPIRE_CORRUPTED";
string data = "1638_270328,525";
VerifyResult result = Verifier.VerifyUserquake(data, dataExpire, dataSignature, publicKey, keySignature, keyExpire, DateTime.Parse("2018/02/27 03:29:32"));
Assert.IsTrue(result.isExpired);
Assert.IsFalse(result.isValidSignature);
}
public void Open(EndianBinaryReader reader)
{
VerifyResult verifyResult = VerifyMagicNumber(reader, this.GetType());
if (verifyResult != VerifyResult.WrongMagicNumber)
{
OnOpen(reader);
isLoaded = true;
}
else
{
throw new Exception("Invalid magic number");
}
}
/// <summary>
/// Adds an already verified transaction to the memory pool.
///
/// Note: This must only be called from a single thread (the Blockchain actor). To add a transaction to the pool
/// tell the Blockchain actor about the transaction.
/// </summary>
/// <param name="hash"></param>
/// <param name="tx"></param>
/// <returns></returns>
internal VerifyResult TryAdd(Transaction tx, StoreView snapshot)
{
var poolItem = new PoolItem(tx);
if (_unsortedTransactions.ContainsKey(tx.Hash))
{
return(VerifyResult.AlreadyExists);
}
List <Transaction> removedTransactions = null;
_txRwLock.EnterWriteLock();
try
{
VerifyResult result = tx.Verify(snapshot, VerificationContext);
if (result != VerifyResult.Succeed)
{
return(result);
}
_unsortedTransactions.Add(tx.Hash, poolItem);
VerificationContext.AddTransaction(tx);
_sortedTransactions.Add(poolItem);
if (Count > Capacity)
{
removedTransactions = RemoveOverCapacity();
}
}
finally
{
_txRwLock.ExitWriteLock();
}
foreach (IMemoryPoolTxObserverPlugin plugin in Plugin.TxObserverPlugins)
{
plugin.TransactionAdded(poolItem.Tx);
if (removedTransactions != null)
{
plugin.TransactionsRemoved(MemoryPoolTxRemovalReason.CapacityExceeded, removedTransactions);
}
}
if (!_unsortedTransactions.ContainsKey(tx.Hash))
{
return(VerifyResult.OutOfMemory);
}
return(VerifyResult.Succeed);
}
private void SetUiAfterVerification(VerifyResult result)
{
mProgressDialog.Dismiss();
SetAllButtonEnabledStatus(true);
// Show verification result.
if (result != null)
{
DecimalFormat formatter = new DecimalFormat("#0.00");
string verificationResult = ((result.IsIdentical ? "The same person" : "Different persons") + ". The confidence is " + result.Confidence.ToString());
SetInfo((string)verificationResult);
}
}
/// <summary>
/// Verify a member of the entity. <br />
/// 成员验证入口
/// </summary>
/// <param name="declaringType"></param>
/// <param name="memberValue"></param>
/// <param name="memberName"></param>
/// <param name="keyValueCollection"></param>
/// <returns></returns>
VerifyResult IValidator.VerifyOneWithDictionary(Type declaringType, object memberValue, string memberName, IDictionary <string, object> keyValueCollection)
{
if (memberValue is null)
{
return(_options.ReturnNullReferenceOrSuccess());
}
var parentContract = VerifiableObjectContractManager.Resolve(declaringType);
var memberContract = parentContract?.GetMemberContract(memberName);
if (memberContract is null)
{
return(VerifyResult.MemberIsNotExists(memberName));
}
return(VerifyOneInternal(VerifiableMemberContext.Create(memberValue, memberContract, parentContract.WithDictionary(keyValueCollection))));
}
/// <summary>
/// Verify a member of the entity. <br />
/// 成员验证入口
/// </summary>
/// <param name="memberValue"></param>
/// <param name="memberName"></param>
/// <param name="instance"></param>
/// <returns></returns>
public VerifyResult VerifyOneWithInstance(object memberValue, string memberName, T instance)
{
if (memberValue is null)
{
return(_options.ReturnNullReferenceOrSuccess());
}
var parentContract = VerifiableObjectContractManager.Resolve <T>();
var memberContract = parentContract?.GetMemberContract(memberName);
if (memberContract is null)
{
return(VerifyResult.MemberIsNotExists(memberName));
}
return(VerifyOneInternal(VerifiableMemberContext.Create(memberValue, memberContract, parentContract.WithInstance(instance))));
}
/// <summary>
/// Verify a member of the entity. <br />
/// 成员验证入口
/// </summary>
/// <param name="expression"></param>
/// <param name="memberValue"></param>
/// <typeparam name="TVal"></typeparam>
/// <returns></returns>
public VerifyResult VerifyOne <TVal>(Expression <Func <T, TVal> > expression, TVal memberValue)
{
if (expression is null)
{
return(_options.ReturnNullReferenceOrSuccess());
}
var memberName = PropertySelector.GetPropertyName(expression);
var memberContract = VerifiableObjectContractManager.Resolve <T>()?.GetMemberContract(memberName);
if (memberContract is null)
{
return(VerifyResult.MemberIsNotExists(memberName));
}
return(VerifyOneInternal(VerifiableMemberContext.Create(memberValue, memberContract)));
}
public async Task <IActionResult> FaceCompare(string IMAGE_URL1, string IMAGE_URL2)
{
try
{
bool saveFirebase;
List <DetectedFace> facesDetected1 = await _cognitivevision.DetectFaceRecognize(IMAGE_URL1, RecognitionModel.Recognition03);
Dictionary <string, object> dataObject1 = _firebase.TransformObjectRecognition(IMAGE_URL1, facesDetected1[0].FaceId.Value.ToString());
saveFirebase = await _firebase.SaveObject("face-reconigtion", dataObject1);
if (facesDetected1.Count != 1)
{
throw new ArgumentException("Una de las fotos contiene ninguna o mas de una cara.");
}
List <DetectedFace> facesDetected2 = await _cognitivevision.DetectFaceRecognize(IMAGE_URL2, RecognitionModel.Recognition03);
Dictionary <string, object> dataObject2 = _firebase.TransformObjectRecognition(IMAGE_URL2, facesDetected2[0].FaceId.Value.ToString());
saveFirebase = await _firebase.SaveObject("face-reconigtion", dataObject2);
if (facesDetected2.Count != 1)
{
throw new ArgumentException("Una de las fotos contiene ninguna o mas de una cara.");
}
Guid guid1 = facesDetected1[0].FaceId.Value;
Guid guid2 = facesDetected2[0].FaceId.Value;
VerifyResult verifyObjectResult = await _cognitivevision.VerifyTwoFaces(guid1, guid2);
Dictionary <string, object> dataObject3 = _firebase.TransformObjectCompare(verifyObjectResult, guid1, guid2);
saveFirebase = await _firebase.SaveObject("face-compare", dataObject3);
return(new ObjectResult(new { IsIdentical = verifyObjectResult.IsIdentical, Confidence = verifyObjectResult.Confidence })
{
StatusCode = 200
});
}
catch (System.Exception error)
{
return(new ObjectResult(new { error = error.Message, facesCount = 0 })
{
StatusCode = 500
});
}
}
public static Package Verify(this Package package)
{
if (!IsSigned(package))
{
return(package);
}
// Create the PackageDigitalSignatureManager
var dsm = new PackageDigitalSignatureManager(package)
{
HashAlgorithm = "http://www.w3.org/2001/04/xmlenc#sha256"
};
// Verify the collection of certificates in the package (one, in this case)
foreach (PackageDigitalSignature signature in dsm.Signatures)
{
var x = PackageDigitalSignatureManager.VerifyCertificate(signature.Signer);
if (x == X509ChainStatusFlags.NoError)
{
continue;
}
// If the certificate has expired, but signature is created while the certificate was valid, we accept it
else if (x == X509ChainStatusFlags.NotTimeValid)
{
var signer = signature.Signer as X509Certificate2;
if (signer != null &&
signature.SigningTime >= signer.NotBefore &&
signature.SigningTime <= signer.NotAfter)
{
continue;
}
}
throw new Exception(string.Format("Certificate validation failed : {0}", x));
}
// If all certificates are valid, verify all signatures in the package.
VerifyResult vResult = dsm.VerifySignatures(false);
//Retrieve innerPackage/originalPackage
var innerPackageName = GetInnerPackageName();
var uriString = "/" + innerPackageName + ".pgx";
var packagePart = package.GetPart(new Uri(uriString, UriKind.Relative));
var stream = packagePart.GetStream();
var originalPackage = Package.Open(stream);
return(originalPackage);
}
public async Task SignVerifyDataStreamRoundTrip([Values] SignatureAlgorithm algorithm)
{
Key key = await CreateTestKey(algorithm);
var cryptoClient = GetCryptoClient(key.Id);
var data = new byte[8000];
Recording.Random.NextBytes(data);
using MemoryStream dataStream = new MemoryStream(data);
using HashAlgorithm hashAlgo = algorithm.GetHashAlgorithm();
byte[] digest = hashAlgo.ComputeHash(dataStream);
dataStream.Seek(0, SeekOrigin.Begin);
SignResult signResult = await cryptoClient.SignAsync(algorithm, digest);
SignResult signDataResult = await cryptoClient.SignDataAsync(algorithm, dataStream);
Assert.AreEqual(algorithm, signResult.Algorithm);
Assert.AreEqual(algorithm, signDataResult.Algorithm);
Assert.AreEqual(key.Id, signResult.KeyId);
Assert.AreEqual(key.Id, signDataResult.KeyId);
Assert.NotNull(signResult.Signature);
Assert.NotNull(signDataResult.Signature);
dataStream.Seek(0, SeekOrigin.Begin);
VerifyResult verifyResult = await cryptoClient.VerifyAsync(algorithm, digest, signDataResult.Signature);
VerifyResult verifyDataResult = await cryptoClient.VerifyDataAsync(algorithm, dataStream, signResult.Signature);
Assert.AreEqual(algorithm, verifyResult.Algorithm);
Assert.AreEqual(algorithm, verifyDataResult.Algorithm);
Assert.AreEqual(key.Id, verifyResult.KeyId);
Assert.AreEqual(key.Id, verifyDataResult.KeyId);
Assert.True(verifyResult.IsValid);
Assert.True(verifyResult.IsValid);
RegisterForCleanup(key);
}
private bool AddTransaction(Transaction tx, bool verify)
{
if (verify)
{
VerifyResult result = tx.Verify(context.Snapshot, context.VerificationContext);
if (result != VerifyResult.Succeed)
{
Log($"Rejected tx: {tx.Hash}, {result}{Environment.NewLine}{tx.ToArray().ToHexString()}", LogLevel.Warning);
RequestChangeView(result == VerifyResult.PolicyFail ? ChangeViewReason.TxRejectedByPolicy : ChangeViewReason.TxInvalid);
return(false);
}
}
context.Transactions[tx.Hash] = tx;
context.VerificationContext.AddTransaction(tx);
return(CheckPrepareResponse());
}
public void Sign_CertificateNotPassed_Success()
{
const string path = "Resources\\UnsignedDocument.docx";
using MemoryStream stream = FileCloner.CopyFileStreamToMemoryStream(path);
using (OpenXmlPackage openXmlPackage = Open(stream, true, path))
{
PackageDigitalSignature signature = OpenXmlDigitalSignatureManager.Sign(openXmlPackage);
VerifyResult verifyResult = signature.Verify();
Assert.Equal(VerifyResult.Success, verifyResult);
}
File.WriteAllBytes("OpenXml_CertNotPassed_SignedDocument.docx", stream.ToArray());
}
/// <summary>
/// Verify a member of the entity. <br />
/// 成员验证入口
/// </summary>
/// <param name="expression"></param>
/// <param name="memberValue"></param>
/// <param name="keyValueCollection"></param>
/// <typeparam name="TVal"></typeparam>
/// <returns></returns>
public VerifyResult VerifyOneWithDictionary <TVal>(Expression <Func <T, TVal> > expression, TVal memberValue, IDictionary <string, object> keyValueCollection)
{
if (expression is null)
{
return(_options.ReturnNullReferenceOrSuccess());
}
var parentContract = VerifiableObjectContractManager.Resolve <T>();
var memberName = PropertySelector.GetPropertyName(expression);
var memberContract = parentContract?.GetMemberContract(memberName);
if (memberContract is null)
{
return(VerifyResult.MemberIsNotExists(memberName));
}
return(VerifyOneInternal(VerifiableMemberContext.Create(memberValue, memberContract, parentContract.WithDictionary(keyValueCollection))));
}
bool ValidateRemoteCert(
object obj,
X509Certificate cert,
X509Chain chain,
int depth,
VerifyResult result)
{
Console.WriteLine("Validate> {0} depth: {1}, result: {2}", cert.Subject, depth, result);
switch (result)
{
case VerifyResult.X509_V_ERR_CERT_UNTRUSTED:
case VerifyResult.X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
case VerifyResult.X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
case VerifyResult.X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
case VerifyResult.X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
// Check the chain to see if there is a match for the cert
var ret = CheckCert(cert, chain);
if (!ret && depth != 0)
{
return true;
}
return ret;
case VerifyResult.X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
case VerifyResult.X509_V_ERR_CERT_NOT_YET_VALID:
Console.WriteLine("Certificate is not valid yet");
return false;
case VerifyResult.X509_V_ERR_CERT_HAS_EXPIRED:
case VerifyResult.X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:
Console.WriteLine("Certificate is expired");
return false;
case VerifyResult.X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
// we received a self signed cert - check to see if it's in our store
return CheckCert(cert, chain);
case VerifyResult.X509_V_OK:
return true;
default:
return false;
}
}
protected virtual void PrepareTest()
{
DisplayName = Name;
ExpectValue = CheckValue;
VerifyResult = VerifyResult.Unknow;
}
public void DoValidation()
{
try
{
PrepareTest();
Verify();
}
catch (Exception ex)
{
VerifyResult = VerifyResult.Failed;
Information = ex.Message.Trim(Environment.NewLine.ToCharArray());
}
}
internal void SetVerifyResult(VerifyResult result)
{
Native.SSL_set_verify_result(ptr, (int)result);
}
bool ValidateRemoteCert(object obj, X509Certificate cert, X509Chain chain, int depth, VerifyResult result) {
bool ret = false;
switch (result) {
case VerifyResult.X509_V_ERR_CERT_UNTRUSTED:
case VerifyResult.X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
case VerifyResult.X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
case VerifyResult.X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE: {
// Check the chain to see if there is a match for the cert
ret = CheckCert(cert, chain);
if (!ret && depth != 0) {
ret = true; // We want to keep checking until we get to depth 0
}
}
break;
case VerifyResult.X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
case VerifyResult.X509_V_ERR_CERT_NOT_YET_VALID: {
Console.WriteLine("Certificate is not valid yet");
ret = false;
}
break;
case VerifyResult.X509_V_ERR_CERT_HAS_EXPIRED:
case VerifyResult.X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD: {
Console.WriteLine("Certificate is expired");
ret = false;
}
break;
case VerifyResult.X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT: {
// we received a self signed cert - check to see if it's in our store
ret = CheckCert(cert, chain);
}
break;
case VerifyResult.X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN: {
// A self signed certificate was encountered in the chain
// Check the chain to see if there is a match for the cert
ret = CheckCert(cert, chain);
if (!ret && depth != 0) {
ret = true; // We want to keep checking until we get to depth 0
}
}
break;
case VerifyResult.X509_V_OK: {
ret = true;
}
break;
}
return ret;
}
//------------------------------------------------------
//
// Internal Members
//
//-----------------------------------------------------
internal SignatureVerificationEventArgs(PackageDigitalSignature signature,
VerifyResult result)
{
// verify arguments
if (signature == null)
throw new ArgumentNullException("signature");
if (result < VerifyResult.Success || result > VerifyResult.NotSigned)
throw new System.ArgumentOutOfRangeException("result");
_signature = signature;
_result = result;
}
/// <summary>Override to review certificate validation decisions.</summary>
protected bool RemoteCertificateValidation(object sender,
X509Certificate cert, X509Chain chain, int depth, VerifyResult result)
{
return result == VerifyResult.X509_V_OK;
}
