fix failbak bug

modify flask demo for new version

Author: Freamerhxl

demo/flask_demo/start.py

@@ -1,43 +1,30 @@
 # coding:utf-8
 from flask import session, make_response, Flask, request, render_template
-from sdk.geetestlib import GeetestLib
-
-id = "a40fd3b0d712165c5d13e6f747e948d4"
-key = "0f1a37e33c9ed10dd2e133fe2ae9c459"
-product = "embed"
-
-# 弹出式
-# product = "popup&popupbtnid=submit-button"
+from geetest import GeetestLib
+captcha_id = "a40fd3b0d712165c5d13e6f747e948d4"
+private_key = "0f1a37e33c9ed10dd2e133fe2ae9c459"
 
 app = Flask(__name__)
 app.config.update(
     DEBUG=True,
-    #SERVER_NAME='127.0.0.1:5000'
 )
 
 @app.route('/getcaptcha', methods=["GET"])
 def get_captcha():
-    gt =  GeetestLib(id, key)
-    if gt.pre_process():
-        res_str = gt.success_pre_process()
-        gt.set_gtserver_session(session.__setitem__, 1, gt.challenge)
-    else:
-        res_str = gt.fail_pre_process()
-        gt.set_gtserver_session(session.__setitem__, 0, gt.challenge)
-    return res_str
+    gt =  GeetestLib(captcha_id, private_key)
+    status, response_str = gt.pre_process()
+    session[gt.GT_STATUS_SESSION_KEY] = status
+    return response_str
 
 @app.route('/validate', methods=["POST"])
 def validate_capthca():
-    challenge = request.form['geetest_challenge']
-    validate = request.form['geetest_validate']
-    seccode = request.form['geetest_seccode']
-    gt = GeetestLib(id,key)
-    gt.challenge = gt.get_gtserver_challenge(session.__getitem__)
-    gt_server_status = gt.get_gtserver_session(session.__getitem__)
-    if gt_server_status == 1:
-        result = gt.post_validate(challenge, validate, seccode)
-    else:
-        result = gt.failback_validate(challenge, validate, seccode)
+    gt = GeetestLib(captcha_id, private_key)
+    status = session[gt.GT_STATUS_SESSION_KEY]
+    challenge = request.form[gt.FN_CHALLENGE]
+    validate = request.form[gt.FN_VALIDATE]
+    seccode = request.form[gt.FN_SECCODE]
+    gt = GeetestLib(captcha_id, private_key)
+    result = gt.validate(status, challenge, validate, seccode)
     return result
 
 @app.route('/')

geetest/geetest.py

@@ -16,6 +16,8 @@ class GeetestLib(object):
     FN_VALIDATE = "geetest_validate" 
     FN_SECCODE = "geetest_seccode" 
 
+    GT_STATUS_SESSION_KEY = "gt_server_status"
+
     SUCCESS_RES = "success" 
     FAIL_RES = "fail" 
 
@@ -24,9 +26,9 @@ class GeetestLib(object):
     VALIDATE_HANDLER = "/validate.php"
 
 
-    def __init__(self, id, key):
-        self.private_key = key                    #私钥
-        self.captcha_id = id                      #公钥
+    def __init__(self, captcha_id, private_key):
+        self.private_key = private_key                    #私钥
+        self.captcha_id = captcha_id                      #公钥
         self.sdk_version = VERSION              #SDK版本
 
     def pre_process(self):
@@ -36,17 +38,18 @@ def pre_process(self):
         :return Boolean:
         """
         status, challenge = self._register()
+        return status, self._make_response_format(status, challenge)
 
     def _register(self):
-        challenge=self._register_challenge()
+        challenge = self._register_challenge()
         if len(challenge) == 32:
             return 1, challenge
         else:
             return 0, self._make_fail_challenge()
 
     def _make_fail_challenge(self):
-        rnd1 = int(round(random.random()*100))
-        rnd2 = int(round(random.random()*100))
+        rnd1 = random.randint(0, 99)
+        rnd2 = random.randint(0, 99)
         md5_str1 = self.md5_encode(str(rnd1))
         md5_str2 = self.md5_encode(str(rnd2))
         challenge = md5_str1 + md5_str2[0:2]
@@ -55,7 +58,7 @@ def _make_fail_challenge(self):
     def _make_response_format(self, success=1, challenge=None):
         if not challenge:
             challenge = self._make_fail_challenge()
-        string_format = json.dumps({'success': success, 'gt':self.captcha_ID ,'challenge': challenge})
+        string_format = json.dumps({'success': success, 'gt':self.captcha_id ,'challenge': challenge})
         return string_format
 
     def _register_challenge(self):
@@ -67,7 +70,7 @@ def _register_challenge(self):
             res_string = ""
         return res_string
 
-    def post_validate(self, status, challenge, validate, seccode):
+    def validate(self, status, challenge, validate, seccode):
         """
         validate二次验证.
 
@@ -131,52 +134,40 @@ def failback_validate(self, challenge, validate, seccode):
         :param seccode:
         :return result:
         """
-        if not self.request_is_legal(challenge, validate, seccode):
-            return self.fail_res
-        validate_str = "".join(validate.split('_'))
+        if not self._check_para(challenge, validate, seccode):
+            return self.FAIL_RES
+        validate_str = validate.split('_')
         encode_ans = validate_str[0]
         encode_fbii = validate_str[1]      #_fbii : Full Bg Img Index
         encode_igi = validate_str[2]
-        decode_ans = self.decode_response(self.challenge, encode_ans)
-        decode_fbii = self.decode_response(self.challenge, encode_fbii)
-        decode_igi = self.decode_response(self.challenge, encode_igi)  #_igi : Img Grp Index
-        validate_result = self.validate_fail_image(decode_ans, decode_fbii, decode_igi)
-        if not validate_result == self.fail_res:
-            rand1 = self.random_num()
-            md5Str = self.md5_encode(rand1 + "")
-            self.challenge = md5Str
+        decode_ans = self.decode_response(challenge, encode_ans)
+        decode_fbii = self.decode_response(challenge, encode_fbii)
+        decode_igi = self.decode_response(challenge, encode_igi)  #_igi : Img Grp Index
+        validate_result = self._validate_fail_image(decode_ans, decode_fbii, decode_igi)
         return validate_result
 
     def _check_para(self, challenge, validate, seccode):
         return bool(challenge.strip()) and bool(validate.strip()) and  bool(seccode.strip())
 
-    def validate_fail_image(self, ans, full_bg_index , img_grp_index):
-        """
-        failback模式下，简单判断轨迹是否通过
-
-        :param ans:
-        :param full_bg_index:
-        :param img_grp_index:
-        :return result:
-        """
+    def _validate_fail_image(self, ans, full_bg_index , img_grp_index):
         thread = 3
         full_bg_name = str(self.md5_encode(str(full_bg_index)))[0:10]
-        bg_name = str(self.md5_encode(str(img_grp_index)))[0:10]
+        bg_name = str(self.md5_encode(str(img_grp_index)))[10:20]
         answer_decode = ""
         for i in range(0,9):
             if i % 2 == 0:
                 answer_decode += full_bg_name[i]
             elif i % 2 == 1:
                 answer_decode += bg_name[i]
-        x_decode = answer_decode[4]
-        x_int = string.atoi(x_decode, 16)
+        x_decode = answer_decode[4:]
+        x_int = int(x_decode, 16)
         result = x_int % 200
         if result < 40:
             result = 40
         if abs(ans - result) < thread:
-            return self.success_res
+            return self.SUCCESS_RES
         else:
-            return self.fail_res
+            return self.FAIL_RES
 
     def md5_encode(self, values):
         """
@@ -196,16 +187,15 @@ def decode_rand_base(self, challenge):
         :param challenge:
         :return decode_result:
         """
-        str_base = challenge[32:34]
+        str_base = challenge[32:]
         i = 0
         temp_array = []
-        while i < len(str_base):
+        for i in xrange(len(str_base)):
             temp_char = str_base[i]
-            temp_Ascii = ord(temp_char)
-            result = temp_Ascii - 87 if temp_Ascii > 57 else temp_Ascii - 48
+            temp_ascii = ord(temp_char)
+            result = temp_ascii - 87 if temp_ascii > 57 else temp_ascii - 48
             temp_array.append(result)
-            i += 1
-        decode_res = temp_array[1]*36 + temp_array[1]
+        decode_res = temp_array[0]*36 + temp_array[1]
         return decode_res
 
     def decode_response(self, challenge, userresponse):
@@ -219,20 +209,21 @@ def decode_response(self, challenge, userresponse):
         if len(userresponse) > 100:
             return 0
         shuzi = (1, 2, 5, 10, 50)
-        chongfu = []
+        chongfu = set()
         key = {}
         count = 0
         for i in challenge:
             if i in chongfu:
                 continue
             else:
                 value = shuzi[count % 5]
-                chongfu.append(i)
+                chongfu.add(i)
                 count += 1
                 key.update({i: value})
         res = 0
         for i in userresponse:
             res += key.get(i, 0)
+        res = res - self.decode_rand_base(challenge)
         return res
 
     def random_num():
@@ -242,11 +233,4 @@ def random_num():
         :return Float:
         """
         rand_num = random.random()*100
-        return rand_num
-
-
-
-
-
-
-
+        return rand_num