public Response <ValidationResponse> Post([FromBody] ValidationRequest request) { var result = new Response <ValidationResponse>("payment/validate", 2); result.Data = new ValidationResponse(); try { var detector = new CreditCardDetector(request.CreditCardNumber); result.Data.Status = detector.IsValid(CardIssuer.MasterCard, CardIssuer.Maestro, CardIssuer.Visa, CardIssuer.AmericanExpress, CardIssuer.DinersClub, CardIssuer.Discover, CardIssuer.RuPay); if (!result.Data.Status) { result.Data.Message = "credit card is not valid. currently supporting only mastercard, maestro, visa, americanexpress, dinersclub, discover and rupay cards"; } } catch (Exception e) { result.Data.Status = false; result.Data.Message = e.Message; } return(result); }
/// <summary> /// Processes Alexa request AND validates request signature /// </summary> /// <param name="httpRequest"></param> /// <returns></returns> public virtual HttpResponseMessage GetResponse(HttpRequestMessage httpRequest) { var request = new ValidationRequest { HttpRequest = httpRequest, RequestTime = DateTime.UtcNow }; var response = OnRequestValidation(request); if (!response.Success) { return new HttpResponseMessage(HttpStatusCode.BadRequest) { ReasonPhrase = response.ValidationResult.ToString() }; } string alexaResponse = DoProcessRequest(response.AlexaRequest); HttpResponseMessage httpResponse; if (alexaResponse == null) { httpResponse = new HttpResponseMessage(HttpStatusCode.InternalServerError); } else { httpResponse = new HttpResponseMessage(HttpStatusCode.OK); httpResponse.Content = new StringContent(alexaResponse, Encoding.UTF8, "application/json"); Debug.WriteLine(httpResponse.ToLogString()); } return httpResponse; }
public void Handler_Shall_Pass_Validattion_to_next() { var validations = new Dictionary <ValidationTypes, IValidation>() { { ValidationTypes.Security, new SecurityValidation( ValidationResult.Valid, new DateTime(2019, 10, 1)) }, { ValidationTypes.Comfort, new ComfortValidation( ValidationResult.Valid, new DateTime(2019, 10, 1)) } }; IValidationRequest request = new ValidationRequest(validations); IHandler comfortHandler = new ValidationHandler <IValidationRequest, ComfortValidation>( request, new ComfortValidation(ValidationResult.OnReview, new DateTime(2019, 10, 1)), null); IHandler securityHandler = new ValidationHandler <IValidationRequest, SecurityValidation>( request, new SecurityValidation(ValidationResult.Valid, new DateTime(2019, 10, 1)), comfortHandler); securityHandler.Handle(); }
private void ValidationRequestHandler(ValidationRequest request) { ValidationResponse response = new ValidationResponse(request); EventArguments.ClientValidatingEventArgs args = new EventArguments.ClientValidatingEventArgs(() => { //Confirm Action Status = StatusEnum.Validated; Email = request.Email; response.IsValid = true; SendMessage(response); Server.OnClientValidated(this); }, () => { //Refuse Action response.IsValid = false; response.HasError = true; response.Exception = new AuthenticationException("Login failed for user " + request.Email); SendMessage(response); }); args.Receiver = this; args.Request = request; Server.OnClientValidating(args); }
public ValidationResponse Validate(ValidationRequest sessionValidationRequest, bool save) { var validationResponse = new ValidationResponse { ServerValidatedSessionID = 11, Errors = new List <string>(), Warnings = new List <string> { "This is a warning" }, Messages = new List <string> { "This is a message" }, NoteQuestions = new List <NoteQuestion> { new NoteQuestion { NoteQuestionID = 2, Question = "Programs Reviewed" }, new NoteQuestion { NoteQuestionID = 3, Question = "Behaviors Reviewed" } }, }; if (sessionValidationRequest.RequestedValidatedSession.Duration > TimeSpan.FromMinutes(30)) { validationResponse.Errors.Add("The time cannot be more than 30 minutes"); } return(validationResponse); }
public ValidationResult Validate(IBehaviorContext context, ValidationRequest request) { Log.Append(ViewModelValidationSourceBehaviorTests.Validate); LastContext = context; LastRequest = request; return(ResultToReturn); }
public async Task ForwardsCallToValidatorStateService() { var request = new ValidationRequest(Guid.NewGuid(), 42, "somepackage", "somversion", "https://example.com/package.nupkg"); var status = new ValidatorStatus { State = ValidationStatus.Incomplete, NupkgUrl = null, ValidatorIssues = new List <ValidatorIssue>() }; _validatorStateServiceMock .Setup(vss => vss.GetStatusAsync(request)) .ReturnsAsync(status); var result = await _target.GetResultAsync(request); _validatorStateServiceMock .Verify(vss => vss.GetStatusAsync(request), Times.Once); _validatorStateServiceMock .Verify(vss => vss.GetStatusAsync(It.IsAny <ValidationRequest>()), Times.Once); _validatorStateServiceMock .Verify(vss => vss.GetStatusAsync(It.IsAny <Guid>()), Times.Never); Assert.Empty(result.Issues); Assert.Equal(status.State, result.Status); Assert.Equal(status.NupkgUrl, result.NupkgUrl); }
private void PrizeLevelListChanged(object sender, PropertyChangedEventArgs e) { if (e.PropertyName.Equals("PrizeLevelList")) { PrizeLevelList.Children.Clear(); for (int i = 0; i < _model.NumberOfPrizeLevels; ++i) { var prizeLevelUC = new PrizeLevelUserControl(_model.PrizeLevelList[i]); prizeLevelUC.SetLocalization(_localization.PrizeLevel); prizeLevelUC.GotFocus += FocusPrizeLevel; prizeLevelUC.LostFocus += LostFocusPrizeLevel; prizeLevelUC.CloseButton.IsEnabled = true; if (ValidationRequest != null) { foreach (var validator in ValidationRequest.GetInvocationList()) { prizeLevelUC.SetValidator(validator as ValidationRequested); } } PrizeLevelList.Children.Add(prizeLevelUC); } if (ValidationRequest != null) { ValidationRequest(); } if (PrizeLevelList.Children.Count == 2) { foreach (UIElement currentPL in PrizeLevelList.Children) { (currentPL as PrizeLevelUserControl).CloseButton.IsEnabled = false; } } } }
public void OnMessageReceived(BrokeredMessage receivedMessage) { try { Trace.WriteLine("Processing Service Bus message: " + receivedMessage.SequenceNumber.ToString()); ValidationRequest request = receivedMessage.GetBody <ValidationRequest>(); Image image = db.Images.Find(request.imageId); if (ImageStorage.Validate(request.imageId)) { image.Validated = true; db.SaveChanges(); } else { ImageStorage.DeleteFile(null, request.imageId); db.Images.Remove(image); db.SaveChanges(); } receivedMessage.Complete(); } catch { // Handle any Message } }
private async Task PreProcessFile(SingleFile file) { var request = new ValidationRequest() { FileName = file.FileName, Flow = file.Flow }; var validateresponse = await _service.Validate(request); file.Valid = validateresponse.Valid; if (validateresponse.Messages != null) { file.Messages.AddRange(validateresponse.Messages); } if (file.Valid && file.IsArchive) { var templocation = Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(file.FileName)); Directory.CreateDirectory(templocation); using (ZipArchive archive = ZipFile.OpenRead(file.FileName)) { foreach (ZipArchiveEntry entry in archive.Entries) { string extractedfile = Path.Combine(templocation, entry.FullName); entry.ExtractToFile(extractedfile); file.SingleFiles.Add(new SingleFile(Guid.NewGuid()) { Flow = file.Flow, FileName = extractedfile, ParentId = file.DeliveryId, SubFolder = Path.GetFileNameWithoutExtension(file.FileName) }); } } } foreach (var sf in file.SingleFiles) { await PreProcessFile(sf); } }
public static void AreEqual(ValidationRequest expected, ValidationRequest actual) { if (!AreEqualCore(expected, actual)) { Assert.Fail("Expected {0} but was {1}.", expected, actual); } }
public async Task WhenRepositorySigningIsDisabled_SuppressesNupkgUrl() { _config.RepositorySigningEnabled = false; var request = new ValidationRequest(Guid.NewGuid(), 42, "somepackage", "somversion", "https://example.com/package.nupkg"); var status = new ValidatorStatus { State = ValidationStatus.Incomplete, NupkgUrl = "https://nuget.test/package.nupkg", ValidatorIssues = new List <ValidatorIssue>() }; _validatorStateServiceMock .Setup(vss => vss.GetStatusAsync(request)) .ReturnsAsync(status); var result = await _target.GetResultAsync(request); _validatorStateServiceMock .Verify(vss => vss.GetStatusAsync(request), Times.Once); _validatorStateServiceMock .Verify(vss => vss.GetStatusAsync(It.IsAny <ValidationRequest>()), Times.Once); _validatorStateServiceMock .Verify(vss => vss.GetStatusAsync(It.IsAny <Guid>()), Times.Never); Assert.Empty(result.Issues); Assert.Equal(status.State, result.Status); Assert.Null(result.NupkgUrl); }
public async Task DoesNotSkipCheckWhenPackageFitsCriteria() { var request = new ValidationRequest(Guid.NewGuid(), 42, "somepackage", "somversion", "https://example.com/package.nupkg"); var status = new ValidatorStatus { State = ValidationStatus.NotStarted, NupkgUrl = null, ValidatorIssues = new List <ValidatorIssue>() }; _criteriaEvaluatorMock .Setup(ce => ce.IsMatch(It.IsAny <ICriteria>(), It.IsAny <SymbolPackage>())) .Returns(false); _validatorStateServiceMock .Setup(vss => vss.GetStatusAsync(request)) .ReturnsAsync(status); var result = await _target.GetResultAsync(request); Assert.Equal(ValidationStatus.NotStarted, result.Status); _validatorStateServiceMock .Verify(vss => vss.GetStatusAsync(It.IsAny <ValidationRequest>()), Times.Once); _validatorStateServiceMock .Verify(vss => vss.GetStatusAsync(It.IsAny <Guid>()), Times.Never); }
/// <summary> /// Add a new prize level /// </summary> /// <param name="model">The prize level model</param> /// <returns></returns> public bool AddPrizeLevel(PrizeLevelModel model) { if ((_prizeLevelList ?? (_prizeLevelList = new List <PrizeLevelModel>())).Count < MaxPrizeLevels) { model.Index = _prizeLevelList.Count; if (ValidationRequest != null) { foreach (var i in ValidationRequest.GetInvocationList()) { model.SetValidator(i as ValidationRequested); } } _prizeLevelList.Add(model); if (PropertyChanged != null) { PropertyChanged(this, new PropertyChangedEventArgs("NumberOfPrizeLevels")); PropertyChanged(this, new PropertyChangedEventArgs("PrizeLevelList")); PropertyChanged(this, new PropertyChangedEventArgs("PrizeLevelList2")); } return(true); } else { return(false); } }
private ValidationResponse ValidateSavedFile( string originalFileName, string savedFilePath) { ValidationResponse validationResponse = null; // Send request to Validation service ValidationRequest validationRequest = new ValidationRequest { PostedFileName = originalFileName, SavedFileName = Path.GetFileName(savedFilePath) }; try { validationResponse = _validationService.Validate(validationRequest); } finally { if (_fileSystem.FileExists(savedFilePath)) { _fileSystem.FileDelete(savedFilePath); } } return(validationResponse); }
/// <summary> /// Adds a division to the model /// </summary> /// <param name="model"></param> /// <returns></returns> public bool AddDivision(DivisionModel model) { if ((_divisionList ?? (_divisionList = new List <DivisionModel>())).Count < MaxDivisions) { if (ValidationRequest != null) { foreach (var i in ValidationRequest.GetInvocationList()) { model.SetValidator(i as ValidationRequested); } } _divisionList.Add(model); if (PropertyChanged != null) { PropertyChanged(this, new PropertyChangedEventArgs("DivisionList")); PropertyChanged(this, new PropertyChangedEventArgs("NumberOfDivisions")); } if (ValidationRequest != null) { ValidationRequest(); } return(true); } else { return(false); } }
public Response <ValidationResponse> Post([FromBody] ValidationRequest request) { var result = new Response <ValidationResponse>("payment/validate", 1); result.Data = new ValidationResponse(); try { var detector = new CreditCardDetector(request.CreditCardNumber); result.Data.Status = detector.IsValid(CardIssuer.MasterCard, CardIssuer.Visa); if (!result.Data.Status) { result.Data.Message = "credit card is not valid. currently supporting only mastercard and visa cards"; } } catch (Exception e) { result.Data.Status = false; result.Data.Message = e.Message; } return(result); }
private async Task <ValidationResponse> ValidateSavedFileAsync( HttpRequestBase request, string baseAddress, string originalFileName, string savedFilePath) { ValidationResponse validationResponse = null; request.ContentType = "application/json"; // Send request to Validation service ValidationRequest validationRequest = new ValidationRequest { PostedFileName = originalFileName, SavedFileName = Path.GetFileName(savedFilePath) }; try { validationResponse = await GetValidationResponse(validationRequest, baseAddress); } finally { if (_fileSystem.FileExists(savedFilePath)) { _fileSystem.DeleteFile(savedFilePath); } } return(validationResponse); }
public async Task <ValidationResponse> Validate(ValidationRequest request) { ValidationResponse response = new ValidationResponse(); foreach (var valrule in context.FlowValidations.Where(r => r.FlowConfiguration.Flow == request.Flow && r.Extension == Path.GetExtension(request.FileName).ToLower())) { Match m = Regex.Match(Path.GetFileName(request.FileName), valrule.Filter, RegexOptions.IgnoreCase); if (m.Success) { request.Rule = new ValidationRule() { Content = valrule.Content, Extensie = valrule.Extension, Filter = valrule.Filter }; break; } } if (request.Rule == null) { response.Valid = false; response.Messages = new string[] { "no rule found" }; } else { IValidator validator = ValidatorFactory.CreateValidator(request); response = await validator.Validate(); } return(response); }
public async Task SendsMessage() { var request = new ValidationRequest(Guid.NewGuid(), 42, "somepackage", "someversion", "https://example.com/testpackage.nupkg"); await _target.EnqueueScanAsync(request.ValidationId, request.NupkgUrl); Assert.Same(_serializedMessage, _capturedBrokeredMessage); }
public async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] ValidationRequest request, ILogger log) { log.LogInformation("C# HTTP trigger function processed a request."); log.LogInformation($"request: {JsonConvert.SerializeObject(request)}"); IActionResult response; var extensionAttribute = GetExtensionAttribute(request.SignInName); if (extensionAttribute == null) { response = GenerateErrorMessageWithMessage("Extension attribute is not valid!"); } else { // Return the output claim(s) response = new OkObjectResult(new ValidationResponseContent { SignInName = request.SignInName, ExtensionAttribute = extensionAttribute }); } log.LogInformation($"response: {JsonConvert.SerializeObject(response)}"); return(response); }
public bool CompareHashSettingsLicenseAndRequest(License license, ValidationRequest validationRequest) { return(string.Equals( Crypto.concatenate_sha256_hash(license.LicenseSettings.GetValueList()), Crypto.concatenate_sha256_hash(validationRequest.ValidationSettings.GetValueList()) )); }
public SessionReportConfiguration GetSessionReportConfiguration(ValidationRequest sessionValidationRequest) { // TODO: Change this call to the real call to return the SessionReportConfiguration for the ValidationRequest services var aabcSessionReportConfiguration = AABC.DomainServices.Sessions.SessionReportConfiguration.CreateSample(); // convert the aabcSessionReportConfiguration to an ATrack SessionReportConfiguration return(ConvertSessionReportConfiguration(aabcSessionReportConfiguration)); }
public async Task <ValidationResponse> Validate(ValidationRequest request) { if (!(request is DigitalSupportsValidationRequest r)) { throw new InvalidOperationException($"{nameof(ISupportProcessingStrategy)} of type {nameof(DigitalSupportProcessingStrategy)} can only handle {nameof(DigitalSupportsValidationRequest)} request types"); } return(await HandleInternal(r)); }
public ValidationResponse Validate(ValidateUserSettings settings) { if (settings == null) { throw new ArgumentNullException(nameof(settings)); } var mock = bool.Parse(ConfigurationManager.AppSettings.Get("Mock")); if (!mock) { try { var identification = new Identification { Number = settings.Identification, Type = settings.IdentificationType }; var dataValidation = new ValidationRequest { Identification = identification, LastName = settings.LastName, Names = settings.Names, SecondLastName = settings.SecondLastName, ExpeditionDate = new ExpeditionDate { Timestamp = settings.ExpeditionDate.ToTimestamp() } }; var serialized = _xmlProcessor.Serialize(dataValidation); var response = validar(settings.ParamProduct, settings.Product, settings.Channel, serialized); var deserialized = _xmlProcessor.Deserialize <ValidationResponse>(response); return(deserialized); } catch (Exception exception) { var clientLog = new TelemetryClient(); clientLog.TrackException(exception); clientLog.TrackException(exception); var consultationException = _webSettingsConsultationSettingsBuilder.WithPayload( JsonConvert.SerializeObject(new { Exception = exception })) .WithExecutionId(settings.ExecutionId) .WithTypeOfConsultation((int)TypeOfConsultation.CommunicationError) .WithWebServiceName("Error consultando " + ServiceNameType.Validate.GetStringValue()) .Build(); AddWebServiceConsultation(consultationException); return(new ValidationResponse { ProcessResult = false }); } } return(new ValidationResponse { Result = 5, ProcessResult = true, }); }
public ActionResult ValidateScholarship(ValidationRequest requestModel, HttpPostedFileBase[] scholarshipForms, string parentFirstName, string parentMiddleName, string parentLastName) { try { if (User.IsInRole("Student")) { string firstNameParent = parentFirstName; string middleNameParent = parentMiddleName; string lastNameParent = parentLastName; ModelState.Remove("parentFirstName"); ModelState.Remove("parentMiddleName"); ModelState.Remove("parentLastName"); if (ModelState.IsValid) { if (FileVerification.AreFilesPDF(scholarshipForms)) { studentActions.UploadStudentRequest(requestModel); AddRequestFilesToResource(requestModel, scholarshipForms); if (firstNameParent != null && middleNameParent != null && lastNameParent != null) { studentActions.InsertParent(requestModel.RequestID, firstNameParent, middleNameParent, lastNameParent); } return(RedirectToAction("RequestStatus")); } else { ViewBag.errorMessage = "Please upload pdf files only. Please try again."; } } else { ViewBag.errorMessage = "Invalid inputs. Please try again."; } bool isScholarshipSiblingDiscount = studentActions.GetScholarshipByID(requestModel.ScholarshipID).ScholarshipName.ToLower() == "sibling discount" ? true : false; ViewBag.isScholarshipSiblingDiscount = isScholarshipSiblingDiscount; bool isStudentPassedApplicationForm = studentActions.IsStudentPassedApplicationForm(requestModel.ScholarshipID, User.Identity.GetUserId()); ViewBag.isStudentPassedApplicationForm = isStudentPassedApplicationForm; return(View(requestModel)); //fall-through } else { TempData["errorMessage"] = "Sorry you do not have access."; return(RedirectToAction("Announcement", "WebsiteContent")); } } catch (Exception e) { TempData["errorMessage"] = "There was an error. Please try again, thank you!" + e.ToString(); return(RedirectToAction("RequestStatus")); } }
public JwtResponse Validate(ValidationRequest validationRequest) { var identity = _authService.ValidatePin(validationRequest.Token, validationRequest.Pin); var jwt = BuildToken(identity); return(new JwtResponse { Token = jwt }); }
public ActionResult Upload(ImageView image, HttpPostedFileBase ImageFile) { CheckAda(); ApplicationUser user = GetLoggedInUser(); ViewData["tags"] = new SelectList(db.Tags, "Id", "Name", 1); if (ModelState.IsValid) { /* * Save image infomation in the database */ Image imageEntity = new Image(); imageEntity.Caption = image.Caption; imageEntity.Description = image.Description; imageEntity.DateTaken = image.DateTaken; imageEntity.TagId = image.TagId; imageEntity.UserId = user.Id; imageEntity.Validated = false; imageEntity.Approved = false; if (ImageFile != null && ImageFile.ContentLength > 0) { if (!ImageFile.ContentType.Equals("image/jpeg")) { ViewBag.Message = "The file you uploaded is not a jpg file"; return(View()); } else { db.Images.Add(imageEntity); db.SaveChanges(); db.Images.Find(imageEntity.Id).Uri = ImageStorage.ImageURI(Url, imageEntity.Id); db.SaveChanges(); ImageStorage.SaveFile(Server, ImageFile, imageEntity.Id); // string imgFileName = Server.MapPath("~/Content/Images/img-" + imageEntity.Id + ".jpg"); // ImageFile.SaveAs(imgFileName); ValidationRequest validationReq = new ValidationRequest(); validationReq.imageId = imageEntity.Id; validationReq.UserId = user.Id; return(RedirectToAction("Details", new { Id = imageEntity.Id })); } } else { ViewBag.Message = "No image file specified!"; return(View()); } } else { ViewBag.Message = "Please correct the errors in the form!"; return(View()); } }
public static ValidationResult Validate(ValidationData data) { ObjectBinder binder = CreateObjectBinder(data); ValidationRequest request = new ValidationRequest(binder); FlowErrorTrace errorTrace = data.flow.Validate(request); ValidationResult result = new ValidationResult(errorTrace); return(result); }
public ActionResult View(int id, string status) { ViewBag.Status = status; ValidationRequest request = db.ValidationRequests.Where(e => e.RequestID.Equals(id)).FirstOrDefault(); ViewBag.Statuses = db.ValidationStatus.ToList(); return(View(request)); }
public static void Send(ValidationRequest request) { if (Client == null) { Initialize(); } //Send message Client.Send(new BrokeredMessage(request)); }
public void RequestIsValid() { var request = new ValidationRequest { HttpRequest = new HttpRequestMessage { Properties = { { HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration() } }, Headers = { { Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER, "TestSignatureCertChainUrlValue" }, { Sdk.SIGNATURE_REQUEST_HEADER, "TestSignatureValue" } }, Content = new StringContent(GenericSuccessMessage) }, RequestTime = DateTime.UtcNow }; var speechlet = new EmptySpeechlet(); var response = speechlet.OnRequestValidation(request); //Need to validate no errors except for InvalidSignature since SSL Cert not supplied <see cref="SignatureVerifierTests"> Assert.True( (response.ValidationResult & SpeechletRequestValidationResult.NoCertHeader) != SpeechletRequestValidationResult.NoCertHeader && (response.ValidationResult & SpeechletRequestValidationResult.NoSignatureHeader) != SpeechletRequestValidationResult.NoSignatureHeader && (response.ValidationResult & SpeechletRequestValidationResult.InvalidJson) != SpeechletRequestValidationResult.InvalidJson && (response.ValidationResult & SpeechletRequestValidationResult.InvalidSpeechlet) != SpeechletRequestValidationResult.InvalidSpeechlet && (response.ValidationResult & SpeechletRequestValidationResult.InvalidTimestamp) != SpeechletRequestValidationResult.InvalidTimestamp && (response.ValidationResult & SpeechletRequestValidationResult.Error) != SpeechletRequestValidationResult.Error ); }
public void RequestIsEmptyAlexaMessage() { var request = new ValidationRequest { HttpRequest = new HttpRequestMessage { Properties = { { HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration() } }, Headers = { { Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER, "TestSignatureCertChainUrlValue" }, { Sdk.SIGNATURE_REQUEST_HEADER, "TestSignatureValue" } }, Content = new StringContent(string.Empty) } }; var alexaBytes = AsyncHelpers.RunSync(() => request.HttpRequest.Content.ReadAsByteArrayAsync()); var speechlet = new EmptySpeechlet(); var response = new ValidationResponse { ValidationResult = SpeechletRequestValidationResult.OK }; speechlet.GetRequest(alexaBytes, ref response); Assert.True((response.ValidationResult & SpeechletRequestValidationResult.InvalidSpeechlet) == SpeechletRequestValidationResult.InvalidSpeechlet); }
public void TimestampRequestIsNotWithinTolerance() { var request = new ValidationRequest { HttpRequest = new HttpRequestMessage { Properties = { { HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration() } }, Headers = { { Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER, "TestSignatureCertChainUrlValue" }, { Sdk.SIGNATURE_REQUEST_HEADER, "TestSignatureValue" } }, Content = new StringContent(OutdatedMessage) }, RequestTime = DateTime.UtcNow }; var speechlet = new EmptySpeechlet(); var response = speechlet.OnRequestValidation(request); Assert.True((response.ValidationResult & SpeechletRequestValidationResult.InvalidTimestamp) == SpeechletRequestValidationResult.InvalidTimestamp); }
public void TimestampIsNotWithinTolerance() { var request = new ValidationRequest { HttpRequest = new HttpRequestMessage { Properties = { { HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration() } }, Headers = { { Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER, "TestSignatureCertChainUrlValue" }, { Sdk.SIGNATURE_REQUEST_HEADER, "TestSignatureValue" } }, Content = new StringContent(OutdatedMessage) }, RequestTime = DateTime.UtcNow }; var alexaBytes = AsyncHelpers.RunSync(() => request.HttpRequest.Content.ReadAsByteArrayAsync()); var alexaRequest = SpeechletRequestEnvelope.FromJson(Encoding.UTF8.GetString(alexaBytes)); var validTimestamp = SpeechletRequestTimestampVerifier.VerifyRequestTimestamp(alexaRequest, request.RequestTime); Assert.False(validTimestamp); }
public void HeaderContainsBlankSignatureFails() { var request = new ValidationRequest { HttpRequest = new HttpRequestMessage { Properties = { { HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration() } }, Headers = { { Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER, "TestSignatureCertChainUrlValue" }, { Sdk.SIGNATURE_REQUEST_HEADER, "" } }, Content = new StringContent(GenericSuccessMessage) } }; var speechlet = new EmptySpeechlet(); var response = speechlet.OnRequestValidation(request); Assert.True((response.ValidationResult & SpeechletRequestValidationResult.NoSignatureHeader) == SpeechletRequestValidationResult.NoSignatureHeader); }
/// <summary> /// For Testing Purposes Override Request Validation to just convert Request to Alexa Response Object /// </summary> /// <param name="request"></param> /// <returns></returns> public override ValidationResponse OnRequestValidation(ValidationRequest request) { var response = new ValidationResponse { ValidationResult = SpeechletRequestValidationResult.OK, Success = true }; var alexaBytes = AsyncHelpers.RunSync(() => request.HttpRequest.Content.ReadAsByteArrayAsync()); GetRequest(alexaBytes, ref response); return response; }
/// <summary> /// Opportunity to set policy for handling requests with invalid signatures and/or timestamps /// </summary> /// <returns>Validation Response Object. Success will be true if tests pass</returns> public virtual ValidationResponse OnRequestValidation(ValidationRequest request) { var response = new ValidationResponse { ValidationResult = SpeechletRequestValidationResult.OK }; string chainUrl = null; if (!request.HttpRequest.Headers.Contains(Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER) || String.IsNullOrEmpty(chainUrl = request.HttpRequest.Headers.GetValues(Sdk.SIGNATURE_CERT_URL_REQUEST_HEADER).First())) { response.ValidationResult = response.ValidationResult | SpeechletRequestValidationResult.NoCertHeader; } string signature = null; if (!request.HttpRequest.Headers.Contains(Sdk.SIGNATURE_REQUEST_HEADER) || String.IsNullOrEmpty(signature = request.HttpRequest.Headers.GetValues(Sdk.SIGNATURE_REQUEST_HEADER).First())) { response.ValidationResult = response.ValidationResult | SpeechletRequestValidationResult.NoSignatureHeader; } var alexaBytes = AsyncHelpers.RunSync<byte[]>(() => request.HttpRequest.Content.ReadAsByteArrayAsync()); //Debug.WriteLine(request.HttpRequest.ToLogString()); // attempt to verify signature only if we were able to locate certificate and signature headers if (response.ValidationResult == SpeechletRequestValidationResult.OK) { if (!SpeechletRequestSignatureVerifier.VerifyRequestSignature(alexaBytes, signature, chainUrl)) { response.ValidationResult = response.ValidationResult | SpeechletRequestValidationResult.InvalidSignature; } } GetRequest(alexaBytes, ref response); // attempt to verify timestamp only if we were able to parse request body if (response.AlexaRequest != null) { if (!SpeechletRequestTimestampVerifier.VerifyRequestTimestamp(response.AlexaRequest, request.RequestTime)) { response.ValidationResult = response.ValidationResult | SpeechletRequestValidationResult.InvalidTimestamp; } } response.Success = (response.ValidationResult == SpeechletRequestValidationResult.OK); return response; }