def register(request): captcha_error = "" captcha_valid = True if request.method == 'POST': form = RegistrationForm(request.POST) if settings.USE_CAPTCHA: captcha_response = captcha.submit(request.POST.get("recaptcha_challenge_field", None), request.POST.get("recaptcha_response_field", None), settings.RECAPTCHA_PRIVATE_KEY, request.META.get("REMOTE_ADDR", None)) captcha_valid = captcha_response.is_valid if not captcha_valid: captcha_error = "&error=%s" % captcha_response.error_code else: if form.is_valid(): u = form.save() msg = render_to_string('registration/welcome.mail', {'username': u.username}, context_instance = RequestContext(request)) u.email_user(_('Welcome to %(project)s') % {'project':settings.PROJECT_NAME}, msg) return render_to_response("contact/message.html", {'message': _('You can now sign in with the choosen username and password.')}, context_instance = RequestContext(request)) else: if request.user.is_authenticated(): return HttpResponseRedirect(reverse('home')) form = RegistrationForm() return render_to_response("registration/register.html", {'form': form, 'captcha_error': captcha_error, 'settings': settings}, context_instance = RequestContext(request))
def clean(self): siteconfig = SiteConfiguration.objects.get_current() if siteconfig.get('auth_registration_show_captcha'): challenge = self.cleaned_data.get('recaptcha_challenge_field', None) response = self.cleaned_data.get('recaptcha_response_field', None) if challenge and response: captcha_response = \ captcha.submit( challenge, response, siteconfig.get('recaptcha_private_key'), self.request.META.get('REMOTE_ADDR', None)) if not captcha_response.is_valid: self.captcha_error_query_str = '&error=%s' % \ captcha_response.error_code # This isn't actually seen in the Review Board UI, # as the reCAPTCHA widget itself displays the error # message. However, this may be useful for testing or # debugging. raise forms.ValidationError( _("The text you entered didn't match what was " "displayed")) else: self.captcha_error_query_str = '&error=incorrect-captcha-sol' raise forms.ValidationError( _('You need to respond to the captcha')) return super(RegistrationForm, self).clean()
def save_child(request,parent=None,parentString=''): request.session['errors'] = '' if settings.USE_RECAPTCHA: response = captcha.submit(request.POST.get('recaptcha_challenge_field'),request.POST.get('recaptcha_response_field'),settings.RECAPTCHA_PRIVATE_KEY,request.META['REMOTE_ADDR']) if not response.is_valid: request.session['errors'] = 'captcha' return redirect(settings.URL_ROOT+parentString) email = request.POST.get('email', '') request.session['email'] = email if not is_valid_email(email): request.session['errors'] = 'email' return redirect(settings.URL_ROOT+parentString) #invalid email, send back to start hash = hash_email(email) ip = request.META.get('REMOTE_ADDR') slider = 50 newp = Person.objects.filter(email = email) dup = (len(newp) > 0) if dup: newp = newp[0] rating = Rating.objects.filter(person = newp) if len(rating) > 0: slider = rating[0].rating else: if parent == None or len(parent) == 0: newp = Person(email = email, hash = hash, ipaddress=ip, influence=0,parent_node=None,session_key=str(request.session.session_key)) newp.save() else: newp = Person(email = email, hash = hash, ipaddress=ip, parent=parent[0].email,parent_node=parent[0],influence=0, session_key=str(request.session.session_key)) newp.save() update_score(newp) t = loader.get_template('save.html') c = RequestContext(request, {'link':settings.URL_ROOT+str(newp.id),'score_link':settings.URL_ROOT+'score/'+str(newp.id),'csrf_token':csrf(request)['csrf_token'],'url':settings.URL_ROOT,'saved': '','slider': slider,'dup':dup}) return HttpResponse(t.render(c))
def wrapped(config, users, messages, *args, **kwargs): if config.captcha.enabled: from recaptcha.client import captcha challenge = bottle.request.POST.pop('recaptcha_challenge_field', None) response = bottle.request.POST.pop('recaptcha_response_field', None) if challenge is None or response is None: messages.error('Captcha values are missing') bottle.redirect('/') result = captcha.submit(challenge, response, config.captcha.recaptcha_private_key, bottle.request.remote_addr) if not result.is_valid: messages.error('Captcha invalid') bottle.redirect(__on_error__) # Call the wrapped function return func(*args, **kwargs)
def signup(request): if 'user' in request.session: return HttpResponseRedirect("/bookManiacs/") else: if 'name' in request.POST: name = request.POST['name'] email = request.POST['email'] phone = request.POST['phone'] password = request.POST['pass'] confirmPass = request.POST['confPass'] bhawan = request.POST['bhawan'] room = request.POST['room'] userExist = Profile.objects.filter(email=email).exists() if userExist==False: # if makeValidation(): if password == confirmPass: response = captcha.submit( request.POST.get('recaptcha_challenge_field'), request.POST.get('recaptcha_response_field'), '6Le7XvASAAAAAKk5cQcHOwxBRNjKBl49I_yRw2ym', request.META['REMOTE_ADDR'],) if response.is_valid: p = Profile.objects.create(name = name, email = email, password = password, mobile_number = phone, room_number = room, hostel = bhawan) messageString = 'you have registered successfully' return render(request, 'bookManiacs/login.html', {'messageString': messageString}) else: errorString = 'please fill the captcha correctly' else: errorString = 'your password did not match with the confirm password' else: errorString = 'This Id is already registered' return render(request, 'bookManiacs/signup.html', {'errorString': errorString}) else: return render(request, 'bookManiacs/signup.html')
def signup(req): '''注册''' if req.user.is_authenticated(): return HttpResponseRedirect('/') captcha_ok = True if req.method == 'POST': form = SignUpForm(req.POST) if form.is_valid(): # check reCAPTCHA challenge, response = req.POST.get('recaptcha_challenge_field', ''), req.POST.get('recaptcha_response_field', '') if challenge and response: ret = captcha.submit(challenge, response, settings.CAPTCHA_PRIVATE_KEY, req.META['REMOTE_ADDR']) if ret.is_valid: user = form.save() # hack for not using authenticate() user.backend = 'django.contrib.auth.backends.ModelBackend' login(req, user) return HttpResponseRedirect('/') captcha_ok = False else: form = SignUpForm() return render_to_response('signup.html', { 'form': form, 'captcha_ok': captcha_ok, }, context_instance=RequestContext(req))
def register(request): if request.method == 'POST': if 'recaptcha_challenge_field' in request.POST: check_captcha = captcha.submit(request.POST['recaptcha_challenge_field'], request.POST['recaptcha_response_field'], settings.RECAPTCHA_PRIVATE_KEY, request.META['REMOTE_ADDR']) if not check_captcha.is_valid: messages.error(request, "Captcha was incorrect!") #% check_captcha.error_code) return HttpResponseRedirect(reverse('register')) form = RegisterForm(request.POST) if form.is_valid(): cd = form.cleaned_data username,email,password = cd['username'], cd['email'], cd['password'] new_user = User.objects.create_user(username = username, email = email, password = password) #TODO: fix this, weird postgres issue in django 1.3 see trac issue #15682 user = User.objects.get(username=new_user.username) profile = UserProfile.objects.create(user=user) messages.success(request, "Thanks for registering %s! Welcome to tehorng." % new_user) authed_user = authenticate(username=username, password=password) login(request, authed_user) return HttpResponseRedirect(reverse('profile')) else: form = RegisterForm(initial=request.POST) return render_to_response('registration/register.html', { 'form': form, 'captcha': mark_safe(captcha.displayhtml(settings.RECAPTCHA_PUBLIC_KEY)), }, context_instance=RequestContext(request))
def post(self): p = Pregunta() p.titulo = cgi.escape(self.request.get('titulo'), True) p.contenido = cgi.escape(self.request.get('contenido'), True) p.get_tags( self.sc.get_alltags() ) p.os = self.request.environ['HTTP_USER_AGENT'] if users.get_current_user() and self.request.get('titulo') and self.request.get('contenido'): if self.request.get('anonimo') != 'on': p.autor = users.get_current_user() try: p.put() self.redirect( p.get_link() ) except: self.redirect('/error/503') elif self.request.get('titulo') and self.request.get('contenido'): challenge = self.request.get('recaptcha_challenge_field') response = self.request.get('recaptcha_response_field') remoteip = self.request.remote_addr cResponse = captcha.submit( challenge, response, RECAPTCHA_PRIVATE_KEY, remoteip) if cResponse.is_valid: try: p.put() self.redirect( p.get_link() ) except: self.redirect('/error/503') else: self.redirect('/error/403c') else: self.redirect('/error/403')
def custom_register (request, *args, **kwargs): """ Wrap the django-registration register view in a custom view, so that we can use reCAPTCHA. """ if request.method == "POST": # Check the captcha check_captcha = captcha.submit(\ request.POST["recaptcha_challenge_field"], request.POST["recaptcha_response_field"], settings.RECAPTCHA_PRIVATE_KEY, request.META["REMOTE_ADDR"]) if not check_captcha.is_valid: # If the captcha is wrong, error form = kwargs["form_class"](request.POST) context = {"form": form, "recaptcha_failed": True} if "extra_context" in kwargs: context.update(kwargs["extra_context"]) return render_to_response("registration/registration_form.html", context, context_instance=RequestContext(request)) return register(request, *args, **kwargs)
def create_user(self, r, email, password, confirm, mobile, captcha_challenge, captcha_response): remote_ip = r.environ['REMOTE_ADDR'] captcha_result = captcha.submit(captcha_challenge, captcha_response, self.captcha_key, remote_ip) if captcha_result.is_valid: # check for existing email and mobile self._check_duplicate_email(r.connection, email) self._check_duplicate_mobile(r.connection, mobile) log.debug('captcha is ok, saving registration data') confirm = ConfirmationCode() confirm.code = self._confirmation_code() mobile = ''.join(self.non_digits_regex.split(mobile)) confirm.data = self._serialize(dict(email=email.lower(), password=password, mobile=mobile)) confirm.created = datetime.utcnow() status, data = r.hub.sendConfirmation(mobile, confirm.code) if str(status) == 'ok': r.session.save(confirm) r.session.flush() return dict(success=True, sms_id=data) else: log.debug('Failed to send sms: %s', data) raise ValidationFailedException(dict(mobile='Unable to send SMS: %s' % data)) else: log.debug('captcha is invalid') raise ValidationFailedException(dict(captcha_response='Validation failed'))
def register(request): if request.method == "POST": if "recaptcha_challenge_field" in request.POST: check_captcha = captcha.submit( request.POST["recaptcha_challenge_field"], request.POST["recaptcha_response_field"], settings.RECAPTCHA_PRIVATE_KEY, request.META["REMOTE_ADDR"], ) if not check_captcha.is_valid: messages.error(request, "Captcha didn't pan out! '%s'" % check_captcha.error_code) return HttpResponseRedirect(reverse("register")) form = RegisterForm(request.POST) if form.is_valid(): cd = form.cleaned_data username, email, password = cd["username"], cd["email"], cd["password"] new_user = User.objects.create_user(username=username, email=email, password=password) profile = UserProfile.objects.create(user=new_user) messages.success(request, "Thanks for registering %s! Welcome to tehorng." % new_user) authed_user = authenticate(username=username, password=password) login(request, authed_user) return HttpResponseRedirect(reverse("profile")) else: form = RegisterForm() return render_to_response( "registration/register.html", {"form": form, "captcha": mark_safe(captcha.displayhtml(settings.RECAPTCHA_PUBLIC_KEY))}, context_instance=RequestContext(request), )
def index(request): info = {} info['links'] = Link.objects.filter(is_public=True) if request.method == 'POST': # If the form has been submitted... form = ContactForm(request.POST) # A form bound to the POST data if form.is_valid(): # All validation rules pass r = captcha.submit(request.POST['recaptcha_challenge_field'], request.POST['recaptcha_response_field'], settings.RECAPTCHA_PRIVATE_KEY, request.META['REMOTE_ADDR']) if not r.is_valid: return redirect('/contact/') # Invalid form entry # Process the data in form.cleaned_data name = form.cleaned_data['name'] email = form.cleaned_data['email'] message = form.cleaned_data['message'] recipients = ['*****@*****.**', '*****@*****.**'] email = EmailMessage('Contact Message From ' + name + ' - JessicaSteiber.com', message, email, recipients) email.send() info['msg'] = '<p class="success">Message successfully sent.</p>' info['form'] = ContactForm() else: info['form'] = ContactForm() # An unbound form info['msg'] = '' verses = Verse.objects.filter(is_public=True).order_by('?') info['verse'] = verses[0] info['active'] = 'contact' return render_to_response('contact/index.html', { 'info': info }, context_instance=RequestContext(request))
def post(self): target_name = self.request.get('id') message = self.request.get('email_message') or None sender_email = self.request.get('email_address') or '' target = get_target(target_name) if not target: self.response.set_status(404) return if target.anonymous: response = captcha.submit( self.request.get('recaptcha_challenge_field'), self.request.get('recaptcha_response_field'), RECAPTCHA_PRIVATE_KEY, self.request.remote_addr) if not response.is_valid: logging.info('reCaptcha failed: error_code=%s', response.error_code) self.response.set_status(400) return reply_to = sender_email else: current_user = users.get_current_user() if not current_user: self.response.set_status(400) return reply_to = current_user.email() taskqueue.add( url='/work/send_email', params=dict(target_name=target_name, reply_to=reply_to, message=message), queue_name='send') logging.info('Enqueued email for target=%s', target_name)
def pre_process_request(self, req, handler): if isinstance(handler, RegistrationModule): if not (self.private_key or self.private_key): self.log.warning('public_key and private_key under [recaptcha] are ' 'not configured. Not showing the reCAPTCHA form!') return handler self.check_config() if req.method == 'POST' and req.args.get('action') == 'create': response = captcha.submit( req.args.get('recaptcha_challenge_field'), req.args.get('recaptcha_response_field'), self.private_key, req.remote_addr, ) if not response.is_valid: add_warning(req, 'reCAPTCHA incorrect. Please try again.') req.environ['REQUEST_METHOD'] = 'GET' req.args.pop('password', None) req.args.pop('password_confirm', None) # Admin Configuration if req.path_info.startswith('/admin/accounts/config') and \ req.method == 'POST': self.config.set('recaptcha', 'lang', req.args.get('recaptcha_lang')) self.config.set('recaptcha', 'public_key', req.args.get('recaptcha_public_key')) self.config.set('recaptcha', 'private_key', req.args.get('recaptcha_private_key')) self.config.set('recaptcha', 'theme', req.args.get('recaptcha_theme')) self.config.save() return handler
def post(self): if self.get_logged_in_person(): p = self.get_logged_in_person() challenge = self.request.get('recaptcha_challenge_field') response = self.request.get('recaptcha_response_field') remoteip = environ['REMOTE_ADDR'] cResponse = captcha.submit( challenge, response, recaptcha_keys.recaptcha_private_key, remoteip) if cResponse.is_valid: # response was valid p.ishuman = True p.put() self.render('confirm') else: error = cResponse.error_code chtml = captcha.displayhtml( public_key = recaptcha_keys.recaptcha_public_key, use_ssl = False, error = cResponse.error_code) template_values = { 'captchahtml': chtml } self.render('home', template_values) else: self.redirect('/')
def comment(request, post_id): if request.method == 'POST': form = CommentForm(request.POST) if form.is_valid(): if not request.user.is_authenticated(): r = captcha.submit(request.POST['recaptcha_challenge_field'], request.POST['recaptcha_response_field'], settings.RECAPTCHA_PRIVATE_KEY, request.META['REMOTE_ADDR']) if not r.is_valid: return redirect('/blog/'+post_id+'/') # Invalid form entry f = form.save(commit=False); f.post_id = post_id if request.user.is_authenticated(): f.author_id = request.user.id f.author_name = '' f.author_email = '' f.save() email_msg = 'You have a new comment at http://www.jessicasteiber.com/blog/'+post_id+'/#comments' email_from = '*****@*****.**' email_to = ['*****@*****.**', '*****@*****.**'] # Send email notification send_mail('New Blog Comment - JessicaSteiber.com', email_msg, email_from, email_to) return redirect('/blog/'+post_id+'/#comments') # Go back to blog with new comment else: return redirect('/blog/'+post_id+'/') # Invalid form entry else: return redirect('/blog/'+post_id+'/') # Go back to blog
def attempt_payout(bank): form = bottle.request.forms addr = form.get('addr') if captcha and bank.captcha_priv_key: response = captcha.submit( form.get('recaptcha_challenge_field'), form.get('recaptcha_response_field'), bank.captcha_priv_key, bottle.request['REMOTE_ADDR'], ) if not response.is_valid: return http_err(403, "I think you're a robot!") try: amt = bank.schedule_payment(addr) except ValueError: return http_err(400, "Invalid address: "+addr) except DuplicateKeyError as e: t, v = e.args return http_err(400, t+" ("+v+") already queued") if amt == 0: return http_err(595, "Out of "+bank.coin) return bottle.template('payout', amount=amt, address=addr, **bank.get_public_status())
def captcha_check(self, *args, **kwargs): if not "recaptcha_challenge_field" in kwargs: raise cherrypy.HTTPRedirect("/new_user?error=No captcha challenge field. That is totally weird. Please try reloading the page.") if not "recaptcha_response_field" in kwargs: raise cherrypy.HTTPRedirect("/new_user?error=No captcha response field. That is totally weird. Please try reloading the page.") recaptcha_challenge_field = kwargs["recaptcha_challenge_field"] recaptcha_response_field = kwargs["recaptcha_response_field"] captcha_results = captcha.submit( recaptcha_challenge_field, recaptcha_response_field, cherrypy.request.app.config["captcha"]["private"], cherrypy.request.headers["Remote-Addr"],) if captcha_results.is_valid: # TODO redirect to "your email should get a code" page return "valid" if captcha_results.error_code: # needs an error message if captcha_results.error_code == "invalid-site-private-key": # TODO log and alert operator pass raise cherrypy.HTTPRedirect("/new_user?error=%s"% captcha_results.error_code)
def post(self): c = Comentario() c.contenido = cgi.escape(self.request.get('contenido'), True) c.id_enlace = self.request.get('id_enlace') c.os = self.request.environ['HTTP_USER_AGENT'] c.ips = [self.request.remote_addr] if users.get_current_user() and self.request.get('contenido') and self.request.get('id_enlace'): if self.request.get('anonimo') != 'on': c.autor = users.get_current_user() self.finalizar( c ) elif self.request.get('contenido') and self.request.get('id_enlace'): challenge = self.request.get('recaptcha_challenge_field') response = self.request.get('recaptcha_response_field') remoteip = self.request.remote_addr cResponse = captcha.submit( challenge, response, RECAPTCHA_PRIVATE_KEY, remoteip) if cResponse.is_valid: self.finalizar( c ) else: self.redirect('/error/403c') else: self.redirect('/error/403')
def suggest_resource(request, **kwargs): suggest = None output = {} template = '' captcha_is_valid = True captcha_error = '' suggest = SuggestResource() form = ExternalSuggestResourceForm(request.POST, instance=suggest) if settings.RECAPTCHA_PRIVATE_KEY: # Check the captcha with reCAPTCHA (google service) captcha_response = captcha.submit( request.POST.get('recaptcha_challenge_field'), request.POST.get('recaptcha_response_field'), settings.RECAPTCHA_PRIVATE_KEY, request.META['REMOTE_ADDR'],) if not captcha_response.is_valid: # captcha is wrong show a error message in the template. captcha_is_valid = False captcha_error = captcha_response.error_code if form.is_valid() and captcha_is_valid: template = 'suggest/thanks.html' suggest = form.save() else: template = 'suggest/invalid-link.html' output['form'] = form output['captcha_error'] = captcha_error return render_to_response(template, output, context_instance=RequestContext(request))
def contact(request): captcha_error = "" captcha_pub_key = settings.RECAPTCHA_PUBLIC_KEY if request.method == 'POST': form = ContactForm(request.POST) cp_response = captcha.submit(request.POST.get("recaptcha_challenge_field", None), request.POST.get("recaptcha_response_field", None), settings.RECAPTCHA_PRIVATE_KEY, request.META.get("REMOTE_ADDR", None)) if not cp_response.is_valid: captcha_error = "&error=%s" % cp_response.error_code else: if form.is_valid(): cd = form.cleaned_data send_mail( cd['subject'], cd['message'], cd.get('email', '*****@*****.**'), ['*****@*****.**'], ) return HttpResponseRedirect('/contact/thanks/') else: form = ContactForm() return render(request, 'contact.html', {'form': form,'captcha_error': captcha_error, 'captcha_pub_key': captcha_pub_key})
def contact(request): ''' Display and process the contact form. Keyword arguments: request -- the request object. Return: The contact form view (if pre-request) or a view with a success message. ''' CAPTCHA_PUBLIC_KEY = settings.AF_RECAPTCHA_PUBLIC_KEY if request.method == 'POST': form = contactForm(request.POST) if form.is_valid(): # Check if the response CAPTCHA value is valid; else redirect back # with an error. response = captcha.submit( request.POST.get('recaptcha_challenge_field'), request.POST.get('recaptcha_response_field'), settings.AF_RECAPTCHA_PRIVATE_KEY, request.META['REMOTE_ADDR'],) if not response.is_valid: captchaWrong = True return render_to_response('contact.html', locals(), context_instance=RequestContext(request)) subject = request.POST['userSubject'] message = "Hello, you've received a message from AfterGlow Cloud.\n" message += "User: "******"userName"] + " (" \ + request.POST["userEmail"] + ") says: \n\n" message += request.POST["userMessage"] from_email = settings.AF_FROM_EMAIL try: send_mail("AfterGlow: " + subject, message, from_email, settings.AF_TO_EMAILS) except BadHeaderError: return HttpResponse('Invalid header found. Please try again.') # Boolean flag used to display a 'success' message on the view. mailSent = True else: form = contactForm() return render_to_response('contact.html', locals(), context_instance=RequestContext(request))
def clean(self): error_list = [] # Test userName is unique if 'userName' in self.cleaned_data: QS = User.objects.filter(username__exact=self.cleaned_data['userName']) if QS.count(): error_list.append("username '%s' is already in use" % (self.cleaned_data['userName'])) # Test emailAddress if 'email' in self.cleaned_data: validaton_errorList = validate_email(self.cleaned_data['email']) if validaton_errorList: error_list += validaton_errorList # Test passwords if 'pass1' in self.cleaned_data and 'pass2' in self.cleaned_data: validaton_errorList = validate_passwords(self.cleaned_data['pass1'], self.cleaned_data['pass2']) if validaton_errorList: error_list += validaton_errorList # test if captcha is valid captcha_response = captcha.submit(self.recaptcha_challenge_field, self.recaptcha_response_field, settings.RECAPTCHA_PRIVATE_KEY, self.REMOTE_ADDR) if not captcha_response.is_valid: error_list.append("incorrect captcha") if error_list: raise ValidationError(error_list) return self.cleaned_data
def clean(self): default_error_messages = { 'captcha_invalid': _(u'Incorrect, please try again.') } cleaned_data = super(RegistrationFormCaptcha, self).clean() remote_ip = cleaned_data.get('remote_ip') values = cleaned_data.get('captcha') recaptcha_challenge_value = smart_unicode(values[0]) recaptcha_response_value = smart_unicode(values[1]) try: use_ssl = settings.RECAPTCHA_USE_SSL except AttributeError: use_ssl = False check_captcha = captcha.submit(recaptcha_challenge_value, recaptcha_response_value, settings.RECAPTCHA_PRIVATE_KEY, remote_ip) if not check_captcha.is_valid: msg = default_error_messages['captcha_invalid'] self._errors['captcha'] = self.error_class([msg]) del cleaned_data['captcha'] return self.cleaned_data
def processPublicRegistration(self): log = logging.getLogger('csdt') log.debug("register_view.processPublicRegistration()") log.debug("context = %s" % self.context) log.debug("request = %s" % self.request) session = self.request.session log.debug("request values:") for k, v in self.request.params.iteritems(): log.debug("key = %s value = %s" % (k, v)) log.debug("session values:") for k, v in session.iteritems(): log.debug("key = %s value = %s" % (k, v)) if "first_name" not in self.request.params or "last_name" not in self.request.params or "email" not in self.request.params: log.warning("request.params is missing a parameter that is essential") raise HTTPNotFound() self.nonUsersOnlyAuthorization(session) host = self.request.host recaptcha_private_key = '6Ldi2MYSAAAAALJ_KaLfTzOTAg5iNHqOmvmgaQOg' captcha_result = captcha.submit( self.request.params['recaptcha_challenge_field'], self.request.params['recaptcha_response_field'], recaptcha_private_key, host, ) if not captcha_result.is_valid: error = captcha_result.error_code json_hash = {'result': '-1', 'error':error} json_dump = json.dumps(json_hash) log.debug("json dump = %s" % json_dump) return Response(json_dump) first_name = self.request.params['first_name'] last_name = self.request.params['last_name'] email = self.request.params['email'] user_id = self.context.doesEmailExist(email) if user_id is not None: json_hash = {'result': '-2'} json_dump = json.dumps(json_hash) log.debug("json dump = %s" % json_dump) return Response(json_dump) plaintext = first_name + ";" + last_name + ";" + email ciphertext = self.context.encryptUrlQuery(unicode(plaintext)) self.context.createConfirmationLetter(self.request.host_url, email, first_name, last_name, ciphertext) json_hash = {'result': '0'} json_dump = json.dumps(json_hash) log.debug("json dump = %s" % json_dump) return Response(json_dump)
def check_recaptcha(turing_value,ip): ''' Check recaptcha @type turing_value: str @param turing_value: turing value in JSON format, should have turing_value["challenge"] and turing_value["response"] @type ip: str @param ip: IP of client @rtype: boolean @return: True iff recaptcha pass ''' if force_output != None: return force_output if not isinstance(turing_value, str): return False if not isinstance(ip, str): return False v = json.loads(s=turing_value,encoding="utf8") if not isinstance(v, dict): return False if not isinstance(v["challenge"], unicode): return False if not isinstance(v["response"], unicode): return False output = captcha.submit(v["challenge"], v["response"], core_config.RECAPTCHA_PRIVATE_KEY, ip) if not output.is_valid: return False return True
def validate(self, value): captchaResponse = captcha.submit(value['recaptcha_challenge_name'], value['recaptcha_response_name'], settings.RECAPTCHA_PRIVATE_KEY, '') if not captchaResponse.is_valid: raise ValidationError(self.default_error_messages['invalid_answer'])
def process_request(self, req): self.check_config() action = req.args.get('action') if req.method == 'POST' and action == 'create': response = captcha.submit( req.args['recaptcha_challenge_field'], req.args['recaptcha_response_field'], self.private_key, req.remote_addr, ) if not response.is_valid: data = {} data['registration_error'] = 'Captcha incorrect. Please try again.' data['recaptcha_javascript'] = captcha.displayhtml(self.public_key) data['recaptcha_theme'] = self.theme return "recaptcharegister.html", data, None else: ret = super(RecaptchaRegistrationModule, self).process_request(req) h, data, n = ret data['recaptcha_theme'] = self.theme return "recaptcharegister.html", data, n else: ret = super(RecaptchaRegistrationModule, self).process_request(req) h, data, n = ret data['recaptcha_javascript'] = captcha.displayhtml(self.public_key) data['recaptcha_theme'] = self.theme return "recaptcharegister.html", data, n
def captcha_verify(request, post_pk, pk): """ Verify the captcha response. If it is invalid, inform the user. Otherwise allow the post to be listed. """ post = Post.objects.get(pk=post_pk) comment = Comment.objects.get(pk=pk) response = captcha.submit( request.POST.get("recaptcha_challenge_field"), request.POST.get("recaptcha_response_field"), settings.GOOGLE_CAPTCHA_PRIVATE_API_KEY, request.META["REMOTE_ADDR"], ) if response.is_valid: comment.listed = True comment.save() return HttpResponseRedirect( reverse("blog:index") + "%d/%.2d/%s/#comments" % (post.pub_date.year, post.pub_date.month, post.slug) ) else: ctx = RequestContext( request, { "google_captcha_api_key": settings.GOOGLE_CAPTCHA_PUBLIC_API_KEY, "post": post, "comment": comment, "captcha_response": "Invalid Captcha.", }, ) return render_to_response("blog/captcha.html", ctx)
def register(): #Handle registration if request.method == 'POST': username = request.form.get('username', None) password = request.form.get('password', None) challenge = request.form.get('recaptcha_challenge_field', '') response = request.form.get('recaptcha_response_field', '') #Google Recaptcha response = captcha.submit( challenge, response, '6LdcwckSAAAAAGFCGW1Q4F0A7gkp43AzyTsHVkJh', request.remote_addr, ) #Check for username and passwords if username and password and response.is_valid: #Actually do the db mucking ok = make_user(username, password) if not ok: return render_template("register.html") else: return redirect("/login/") return render_template("register.html", logged_in = not current_user.is_anonymous())
def validate_captcha(self): rcf = self.cleaned_data['recaptcha_challenge_field'] rrf = self.cleaned_data['recaptcha_response_field'] check = captcha.submit( rcf, rrf, settings.RECAPTCHA_PRIVATE_KEY, self.ip) if not check.is_valid: raise forms.ValidationError(_( astakos_messages.CAPTCHA_VALIDATION_ERR))
def get_captcha_response(self): """Returns an object containing the CAPTCHA response information for the given request's CAPTCHA field information.""" challenge = self.request.get('recaptcha_challenge_field') response = self.request.get('recaptcha_response_field') remote_ip = os.environ['REMOTE_ADDR'] return captcha.submit(challenge, response, config.get('captcha_private_key'), remote_ip)
def save_child(request, parent=None, parentString=''): request.session['errors'] = '' if settings.USE_RECAPTCHA: response = captcha.submit( request.POST.get('recaptcha_challenge_field'), request.POST.get('recaptcha_response_field'), settings.RECAPTCHA_PRIVATE_KEY, request.META['REMOTE_ADDR']) if not response.is_valid: request.session['errors'] = 'captcha' return redirect(settings.URL_ROOT + parentString) email = request.POST.get('email', '') request.session['email'] = email if not is_valid_email(email): request.session['errors'] = 'email' return redirect(settings.URL_ROOT + parentString) #invalid email, send back to start hash = hash_email(email) ip = request.META.get('REMOTE_ADDR') slider = 50 newp = Person.objects.filter(email=email) dup = (len(newp) > 0) if dup: newp = newp[0] rating = Rating.objects.filter(person=newp) if len(rating) > 0: slider = rating[0].rating else: if parent == None or len(parent) == 0: newp = Person(email=email, hash=hash, ipaddress=ip, influence=0, parent_node=None, session_key=str(request.session.session_key)) newp.save() else: newp = Person(email=email, hash=hash, ipaddress=ip, parent=parent[0].email, parent_node=parent[0], influence=0, session_key=str(request.session.session_key)) newp.save() update_score(newp) t = loader.get_template('save.html') c = RequestContext( request, { 'link': settings.URL_ROOT + str(newp.id), 'score_link': settings.URL_ROOT + 'score/' + str(newp.id), 'csrf_token': csrf(request)['csrf_token'], 'url': settings.URL_ROOT, 'saved': '', 'slider': slider, 'dup': dup }) return HttpResponse(t.render(c))
def clean_captcha(self): value = None if self.request: challenge = self.data['recaptcha_challenge_field'] response = self.data['recaptcha_response_field'] captcha_response = captcha.submit(challenge, response, settings.RECAPTCHA_PRIVATE_KEY, request_helpers.get_ip(self.request)) if not captcha_response.is_valid: raise forms.ValidationError("Incorrect response entered.") return value
def clean(self, values): super(ReCaptchaField, self).clean(values[1]) recaptcha_challenge_value = smart_unicode(values[0]) recaptcha_response_value = smart_unicode(values[1]) check_captcha = captcha.submit(recaptcha_challenge_value, recaptcha_response_value, settings.RECAPTCHA_PRIVATE_KEY, {}) if not check_captcha.is_valid: raise forms.util.ValidationError(self.error_messages['captcha_invalid']) return values[0]
def checkCaptcha(request): check = captcha.submit( request.POST['recaptcha_challenge_field'], request.POST['recaptcha_response_field'], privateKey, '192.168.1.1') if check.is_valid: return render(request, 'success.html') else: return render(request, 'failure.html')
def post(self): args = self.parser.parse_args() response = captcha.submit(args['recaptcha_challenge_field'], args['recaptcha_response_field'], '6LdaFvsSAAAAAPhdPEuKa5KBOYNGNPNCkhxIo8mG', request.headers.get('REMOTE_ADDR')) if response.is_valid: return Response("NICE") return abort(self.HTTP_FORBIDDEN)
def submit(self): """Return an instance of recaptcha.client.captcha.RecaptchaResponse.""" if request.environ.get('paste.testing', False): return RecaptchaResponse(False, 'paste.testing') recaptcha_challenge_field = request.POST.get( 'recaptcha_challenge_field', None) recaptcha_response_field = request.POST.get('recaptcha_response_field', None) return submit(recaptcha_challenge_field, recaptcha_response_field, self._private_key, "127.0.0.1")
def clean(self, data, initial): if initial is None or initial == '': raise Exception("ReCaptchaField requires the client's IP be set to the initial value") ip = initial resp = captcha.submit(data.get("recaptcha_challenge_field", None), data.get("recaptcha_response_field", None), settings.RECAPTCHA_SECRET, ip) if not resp.is_valid: raise forms.ValidationError(self.default_error_messages.get( resp.error_code, "Unknown error: %s" % (resp.error_code)))
def validate_captcha(request, form): """ Validates the captcha challenge found on the contact form """ response = captcha.submit(request.POST.get('recaptcha_challenge_field'), request.POST.get('recaptcha_response_field'), settings.RECAPTCHA_PRIVATE_KEY, request.META.get('REMOTE_ADDR', None)) return response.is_valid
def clean(self, value): if value is None: raise ValidationError(_('Invalid request')) resp = captcha.submit(value.get('challenge', None), value.get('response', None), askbot_settings.RECAPTCHA_SECRET, value.get('ip', None)) if not resp.is_valid: self.widget.attrs['error'] = resp.error_code raise ValidationError( HUMAN_ERRORS.get(resp.error_code, _(u'Unknown error.')))
def change_password(self, *args, **kwargs): ''' Updates a user accounts password ''' user = User.by_user_name(self.session.data['user_name']) try: old_password = self.get_argument("old_password") new_password = self.get_argument("new_password") new_password_two = self.get_argument("new_password2") except: self.render("user/error.html", operation="Changing Password", errors="Please fill out all forms" ) try: response = captcha.submit( self.get_argument('recaptcha_challenge_field'), self.get_argument('recaptcha_response_field'), self.application.settings['recaptcha_private_key'], self.request.remote_ip ) except: self.render("user/error.html", operation="Changing Password", errors="Please fill out recaptcha" ) if user.validate_password(old_password): if new_password == new_password_two: if 12 <= len(new_password): if response.is_valid: user.password = new_password self.dbsession.add(user) self.dbsession.flush() self.render("user/settings.html", message="Succesfully Changed Password!" ) else: self.render("user/error.html", operation="Changing Password", errors="Invalid recaptcha" ) else: self.render("user/error.html", operation="Change Password", errors="Password must be at least 12 chars" ) else: self.render("user/error.html", operation="Changing Password", errors="New password's didn't match" ) else: self.render("user/error.html", operation="Changing Password", errors="Invalid old password" )
def clean(self, values): super(ReCaptchaField, self).clean(values[1]) challenge = smart_unicode(values[0]) response = smart_unicode(values[1]) ip = smart_unicode(values[2]) key = settings.RECAPTCHA_PRIVATE_KEY res = captcha.submit(challenge, response, key, ip) if not res.is_valid: raise forms.util.ValidationError( self.error_messages['captcha_invalid']) return challenge
def index(req): ipaddr = req.META.get('REMOTE_ADDR', '') _content = '' _need_recaptcha = False if req.method == 'POST': _content = req.POST.get('content', '') _need_recaptcha = needRecaptchar(ipaddr, _content) if _need_recaptcha and len( req.POST.get('recaptcha_challenge_field', '')) == 0: messages.error(req, MSG['RECAPTCHA_NEEDED']) elif _need_recaptcha and not captcha.submit( req.POST.get('recaptcha_challenge_field', ''), req.POST.get('recaptcha_response_field'), RECAPTCHA_PRIVATE_KEY, ipaddr).is_valid: messages.error(req, MSG['RECAPTCHA_INCORRECT']) elif not checkIP(ipaddr): messages.error(req, MSG['IP_NOT_VALID']) elif not (len(_content) < 120 and len(_content) > 5): messages.error(req, MSG['CONTENT_TOO_LONG']) elif ContentModel.objects.filter(ip=ipaddr, time__range=\ (datetime.now()-timedelta(minutes=30), datetime.now())).count() > 0: messages.error(req, MSG['TOO_MANY_TIMES']) else: try: postStatu(_content, ipaddr) except: messages.error(req, MSG['PUBLISH_ERROR']) logging.error('Error in ' + str(ContentModel.objects.count())) else: messages.success(req, MSG['PUBLISH_OK']) _content = '' # for doreamon icon try: icon = int(req.path[1:]) except ValueError: icon = 0 tourl = '' if icon == 0 or req.session.get('redirect', 0) == 0: req.session['redirect'] = 1 tourl = '/' + str(random.randint(1, 16)) else: req.session['redirect'] = 0 isIphone = ('iPhone' in req.META.get('HTTP_USER_AGENT', '') and req.method == 'GET') return render_to_response('index.html', \ {'ICO_NUM': icon, 'TOURL': tourl, 'ISIPHONE': isIphone, 'LINKS': LINKS, 'PLACEHOLER': PlaceholderModel.objects.order_by('?')[0].content, 'content': _content, 'RECAPTCHA_PUBLIC_KEY': RECAPTCHA_PUBLIC_KEY, 'need_recaptcha': _need_recaptcha, 'COLOR': random.choice(COLORS)}, context_instance=RequestContext(req))
def get_captcha_response(self): """Returns an object containing the CAPTCHA response information for the given request's CAPTCHA field information.""" # Allows faking the CAPTCHA response by an HTTP request parameter, but # only locally, for testing purpose. faked_captcha_response = self.request.get('faked_captcha_response') if faked_captcha_response and self.request.remote_addr == '127.0.0.1': return captcha.RecaptchaResponse( is_valid=faked_captcha_response == 'success') captcha_response = self.request.get('g-recaptcha-response') return captcha.submit(captcha_response)
def clean(self, values): super(FormCaptchaField, self).clean(values[1]) if not settings.SHOW_CAPTCHAS: return values recaptcha_challenge_value = smart_unicode(values[0]) recaptcha_response_value = smart_unicode(values[1]) check_captcha = captcha.submit(recaptcha_challenge_value, recaptcha_response_value, settings.RECAPTCHA_PRIVATE_KEY, {}) if not check_captcha.is_valid: raise forms.util.ValidationError(_(u'Invalid captcha')) return values[0]
def password_reset(self): settings = SettingsModel().get_all_settings() captcha_private_key = settings.get('rhodecode_captcha_private_key') captcha_active = bool(captcha_private_key) captcha_public_key = settings.get('rhodecode_captcha_public_key') render_ctx = { 'captcha_active': captcha_active, 'captcha_public_key': captcha_public_key, 'defaults': {}, 'errors': {}, } if self.request.POST: password_reset_form = PasswordResetForm()() try: form_result = password_reset_form.to_python( self.request.params) if captcha_active: response = submit( self.request.params.get('recaptcha_challenge_field'), self.request.params.get('recaptcha_response_field'), private_key=captcha_private_key, remoteip=get_ip_addr(self.request.environ)) if captcha_active and not response.is_valid: _value = form_result _msg = _('bad captcha') error_dict = {'recaptcha_field': _msg} raise formencode.Invalid(_msg, _value, None, error_dict=error_dict) # Generate reset URL and send mail. user_email = form_result['email'] user = User.get_by_email(user_email) password_reset_url = self.request.route_url( 'reset_password_confirmation', _query={'key': user.api_key}) UserModel().reset_password_link( form_result, password_reset_url) # Display success message and redirect. self.session.flash( _('Your password reset link was sent'), queue='success') return HTTPFound(self.request.route_path('login')) except formencode.Invalid as errors: render_ctx.update({ 'defaults': errors.value, 'errors': errors.error_dict, }) return render_ctx
def clean(self, value): plugin = get_plugin('contactform') privkey = plugin.get_config().get('rprivk', None) if privkey: privkey = privkey.value else: privkey = '' challenge, response = value recaptcha_response = captcha.submit(challenge, response, privkey, self.client_addr) if not recaptcha_response.is_valid: raise ValidationError(_("The captcha was invalid, try again."))
def nouveau(request): if request.method == "POST": response = captcha.submit( request.POST.get('recaptcha_challenge_field'), request.POST.get('recaptcha_response_field'), '6LfDrPESAAAAABINT7Y69VTIviZLqijba7V3tgeK', request.META['REMOTE_ADDR'], ) if not response.is_valid: return render_to_response('profil/inscription.html', {'msg_error': response.error_code}, RequestContext(request)) return redirect('/profil/') pseudo = request.POST['pseudo'] if pseudo == '': msg = "Le pseudo est vide" return render_to_response('profil/inscription.html', {'msg_error': msg}, RequestContext(request)) elif request.POST['pwd1'] == "": msg = "Le mot de passe est vide" return render_to_response('profil/inscription.html', {'msg_error': msg}, RequestContext(request)) elif User.objects.filter(username=pseudo) or Profil.objects.filter( pseudo=pseudo): msg = "Ce pseudo est déjà utilisé" return render_to_response('profil/inscription.html', {'msg_error': msg}, RequestContext(request)) elif request.POST['pwd1'] != request.POST['pwd2']: msg = "Mots de passe non identiques" return render_to_response('profil/inscription.html', {'msg_error': msg}, RequestContext(request)) elif " " in request.POST['pseudo']: msg = "Pas d'espace dans un pseudo" return render_to_response('profil/inscription.html', {'msg_error': msg}, RequestContext(request)) else: new_user = User.objects.create(username=pseudo, is_active=True) new_user.set_password(request.POST['pwd1']) new_user.save() new_profil = Profil.objects.create(pseudo=pseudo, u=new_user) new_profil.save() u = authenticate(username=new_user.username, password=request.POST['pwd1']) login(request, u) return redirect('/') else: return redirect('/profil/')
def recaptcha(self): """ """ try: challenge = request.form['recaptcha_challenge_field'] response = request.form['recaptcha_response_field'] cResponse = captcha.submit( challenge, response, "6Ldph8cSAAAAAFZt4S2na02xnflgTC3jDNBX91_C", request.remote_addr) return cResponse.is_valid except: return True
def validate_captcha(self): rcf = self.cleaned_data['recaptcha_challenge_field'] rrf = self.cleaned_data['recaptcha_response_field'] ip_address = self._request.META['REMOTE_ADDR'] # only submit captcha information if it is enabled if self.captcha_enabled: check = captcha.submit(rcf, rrf, settings.RECAPTCHA_PRIVATE_KEY, ip_address) if not check.is_valid: raise forms.ValidationError( 'You have not entered the correct words')
def clean(self): super(InviteUserForm, self).clean() if CAPTCHA: # reCAPTCHA works on production recaptcha_response_value = self.cleaned_data[ 'recaptcha_response_field'] recaptcha_challenge_value = self.cleaned_data[ 'recaptcha_challenge_field'] check_captcha = captcha.submit(recaptcha_challenge_value, recaptcha_response_value, RECAPTCHA_PRIVATE_KEY, {}) if not check_captcha.is_valid: self.add_error('recaptcha_response_field', 'Try captcha again') return self.cleaned_data
def is_captcha_valid(self, cr, uid, ids, challenge, response, context=None): assert len(ids) == 1 website = self.browse(cr, uid, ids[0]) res = captcha.submit(challenge, response, website.recaptcha_private_key, website.name) return res.is_valid
def _clean_captcha(self): if self.need_captcha and \ getattr(settings, 'RECAPTCHA_PRIVATE_KEY', None) and \ getattr(settings, 'RECAPTCHA_PUBLIC_KEY', None): challenge_field = self.data.get('recaptcha_challenge_field') response_field = self.data.get('recaptcha_response_field') client = self.recaptcha_ip # Must be set by our view code. check_captcha = captcha.submit(challenge_field, response_field, settings.RECAPTCHA_PRIVATE_KEY, client) if check_captcha.is_valid is False: self.errors['recaptcha'] = 'Invalid captcha value'
def register_post(self): captcha_private_key = SettingsModel().get_setting_by_name( 'rhodecode_captcha_private_key') captcha_active = bool(captcha_private_key) auto_active = 'hg.register.auto_activate' in User.get_default_user()\ .AuthUser.permissions['global'] register_form = RegisterForm()() try: form_result = register_form.to_python(self.request.params) form_result['active'] = auto_active if captcha_active: response = submit( self.request.params.get('recaptcha_challenge_field'), self.request.params.get('recaptcha_response_field'), private_key=captcha_private_key, remoteip=get_ip_addr(self.request.environ)) if captcha_active and not response.is_valid: _value = form_result _msg = _('bad captcha') error_dict = {'recaptcha_field': _msg} raise formencode.Invalid(_msg, _value, None, error_dict=error_dict) new_user = UserModel().create_registration(form_result) event = UserRegistered(user=new_user, session=self.session) self.request.registry.notify(event) self.session.flash( _('You have successfully registered with RhodeCode'), queue='success') Session().commit() redirect_ro = self.request.route_path('login') raise HTTPFound(redirect_ro) except formencode.Invalid as errors: del errors.value['password'] del errors.value['password_confirmation'] return self.register( defaults=errors.value, errors=errors.error_dict) except UserCreationError as e: # container auth or other auth functions that create users on # the fly can throw this exception signaling that there's issue # with user creation, explanation should be provided in # Exception itself self.session.flash(e, queue='error') return self.register()
def validate_layout_submit(request): if request.method != 'POST': return redirect(layout_submit) if settings.RECAPTCHA_ENABLED: check_captcha = captcha.submit( request.POST['recaptcha_challenge_field'], request.POST['recaptcha_response_field'], settings.RECAPTCHA_PRIVATE_KEY, request.META['REMOTE_ADDR']) if not check_captcha.is_valid: return layout_submit(request) form = StationLayoutQuarantineForm(request.POST) if not form.is_valid(): return layout_submit(request) new_layout = StationLayoutQuarantine( name=form.cleaned_data['name'], email=form.cleaned_data['email'], station=form.cleaned_data['station'], active_date=form.cleaned_data['active_date'], detector_1_alpha=form.cleaned_data['detector_1_alpha'], detector_1_beta=form.cleaned_data['detector_1_beta'], detector_1_radius=form.cleaned_data['detector_1_radius'], detector_1_height=form.cleaned_data['detector_1_height'], detector_2_alpha=form.cleaned_data['detector_2_alpha'], detector_2_beta=form.cleaned_data['detector_2_beta'], detector_2_radius=form.cleaned_data['detector_2_radius'], detector_2_height=form.cleaned_data['detector_2_height'], detector_3_alpha=form.cleaned_data['detector_3_alpha'], detector_3_beta=form.cleaned_data['detector_3_beta'], detector_3_radius=form.cleaned_data['detector_3_radius'], detector_3_height=form.cleaned_data['detector_3_height'], detector_4_alpha=form.cleaned_data['detector_4_alpha'], detector_4_beta=form.cleaned_data['detector_4_beta'], detector_4_radius=form.cleaned_data['detector_4_radius'], detector_4_height=form.cleaned_data['detector_4_height']) new_layout.generate_hashes() new_layout.save() new_layout.sendmail_submit() return render( request, 'layout_submitted.html', { 'name': form.cleaned_data['name'], 'email': form.cleaned_data['email'], 'station': form.cleaned_data['station'] })
def DoRecaptchaValidation(request, template, template_dict): if settings.SCALEREG_SIMPLECFP_USE_RECAPTCHA: try: recaptcha_response = submit( request.POST['recaptcha_challenge_field'], request.POST['recaptcha_response_field'], settings.RECAPTCHA_PRIVATE_KEY, request.META['REMOTE_ADDR']) except: # If we cannot get a recaptcha, let the user continue. return None if not recaptcha_response.is_valid: template_dict['recaptcha_html'] = GenerateRecaptchaHTML( request, recaptcha_response.error_code) return cfp_render_to_response(request, template, template_dict) return None
def validate_captcha(self): rcf = self.cleaned_data['recaptcha_challenge_field'] rrf = self.cleaned_data['recaptcha_response_field'] ip_address = self._request.META['REMOTE_ADDR'] # only submit captcha information if it is enabled if self.captcha_enabled: try: check = captcha.submit(rcf, rrf, settings.RECAPTCHA_PRIVATE_KEY, ip_address) if not check.is_valid: raise forms.ValidationError('You have not entered the correct words') except URLError, timeout: # We often sometimes see error messages that recaptcha url is unreachable and # this causes 500 errors. If recaptcha is unreachable, just skip captcha validation. pass
def _validate_captcha(self): rcf = self.cleaned_data['recaptcha_challenge_field'] rrf = self.cleaned_data['recaptcha_response_field'] if rrf == '': raise forms.ValidationError( _('You did not enter any of the two words shown in the image.') ) else: from recaptcha.client import captcha as recaptcha ip = self._request.META['REMOTE_ADDR'] private_key = getattr(settings, "RECAPTCHA_PRIVATE_KEY") check = recaptcha.submit(rcf, rrf, private_key, ip) if not check.is_valid: raise forms.ValidationError( _('The words you entered did not match the image.'))
def _validate_captcha(self): if not self.recaptcha_always_validate: rcf = self.cleaned_data['recaptcha_challenge_field'] rrf = self.cleaned_data['recaptcha_response_field'] if rrf == '': raise forms.ValidationError( _('You did not enter the two words shown in the image.')) else: from recaptcha.client import captcha as recaptcha ip = self._request.META['REMOTE_ADDR'] check = recaptcha.submit(rcf, rrf, self._recaptcha_private_key, ip) if not check.is_valid: raise forms.ValidationError( _('The words you entered did not match the image.'))