Python signing.BadSignature方法代码示例

# 需要导入模块: from django.core import signing [as 别名]
# 或者: from django.core.signing import BadSignature [as 别名]
def verify(self):
        data = self._data
        signature = data.get(self.SIGNATURE_FIELD, None)
        if signature is None:
            raise BadSignature()
        expected_signature = self.calculate_signature()
        if not constant_time_compare(signature, expected_signature):
            raise BadSignature()

        valid_period = self.get_valid_period()

        if self.USE_TIMESTAMP and valid_period is not None:
            timestamp = data[self.TIMESTAMP_FIELD]
            timestamp = int(timestamp)
            current_timestamp = get_current_timestamp()
            valid_period_secs = valid_period.total_seconds()
            if current_timestamp - timestamp > valid_period_secs:
                raise SignatureExpired() 

# 需要导入模块: from django.core import signing [as 别名]
# 或者: from django.core.signing import BadSignature [as 别名]
def get_signed_cookie(self, key, default=RAISE_ERROR, salt='', max_age=None):
        """
        Attempts to return a signed cookie. If the signature fails or the
        cookie has expired, raises an exception... unless you provide the
        default argument in which case that value will be returned instead.
        """
        try:
            cookie_value = self.COOKIES[key]
        except KeyError:
            if default is not RAISE_ERROR:
                return default
            else:
                raise
        try:
            value = signing.get_cookie_signer(salt=key + salt).unsign(
                cookie_value, max_age=max_age)
        except signing.BadSignature:
            if default is not RAISE_ERROR:
                return default
            else:
                raise
        return value 

# 需要导入模块: from django.core import signing [as 别名]
# 或者: from django.core.signing import BadSignature [as 别名]
def get(self, request, **kwargs):
        token = kwargs.get('token')
        try:
            new_email = loads(token, max_age=self.timeout_seconds)

        # 期限切れ
        except SignatureExpired:
            return HttpResponseBadRequest()

        # tokenが間違っている
        except BadSignature:
            return HttpResponseBadRequest()

        # tokenは問題なし
        else:
            User.objects.filter(email=new_email, is_active=False).delete()
            request.user.email = new_email
            request.user.save()
            return super().get(request, **kwargs) 

# 需要导入模块: from django.core import signing [as 别名]
# 或者: from django.core.signing import BadSignature [as 别名]
def get_signed_cookie(self, key, default=RAISE_ERROR, salt='', max_age=None):
        """
        Attempt to return a signed cookie. If the signature fails or the
        cookie has expired, raise an exception, unless the `default` argument
        is provided,  in which case return that value.
        """
        try:
            cookie_value = self.COOKIES[key]
        except KeyError:
            if default is not RAISE_ERROR:
                return default
            else:
                raise
        try:
            value = signing.get_cookie_signer(salt=key + salt).unsign(
                cookie_value, max_age=max_age)
        except signing.BadSignature:
            if default is not RAISE_ERROR:
                return default
            else:
                raise
        return value 

# 需要导入模块: from django.core import signing [as 别名]
# 或者: from django.core.signing import BadSignature [as 别名]
def validate_token(token):
        """
        Validate token.

        returns MeetingInvitation or None
        """

        try:
            # Valid in 7 days
            valid_in = 60 * 60 * 24 * 7
            data = signing.loads(TimestampSigner().unsign(token, max_age=valid_in))

            return MeetingInvitation.objects.filter(
                user=int(data["user_id"]), meeting=int(data["meeting_id"])
            )[0]
        except (BadSignature, SignatureExpired):
            return None 

# 需要导入模块: from django.core import signing [as 别名]
# 或者: from django.core.signing import BadSignature [as 别名]
def track(cls, http_meta, encrypted):
        class Request(object):
            META = http_meta

        try:
            request = Request()

            mail_log_id = signing.loads(encrypted)
            mail_log = MailLog.objects.get(log_id=mail_log_id)

            track_log = MailLogTrack.objects.filter(mail_log=mail_log)
            if not track_log.exists():
                MailLogTrack.objects.create(
                    mail_log=mail_log,
                    ip=get_ip(request),
                    ua=request.META.get('HTTP_USER_AGENT'),
                    is_read=True,
                )
            else:
                track_log[0].save()
        except (signing.BadSignature, MailLog.DoesNotExist):
            pass 

# 需要导入模块: from django.core import signing [as 别名]
# 或者: from django.core.signing import BadSignature [as 别名]
def survey_opt_out(request, survey_slug):
    signer = TimestampSigner()
    try:
        this_pk = signer.unsign(survey_slug)
    except BadSignature:
        raise PermissionDenied("Bad survey opt-out link.")

    try:
        survey_tracker = AlumSurveyTracker.objects.get(pk=this_pk)
    except AlumSurveyTracker.DoesNotExist:
        raise PermissionDenied("Bad survey opt-out link.")

    if survey_tracker.alumni_info != None:
        survey_tracker.alumni_info.survey_opt_out = True
        survey_tracker.alumni_info.save()
    elif survey_tracker.intern_info != None:
        survey_tracker.intern_info.survey_opt_out = True
        survey_tracker.intern_info.save()

    return render(request, 'home/survey_opt_out_confirmation.html') 

# 需要导入模块: from django.core import signing [as 别名]
# 或者: from django.core.signing import BadSignature [as 别名]
def get_object(self):
        # Decode the timestamped data:
        # - the PK of the AlumSurveyTracker
        #
        # If the timestamp is older than 1 month, display an error message.
        #
        # Figure out which model is not null (alumni_info or intern_info) to use.
        # See if we already have an AlumSurvey that points to this survey tracker.
        # If not, create it.
        signer = TimestampSigner()
        try:
            this_pk = signer.unsign(self.kwargs['survey_slug'], max_age=timedelta(days=30))
        except SignatureExpired:
            raise PermissionDenied("The survey link has expired.")
        except BadSignature:
            raise PermissionDenied("Bad survey link.")

        try:
            return AlumSurvey.objects.get(survey_tracker__pk=this_pk)
        except AlumSurvey.DoesNotExist:
            tracker = get_object_or_404(AlumSurveyTracker, pk=this_pk)
            return AlumSurvey(survey_tracker=tracker, survey_date=datetime.now())

    # No need to override get_context because we can get everything from
    # form.instance.survey_tracker 

# 需要导入模块: from django.core import signing [as 别名]
# 或者: from django.core.signing import BadSignature [as 别名]
def check_anti_spam_challange(key: str, answer: str, poll_id: int) -> bool:
    """Checks if the anti spam cheallenge was solved and not expired"""
    try:
        spam_data = signing.loads(key)
        if spam_data.get('type') != 'anti_spam':
            raise ValidationError(_("Error while checking response"))
    except BadSignature:
        raise ValidationError(_("Error while checking response"))
    if spam_data['poll_id'] != poll_id:
        raise ValidationError(_("Error while checking response"))
    if spam_data['time'] <= time.time() - django_settings.ANTI_SPAM_CHALLENGE_TTL:
        raise ValidationError(_("Question Expired, please solve the new question."))
    if answer is None:
        raise ValidationError(_('Field is required'))
    op = spam_data['op']
    x = spam_data['x']
    y = spam_data['y']

    if op == '+':
        return answer == x + y
    if op == '-':
        return answer == x - y
    if op == '*':
        return answer == x * y
    raise ValidationError(_("Error while checking response")) 

# 需要导入模块: from django.core import signing [as 别名]
# 或者: from django.core.signing import BadSignature [as 别名]
def change_email(request, token):
    try:
        data = signing.loads(token, max_age=TOKEN_MAX_AGE)
    except signing.SignatureExpired:
        return TemplateResponse(request, 'registration/token_expired.html')
    except signing.BadSignature:
        return TemplateResponse(request, 'registration/token_invalid.html')
    if request.user.username != data.get('username'):
        return TemplateResponse(request, 'registration/token_invalid.html')
    email = data.get('email')
    try:
        validate_email(email)
    except ValidationError:
        return TemplateResponse(request, 'registration/token_invalid.html')
    request.user.email = email
    request.user.save()

    messages.success(request, _('Your email address has been changed.'))
    return redirect('registration_account') 

# 需要导入模块: from django.core import signing [as 别名]
# 或者: from django.core.signing import BadSignature [as 别名]
def has_elevated_privileges(request):
    """
    Check if a request is allowed to perform Elevate actions
    """
    if getattr(request, '_elevate', None) is None:
        try:
            request._elevate = (
                is_authenticated(request.user) and
                constant_time_compare(
                    request.get_signed_cookie(COOKIE_NAME, salt=COOKIE_SALT, max_age=COOKIE_AGE),
                    request.session[COOKIE_NAME]
                )
            )
        except (KeyError, BadSignature):
            request._elevate = False
    return request._elevate 

# 需要导入模块: from django.core import signing [as 别名]
# 或者: from django.core.signing import BadSignature [as 别名]
def test_decode_detects_tampering(self):
        "loads should raise exception for tampered objects"
        transforms = (
            lambda s: s.upper(),
            lambda s: s + 'a',
            lambda s: 'a' + s[1:],
            lambda s: s.replace(':', ''),
        )
        value = {
            'foo': 'bar',
            'baz': 1,
        }
        encoded = signing.dumps(value)
        self.assertEqual(value, signing.loads(encoded))
        for transform in transforms:
            with self.assertRaises(signing.BadSignature):
                signing.loads(transform(encoded)) 

# 需要导入模块: from django.core import signing [as 别名]
# 或者: from django.core.signing import BadSignature [as 别名]
def verify_signer_or_bad_request(signer):
    try:
        signer.verify()
    except SignatureExpired:
        raise BadRequest(_("Signature expired"))
    except BadSignature:
        raise BadRequest(_("Invalid signature")) 

# 需要导入模块: from django.core import signing [as 别名]
# 或者: from django.core.signing import BadSignature [as 别名]
def test_verify_tamper_email(self):
        signer1 = self.create_signer({
            'email': self.test_email,
        })
        signed_data = signer1.get_signed_data()
        signed_data['email'] = 'a' + signed_data['email']
        signer2 = self.create_signer(signed_data)
        self.assertRaises(BadSignature, signer2.verify) 

# 需要导入模块: from django.core import signing [as 别名]
# 或者: from django.core.signing import BadSignature [as 别名]
def test_verify_missing_singature(self):
        signer1 = self.create_signer({
            'email': self.test_email,
        })
        self.assertRaises(BadSignature, signer1.verify)