public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
ILogger log, ExecutionContext context)
{
var formContents = await FormContentsFactory.Create(req);
var comment = CommentFactory.Create(formContents);
var settings = SettingsFactory.Create(formContents.Options.Origin, log);
var reCaptcha = new ReCaptchaService(settings.ReCaptchaSecretKey, log);
var reCaptchaResponse = await reCaptcha.Validate(formContents.Options.Recaptcha.Token);
var akismetService = new AkismetService(settings, log);
var akismetResponse = await akismetService.IsSpam(req, comment, formContents);
var gitHubService = new GitHubService(settings.GitHubOwner, settings.GitHubRepository, settings.GitHubBranch,
settings.GitHubCommentPath, settings.GitHubToken);
var knownCommenterResponse = await gitHubService.IsKnownCommenter(comment.Name, comment.Email);
var analyzer = new ModerationAnalyzer(settings, log);
var analysisReport = analyzer.NeedsModeration(comment, reCaptchaResponse, akismetResponse, knownCommenterResponse);
await gitHubService.AddComment(comment, analysisReport, knownCommenterResponse);
return(new OkResult());
}
public HomeController(WordInSentencesService wordInSentencesService, ReCaptchaService recaptchaService, BookSearchService bookSearchService, APIService apiService)
{
_wordInSentencesService = wordInSentencesService ?? throw new ArgumentNullException(nameof(wordInSentencesService));
_recaptchaService = recaptchaService ?? throw new ArgumentNullException(nameof(recaptchaService));
_bookSearchService = bookSearchService ?? throw new ArgumentNullException(nameof(bookSearchService));
_apiService = apiService ?? throw new ArgumentNullException(nameof(apiService));
}
private async Task VerifyCaptcha(CancellationToken cancellationToken)
{
var captchaService = new ReCaptchaService();
var clientToken = this.GetClientToken();
var ipAddress = this.GetClientIPAddress();
var result = await captchaService.Verify3Async(clientToken, ipAddress, CaptchaSettings.SecretKey, cancellationToken);
if (result == null)
{
SetStatus("ERROR: Verification result is null.", Color.Red);
return;
}
if (!result.IsSuccess ||
result.Action != PageAction ||
result.Score < 0.5)
{
SetStatus("ERROR: Something went wrong. I think you're a bot!", Color.Red);
return;
}
var now = DateTime.Now;
SetStatus("Cool. Validation passed. Time is: " + now + ". Your message is: " + this.message.Text, Color.Lime);
}
public void ThrowsIfSecretKeyIsNotSet()
{
var verificationService = new ReCaptchaService(new MockHttpService(), new ReCoreOptions());
var exception = Assert.Throws <Exception>(() => new ReCoreFilter(new ReCoreOptions(), verificationService));
Assert.Equal(Strings.SECRET_KEY_REQUIRED, exception.Message);
}
public async Task can_make_good_request()
{
var service = new ReCaptchaService();
service.EnableFiddlerDebugProxy("http://localhost.:8888");
//response.IsSuccess.Should().BeTrue();
}
public UserFacade(AppDbContext context, ConfigEnvironment config)
{
_userService = new UserService(context);
_invitationKeyService = new InvitationKeyService(context);
_emailService = new EmailService(EmailType.BlueGray);
_reCaptchaService = new ReCaptchaService();
_config = config;
}
protected void vcustCaptcha_ServerValidate(object source, ServerValidateEventArgs args)
{
bool status = false;
ReCaptchaService recaptchaObj = new ReCaptchaService();
status = recaptchaObj.getReCaptchaStatus(Request["g-recaptcha-response"]);
args.IsValid = status;
}
public async Task can_make_process_bad_request()
{
var service = new ReCaptchaService();
service.EnableFiddlerDebugProxy("http://localhost.:8888");
var response = await service.Verify3Async("ffff", "127.0.0.1", "bbbb");
response.IsSuccess.Should().BeFalse();
}
public ValidateReCaptchaTask(
ReCaptchaService reCaptchaService,
IUpdateModelAccessor updateModelAccessor,
IStringLocalizer <ValidateReCaptchaTask> localizer
)
{
_reCaptchaService = reCaptchaService;
_updateModelAccessor = updateModelAccessor;
S = localizer;
}
public async Task <IActionResult> OnPost()
{
Input.IpAddress = httpContext?.Connection?.RemoteIpAddress?.MapToIPv4()?.ToString();
var service = new ReCaptchaService(Environment.GetEnvironmentVariable("RECAPTCHA_SECRET"));
var response = await service.VerifyAsync(Input.Token, Input.IpAddress);
Input.ApiResponse = Utf8Json.JsonSerializer.ToJsonString(response);
return(Page());
}
private async Task <bool> Verify(string captchaResponse, IPAddress clientIp)
{
if (string.IsNullOrEmpty(captchaResponse) || clientIp is null)
{
return(false);
}
var captchaApi = new ReCaptchaService();
return(await captchaApi.Verify2Async(captchaResponse, clientIp.ToString(), _recaptchaSettings.Value.SecretKey));
}
public LoginModel(
SignInManager <User> signInManager,
ILogger <LoginModel> logger,
UserManager <User> userManager,
ReCaptchaService recaptchaService)
{
this.userManager = userManager;
this.recaptchaService = recaptchaService;
this.signInManager = signInManager;
this.logger = logger;
}
public ReCaptchaLoginFilter(
ILayoutAccessor layoutAccessor,
ISiteService siteService,
ReCaptchaService reCaptchaService,
IShapeFactory shapeFactory)
{
_layoutAccessor = layoutAccessor;
_siteService = siteService;
_reCaptchaService = reCaptchaService;
_shapeFactory = shapeFactory;
}
public void ThrowsIfOptsAreNull()
{
var services = new ServiceCollection();
services.AddHttpClient();
var provider = services.BuildServiceProvider();
var service = new ReCaptchaService(new MockHttpService(), new ReCoreOptions());
Assert.Throws <ArgumentNullException>(() => new ReCoreFilter(null, service));
}
public void ValidateResponse_InvalidResponseWithNull()
{
var mock = new Mock <IRestClient>();
mock.Setup(x => x.Execute(It.IsAny <IRestRequest>()))
.Returns((IRestResponse)null);
var client = new ReCaptchaService(mock.Object);
var response = client.ValidateResponse(TestKey, TestResponse, TestIpAddress);
Assert.IsTrue(response == ReCaptchaValidationResult.InvalidResponse);
}
public ValidateReCaptchaTask(
IHttpContextAccessor httpContextAccessor,
ReCaptchaService reCaptchaService,
IUpdateModelAccessor updateModelAccessor,
IStringLocalizer <ValidateReCaptchaTask> localizer
)
{
_httpContextAccessor = httpContextAccessor;
_reCaptchaService = reCaptchaService;
_updateModelAccessor = updateModelAccessor;
T = localizer;
}
public void ValidateResponse_SuccessResponse()
{
var mock = new Mock <IRestClient>();
mock.Setup(x => x.Execute(It.IsAny <IRestRequest>()))
.Returns(new RestResponse {
Content = "{success:true}"
});
var client = new ReCaptchaService(mock.Object);
var response = client.ValidateResponse(TestKey, TestResponse, TestIpAddress);
Assert.IsTrue(response == ReCaptchaValidationResult.Success);
}
public async Task can_parse_errors()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Post, Constants.VerifyUrl)
.Respond("application/json", ErrorJson)
.WithExactFormData("response=aaa&remoteip=bbb&secret=ccc");
var captcha = new ReCaptchaService(client: mockHttp.ToHttpClient());
var response = await captcha.Verify3Async("aaa", "bbb", "ccc");
response.IsSuccess.Should().BeFalse();
response.ErrorCodes.Should().BeEquivalentTo("invalid-input-response", "invalid-input-secret");
}
public RegisterModel(
UserManager <User> userManager,
SignInManager <User> signInManager,
ILogger <RegisterModel> logger,
IEmailSender emailSender,
IWebHostEnvironment env,
ReCaptchaService recaptchaService)
{
this.userManager = userManager;
this.signInManager = signInManager;
this.logger = logger;
this.emailSender = emailSender;
this.env = env;
this.recaptchaService = recaptchaService;
}
public async Task can_verify_failed_response()
{
var responseJson = ResponseJson(false);
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Post, Constants.VerifyUrl)
.Respond("application/json", responseJson)
.WithExactFormData("response=aaaaa&remoteip=bbbb&secret=cccc");
var captcha = new ReCaptchaService(client: mockHttp.ToHttpClient());
var response = await captcha.Verify2Async("aaaaa", "bbbb", "cccc");
response.Should().BeFalse();
mockHttp.VerifyNoOutstandingExpectation();
}
public async Task <IHttpActionResult> Register(RegisterBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Validate Recaptcha
var reCaptchaVerfiyUrl = ConfigurationManager.AppSettings["ReCaptchaVerfiyUrl"];
var reCaptchaSecretKey = ConfigurationManager.AppSettings["ReCaptchaSecretKey"];
if (!string.IsNullOrEmpty(reCaptchaVerfiyUrl) && !string.IsNullOrEmpty(reCaptchaSecretKey))
{
var remoteIpAddress = Request.GetOwinContext().Request.RemoteIpAddress;
var reCaptchaService = new ReCaptchaService(new RestClient(reCaptchaVerfiyUrl));
var validationResults = reCaptchaService.ValidateResponse(reCaptchaSecretKey, model.ReCaptchaResponse, remoteIpAddress);
if (validationResults != ReCaptchaValidationResult.Disabled && validationResults != ReCaptchaValidationResult.Success)
{
ModelState.AddModelError("ReCaptchaResponse", new Exception("Unable to validate reCaptcha Response"));
return(BadRequest(ModelState));
}
}
// Add User
var user = new ApplicationUser()
{
UserName = model.Email, Email = model.Email
};
user.Organizations.Add(new OrganizationMembership {
EIN = model.EIN, IsAdmin = true
});
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public async Task can_parse_good_response()
{
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Post, Constants.VerifyUrl)
.Respond("application/json", GoodJson)
.WithExactFormData("response=aaa&remoteip=bbb&secret=ccc");
var captcha = new ReCaptchaService(client: mockHttp.ToHttpClient());
var response = await captcha.Verify3Async("aaa", "bbb", "ccc");
response.IsSuccess.Should().BeTrue();
response.ErrorCodes.Should().BeNull();
response.ChallengeTs.Should().Be("2019-04-30T02:37:21Z");
response.HostName.Should().Be("www.bitarmory.com");
response.Score.Should().Be(0.9f);
response.Action.Should().Be("purchase");
}
public PasswordRecoveryFormEventEventHandler(ReCaptchaService recaptchaService)
{
_recaptchaService = recaptchaService;
}
public LoginFormEventEventHandler(ReCaptchaService reCaptchaService)
{
_reCaptchaService = reCaptchaService;
}
public RegistrationFormEventHandler(ReCaptchaService recaptchaService)
{
_reCaptchaService = recaptchaService;
}
public UsuarioController(UsuarioService usuarioService, ReCaptchaService reCaptchaService, VagasService vagasService)
{
_usuarioService = usuarioService;
_reCaptchaService = reCaptchaService;
_vagasService = vagasService;
}
public AccountController(AccountService accountService, ReCaptchaService reCaptchaService)
{
_accountService = accountService;
_reCaptchaService = reCaptchaService;
}
public async Task <IHttpActionResult> Register(RegisterViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// Validate Recaptcha
var reCaptchaVerfiyUrl = AppSettings.Get <string>("ReCaptchaVerfiyUrl");
var reCaptchaSecretKey = AppSettings.Get <string>("ReCaptchaSecretKey");
if (!string.IsNullOrEmpty(reCaptchaVerfiyUrl) && !string.IsNullOrEmpty(reCaptchaSecretKey))
{
var remoteIpAddress = Request.GetOwinContext().Request.RemoteIpAddress;
var reCaptchaService = new ReCaptchaService(new RestClient(reCaptchaVerfiyUrl));
var validationResults = reCaptchaService.ValidateResponse(reCaptchaSecretKey, model.ReCaptchaResponse, remoteIpAddress);
if (validationResults != ReCaptchaValidationResult.Disabled && validationResults != ReCaptchaValidationResult.Success)
{
ModelState.AddModelError("ReCaptchaResponse", new Exception("Unable to validate reCaptcha Response"));
return(BadRequest(ModelState));
}
}
// Add User
var now = DateTime.UtcNow;
var user = new ApplicationUser()
{
UserName = model.Email, Email = model.Email, EmailConfirmed = false
};
user.Organizations.Add(new OrganizationMembership {
EIN = model.EIN, IsAdmin = true, CreatedAt = now, LastModifiedAt = now, CreatedBy_Id = user.Id, LastModifiedBy_Id = user.Id
});
IdentityResult result = await UserManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
// Add to application role
result = await UserManager.AddToRoleAsync(user.Id, Roles.Applicant);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
// Send Verification Email
var nounce = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var queryString = HttpUtility.ParseQueryString(string.Empty);
queryString["userId"] = user.Id;
queryString["code"] = nounce;
//TODO: Support Urls with existing querystring
var callbackUrl = $@"{model.EmailVerificationUrl}?{queryString}";
await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account: " + callbackUrl);
return(Ok());
}
public void BeforeEachTest()
{
server = new HttpTest();
captcha = new ReCaptchaService();
}
public RecaptchaVerificator(ReCaptchaService reCaptchaService, IOptions <RecaptchaOptions> recaptchaOptions)
{
this.reCaptchaService = reCaptchaService;
this.recaptchaOptions = recaptchaOptions;
}
