Tôi đang thực hiện một số nghiên cứu về việc tìm một ví dụ hay về trình kiểm tra Độ mạnh mật khẩu sử dụng JavaScript và Biểu thức chính quy [Regex]. Trong ứng dụng tại nơi làm việc của tôi, chúng tôi đăng lại để xác minh độ mạnh của mật khẩu và nó khá bất tiện cho người dùng của chúng tôi
Một bản hack đơn giản để lấp đầy kênh của bạn w
Vui lòng bật JavaScript
Một mẹo đơn giản để lấp đầy kênh của bạn với các triển vọng đủ điều kiện trên LinkedInRegex là gì?
Biểu thức chính quy là một chuỗi các ký tự xác định mẫu tìm kiếm. Thông thường, các mẫu như vậy được sử dụng bởi các thuật toán tìm kiếm chuỗi để tìm hoặc tìm và thay thế các hoạt động trên chuỗi hoặc để xác thực đầu vào.
Bài viết này chắc chắn không phải để dạy bạn các biểu thức chính quy. Chỉ cần biết rằng khả năng sử dụng Biểu thức chính quy sẽ đơn giản hóa hoàn toàn quá trình phát triển của bạn khi bạn tìm kiếm các mẫu trong văn bản. Cũng cần lưu ý rằng hầu hết các ngôn ngữ phát triển đã tối ưu hóa việc sử dụng biểu thức chính quy… vì vậy thay vì phân tích cú pháp và tìm kiếm chuỗi từng bước, Regex thường nhanh hơn nhiều cả phía máy chủ và phía máy khách
Tôi đã tìm kiếm khá nhiều trên web trước khi tìm thấy ví dụ về một số Biểu thức chính quy tuyệt vời tìm kiếm sự kết hợp giữa độ dài, ký tự và ký hiệu. Tuy nhiên, mã hơi quá so với sở thích của tôi và phù hợp với. BỌC LƯỚI. Vì vậy, tôi đã đơn giản hóa mã và đưa nó vào JavaScript. Điều này làm cho nó xác thực độ mạnh của mật khẩu trong thời gian thực trên trình duyệt của khách hàng trước khi đăng lại… và cung cấp một số phản hồi cho người dùng về độ mạnh của mật khẩu
Gõ mật khẩu
Với mỗi lần gõ bàn phím, mật khẩu được kiểm tra dựa trên biểu thức chính quy và sau đó phản hồi được cung cấp cho người dùng trong một khoảng bên dưới nó
Nhập mật khẩu.Đây là Mã
Biểu thức chính quy thực hiện công việc tuyệt vời là giảm thiểu độ dài của mã. Chức năng Javascript này kiểm tra độ mạnh của mật khẩu và xem việc phá mật khẩu dễ, trung bình, khó hay cực kỳ khó đoán. Khi người đó nhập, nó sẽ hiển thị các mẹo để khuyến khích nó mạnh hơn. Nó xác nhận mật khẩu dựa trên
- Độ dài – Nếu độ dài dưới hoặc trên 8 ký tự
- Trường hợp hỗn hợp – Nếu mật khẩu có cả ký tự chữ hoa và chữ thường
- Số – Nếu mật khẩu bao gồm số
- Ký tự đặc biệt – Nếu mật khẩu bao gồm các ký tự đặc biệt
Chức năng hiển thị độ khó cũng như một số mẹo tăng độ khó cho mật khẩu
function checkPasswordStrength[password] {
// Initialize variables
var strength = 0;
var tips = "";
// Check password length
if [password.length < 8] {
tips += "Make the password longer. ";
} else {
strength += 1;
}
// Check for mixed case
if [password.match[/[a-z]/] && password.match[/[A-Z]/]] {
strength += 1;
} else {
tips += "Use both lowercase and uppercase letters. ";
}
// Check for numbers
if [password.match[/\d/]] {
strength += 1;
} else {
tips += "Include at least one number. ";
}
// Check for special characters
if [password.match[/[^a-zA-Z\d]/]] {
strength += 1;
} else {
tips += "Include at least one special character. ";
}
// Return results
if [strength < 2] {
return "Easy to guess. " + tips;
} else if [strength === 2] {
return "Medium difficulty. " + tips;
} else if [strength === 3] {
return "Difficult. " + tips;
} else {
return "Extremely difficult. " + tips;
}
}Làm cứng yêu cầu mật khẩu của bạn
Điều cần thiết là bạn không chỉ xác thực cấu trúc mật khẩu trong Javascript của mình. Điều này sẽ cho phép bất kỳ ai có công cụ phát triển trình duyệt bỏ qua tập lệnh và sử dụng bất kỳ mật khẩu nào họ muốn. Bạn LUÔN LUÔN sử dụng kiểm tra phía máy chủ để xác thực độ mạnh của mật khẩu trước khi lưu trữ mật khẩu trong nền tảng của mình
Xác thực độ mạnh của mật khẩu là một bước quan trọng để đảm bảo tính bảo mật của tài khoản người dùng. Một cách để làm điều này là sử dụng biểu thức chính quy [regex] và JavaScript
Để bắt đầu, hãy xác định ý nghĩa của mật khẩu mạnh. Mật khẩu mạnh thường là mật khẩu mà người khác khó đoán hoặc bẻ khóa. Điều này có thể đạt được bằng cách sử dụng kết hợp chữ hoa và chữ thường, số và ký tự đặc biệt và có độ dài tối thiểu ít nhất là 8 ký tự
Bây giờ hãy xem cách chúng ta có thể sử dụng regex và JavaScript để xác thực độ mạnh của mật khẩu
Trước tiên, chúng ta có thể sử dụng mẫu biểu thức chính quy để kiểm tra xem mật khẩu có đáp ứng yêu cầu về độ dài tối thiểu và chứa ít nhất
/^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/
/^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/
/^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/
/^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/
/^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/
Vào chế độ toàn màn hình Thoát chế độ toàn màn hình
Tiếp theo, chúng ta có thể sử dụng JavaScript để kiểm tra xem mật khẩu mà người dùng đã nhập có khớp với mẫu biểu thức chính quy này không. Chúng ta có thể làm điều này bằng cách sử dụng phương thức
/^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/
/^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/
let regex = /^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/;
let password = "P@ssw0rd";
let result = regex.test[password];
Vào chế độ toàn màn hình Thoát chế độ toàn màn hình
1-
0. Điều này đánh dấu sự bắt đầu và kết thúc của mẫu biểu thức chính quylet regex = /^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/; let password = "P@ssw0rd"; let result = regex.test[password];2-
1. Điều này chỉ định rằng mẫu sẽ bắt đầu ở đầu chuỗilet regex = /^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/; let password = "P@ssw0rd"; let result = regex.test[password];3-
0. Đây là một xác nhận nhìn trước tích cực để kiểm tra sự hiện diện của ít nhất một chữ cái viết thường.let regex = /^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/; let password = "P@ssw0rd"; let result = regex.test[password];1 có nghĩa là khớp với bất kỳ ký tự nào [ngoại trừ một dòng mới] 0 hoặc nhiều lần hơn vàlet regex = /^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/; let password = "P@ssw0rd"; let result = regex.test[password];2 có nghĩa là khớp với bất kỳ chữ cái viết thường nào. Xác nhận nhìn trước tích cực kiểm tra sự hiện diện của mẫu này, nhưng không sử dụng nó như một phần của đối sánhlet regex = /^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/; let password = "P@ssw0rd"; let result = regex.test[password];4-
3. Đây là một xác nhận nhìn trước tích cực để kiểm tra sự hiện diện của ít nhất một chữ cái viết hoa.let regex = /^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/; let password = "P@ssw0rd"; let result = regex.test[password];1 có nghĩa là khớp với bất kỳ ký tự nào [ngoại trừ một dòng mới] 0 hoặc nhiều lần hơn vàlet regex = /^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/; let password = "P@ssw0rd"; let result = regex.test[password];5 có nghĩa là khớp với bất kỳ chữ cái viết hoa nào. Xác nhận nhìn trước tích cực kiểm tra sự hiện diện của mẫu này, nhưng không sử dụng nó như một phần của đối sánhlet regex = /^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/; let password = "P@ssw0rd"; let result = regex.test[password];5-
6. Đây là một xác nhận nhìn trước tích cực để kiểm tra sự hiện diện của ít nhất một chữ số.let regex = /^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/; let password = "P@ssw0rd"; let result = regex.test[password];1 có nghĩa là khớp với bất kỳ ký tự nào [ngoại trừ một dòng mới] 0 hoặc nhiều lần vàlet regex = /^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/; let password = "P@ssw0rd"; let result = regex.test[password];8 có nghĩa là khớp với bất kỳ chữ số nào [0-9]. Xác nhận nhìn trước tích cực kiểm tra sự hiện diện của mẫu này, nhưng không sử dụng nó như một phần của đối sánhlet regex = /^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/; let password = "P@ssw0rd"; let result = regex.test[password];6-
9. Đây là một xác nhận nhìn trước tích cực để kiểm tra sự hiện diện của ít nhất một ký tự đặc biệt.let regex = /^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/; let password = "P@ssw0rd"; let result = regex.test[password];1 có nghĩa là khớp với bất kỳ ký tự nào [ngoại trừ một dòng mới] 0 hoặc nhiều lần hơn vàlet regex = /^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/; let password = "P@ssw0rd"; let result = regex.test[password];41 có nghĩa là khớp với bất kỳ ký tự đặc biệt nào được liệt kê. Xác nhận nhìn trước tích cực kiểm tra sự hiện diện của mẫu này, nhưng không sử dụng nó như một phần của đối sánh/^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/7-
42. Bộ ký tự này khớp với bất kỳ chữ hoa, chữ thường, chữ số hoặc ký tự đặc biệt nào được liệt kê. Nó được sử dụng để chỉ định các ký tự có thể khớp với nhau như một phần của mật khẩu/^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/8-
43. Điều này chỉ định rằng bộ ký tự trước đó phải được khớp 8 lần trở lên. Điều này thực thi yêu cầu độ dài tối thiểu cho mật khẩu/^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/9-
44. Điều này chỉ định rằng mẫu sẽ kết thúc ở cuối chuỗi/^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/
Trong ví dụ này, phương thức
/^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/
/^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/
/^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/
Sau đó, chúng tôi có thể sử dụng giá trị
/^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/
/^[?=.*[a-z]][?=.*[A-Z]][?=.*\d][?=.*[@$!%*?&]][A-Za-z\d@$!%*?&]{8,}$/
Bạn cũng nên xem xét thêm các kiểm tra xác thực độ mạnh mật khẩu bổ sung ngoài biểu thức chính quy. Ví dụ: bạn có thể kiểm tra xem mật khẩu có phải là mật khẩu thường được sử dụng hay mật khẩu không chứa tên hoặc địa chỉ email của người dùng
Bằng cách sử dụng regex và JavaScript để xác thực độ mạnh của mật khẩu, chúng tôi có thể giúp đảm bảo tính bảo mật của tài khoản người dùng và bảo vệ chống lại các cuộc tấn công bẻ khóa mật khẩu
Ghi chú. Xem xét các quy tắc của trình quản lý mật khẩu của bạn khi triển khai xác thực độ mạnh của mật khẩu. Các hạn chế về số và ký tự đặc biệt có thể xung đột với một số trình quản lý mật khẩu nhất định và gây ra sự cố khi lưu và sử dụng mật khẩu. Căn chỉnh tiêu chí xác thực độ mạnh mật khẩu của bạn với quy tắc của trình quản lý mật khẩu để có trải nghiệm liền mạch
Tôi hy vọng hướng dẫn này hữu ích trong việc chỉ cho bạn cách xác thực độ mạnh của mật khẩu bằng regex và JavaScript. Tôi đã cố gắng hết sức để đưa ra một mẫu biểu thức chính quy đáp ứng các yêu cầu về mật khẩu mạnh, nhưng nếu bạn nhận thấy bất kỳ lỗi nào hoặc có đề xuất về một mẫu tốt hơn, vui lòng để lại nhận xét bên dưới. Phản hồi của bạn luôn được chào đón và đánh giá cao