เจาะลึกการรับรองความถูกต้อง ตอนที่ 2

ประเภทของการรับรองความถูกต้อง

ยินดีต้อนรับกลับ! ใน บทความ ก่อนหน้านี้ เราได้เจาะลึกโลกแห่งการรับรองความถูกต้องอันน่าทึ่ง เราได้สำรวจวิธีการต่างๆ ที่ใช้กันทั่วไปเพื่อรักษาสถานะการรับรองความถูกต้องในเว็บแอปพลิเคชัน และยังให้ตัวอย่างที่เป็นประโยชน์เกี่ยวกับวิธีการนำไปใช้งานโดยใช้ Python

ตอนนี้เตรียมพร้อมที่จะยกระดับความเข้าใจในการรับรองความถูกต้องของคุณไปอีกระดับในขณะที่เราเจาะลึกการรับรองความถูกต้องประเภทต่างๆ ในบทความนี้ เราจะกล่าวถึงรูปแบบการตรวจสอบสิทธิ์ที่ได้รับความนิยมมากที่สุด ข้อดี ข้อเสีย และเวลาที่ควรใช้

ไม่ว่าคุณจะเป็นนักพัฒนาที่มีประสบการณ์หรือเป็นมือใหม่ในโลกแห่งการพัฒนาเว็บ บทความนี้เป็นสิ่งที่ต้องอ่าน ดังนั้น รัดเข็มขัดแล้วเริ่มกันเลย!

ในบทความนี้ เราจะดำเนินการต่อจากจุดที่เราหยุดไว้และดำเนินการต่อเพื่อเรียนรู้เกี่ยวกับการรับรองความถูกต้องประเภทต่างๆ ข้อดีและข้อเสีย และวิธีการนำไปใช้ในโค้ด

การตรวจสอบสิทธิ์ด้วยรหัสผ่าน

การรับรองความถูกต้องโดยใช้รหัสผ่านเป็นประเภทการรับรองความถูกต้องที่ใช้บ่อยที่สุด เมื่อผู้ใช้ลงทะเบียนแอปพลิเคชัน พวกเขาจะต้องให้ข้อมูลส่วนบุคคลและยังให้ข้อมูลลับเช่นรหัสผ่านหรือ PIN ข้อมูลที่ให้ไว้จะเชื่อมโยงกับตัวระบุที่ไม่ซ้ำ เช่น ที่อยู่อีเมลหรือหมายเลขโทรศัพท์

ข้อมูลลับถูกเข้ารหัสโดยใช้ฟังก์ชันแฮชทางเดียวและเก็บไว้บนเซิร์ฟเวอร์ สิ่งนี้ทำเพื่อให้แน่ใจว่าแม้ว่าเซิร์ฟเวอร์จะถูกบุกรุก แต่ผู้โจมตีก็ไม่สามารถเข้าถึงความลับได้อย่างง่ายดาย เมื่อใดก็ตามที่ผู้ใช้ต้องการตรวจสอบสิทธิ์ ผู้ใช้จะระบุตัวระบุเฉพาะและความลับของตน

บนเซิร์ฟเวอร์ ข้อมูลลับที่ให้มาจะได้รับการตรวจสอบโดยการเปรียบเทียบกับข้อมูลที่เก็บไว้สำหรับตัวระบุเฉพาะที่เกี่ยวข้อง หากข้อมูลลับตรงกัน ผู้ใช้จะได้รับการตรวจสอบสิทธิ์และให้สิทธิ์เข้าถึงทรัพยากรที่ร้องขอ หากข้อมูลลับไม่ตรงกัน เซิร์ฟเวอร์จะส่งคืนการตอบกลับที่ไม่ได้รับอนุญาต โดยปฏิเสธการเข้าถึงของผู้ใช้

มาเจาะลึกถึงวิธีการทำกัน

สำหรับการสาธิตนี้ เราจะสร้างแอปทางการเงินจำลองที่ผู้ใช้สามารถรับเงินฟรีได้ เราจะเพิ่มการตรวจสอบสิทธิ์ด้วยรหัสผ่านให้กับแอปด้วย นี่คือตัวอย่างหน้าแรกของเรา

เริ่มจากเส้นทางการลงทะเบียนของเรา

เส้นทางการลงทะเบียนของเราสามารถรองรับได้สองวิธีคือ "GET" และ "POST" หากลูกค้าส่งคำขอ "GET" เราจะส่งคืนหน้าลงทะเบียน

โปรดทราบว่าพารามิเตอร์ที่ตั้งค่าไว้สำหรับ render_template ช่วยให้ฉันใช้ไฟล์ html เดียวกันซ้ำได้สำหรับทั้งหน้าเข้าสู่ระบบและหน้าลงทะเบียน

หากคำขอเป็นคำขอโพสต์ เราจะแยกอีเมลและรหัสผ่านที่ส่งมา จากนั้นเราจะจัดเก็บข้อมูลไว้ในพจนานุกรม โดยอีเมลที่ให้ไว้จะถูกใช้เป็นรหัสของผู้ใช้

หมายเหตุ: ไม่มีการตรวจสอบความถูกต้องที่นี่ ในการผลิต ข้อมูลที่ส่งมาจะได้รับการตรวจสอบความถูกต้องเพื่อตรวจสอบว่าตรงตามข้อกำหนดเฉพาะหรือไม่ เช่น รหัสผ่านมีความรัดกุมเพียงพอ ข้อมูลผู้ใช้จะถูกจัดเก็บไว้ในฐานข้อมูลด้วย

เราเรียกใช้ฟังก์ชัน login_user ซึ่งตั้งค่าคุกกี้สำหรับเซสชันของผู้ใช้และส่งคืนการตอบสนองการเปลี่ยนเส้นทางเพื่อเปลี่ยนเส้นทางผู้ใช้ไปยังหน้าแรก (เราเคยใช้สิ่งนี้มาก่อนในส่วนที่ 1)

def login_user():
    id = "".join(random.sample(letters, 10))
    resp = make_response(redirect(url_for("home")))
    resp.set_cookie("auth_cookie", id)
    return resp, id

ในเส้นทางดัชนีของเรา เราจะดึงข้อมูลคุกกี้ “auth_cookie” และเรียกใช้ฟังก์ชันดึงข้อมูล_user เพื่อรับผู้ใช้ที่เป็นเจ้าของเซสชันนี้

def retrieve_user(cookie):
    user_email = cookies.get(cookie, "")
    user_details = database.get(user_email, {})
    return user_email, user_details

หากไม่พบผู้ใช้ เราจะเปลี่ยนเส้นทางไคลเอนต์ไปยังหน้าเข้าสู่ระบบ

ตอนนี้เราเสร็จสิ้นขั้นตอนการตรวจสอบสิทธิ์หลักแล้ว เรามาพูดถึงแอปของเรากันดีกว่า

แอปของเรามีฟังก์ชันหลักสองฟังก์ชัน ให้เงินแก่ผู้ใช้และยังอนุญาตให้ผู้ใช้ใช้จ่ายเงินอีกด้วย

ฟังก์ชันธุรกรรมดำเนินตรรกะทางธุรกิจของแอปพลิเคชันของเรา ลูกค้าสามารถส่งคำขอโพสต์ไปยังปลายทางนี้เท่านั้น โดยส่งการดำเนินการที่พวกเขาต้องการดำเนินการซึ่งอาจเป็น "ส่ง" หรือ "เพิ่ม" ก็ได้

โฟกัสที่นี่จะอยู่ที่สี่บรรทัดแรก ก่อนอื่นเราจะดึงค่าของคุกกี้ “auth_token” จากนั้นเราจะส่งต่อไปยังจุดสิ้นสุดผู้ใช้ที่ดึงข้อมูล ซึ่งจะดึงข้อมูลผู้ใช้ที่มีเซสชันเชื่อมโยงกับคุกกี้ที่กำหนด หากไม่มีผู้ใช้ พบว่าเราส่งคืนการตอบกลับที่ไม่ได้รับอนุญาต

เราสามารถแยกสี่บรรทัดแรกเป็นฟังก์ชันแบบสแตนด์อโลน และเพิ่มลงในจุดสิ้นสุดที่ได้รับการป้องกัน เพื่อรับและติดตามผู้ใช้ที่เข้าถึงจุดสิ้นสุด

การตรวจสอบสิทธิ์แบบไร้รหัสผ่าน

การตรวจสอบสิทธิ์โดยใช้รหัสผ่านกำหนดให้ผู้ใช้ต้องระบุความลับระหว่างการลงทะเบียน แต่วิธีนี้มีข้อเสียอย่างมาก ผู้ใช้มักลืมรหัสผ่านของตน และการจัดเก็บไว้อย่างไม่ปลอดภัยอาจทำให้เสี่ยงต่อการละเมิดความปลอดภัยได้ เป็นผลให้แอปพลิเคชันจำนวนมากหันไปใช้วิธีอื่น เช่น การตรวจสอบสิทธิ์แบบไม่ใช้รหัสผ่าน เพื่อเพิ่มความปลอดภัยและปรับปรุงประสบการณ์ผู้ใช้

การตรวจสอบสิทธิ์แบบไม่ใช้รหัสผ่านคืออะไร

การตรวจสอบสิทธิ์แบบไม่ใช้รหัสผ่านเป็นวิธีการตรวจสอบตัวตนของผู้ใช้โดยไม่ต้องใช้รหัสผ่าน มันเป็นทางเลือกแทนวิธีการพิสูจน์ตัวตนด้วยรหัสผ่านแบบดั้งเดิม ซึ่งอาจเสี่ยงต่อภัยคุกคามความปลอดภัย เช่น การแฮ็ก ฟิชชิ่ง และการโจมตีแบบดุร้าย แทนที่จะใช้รหัสผ่าน จะใช้วิธีอื่นในการตรวจสอบตัวตนของผู้ใช้ เช่น การรับรองความถูกต้องด้วยชีวมาตร (เช่น ลายนิ้วมือหรือการจดจำใบหน้า) คีย์การเข้ารหัส หรือรหัสผ่านแบบใช้ครั้งเดียว (OTP) ที่ส่งทางอีเมลหรือ SMS

ขั้นตอนการตรวจสอบสิทธิ์แบบไร้รหัสผ่านด้วย OTP

1. ผู้ใช้ระบุที่อยู่อีเมลของตนในระหว่างขั้นตอนการลงทะเบียน
2. เซิร์ฟเวอร์สร้างโทเค็นที่ไม่ซ้ำกันและส่งไปยังที่อยู่อีเมลที่ให้ไว้
3. ผู้ใช้ได้รับโทเค็นทางอีเมลและคลิกที่ลิงก์การยืนยัน เพื่อเปลี่ยนเส้นทางไปยังหน้าการยืนยัน
4. ผู้ใช้ป้อนรหัสที่ส่งไปยังที่อยู่อีเมลของพวกเขาในหน้าการยืนยัน
5. เซิร์ฟเวอร์ตรวจสอบรหัสที่ป้อนโดยผู้ใช้และให้สิทธิ์การเข้าถึงหากรหัสถูกต้อง .
6. ในการเข้าสู่ระบบครั้งต่อไป ผู้ใช้จะต้องระบุที่อยู่อีเมลของตนเพื่อเข้าสู่ระบบโดยไม่ต้องใช้รหัสผ่าน

เราจะแก้ไขขั้นตอนการตรวจสอบสิทธิ์สำหรับแอปทางการเงินของเราให้ใช้การตรวจสอบสิทธิ์แบบไม่ใช้รหัสผ่าน

@app.route("/register", methods=["POST", "GET"])
def register():
    if request.method == "GET":
        return render_template(
            "login.html",
            page="Registration Form",
            action="Register",
            alt="Already have an account",
            alt_text="Login",
            alt_route="/login",
        )

    email = request.form.get("email")
    resp = send_otp(mail, email)
    return resp

นี่คือจุดสิ้นสุดการลงทะเบียนที่แก้ไขซึ่งจะดึงที่อยู่อีเมลที่ลูกค้าส่งมาและเรียกใช้ฟังก์ชัน send_otp เพื่อสร้างและส่งรหัสผ่านครั้งเดียว (OTP) ที่ไม่ซ้ำกันไปยังที่อยู่อีเมลที่ให้ไว้:

def send_otp(mail, email):
    token = "".join(random.sample(letters, 5))
    msg = Message("Login Token", sender=email_address, recipients=[email])
    msg.body = f"Your login token is {token}"
    print(msg.body)

    tokens[token] = email
    mail.send(msg)
    resp = make_response(redirect(url_for("verify_otp")))
    return resp

ฟังก์ชัน send_otp จะสร้างโทเค็นแบบสุ่มให้กับผู้ใช้ บันทึกโทเค็น และส่งโทเค็นที่สร้างขึ้นไปยังที่อยู่อีเมลของผู้ใช้ นอกจากนี้เรายังเปลี่ยนเส้นทางผู้ใช้ไปยังหน้า Verify_otp เพื่อให้พวกเขาสามารถป้อน OTP ของตนได้

@app.route("/verify_otp", methods=["POST", "GET"])
def verify_otp():
    if request.method == "GET":
        return render_template(
            "login.html",
            page="Verify OTP",
            action="Verify",
            alt="Don't have an account",
            alt_text="Register",
            alt_route="/register",
        )
    otp = request.form.get("otp")

    if not otp:
        flash("OTP not provided")
        return redirect(url_for("verify_otp"))

    email = tokens.get(otp)

    if not email:
        flash("Invalid OTP provided")
        return redirect(url_for("verify_otp"))

    resp, id = login_user()
    cookies[id] = email

    if not database.get(email):
        database[email] = {"balance": 400}
    return resp

นี่คือหัวใจหลักของขั้นตอนการตรวจสอบสิทธิ์แบบไม่ใช้รหัสผ่านของเรา เมื่อผู้ใช้ส่งคำขอ POST ไปยังตำแหน่งข้อมูลนี้ เราจะแยก OTP ที่พวกเขาให้มา เพื่อตรวจสอบว่ามีอยู่และถูกต้อง จากนั้นเราจะดึงที่อยู่อีเมลที่เกี่ยวข้อง เข้าสู่ระบบของผู้ใช้ และหากยังไม่มีผู้ใช้ เราจะสร้างบัญชีของพวกเขา

การรับรองความถูกต้องเป็นส่วนสำคัญในการสร้างเว็บแอปพลิเคชัน ในบทความนี้ เราได้สำรวจขั้นตอนการตรวจสอบสิทธิ์ขั้นพื้นฐานสำหรับการตรวจสอบสิทธิ์ทั้งแบบใช้รหัสผ่านและแบบไม่ใช้รหัสผ่าน

สำหรับการตรวจสอบสิทธิ์โดยใช้รหัสผ่าน เราเริ่มต้นด้วยการที่ผู้ใช้ระบุอีเมลและรหัสผ่านของตน สำหรับการรับรองความถูกต้อง เราจะตรวจสอบว่ารหัสผ่านที่ให้มาตรงกับรหัสผ่านที่เก็บไว้ในฐานข้อมูลหรือไม่ หากเป็นเช่นนั้น เราจะเข้าสู่ระบบผู้ใช้ มิฉะนั้น เราจะส่งคืนข้อความแสดงข้อผิดพลาด

สำหรับการตรวจสอบสิทธิ์แบบไม่ใช้รหัสผ่าน เราได้ลงทะเบียนผู้ใช้ด้วยที่อยู่อีเมลของพวกเขา และส่งรหัสผ่านแบบใช้ครั้งเดียว (OTP) ที่ไม่ซ้ำกันไปยังอีเมลของพวกเขา จากนั้นผู้ใช้ป้อน OTP บนหน้าการยืนยันเพื่อเข้าถึง ในการเข้าสู่ระบบครั้งต่อไป ผู้ใช้จำเป็นต้องระบุที่อยู่อีเมลของตนเท่านั้น และสามารถเข้าสู่ระบบได้โดยไม่ต้องใช้รหัสผ่าน

แม้ว่าตัวอย่างที่ให้ไว้นี้จะตรงไปตรงมา แต่การสร้างระบบการตรวจสอบสิทธิ์ระดับการใช้งานจริงจำเป็นต้องมีมาตรการเพิ่มเติม เราต้องตรวจสอบอินพุตของผู้ใช้อย่างละเอียด รวบรวมข้อมูลเพิ่มเติมเกี่ยวกับผู้ใช้ จัดเก็บข้อมูลที่รวบรวมไว้ในฐานข้อมูลที่ปลอดภัย และจัดให้มีการตรวจสอบความปลอดภัยเพิ่มเติม เช่น การป้องกัน Cross-Site Request Forgery (CSRF) สำหรับการตรวจสอบสิทธิ์แบบไม่ใช้รหัสผ่าน

ในบทความที่กำลังจะมาถึง เตรียมพร้อมที่จะดำดิ่งลงสู่โลกแห่งการรับรองความถูกต้องอันน่าทึ่ง ขณะที่เราสำรวจวิธีการใช้การรับรองความถูกต้องแบบหลายปัจจัยและเจาะลึกการทำงานของ Single Sign On (SSO) เราจะไม่เพียงแต่เรียนรู้วิธีการทำงาน แต่ยังค้นพบวิธีการใช้ SSO ของเราเองกับนักเทียบท่าอีกด้วย

อย่าพลาดบทความถัดไปของฉัน! ติดตามบัญชีสื่อของฉันเพื่อติดตามเนื้อหาล่าสุดของฉัน