1659800280
Authentication is the process of confirming a user’s or process’s identity. When authentication is breached, attackers can gain access to the user’s data or information, causing damage to your application. Authentication is one of the ways attackers can gain access to a user’s data and your application.
When it comes to authentication, these are the eleven common mistakes to avoid:
See more at: https://blog.openreplay.com/
1659789360
Безопасность аутентификации — важный аспект разработки веб-приложений, который часто упускается из виду при создании продукта. Однако, если вы собираетесь подать заявку онлайн, это является главным приоритетом. В этой статье я объясню некоторые из этих ошибок и как их исправить. Обратите внимание, что это не основные проблемы безопасности, которые рекомендует OWASP ; вместо этого это легко устраняемые проблемы, которые я часто вижу.
Аутентификация — это процесс подтверждения личности пользователя или процесса. При нарушении аутентификации злоумышленники могут получить доступ к данным или информации пользователя, нанеся ущерб вашему приложению. Аутентификация — это один из способов, которым злоумышленники могут получить доступ к данным пользователя и вашему приложению.
Когда дело доходит до аутентификации, вот одиннадцать распространенных ошибок, которых следует избегать:
Отображение определенного сообщения об ошибке опасно, потому что это может позволить злоумышленнику использовать автоматизированный метод проб и ошибок для определения имени пользователя или пароля пользователя.
Вот пример схемы отображения определенного сообщения об ошибке.
При аутентификации формы в вашем веб-приложении вы должны быть осторожны, чтобы не отображать только одно сообщение об ошибке, когда пользователь вводит неверные данные, например «Ваш пароль неверен». Если вы покажете такое конкретное сообщение об ошибке, злоумышленник поймет, что адрес электронной почты или идентификатор пользователя реальны, но пароль неверный. Это позволит злоумышленнику предложить пароль для этого пользователя.
Как исправить этот недостаток
Идентификатор сеанса — это число, которое сервер веб-сайта присваивает одному пользователю на время посещения этого пользователя. Вероятность того, что злоумышленник получит токен сеанса и злоупотребит им, увеличивается, если он размещен непосредственно в URL-адресе. Хотя риск при использовании HTTPS для подключения к веб-серверу ниже, опасность все же существует. Несмотря на то, что URL-адреса HTTPS шифруются при передаче, они часто сохраняются в журналах сервера.
Вот пример схемы интеграции идентификаторов сеансов в URL-адреса.
Как исправить этот недостаток
Атаки с внедрением, утечки памяти и скомпрометированные системы могут произойти, если данные, предоставленные во входных данных формы, не проверены или не отформатированы должным образом. Пользователи часто отправляют, не заполнив всю необходимую информацию, поэтому необходимо проверить вашу форму, чтобы убедиться, что вся необходимая информация была соблюдена, прежде чем отправлять ее на сервер.
Как исправить этот недостаток
Некоторые из предлагаемых библиотек, которые я рекомендую для проверки формы:
Все перечисленные библиотеки хороши для проверки вашей формы.
Процесс поддержания чистоты, фильтрации и очистки ввода формы от вредоносного агента называется очисткой формы. Дезинфекция вашего ввода является обязательной, потому что она предотвращает ошибки инъекций. Хорошо продезинфицированная форма ввода может предотвратить следующие атаки:
Межсайтовый скриптинг (XSS): это тип уязвимости системы безопасности, который часто встречается в веб-приложениях. Эта уязвимость позволяет злоумышленникам вставлять клиентские скрипты в просматриваемые пользователями веб-страницы. Эта атака может нанести значительный ущерб безопасности пользователя, например перенаправить его на вредоносный веб-сайт, заставить его загрузить вредоносное приложение и украсть данные пользователя.
Внедрение SQL: Злоумышленники могут вмешиваться в данные, отправленные в его базу данных через ввод формы.
Дезинфицируя ввод формы, вы должны защитить свой код и данные пользователя от этого вредоносного агента и всех перечисленных уязвимостей. Я лично использую DOM Purify , библиотеку очистки для HTML и строк, и она может фильтровать все, что содержит грязный HTML, и предотвращать атаки XSS.
Как исправить этот недостаток
Нередко можно встретить веб-сайт, на котором нет надежного плана паролей. Недавно я попробовал приложение, которое требовало минимальной длины пароля из пяти символов. Поскольку разработчики пытаются найти правильный баланс между безопасностью и удобством использования, этот недостаток становится все более распространенным. При работе с паролями убедитесь, что пароль, который вы предлагаете пользователю, или пароль, который создает пользователь, представляет собой смесь символов, цифр и букв смешанного регистра. Избегайте слабых планов паролей.
Как исправить этот недостаток
Еще одна распространенная ошибка, которую я вижу в механизмах веб-аутентификации, заключается в том, что они не имеют никаких дополнительных мер безопасности. Двухфакторная аутентификация редко используется разработчиками, особенно для топовых аккаунтов. Двухфакторная аутентификация помогает добавить второй уровень защиты к вашему приложению. Двухфакторная аутентификация имеет решающее значение для веб-безопасности, поскольку она сразу устраняет опасность скомпрометированных учетных данных. Когда пароль взломан, угадан или даже заражен вредоносным ПО, уже недостаточно предоставить доступ злоумышленнику без одобрения на втором факторе аутентификации.
Двухфакторная аутентификация — это дополнительный уровень безопасности, добавляемый к странице аутентификации. Примерами этой двухфакторной аутентификации являются SMS, электронная почта и OTP.
Вот пример схемы двухфакторной аутентификации
Как реализовать двухфакторную аутентификацию
Существует множество способов использования шифрования 2FA. Токены RSA, генераторы кодов, такие как Google Authenticator и Duo, и отправка SMS-сообщений с одноразовыми кодами — все это варианты реализации технологии 2FA.
Это не так часто, но время от времени я вижу веб-приложение, в котором эта возможность реализована неправильно. Часто это происходит из-за того, что пароль пользователя был отправлен ему по электронной почте, или токен, использованный для сброса пароля, был недостаточно надежным. Отправка открытого текста пароля обратно конечному пользователю — еще одна проблема, влияющая на сброс пароля. Это ужасно по разным причинам, одна из которых заключается в том, что пароль был отправлен по электронной почте, что считается небезопасным. Это может означать, что пароль был сохранен в базе данных без достаточного хеширования или в формате, который можно было бы изменить, например base64.
Хэширование — это метод, используемый для проверки или подтверждения качества различных видов входных данных. В системах аутентификации он в основном используется для предотвращения хранения незашифрованных паролей, а хэширование делает невероятно сложным для злоумышленников расшифровку сохраненных паролей.
Base64: Base64 — это метод преобразования двоичных данных в текст. Этот метод часто используется для отправки информации на основе контента через Интернет.
Как исправить этот недостаток
Это еще одна уязвимость, которая может серьезно повредить приложение. Также важно предоставить вашим пользователям безопасный способ выхода из системы, чтобы их сеансы не могли быть перехвачены. Если вы сохраняете идентификатор сеанса на стороне сервера, метод выхода из системы должен сделать его недействительным и стереть файл cookie сеанса в браузере. Это не позволяет злоумышленникам украсть файлы cookie сеанса, а затем использовать их для запуска нового сеанса.
Как исправить этот недостаток
Брутфорс — это метод взлома, используемый для получения учетных данных пользователя путем перебора различных возможных учетных данных. В этой атаке хакеры пытаются угадать пароли, чтобы пройти аутентификацию для одной учетной записи. Используя сценарии, которые пробуют многие часто используемые пароли из словаря и миллионы утекших паролей из предыдущих утечек данных, эти попытки имеют больше шансов на успех.
Как исправить этот недостаток
Контрольный вопрос или запоминающееся слово также могут помочь в защите от автоматизированных атак. Я столкнулся с ненадежными секретными вопросами, ответы на которые предсказуемы, что позволяет злоумышленнику предлагать или угадывать ответы и получать доступ к данным пользователя.
Вот некоторые из популярных вопросов безопасности, с которыми я столкнулся:
Избегайте всех этих вопросов, потому что хакеры могут угадать их из-за некоторой нашей информации в нашем Google или других онлайн-профилях.
Как исправить этот недостаток
Еще одна ошибка, которую я видел у разработчиков, когда дело доходит до аутентификации, — это «неспособность защитить маршрут». Крайне важно защитить определенные маршруты в вашем приложении от пользователей, не прошедших проверку подлинности, так как это предотвратит доступ неизвестных пользователей к некоторым личным данным вашего приложения.
Как исправить этот недостаток
При внедрении аутентификации на своем веб-сайте вы как разработчик должны проявлять крайнюю осторожность, поскольку некоторые методы могут нанести серьезный ущерб вашей программе и дать злоумышленникам возможность захватить контроль над данными пользователей и приложением. Надеюсь, в этой статье были выделены такие ошибки и даны советы по их устранению.
Ссылка: https://blog.openreplay.com/11-authentication-mistakes-and-how-to-fix-them
#authentication
1659778500
身份驗證安全性是 Web 應用程序開發的一個重要方面,在創建產品時經常被忽視。但是,如果您打算在線提交申請,這是當務之急。在本文中,我將解釋其中一些錯誤以及如何修復它們。請注意,這些不是OWASP推薦的主要安全問題;相反,它們是我經常看到的易於修復的問題。
身份驗證是確認用戶或進程身份的過程。當身份驗證被破壞時,攻擊者可以訪問用戶的數據或信息,從而對您的應用程序造成損害。身份驗證是攻擊者可以訪問用戶數據和您的應用程序的方式之一。
在進行身份驗證時,以下是要避免的 11 個常見錯誤:
顯示特定錯誤消息是危險的,因為它可能讓攻擊者使用自動試錯法來確定用戶的用戶名或密碼。
這是顯示特定錯誤消息的圖表示例。
在您的 Web 應用程序上驗證表單時,您必須注意不要在用戶鍵入不正確的詳細信息時只顯示一條錯誤消息——例如“您的密碼不正確”。如果您顯示這樣的特定錯誤消息,攻擊者將意識到電子郵件地址或用戶 ID 是真實的,但密碼是錯誤的。這將使攻擊者建議該用戶的密碼。
如何修復這個缺陷
會話 ID 是網站服務器在該用戶訪問期間向單個用戶提供的數字。如果將會話令牌直接放在 URL 中,則攻擊者獲取和濫用會話令牌的機會會增加。雖然使用 HTTPS 連接 Web 服務器的風險較低,但仍然存在危險。即使 HTTPS URL 在傳輸過程中被加密,它們也經常保存在服務器日誌中。
這是將會話 ID 集成到 URL 中的圖表示例。
如何修復這個缺陷
如果表單輸入中提供的數據未正確檢查或格式化,則可能發生注入攻擊、內存洩漏和系統受損。用戶通常在提交時沒有填寫所有需要的信息,因此有必要驗證您的表單以確保在將其提交到服務器之前已滿足所有必需的信息。
如何修復這個缺陷
我推薦的一些用於表單驗證的建議庫是:
所有列出的庫都適用於驗證您的表單。
保持表單輸入乾淨、過濾和清除惡意代理的過程稱為表單清除。清理您的輸入是必須的,因為它可以防止注入缺陷。經過良好清理的輸入表單可以防止以下攻擊:
跨站腳本 (XSS):這是一種常見於 Web 應用程序中的安全漏洞。此漏洞允許攻擊者將客戶端腳本插入用戶查看的網頁中。這種攻擊會對用戶造成很大的安全危害,例如將用戶重定向到惡意網站、強制用戶下載惡意應用程序以及竊取用戶數據。
SQL 注入:攻擊者可以通過表單輸入乾擾發送到其數據庫的數據。
通過清理表單輸入,您必須保護您的代碼和用戶數據免受此惡意代理和所有列出的漏洞的影響。我個人使用DOM Purify,這是一個用於 HTML 和字符串的淨化庫,它可以過濾任何包含臟 HTML 並防止 XSS 攻擊的內容。
如何修復這個缺陷
遇到沒有按順序設置強密碼計劃的網站並不罕見。我最近嘗試了一個需要五個字符的最小密碼長度的應用程序。隨著開發人員試圖在安全性和可用性之間找到適當的平衡,這個缺陷變得越來越普遍。使用密碼時,請確保您向用戶建議的密碼或用戶創建的密碼是符號、數字和大小寫混合字母的混合。避免使用弱密碼計劃。
如何修復這個缺陷
我看到的 Web 身份驗證機制的另一個常見錯誤是它們沒有任何額外的安全措施。開發人員很少使用雙因素身份驗證,尤其是對於頂級帳戶。雙因素身份驗證有助於為您的應用程序添加第二層保護。雙重身份驗證對於 Web 安全至關重要,因為它可以立即消除憑據洩露的危害。當密碼被破解、猜到,甚至被惡意軟件感染時,在沒有第二個身份驗證因素批准的情況下授予入侵者訪問權限已不再足夠。
雙因素身份驗證是添加到身份驗證頁面的額外安全層。這種雙因素身份驗證的示例是 SMS、電子郵件和 OTP。
這是兩因素身份驗證的圖表示例
如何實現雙重身份驗證
有多種方法可以使用 2FA 加密。RSA 令牌、Google Authenticator 和 Duo 等代碼生成器以及一次性代碼的 SMS 文本發送都是實施 2FA 技術的選項。
這種情況並不常見,但時不時地,我會看到一個 Web 應用程序錯誤地實現了此功能。這通常是因為用戶的密碼是通過電子郵件發送給他們的,或者用於重置密碼的令牌不夠強。將明文密碼發送回最終用戶是影響密碼重置的另一個問題。這很糟糕,原因有很多,其中之一是密碼是通過電子郵件發送的,這被認為是不安全的。這可能意味著密碼存儲在數據庫中沒有足夠的散列或可以反轉的格式,如 base64。
散列 是一種用於驗證或驗證各種輸入質量的技術。在身份驗證系統中,它主要用於防止存儲明文密碼,而哈希使攻擊者難以破譯已存儲的密碼。
Base64: Base64 是一種將二進制數據轉換為文本的方法。該方法經常用於通過 Internet 發送基於內容的信息。
如何修復這個缺陷
這是另一個可能對應用程序造成嚴重破壞的漏洞。為您的用戶提供一種安全的註銷方式也很重要,這樣他們的會話就不會被接管。如果您將會話標識符存儲在服務器端,則註銷方法應使其無效並清除瀏覽器中的會話 cookie。這使攻擊者無法竊取會話 cookie,然後使用它們來啟動新會話。
如何修復這個缺陷
蠻力是一種黑客技術,用於通過嘗試各種可能的憑據來找出用戶的憑據。在這種攻擊中,黑客試圖猜測密碼以通過單個帳戶的身份驗證。使用從字典中嘗試許多常用密碼的腳本以及從以前的數據洩露中洩露的數百萬個密碼,這些嘗試更有可能成功。
如何修復這個缺陷
安全問題或令人難忘的單詞也可以幫助防範自動攻擊。我遇到過具有可預測響應的弱安全問題,允許攻擊者建議或猜測答案並獲得對用戶數據的訪問權限。
以下是我遇到的一些流行的安全問題:
避免所有這些問題,因為黑客可以通過我們在 Google 或其他在線個人資料中的一些信息來猜測它們。
如何修復這個缺陷
我看到開發人員在身份驗證方面犯的另一個錯誤是“未能保護路由”。確保應用程序中的特定路由免受未經身份驗證的用戶的訪問至關重要,因為這將防止未知用戶訪問您應用程序的某些私有數據。
如何修復這個缺陷
在您的網站上實施身份驗證時,作為開發人員,您必須格外小心,因為某些方法可能會對您的程序造成極大的破壞,並為攻擊者奪取用戶數據和應用程序的控制權打開了大門。希望本文突出了此類錯誤並提供了有關如何修復它們的建議。
鏈接:https ://blog.openreplay.com/11-authentication-mistakes-and-how-to-fix-them
#authentication
1659767568
Bảo mật xác thực là một khía cạnh thiết yếu của phát triển ứng dụng web thường bị bỏ qua trong khi tạo sản phẩm. Tuy nhiên, nếu bạn có ý định nộp hồ sơ trực tuyến thì đó là ưu tiên hàng đầu. Trong bài viết này, tôi sẽ giải thích một số lỗi này và cách khắc phục chúng. Xin lưu ý rằng đây không phải là các vấn đề bảo mật chính mà OWASP khuyến nghị; thay vào đó, chúng là những vấn đề dễ sửa chữa mà tôi thường gặp.
Xác thực là quá trình xác nhận danh tính của người dùng hoặc quy trình. Khi xác thực bị vi phạm, những kẻ tấn công có thể giành quyền truy cập vào dữ liệu hoặc thông tin của người dùng, gây ra thiệt hại cho ứng dụng của bạn. Xác thực là một trong những cách mà kẻ tấn công có thể truy cập vào dữ liệu của người dùng và ứng dụng của bạn.
Khi nói đến xác thực, đây là mười một lỗi phổ biến cần tránh:
Việc hiển thị một thông báo lỗi cụ thể là rất nguy hiểm vì nó có thể cho phép kẻ tấn công sử dụng phương pháp thử-và-sai tự động để xác định tên người dùng hoặc mật khẩu của người dùng.
Đây là một ví dụ sơ đồ về việc hiển thị một thông báo lỗi cụ thể.
Khi xác thực một biểu mẫu trên ứng dụng web của bạn, bạn phải cẩn thận để không chỉ hiển thị một thông báo lỗi khi người dùng nhập một chi tiết không chính xác - chẳng hạn như “Mật khẩu của bạn không chính xác”. Nếu bạn hiển thị một thông báo lỗi cụ thể như vậy, kẻ tấn công sẽ nhận ra rằng địa chỉ email hoặc ID người dùng là có thật nhưng mật khẩu là sai. Điều này sẽ cho phép kẻ tấn công đề xuất mật khẩu cho người dùng đó.
Cách sửa lỗi này
ID phiên là một số mà máy chủ của trang web cung cấp cho một người dùng trong thời gian truy cập của người dùng đó. Cơ hội kẻ tấn công lấy được và lạm dụng mã thông báo phiên sẽ tăng lên nếu được đặt trực tiếp trong URL. Mặc dù rủi ro thấp hơn khi sử dụng HTTPS để kết nối với máy chủ web, nhưng vẫn có một mối nguy hiểm. Mặc dù URL HTTPS được mã hóa khi chuyển tiếp, chúng thường được lưu trong nhật ký máy chủ.
Dưới đây là một ví dụ sơ đồ về Tích hợp ID phiên vào URL.
Cách sửa lỗi này
Các cuộc tấn công chèn ép, rò rỉ bộ nhớ và hệ thống bị xâm nhập có thể xảy ra nếu dữ liệu được cung cấp trong đầu vào biểu mẫu không được kiểm tra hoặc định dạng đúng cách. Người dùng thường gửi mà không điền tất cả các thông tin cần thiết, vì vậy cần phải xác thực biểu mẫu của bạn để đảm bảo tất cả các thông tin yêu cầu đã được đáp ứng trước khi gửi đến máy chủ.
Cách sửa lỗi này
Một số thư viện được đề xuất mà tôi đề xuất để xác thực biểu mẫu là:
Tất cả các thư viện được liệt kê đều tốt cho việc xác thực biểu mẫu của bạn.
Quá trình giữ cho đầu vào biểu mẫu của bạn sạch sẽ, được lọc và khử trùng khỏi tác nhân độc hại được gọi là quá trình khử trùng biểu mẫu. Vệ sinh đầu vào của bạn là điều bắt buộc vì nó ngăn ngừa các sai sót khi tiêm. Một biểu mẫu đầu vào được khử trùng tốt có thể ngăn chặn các cuộc tấn công sau:
Cross-site scripting (XSS): Đây là một loại lỗ hổng bảo mật thường được tìm thấy trong các ứng dụng web. Lỗ hổng này cho phép những kẻ tấn công chèn các tập lệnh phía máy khách vào các trang web mà người dùng xem. Cuộc tấn công này có thể gây ra nhiều tổn hại về bảo mật cho người dùng, chẳng hạn như chuyển hướng họ đến một trang web độc hại, buộc họ tải xuống ứng dụng phần mềm độc hại và đánh cắp dữ liệu của người dùng.
SQL injection: Những kẻ tấn công có thể can thiệp vào dữ liệu được gửi đến cơ sở dữ liệu của nó thông qua đầu vào biểu mẫu.
Bằng cách khử trùng đầu vào biểu mẫu, bạn phải bảo vệ mã của mình và dữ liệu của người dùng khỏi tác nhân độc hại này và tất cả các lỗ hổng được liệt kê. Cá nhân tôi sử dụng DOM Purify , một thư viện làm sạch cho HTML và chuỗi, và nó có thể lọc bất kỳ thứ gì chứa HTML bẩn và ngăn chặn các cuộc tấn công XSS.
Cách sửa lỗi này
Không có gì lạ khi bắt gặp một trang web không có gói mật khẩu mạnh theo thứ tự. Gần đây tôi đã thử một ứng dụng yêu cầu độ dài mật khẩu tối thiểu là năm ký tự. Khi các nhà phát triển cố gắng tìm ra sự cân bằng phù hợp giữa bảo mật và khả năng sử dụng, lỗ hổng này ngày càng phổ biến. Khi làm việc với mật khẩu, hãy đảm bảo mật khẩu bạn đề xuất cho người dùng hoặc mật khẩu mà người dùng tạo là hỗn hợp các ký hiệu, số và chữ cái viết hoa hỗn hợp. Tránh các kế hoạch mật khẩu yếu.
Cách sửa lỗi này
Một sai lầm phổ biến khác mà tôi thấy với các cơ chế xác thực web là chúng không có bất kỳ biện pháp an toàn bổ sung nào. Xác thực hai yếu tố hiếm khi được các nhà phát triển sử dụng, đặc biệt là đối với các tài khoản hàng đầu. Xác thực hai yếu tố giúp bổ sung lớp bảo vệ thứ hai cho ứng dụng của bạn. Xác thực hai yếu tố rất quan trọng đối với bảo mật web vì nó ngay lập tức loại bỏ các nguy cơ về thông tin xác thực bị xâm phạm. Khi một mật khẩu bị bẻ khóa, bị đoán hoặc thậm chí bị nhiễm phần mềm độc hại, thì việc cấp quyền truy cập cho kẻ xâm nhập mà không có sự chấp thuận ở yếu tố xác thực thứ hai là không còn đủ.
Xác thực hai yếu tố là một lớp bảo mật bổ sung được thêm vào trang xác thực. Ví dụ về xác thực hai yếu tố này là SMS, email và OTP.
Đây là một ví dụ sơ đồ về xác thực hai yếu tố
Cách triển khai xác thực hai yếu tố
Có nhiều cách khác nhau để sử dụng mã hóa 2FA. Mã thông báo RSA, trình tạo mã như Google Authenticator và Duo và gửi văn bản SMS mã một lần là tất cả các tùy chọn để triển khai công nghệ 2FA.
Điều này không thường xuyên xảy ra, nhưng thỉnh thoảng, tôi thấy một ứng dụng web có khả năng này được triển khai không chính xác. Điều này thường là do mật khẩu của người dùng đã được gửi cho họ qua email hoặc mã thông báo được sử dụng để đặt lại mật khẩu không đủ mạnh. Việc gửi lại mật khẩu bản rõ cho người dùng cuối là một vấn đề khác ảnh hưởng đến việc đặt lại mật khẩu. Điều này thật tồi tệ vì nhiều lý do khác nhau, một trong số đó là mật khẩu được gửi qua email, được coi là không an toàn. Điều này có thể có nghĩa là mật khẩu được lưu trữ trong cơ sở dữ liệu mà không có đủ băm hoặc ở định dạng có thể bị đảo ngược, như base64.
Hashing là một kỹ thuật được sử dụng để xác minh hoặc xác nhận chất lượng của nhiều loại đầu vào khác nhau. Trong các hệ thống xác thực, nó chủ yếu được sử dụng để ngăn chặn việc lưu trữ các mật khẩu văn bản rõ ràng, và Hashing khiến những kẻ tấn công vô cùng khó khăn trong việc giải mã các mật khẩu đã được lưu trữ.
Base64: Base64 là một phương pháp chuyển đổi dữ liệu nhị phân thành văn bản. Phương pháp này thường được sử dụng để gửi thông tin dựa trên nội dung qua Internet.
Cách sửa lỗi này
Đây là một lỗ hổng khác có thể gây ra sự tàn phá lớn cho một ứng dụng. Nó cũng cần thiết để cung cấp cho người dùng của bạn một cách an toàn để đăng xuất để các phiên của họ không thể bị chiếm đoạt. Nếu bạn đang lưu trữ số nhận dạng phiên ở phía máy chủ, phương pháp đăng xuất sẽ làm mất hiệu lực của nó và xóa cookie phiên trong trình duyệt. Điều này ngăn những kẻ tấn công có thể đánh cắp cookie phiên và sau đó sử dụng chúng để bắt đầu một phiên mới.
Cách sửa lỗi này
Brute force là một kỹ thuật hack được sử dụng để tìm ra thông tin đăng nhập của người dùng bằng cách thử nhiều thông tin đăng nhập có thể có. Trong cuộc tấn công này, tin tặc cố gắng đoán mật khẩu để vượt qua xác thực cho một tài khoản. Sử dụng các tập lệnh thử nhiều mật khẩu thường dùng từ từ điển và hàng triệu mật khẩu bị rò rỉ từ các lần vi phạm dữ liệu trước đó, những lần thử này có cơ hội thành công cao hơn.
Cách sửa lỗi này
Một câu hỏi bảo mật hoặc từ dễ nhớ cũng có thể hỗ trợ trong việc bảo vệ chống lại các cuộc tấn công tự động. Tôi đã gặp phải các câu hỏi bảo mật yếu có câu trả lời có thể đoán trước, cho phép kẻ tấn công đề xuất hoặc đoán câu trả lời và có được quyền truy cập vào dữ liệu của người dùng.
Dưới đây là một số câu hỏi bảo mật phổ biến mà tôi đã gặp:
Tránh tất cả những câu hỏi này vì tin tặc có thể đoán chúng do một số thông tin trên Google hoặc các hồ sơ trực tuyến khác của chúng tôi.
Cách sửa lỗi này
Một lỗi khác mà tôi đã thấy các nhà phát triển mắc phải khi nói đến xác thực là "không bảo vệ được tuyến đường." Điều quan trọng là phải bảo mật các tuyến đường cụ thể trong ứng dụng của bạn khỏi những người dùng không được xác thực, vì điều này sẽ ngăn những người dùng không xác định truy cập vào một số dữ liệu riêng tư của ứng dụng của bạn.
Cách sửa lỗi này
Khi triển khai xác thực trên trang web của mình, bạn phải hết sức thận trọng với tư cách là nhà phát triển vì một số phương pháp có thể gây hại cho chương trình của bạn và mở ra cánh cửa cho những kẻ tấn công chiếm quyền kiểm soát dữ liệu của người dùng và ứng dụng. Hy vọng rằng, bài viết này đã chỉ ra những lỗi như vậy và đưa ra lời khuyên về cách khắc phục chúng.
Liên kết: https://blog.openreplay.com/11-authentication-mistakes-and-how-to-fix-them
#authentication
1659280292
fhir_auth
This package is supposed to allow easier authentication for FHIR applications (mostly using SMART on FHIR, although there's also support for general oauth2 and Google authentication). I will say, this continues to be the most frustrating package to try and develop/support. I continue to feel as though, even though each server that I work with SAYS that they support SMART on FHIR, and yet I still always struggle and fight with the process. Currently I'm successfully able to authenticate against GCP, Aidbox, Interopland, and MELD, and hopefully Azure soon. I still haven't gotten to AWS. These all work for both mobile and web. If anyone has practice authenticating against any other servers, please let me know!
FHIR® is the registered trademark of HL7 and is used with the permission of HL7. Use of the FHIR trademark does not constitute endorsement of this product by HL7.
All SMART on FHIR capabilities defined, all scopes allowed, all FHIR versions (Dstu2, Stu3, R4 and preview R5 #3) defined. Currently it only allows external to EHR launches, but soon should also support EHR launches.
Setting up your app, because it has to go deeper in Android and iOS than most, is a pain. I'm using oauth2_client. And accordingly, I have followed their recommendations for setup (note, these are not exactly the same as my previous setup).
I've included examples in mobileauthdemo as well as webauthdemo.
In your file android/app/build.gradle
you should have a section entitled defaultConfig
, you need to change it so that it looks similar to the following (please not the update, that for manifestPlaceholders it's now advised that you do += instead of simply = ):
defaultConfig {
// TODO: Specify your own unique Application ID (https://developer.android.com/studio/build/application-id.html).
applicationId "your.application.id"
minSdkVersion 21
targetSdkVersion 29
versionCode flutterVersionCode.toInteger()
versionName flutterVersionName
manifestPlaceholders += [
'appAuthRedirectScheme': 'your.application.id'
]
}
A few notes.
dev.fhirfli.application://callback
(or in the case of google, sometimes they only allow a single slash, i.e. dev.fhirfli.application:/callback
).manifestPlaceholders
as formatted above.In the AndroidManifest.xml file (android/app/src/main/AndroidManifest.xml
), you will need to add this section. You should be able to add it before or after the MainActivity.
<activity android:name="com.linusu.flutter_web_auth.CallbackActivity" >
<intent-filter android:label="flutter_web_auth">
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data android:scheme="dev.fhirfli.mobileauthdemo" />
</intent-filter>
</activity>
You must set the platform in ios/Podfile
platform :ios, '11.0'
final client = SmartClient.getSmartClient(
fhirUrl: FhirUri(url),
clientId: clientId,
redirectUri: fhirCallback,
Scopes(
clinicalScopes: [
ClinicalScope(
Role.patient,
R4ResourceType.Patient,
Interaction.any,
),
],
openid: true,
offlineAccess: true,
),
secret: secret, /// should not be used
authUrl: authUrl == null ? null : FhirUri(authUrl),
tokenUrl: tokenUrl == null ? null : FhirUri(tokenUrl),
);
await client.login();
final request1 = FhirRequest.create(
base: client.fhirUri!.value!,
resource: _newPatient,
fhirClient: client,
);
final response = await request1.request();
In my examples, I'm using an API file for all of the credentials. In order to keep private things private, I haven't uploaded my API.dart file for public consumption. However, it looks something like the following for those playing along at home:
mixin Api {
/// redirect url for oauth2 authentication
static final fhirCallback = FhirUri('com.myshiny.newapp://callback');
/// because google apparently requires/prefers one slash at times
static final googleFhirCallback = FhirUri('com.myshiny.newapp:/callback');
/// Aidbox
static const aidboxUrl = 'https://demo.aidbox.app/fhir';
static const aidboxClientId = 'e67063f5-1234-8558-9fc4-137g1mnod93b';
/// GCS
static const gcsUrl = 'https://healthcare.googleapis.com/v1/projects/'
'brandnewdemo/locations/us-central1/'
'datasets/demo/fhirStores/demo/fhir';
static const gcsClientId =
'1234567890-abcdefghijklmnopqrstuvwxyz.apps.googleusercontent.com';
/// HAPI Server
static const hapiUrl = 'https://hapi.fhir.org/baseR4';
/// Interop
static const interopClientId = 'e77063f5-1234-1234-9de4-137e1abcd83c';
static const interopUrl = 'https://api.interop.community/Demo/data';
/// MELD
static const meldClientId = 'e77063f5-1234-1234-9de4-137e1abcd83c';
static const meldUrl = 'https://meld.interop.community/Demo/data';
}
I've included the ability to use Google sign-in, so if you'd like to connect to the Google Healthcare API. Follow Part 1 and Part 2 for instructions for setting up your own GCP version (this may need to be updated).
To briefly setup your app (assuming you have your GCP setup completed).
com.myshiny.newapp
I've liked Aidbox for a while. They have some nice features setup, so it's definitely worth taking a look. For us though, one of the really nice aspects is a free cloud demo.
PUT /Client/shinynewapp?_pretty=true
content-type: text/yaml
accept: text/yaml
secret: verysecret
grant_types:
- code
auth:
authorization_code:
redirect_uri: com.myshiny.newapp://callback
first_party: true
data:
name: Grey Faulkenberry
roles:
- Administrator
- Doctor
email: user@mail.com
password: password
id: user1
resourceType: User
engine: json-schema
schema:
required:
- client
- user
- request-method
properties:
user:
required:
- data
properties:
data:
required:
- roles
properties:
roles:
not:
items:
not:
enum:
- Administrator
type: array
client:
required:
- id
properties:
id:
const: shinynewapp
request-method:
enum:
- get
- post
- put
- delete
- option
- patch
- head
description: Full access for users with role Administrator from client shinynewapp
id: policy-for-shinynewapp-users-role-administrator
resourceType: AccessPolicy
com.myshiny.newapp://callback
launch patient/Patient.* openid profile offline_access user/Patient.*
static const azureClientId = 'myAzureClientId';
static const azureTenantId = 'myAzureTenantId';
static const azureSecret = 'myAzureSecret';
static const azureUrl = 'https://myfhirserver.azurehealthcareapis.com';
static const azureAuthUrl =
'https://login.microsoftonline.com/$azureTenantId/oauth2/authorize?resource=$azureUrl';
static const azureTokenUrl =
'https://login.microsoftonline.com/$azureTenantId/oauth2/token';
Notice that capability statement will not give the proper endpoints, but it will not attach the url to the resource parameter for the authURl, this is important, and it won't work without it. This is my Azure tutorial, it's not as complete as the one above, but it should be a reasonable start.
You'll most likely be distributing this as a PWA, so you should know what the redirect URL will be ahead of time. Just in case for test purposes, I've included a script you can use to make sure the it will run locally with the same port, and it will print out the redirect url that you can use. If you use this script, the redirect is: http://localhost:8888/redirect.html
The other piece to note is that we need a redirect file in the web folder. I use the one that was demonstrated in this article
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Connexion Succeeded</title>
<meta name="description"
content="Simple, quick, standalone responsive placeholder without any additional resources">
<meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body>
</body>
<script>
window.opener.postMessage(window.location.href, '*');
</script>
</html>
http://localhost:8888
and our redirect is http://localhost:8888/redirect.html
static const azureClientId = 'myAzureClientId';
static const azureTenantId = 'myAzureTenantId';
static const azureSecret = 'myAzureSecret';
static const azureUrl = 'https://myfhirserver.azurehealthcareapis.com';
static const azureAuthUrl =
'https://login.microsoftonline.com/$azureTenantId/oauth2/authorize?resource=$azureUrl';
static const azureTokenUrl =
'https://login.microsoftonline.com/$azureTenantId/oauth2/token';
Notice that capability statement will not give the proper endpoints, but it will not attach the url to the resource parameter for the authURl, this is important, and it won't work without it. This is my Azure tutorial, it's not as complete as the one above, but it should be a reasonable start.
While I can't say I've done much with this, I wanted to ensure we have the capability. Luckily, it's actually SUPER easy to accomplish if you already have a Web App that works. You'll need to setup your web client just like it says above, but this time make sure you really take note of the launch URI (and obviously the redirect URI). Take a look at the ehrlaunchdemo if you get confused. One of the things I changed recently is I removed the need to include the ClientID as part of the code itself (it's not a secret, but one less thing to hard code). It now passes in the iss and the clientId as part of the launchUrl, which also makes it more flexible. In the launch url, you'll need to specify it to include the ClientId, it will automatically include the iss, and the launch token. You'll need to pass this to the Smart client you create. The client will check if there's a launch token. If there is, it will include launch as a scope, and the token as a parameter. And that's it!
As I mentioned above, this is the most difficult package I've tried to publish. Mostly because authentication is a huge pain in the ass. Anyone who has suggestions or wants to open a PR is welcome. If you would like to contact me directly, my email is grey@fhirfli.dev.
FHIR® is a registered trademark of Health Level Seven International (HL7) and its use does not constitute an endorsement of products by HL7®
Run this command:
With Flutter:
$ flutter pub add fhir_auth
This will add a line like this to your package's pubspec.yaml (and run an implicit flutter pub get
):
dependencies:
fhir_auth: ^0.8.0
Alternatively, your editor might support flutter pub get
. Check the docs for your editor to learn more.
Now in your Dart code, you can use:
import 'package:fhir_auth/dstu2.dart';
import 'package:fhir_auth/enums/compartment.dart';
import 'package:fhir_auth/enums/enums.dart';
import 'package:fhir_auth/enums/enums_to_string.dart';
import 'package:fhir_auth/enums/mime_type.dart';
import 'package:fhir_auth/enums/mode.dart';
import 'package:fhir_auth/enums/restful_request.dart';
import 'package:fhir_auth/enums/summary.dart';
import 'package:fhir_auth/fhir_client/authenticate/authenticate.dart';
import 'package:fhir_auth/fhir_client/authenticate/base_authentication.dart';
import 'package:fhir_auth/fhir_client/authenticate/mobile_authentication.dart';
import 'package:fhir_auth/fhir_client/authenticate/web_authentication.dart';
import 'package:fhir_auth/fhir_client/export.dart';
import 'package:fhir_auth/fhir_client/fhir_client.dart';
import 'package:fhir_auth/fhir_client/gcp_fhir_client.dart';
import 'package:fhir_auth/fhir_client/secure_fhir_client.dart';
import 'package:fhir_auth/fhir_client/smart_fhir_client.dart';
import 'package:fhir_auth/main.dart';
import 'package:fhir_auth/r4.dart';
import 'package:fhir_auth/r5.dart';
import 'package:fhir_auth/scopes/dstu2/clinical_scope.dart';
import 'package:fhir_auth/scopes/dstu2/scopes.dart';
import 'package:fhir_auth/scopes/dstu2/scopes.freezed.dart';
import 'package:fhir_auth/scopes/r4/clinical_scope.dart';
import 'package:fhir_auth/scopes/r4/scopes.dart';
import 'package:fhir_auth/scopes/r4/scopes.freezed.dart';
import 'package:fhir_auth/scopes/r5/clinical_scope.dart';
import 'package:fhir_auth/scopes/r5/scopes.dart';
import 'package:fhir_auth/scopes/r5/scopes.freezed.dart';
import 'package:fhir_auth/scopes/stu3/clinical_scope.dart';
import 'package:fhir_auth/scopes/stu3/scopes.dart';
import 'package:fhir_auth/scopes/stu3/scopes.freezed.dart';
import 'package:fhir_auth/stu3.dart';
import 'dart:developer';
import 'package:fhir/r4.dart';
import 'package:fhir_auth/r4.dart';
Future<void> main() async {
const String url = 'http://fhirurl';
const String clientId = 'myClienId';
const String fhirCallback = 'fhir_auth://callback';
final scopes = Scopes(
clinicalScopes: [
ClinicalScope(
Role.patient,
R4ResourceType.Patient,
Interaction.any,
),
],
openid: true,
offlineAccess: true,
);
final client = SmartFhirClient(
fhirUri: FhirUri(url),
clientId: clientId,
redirectUri: FhirUri(fhirCallback),
scopes: scopes.scopesList(),
);
try {
await client.login();
if (client.fhirUri.value != null) {
final newPatient = Patient(id: Id('12345'));
log('Patient to be uploaded:\n${newPatient.toJson()}');
final request1 = FhirRequest.create(
base: client.fhirUri.value!,
//?? Uri.parse('127.0.0.1'),
resource: newPatient,
client: client,
);
Id? newId;
try {
final response = await request1.request();
log('Response from upload:\n${response.toJson()}');
newId = response.id;
} catch (e) {
log(e.toString());
}
if (newId is! Id) {
log(newId.toString());
} else {
final request2 = FhirRequest.read(
base: client.fhirUri.value ?? Uri.parse('127.0.0.1'),
type: R4ResourceType.Patient,
id: newId,
client: client,
);
try {
final response = await request2.request();
log('Response from read:\n${response.toJson()}');
} catch (e) {
log(e.toString());
}
}
}
} catch (e, stack) {
log('Error $e');
log('Stack $stack');
}
}
/// Just to remove errors from this file, doesn't actually do anything
class FhirRequest {
Uri? base;
R4ResourceType? type;
Id? id;
FhirClient? client;
Resource? resource;
FhirRequest(this.base, this.type, this.id, this.client, this.resource);
dynamic request() => '';
factory FhirRequest.read({
Uri? base,
R4ResourceType? type,
Id? id,
FhirClient? client,
}) =>
FhirRequest(base, type, id, client, null);
factory FhirRequest.create({
Uri? base,
Resource? resource,
FhirClient? client,
}) =>
FhirRequest(base, null, null, client, resource);
}
Download Details:
Author: MayJuun
Source Code: https://github.com/MayJuun/fhir/tree/main/fhir_auth
1659012494
Kể từ khi phát triển ứng dụng web ra đời, rất nhiều thông tin nhạy cảm được gửi qua internet khiến khái niệm xác thực là điều mà mọi nhà phát triển web nên hiểu và áp dụng trong ứng dụng để bảo mật thông tin được người dùng giao phó cho ứng dụng. Trong bài viết này, chúng ta sẽ xem xét một phương tiện xác thực cho các ứng dụng web được gọi là xác thực JWT. So với các phương pháp khác, xác thực JWT đã trở thành một yêu thích do có nhiều ưu điểm đối với các nhà phát triển.
Trước khi đi sâu vào mã hóa, chúng tôi sẽ xác định một số thuật ngữ và khái niệm chính để giúp chúng tôi hiểu cách xác thực JWT hoạt động, sau đó chúng tôi sẽ tích hợp hình thức xác thực này vào một dự án có máy chủ được tạo bằng Node.js và front-end được tạo bằng React.js một khung công tác được sử dụng rộng rãi (thực sự là yêu thích của cá nhân tôi) để phát triển front-end.
Để có thể theo dõi phần còn lại của bài viết, bạn cần những điều sau:
JWT là viết tắt của JSON Web Token, một tiêu chuẩn mở được sử dụng để chia sẻ thông tin bảo mật dưới dạng đối tượng JSON giữa máy khách và máy chủ. Sự hiện diện của JWT trong một yêu cầu đến máy chủ từ khách hàng cho thấy rằng thông tin đã được xác minh và độ tin cậy của nó được thiết lập vì nó được ký kỹ thuật số bằng cách sử dụng bí mật được viết bằng thuật toán mật mã để đảm bảo rằng các xác nhận quyền sở hữu không bị thay đổi sau mã thông báo được phát hành. Mặc dù không có người trung gian nào có thể sửa đổi JWT, nhưng bạn nên sử dụng nó trong môi trường HTTPS vì JWT không được mã hóa.
Xác thực JWT là một cơ chế xác thực không trạng thái được sử dụng phổ biến như một phiên không trạng thái phía máy khách. Máy chủ không phải hoàn toàn dựa vào cơ sở dữ liệu để lưu thông tin phiên. Thông tin phiên được lưu trữ trên máy khách; do đó, không cần tra cứu cơ sở dữ liệu để xác minh danh tính của người dùng yêu cầu. Nó hoạt động như thế này:
Có một số lợi thế:
Tuy nhiên, cũng có một số nhược điểm:
Để đối phó với những thách thức này, một số thư viện JWT thêm một lớp bên trên thông số kỹ thuật tiêu chuẩn, cho phép cơ chế làm mới mã thông báo và một số tính năng như buộc người dùng xác thực lại. Dưới đây là một số khuyến nghị cho các nhà phát triển JWT.
Mã thông báo web JSON ở dạng nhỏ gọn bao gồm ba phần được phân tách bằng dấu chấm, đó là:
Tiêu đề chứa hai phần: loại mã thông báo và thuật toán ký. Thuật toán ký có thể là HMAC SHA256 hoặc RSA. JSON này sau đó được mã hóa Base64Url để tạo thành phần đầu tiên của JWT. Đây là một ví dụ về tiêu đề:
{
"alg" : "HS256",
"typ": "JWT"
}
Trọng tải chủ yếu chứa các xác nhận quyền sở hữu. Tuyên bố là tuyên bố về một mặt hàng, trong trường hợp của chúng tôi là người dùng và dữ liệu bổ sung. Máy chủ thường sử dụng thông tin này để xác minh rằng người dùng có quyền thực hiện hành động mà họ đang yêu cầu. Ví dụ:
{
"iss":" Signin route",
"name": "janet",
"sub":"2"
"admin": true
}
Cuối cùng, chữ ký được sử dụng để xác minh rằng tin nhắn không bị thay đổi và nó cũng được sử dụng để xác minh rằng người gửi JWT là người mà nó nói. Chữ ký được tạo bằng cách lấy tiêu đề được mã hóa, trọng tải được mã hóa, bí mật và thuật toán được chỉ định trong tiêu đề và mã hóa đó. Ví dụ: nếu bạn muốn sử dụng thuật toán HMAC SHA256, chữ ký sẽ được tạo theo cách này:
HMAC256(
base64UrlEncode(header) + "." + base64UrlEncode(payload), secret
)
Sau khi tất cả điều này được thực hiện, chúng tôi nhận được ba chuỗi Base64Url đại diện cho ba phần khác nhau của mã thông báo JWT được phân tách bằng dấu chấm có thể dễ dàng chuyển trong môi trường HTML và HTTP. Đây là một ví dụ từ https://token.dev/paseto/ hiển thị tiêu đề, trọng tải, chữ ký và ba chuỗi Base64Url của chúng tôi được phân tách bằng dấu chấm.
Node.js là một môi trường thời gian chạy JavaScript back-end, đa nền tảng, mã nguồn mở, thực thi mã JavaScript bên ngoài trình duyệt web. Nó được thiết kế để xây dựng các ứng dụng mạng có khả năng mở rộng. Đối với tôi, Node.js là React của phát triển web back-end. Sử dụng Node.js, chúng tôi sẽ tạo các tuyến đăng nhập, đăng ký và xác thực sẽ nhận thông tin người dùng từ giao diện người dùng, băm mật khẩu nếu cần, tạo, xác minh và xác thực người dùng bất cứ khi nào người dùng đăng nhập và yêu cầu truy cập tuyến đường được bảo vệ của chúng tôi.
Cùng với Node.js cho dự án này, chúng tôi đã sử dụng PostgreSQL để tạo cơ sở dữ liệu của mình; bạn có thể tìm hiểu cách thực hiện điều đó tại đây , Knex.js để xây dựng truy vấn và bcrypt.js để băm mật khẩu của chúng tôi để nếu cơ sở dữ liệu của chúng tôi bị xâm phạm thì tin tặc sẽ không sử dụng được mật khẩu người dùng.
Đầu tiên, chúng ta cần cài đặt thư viện JWT và các phụ thuộc khác mà chúng ta cần cho dự án này. Để làm điều đó, chúng tôi sẽ chạy lệnh sau:
1npm i jsonwebtoken bcrypt knex postgres --save
Sau đó, chúng tôi sẽ lưu trữ bí mật của chúng tôi trong tệp .env của chúng tôi;
1REACT_APP_TOKEN= "jwtsecrettutorial"
Chúng tôi sẽ tạo điểm cuối đăng ký của mình để nhận thông tin của người dùng từ giao diện người dùng yêu cầu, băm mật khẩu, gửi thông tin đến cơ sở dữ liệu của chúng tôi, tạo mã thông báo JWT của chúng tôi và trả lời giao diện người dùng bằng mã thông báo JWT của chúng tôi;
app.post("/register", (req, res, db, bcrypt, jwt) => {
const { email, name, password } = req.body;
if (!email || !name || !password) {
return res
.status(400)
.json(`${console.log(req.body)}incorrect form submission`);
}
//Hashing our password with bcrypt
const hash = bcrypt.hashSync(password);
db.transaction((trx) => {
trx
.insert({
hash: hash,
email: email,
})
//Inserting our user's info into our login and user table
.into("login")
.returning("email")
.then((loginEmail) => {
return trx("users").returning("*").insert({
email: loginEmail[0].email,
name: name,
joined: new Date(),
});
})
//creating the JWT token and responding to the front end with our token
.then((user) => {
const accessToken = jwt.sign({ email }, process.env.REACT_APP_TOKEN, {
expiresIn: "3000s",
});
res.json({ accessToken });
});
})
.then(trx.commit)
.catch(trx.rollback);
});
Thông tin của khách hàng đã được gửi đến máy chủ bằng Postman trong hình trên. Sau khi lưu thông tin của khách hàng, máy chủ sẽ phản hồi bằng mã thông báo JWT cho một yêu cầu tiếp theo.
Đối với lộ trình đăng nhập, chúng tôi sẽ tạo điểm cuối của mình để nhận thông tin người dùng từ yêu cầu giao diện người dùng, xác minh xem người dùng có tồn tại trong cơ sở dữ liệu của chúng tôi hay không và nếu người dùng tồn tại, mã thông báo JWT sẽ được tạo và gửi đến phía máy khách ; mã thông báo này sẽ được sử dụng cho một yêu cầu API tiếp theo.
app.post("/signin", (req, res, db, bcrypt, jwt) => {
const { email, password } = req.body;
if (!email || !password) {
return res.status(400).json("incorrect form submission");
}
//Getting the user info from the database
db.select("email", "hash")
.from("login")
.where("email", "=", email)
.then((data) => {
//comparing the password rech the one in the database using bcrypt
const isValid = bcrypt.compareSync(password, data[0].hash);
if (isValid) {
return db
.select("*")
.from("users")
.where("email", "=", email)
.then((user) => {
const accessToken = jwt.sign(
{ email },
process.env.REACT_APP_TOKEN,
{ expiresIn: "3000s" }
);
res.json({ accessToken });
})
.catch((err) => res.status(400).json(`${err}wrong credentials`));
} else {
res.status(400).json(`${err}wrong credentials`);
}
})
.catch((err) => res.status(400).json(`${err}wrong credentials`));
});
Trong hình trên, thông tin của khách hàng đã được gửi đến máy chủ bằng Postman. Sau khi kiểm tra chéo và xác nhận thông tin của khách hàng, máy chủ sẽ phản hồi bằng mã thông báo JWT cho các yêu cầu tiếp theo.
Để xác thực, chúng tôi sẽ tạo một phần mềm trung gian thực hiện xác thực bất cứ khi nào yêu cầu được thực hiện thông qua tuyến đường được bảo vệ của chúng tôi. Lộ trình này sẽ yêu cầu mã thông báo người dùng trong tiêu đề yêu cầu là 'x-auth-token' để ủy quyền. Mã thông báo sẽ được lấy từ tiêu đề và được xác minh bởi phần mềm trung gian của chúng tôi. Bạn có thể tìm hiểu thêm về Ủy quyền HTTP qua tiêu đề yêu cầu tại đây . Để tạo phần mềm trung gian, hãy sử dụng mã bên dưới;
require("dotenv").config();
var jwt = require("jsonwebtoken");
module.exports = {
jwtauth(req, res, next) {
const token = req.header("x-auth-token");
if (!token) {
res.status(401).json("token not found");
}
try {
const user = jwt.verify(token, process.env.REACT_APP_TOKEN);
req.user = user.email;
console.log("middleware is working");
next();
} catch (error) {
res.status(401).json("invalid token");
}
},
};
Bây giờ chúng tôi có thể thêm một tuyến đường được bảo vệ vào máy chủ của chúng tôi; một yêu cầu tới tuyến đường này trước tiên sẽ đi qua phần mềm trung gian của chúng tôi trước khi quyền truy cập được cấp hoặc từ chối.
const jwtauth = require("./middleware/jwtauth");
app.post("/protected", jwtauth, (req, res) => {
res.status(200).send("Here's the info you requested ");
});
Nếu một yêu cầu được thực hiện mà không cung cấp mã thông báo bằng 'x-access-token' trong tiêu đề, một thông báo lỗi sẽ được trả về cho biết "không tìm thấy mã thông báo".
Trong hình trên, một yêu cầu được gửi đến máy chủ qua Postman mà không có mã thông báo trong tiêu đề và máy chủ phản hồi bằng một thông báo lỗi cho biết không tìm thấy mã thông báo. Nếu mã thông báo được cung cấp trong tiêu đề và mã thông báo đó chính xác, nó cho phép khách hàng truy cập vào tuyến đường được bảo vệ, nhưng nếu mã thông báo sai, nó sẽ phản hồi bằng một thông báo lỗi cho biết “mã thông báo không hợp lệ”.
Trong hình trên, một yêu cầu được gửi đến máy chủ qua Postman với mã thông báo không chính xác trong tiêu đề và máy chủ phản hồi bằng một thông báo lỗi cho biết mã thông báo không hợp lệ.
Để thực hiện việc này, bạn cần cài đặt Axios trong giao diện người dùng của chúng tôi được tạo bằng React.js bằng cách thực hiện;
1npm i axios
Trong trang đăng ký / đăng ký trong React.js của chúng tôi, chúng tôi muốn phía máy khách lưu trữ JWT mà nó nhận được từ phía máy chủ sau khi thông tin của họ được lưu trữ trên cơ sở dữ liệu. Mã thông báo này sẽ được sử dụng cho các yêu cầu API tiếp theo, vì vậy chúng tôi thêm chức năng này vào mã của mình;
onSubmitSignUp = () => {
console.log(this.state);
axios
.post("http://localhost:3001/register", {
email: this.state.email,
password: this.state.password,
name: this.state.name,
enteries: this.state.enteries,
})
.then((response) => {
if (response.data.accessToken) {
localStorage.setItem("user", JSON.stringify(response.data));
} else {
console.log("no response");
}
});
};
Khi điều này được thực hiện, mã thông báo được lưu trữ trong bộ nhớ cục bộ của chúng tôi ở phía máy khách. Chúng tôi sẽ làm điều tương tự với trang đăng nhập của mình để mã thông báo sẽ được tạo cho các lệnh gọi API tiếp theo khi người dùng hiện có đăng nhập.
onSubmitSignIn = () => {
console.log(this.state);
axios
.post("http://localhost:3001/signin", {
email: this.state.email,
password: this.state.password,
})
.then((response) => {
if (response.data.accessToken) {
localStorage.setItem("user", JSON.stringify(response.data));
} else {
console.log("no response");
}
});
};
Đối với lộ trình xác thực của chúng tôi, chúng tôi phải truy xuất mã thông báo đã được lưu trữ từ bộ nhớ của chúng tôi, sau đó sẽ được gửi đến phía máy chủ để xác thực và thực hiện thêm hành động.
export default function authHeader() {
const user = JSON.parse(localStorage.getItem("user"));
if (useraccessToken) {
return { "x-auth-token": user.accessToken };
}
}
axios.post("http://localhost:3001/protected", { header: authHeader() });
Với tất cả những điều này đã hoàn thành, chúng tôi đã thiết lập thành công một hệ thống xác thực hoạt động hoạt động với node.js (back-end) của chúng tôi, tạo mã thông báo của chúng tôi và gửi nó đến react.js (front-end) của chúng tôi, sau đó lưu trữ mã thông báo của chúng tôi và sử dụng nó cho các yêu cầu tiếp theo đối với tuyến đường được bảo vệ của chúng tôi.
Cho đến nay, chúng tôi đã xem xét xác thực JWT, cấu trúc JWT, xác thực JWT là gì, cách thức hoạt động và cách thêm nó vào các tuyến node.js phía máy chủ và ứng dụng React.js của chúng tôi. Bạn có thể tìm hiểu thêm về JWT cũng như các thư viện và công cụ giúp bạn sử dụng xác thực JWT dễ dàng và an toàn hơn tại đây . Tôi hy vọng hướng dẫn này hữu ích, chúc bạn có những yêu cầu xác thực vui vẻ với Mã thông báo web JSON.
Liên kết: https://blog.openreplay.com/authentication-with-jwt-for-your-website
#jwt #authentication
1659005236
С момента появления разработки веб-приложений через Интернет отправляется много конфиденциальной информации, что делает концепцию аутентификации тем, что каждый веб-разработчик должен понимать и применять в приложении для защиты информации, доверенной приложению пользователем. В этой статье мы рассмотрим средство аутентификации для веб-приложений, известное как аутентификация JWT. По сравнению с другими аутентификация JWT стала фаворитом благодаря своим многочисленным преимуществам для разработчиков.
Прежде чем мы углубимся в программирование, мы определим некоторые ключевые термины и понятия, которые помогут нам понять, как работает аутентификация JWT, после чего мы интегрируем эту форму аутентификации в проект, в котором есть сервер, созданный с помощью Node.js, и интерфейс, созданный с помощью React.js, широко используемого фреймворка (на самом деле, моего личного фаворита) для разработки интерфейса.
Чтобы иметь возможность следовать остальной части статьи, вам необходимо следующее:
JWT означает JSON Web Token, открытый стандарт, используемый для обмена информацией о безопасности в виде объекта JSON между клиентом и сервером. Наличие JWT в запросе к серверу от клиента означает, что информация проверена, и ее достоверность установлена, поскольку она снабжена цифровой подписью с использованием секрета, записанного с помощью криптографического алгоритма, чтобы гарантировать, что утверждения не будут изменены после выдается токен. Хотя ни один посредник не может изменить JWT, рекомендуется использовать его в среде HTTPS, поскольку JWT не зашифрован.
Аутентификация JWT — это механизм аутентификации без сохранения состояния, обычно используемый в качестве сеанса без сохранения состояния на стороне клиента. Серверу не нужно полностью полагаться на базу данных для сохранения информации о сеансе. Информация о сеансе хранится на стороне клиента; поэтому поиск в базе данных не требуется для проверки личности запрашивающего пользователя. Это работает следующим образом:
Есть несколько преимуществ:
Однако есть и некоторые недостатки:
Чтобы справиться с этими проблемами, некоторые библиотеки JWT добавляют уровень выше стандартной спецификации, позволяя использовать механизмы обновления маркеров и некоторые функции, такие как принудительная повторная аутентификация пользователя. Вот несколько рекомендаций для разработчиков JWT.
Веб-токен JSON в компактной форме состоит из трех частей, разделенных точками:
Заголовок состоит из двух частей: тип токена и алгоритм подписи. Алгоритм подписи может быть HMAC SHA256 или RSA. Затем этот JSON кодируется Base64Url, чтобы сформировать первую часть JWT. Вот пример заголовка:
{
"alg" : "HS256",
"typ": "JWT"
}
Полезная нагрузка в основном содержит претензии. Претензии — это утверждения об элементе, в нашем случае о пользователе, и дополнительные данные. Сервер обычно использует эту информацию, чтобы убедиться, что у пользователя есть разрешение на выполнение запрошенного действия. Например:
{
"iss":" Signin route",
"name": "janet",
"sub":"2"
"admin": true
}
Наконец, подпись используется для проверки того, что сообщение не было изменено, а также для проверки того, что отправителем JWT является тот, за кого он себя выдает. Подпись создается путем получения закодированного заголовка, закодированной полезной нагрузки, секрета и алгоритма, указанного в заголовке, и их кодирования. Например, если вы хотите использовать алгоритм HMAC SHA256, подпись будет создана следующим образом:
HMAC256(
base64UrlEncode(header) + "." + base64UrlEncode(payload), secret
)
После того, как все это будет сделано, мы получим три строки Base64Url, представляющие три разные части токена JWT, разделенные точками, которые можно легко передать в средах HTML и HTTP. Вот пример из https://token.dev/paseto/ , показывающий заголовок, полезную нагрузку, подпись и наши три строки Base64Url, разделенные точками.
Node.js — это кроссплатформенная внутренняя среда выполнения JavaScript с открытым исходным кодом, которая выполняет код JavaScript вне веб-браузера. Он был разработан для создания масштабируемых сетевых приложений. Для меня Node.js — это React серверной веб-разработки. Используя Node.js, мы создадим маршруты для входа, регистрации и аутентификации, которые будут получать информацию о пользователе из внешнего интерфейса, при необходимости хешировать пароли, создавать, проверять и аутентифицировать пользователя всякий раз, когда пользователь входит в систему и запрашивать получить доступ к нашему защищенному маршруту.
Наряду с Node.js для этого проекта мы использовали PostgreSQL для создания нашей базы данных; вы можете узнать, как это сделать здесь , Knex.js для построения запросов и bcrypt.js для хеширования наших паролей, чтобы в случае взлома нашей базы данных пароль пользователя не был доступен хакеру.
Во-первых, нам нужно установить библиотеку JWT и другие зависимости, которые нам понадобятся для этого проекта. Для этого мы запустим следующую команду:
1npm i jsonwebtoken bcrypt knex postgres --save
Затем мы сохраним наш секрет в нашем файле .env;
1REACT_APP_TOKEN= "jwtsecrettutorial"
Мы создадим нашу конечную точку регистрации, которая будет получать информацию о пользователе из внешнего запроса, хэшировать пароль, отправлять информацию в нашу базу данных, создавать наш токен JWT и отвечать на внешний интерфейс нашим токеном JWT;
app.post("/register", (req, res, db, bcrypt, jwt) => {
const { email, name, password } = req.body;
if (!email || !name || !password) {
return res
.status(400)
.json(`${console.log(req.body)}incorrect form submission`);
}
//Hashing our password with bcrypt
const hash = bcrypt.hashSync(password);
db.transaction((trx) => {
trx
.insert({
hash: hash,
email: email,
})
//Inserting our user's info into our login and user table
.into("login")
.returning("email")
.then((loginEmail) => {
return trx("users").returning("*").insert({
email: loginEmail[0].email,
name: name,
joined: new Date(),
});
})
//creating the JWT token and responding to the front end with our token
.then((user) => {
const accessToken = jwt.sign({ email }, process.env.REACT_APP_TOKEN, {
expiresIn: "3000s",
});
res.json({ accessToken });
});
})
.then(trx.commit)
.catch(trx.rollback);
});
Информация о клиенте была отправлена на сервер с помощью Postman на изображении выше. После сохранения информации о клиенте сервер отвечает токеном JWT для последующего запроса.
Для маршрута входа мы создадим нашу конечную точку для получения информации о пользователе из внешнего запроса, проверим, существует ли пользователь в нашей базе данных, и, если пользователь существует, токен JWT будет создан и отправлен на сторону клиента. ; этот токен будет использоваться для последующего запроса API.
app.post("/signin", (req, res, db, bcrypt, jwt) => {
const { email, password } = req.body;
if (!email || !password) {
return res.status(400).json("incorrect form submission");
}
//Getting the user info from the database
db.select("email", "hash")
.from("login")
.where("email", "=", email)
.then((data) => {
//comparing the password rech the one in the database using bcrypt
const isValid = bcrypt.compareSync(password, data[0].hash);
if (isValid) {
return db
.select("*")
.from("users")
.where("email", "=", email)
.then((user) => {
const accessToken = jwt.sign(
{ email },
process.env.REACT_APP_TOKEN,
{ expiresIn: "3000s" }
);
res.json({ accessToken });
})
.catch((err) => res.status(400).json(`${err}wrong credentials`));
} else {
res.status(400).json(`${err}wrong credentials`);
}
})
.catch((err) => res.status(400).json(`${err}wrong credentials`));
});
На изображении выше информация о клиенте была отправлена на сервер с помощью Postman. После перекрестной проверки и подтверждения информации клиента сервер ответил токеном JWT для последующих запросов.
Для аутентификации мы создадим промежуточное ПО, которое выполняет аутентификацию всякий раз, когда запрос делается через наш защищенный маршрут. Этот маршрут потребует токен пользователя в заголовке запроса как «x-auth-token» для авторизации. Токен будет получен из заголовка и проверен нашим промежуточным программным обеспечением. Вы можете узнать больше об авторизации HTTP через заголовок запроса здесь . Чтобы создать промежуточное ПО, используйте приведенный ниже код;
require("dotenv").config();
var jwt = require("jsonwebtoken");
module.exports = {
jwtauth(req, res, next) {
const token = req.header("x-auth-token");
if (!token) {
res.status(401).json("token not found");
}
try {
const user = jwt.verify(token, process.env.REACT_APP_TOKEN);
req.user = user.email;
console.log("middleware is working");
next();
} catch (error) {
res.status(401).json("invalid token");
}
},
};
Теперь мы можем добавить защищенный маршрут к нашему серверу; запрос к этому маршруту сначала пройдет через наше промежуточное ПО, прежде чем доступ будет предоставлен или запрещен.
const jwtauth = require("./middleware/jwtauth");
app.post("/protected", jwtauth, (req, res) => {
res.status(200).send("Here's the info you requested ");
});
Если запрос сделан без предоставления токена с использованием «x-access-token» в заголовке, будет возвращено сообщение об ошибке «токен не найден».
На изображении выше запрос отправляется на сервер через Postman без токена в заголовке, а сервер отвечает сообщением об ошибке, в котором говорится, что токен не найден. Если в заголовке указан токен, и этот токен правильный, он разрешает клиенту доступ к защищенному маршруту, но если токен неправильный, он отвечает сообщением об ошибке «недопустимый токен».
На изображении выше запрос отправляется на сервер через Postman с неверным токеном в заголовке, а сервер отвечает сообщением об ошибке, говорящим о недопустимом токене.
Для этого вам нужно будет установить Axios в нашем интерфейсе, созданном с помощью React.js, выполнив;
1npm i axios
На нашей странице регистрации/регистрации в нашем React.js мы хотим, чтобы наша клиентская сторона сохраняла JWT, который она получает со стороны сервера после того, как их информация сохраняется в базе данных. Этот токен будет использоваться для последующих запросов к API, поэтому мы добавляем эту функцию в наш код;
onSubmitSignUp = () => {
console.log(this.state);
axios
.post("http://localhost:3001/register", {
email: this.state.email,
password: this.state.password,
name: this.state.name,
enteries: this.state.enteries,
})
.then((response) => {
if (response.data.accessToken) {
localStorage.setItem("user", JSON.stringify(response.data));
} else {
console.log("no response");
}
});
};
После этого токен сохраняется в нашем локальном хранилище на стороне клиента. Мы проделаем то же самое с нашей страницей входа, чтобы токен создавался для последующих вызовов API, когда уже существующий пользователь входит в систему.
onSubmitSignIn = () => {
console.log(this.state);
axios
.post("http://localhost:3001/signin", {
email: this.state.email,
password: this.state.password,
})
.then((response) => {
if (response.data.accessToken) {
localStorage.setItem("user", JSON.stringify(response.data));
} else {
console.log("no response");
}
});
};
Для нашего маршрута аутентификации мы должны получить уже сохраненный токен из нашего хранилища, который затем будет отправлен на сервер для аутентификации и дальнейших действий.
export default function authHeader() {
const user = JSON.parse(localStorage.getItem("user"));
if (useraccessToken) {
return { "x-auth-token": user.accessToken };
}
}
axios.post("http://localhost:3001/protected", { header: authHeader() });
Сделав все это, мы успешно настроили работающую систему аутентификации, которая работает с нашим node.js (бэкэнд), создает наш токен и отправляет его в наш react.js (интерфейс), который затем сохраняет наш токен. и использует его для последующих запросов к нашему защищенному маршруту.
До сих пор мы рассматривали аутентификацию JWT, структуру JWT, что такое аутентификация JWT, как она работает и как добавить ее в наши маршруты node.js на стороне сервера и наше приложение React.js. Вы можете узнать больше о JWT, библиотеках и инструментах, которые упрощают и делают более безопасным использование аутентификации JWT здесь . Я надеюсь, что это руководство было полезным, получайте удовольствие от аутентификации запросов с помощью веб-токенов JSON.
Ссылка: https://blog.openreplay.com/authentication-with-jwt-for-your-website
#jwt #authentication
1658997973
自從 Web 應用程序開發出現以來,許多敏感信息都通過 Internet 發送,這使得身份驗證的概念成為每個 Web 開發人員都應該理解並在應用程序中應用以保護用戶委託給應用程序的信息。在本文中,我們將介紹一種稱為 JWT 身份驗證的 Web 應用程序身份驗證方法。與其他人相比,JWT 身份驗證因其對開發人員的諸多優勢而成為人們的最愛。
在深入編碼之前,我們將定義一些關鍵術語和概念以幫助我們了解 JWT 身份驗證的工作原理,之後我們會將這種形式的身份驗證集成到一個項目中,該項目有一個使用 Node.js 創建的服務器,以及一個使用 React.js 創建的前端是一個廣泛使用的前端開發框架(實際上是我個人最喜歡的)。
為了能夠繼續閱讀本文的其餘部分,您需要以下內容:
JWT 代表 JSON Web Token,這是一種開放標準,用於在客戶端和服務器之間以 JSON 對象的形式共享安全信息。客戶端向服務器發出的請求中存在 JWT 表示該信息已經過驗證,並且它的可信度已經建立,因為它是使用用加密算法編寫的秘密進行數字簽名的,以確保聲明之後不會被更改發出令牌。雖然沒有中間人可以修改 JWT,但建議在 HTTPS 環境中使用它,因為 JWT 未加密。
JWT 身份驗證是一種無狀態身份驗證機制,通常用作客戶端無狀態會話。服務器不必完全依賴數據庫來保存會話信息。會話信息存儲在客戶端;因此,不需要數據庫查找來驗證請求用戶的身份。它是這樣工作的:
有幾個優點:
但是,也有一些缺點:
為了應對這些挑戰,一些 JWT 庫在標準規範之上添加了一層,允許令牌刷新機制和一些功能,例如強制用戶重新進行身份驗證。以下是對 JWT 開發人員的一些建議。
緊湊形式的 JSON Web 令牌由以點分隔的三部分組成,它們是:
標頭包含兩部分:令牌類型和簽名算法。簽名算法可以是 HMAC SHA256 或 RSA。然後將此 JSON 編碼為 Base64Url 以形成 JWT 的第一部分。下面是一個標頭示例:
{
"alg" : "HS256",
"typ": "JWT"
}
有效載荷主要包含聲明。聲明是關於一個項目的陳述,在我們的例子中,是用戶和附加數據。服務器通常使用此信息來驗證用戶是否有權執行他們請求的操作。例如:
{
"iss":" Signin route",
"name": "janet",
"sub":"2"
"admin": true
}
最後,簽名用於驗證消息沒有被更改,還用於驗證 JWT 的發送者是否就是它所說的那個人。簽名是通過獲取編碼的標頭、編碼的有效負載、秘密以及標頭中指定的算法並對其進行編碼來創建的。例如,如果你想使用 HMAC SHA256 算法,簽名會這樣創建:
HMAC256(
base64UrlEncode(header) + "." + base64UrlEncode(payload), secret
)
完成所有這些之後,我們得到了三個 Base64Url 字符串,它們代表 JWT 令牌的三個不同部分,這些部分用點分隔,可以在 HTML 和 HTTP 環境中輕鬆傳遞。這是來自https://token.dev/paseto/的示例,顯示了標頭、有效負載、簽名和我們的三個用點分隔的 Base64Url 字符串。
Node.js 是一個開源、跨平台的後端 JavaScript 運行時環境,可在 Web 瀏覽器之外執行 JavaScript 代碼。它旨在構建可擴展的網絡應用程序。對我來說,Node.js 是後端 Web 開發的 React。使用 Node.js,我們將創建我們的登錄、註冊和身份驗證路由,這些路由將從前端接收用戶信息,在必要時對密碼進行哈希處理,在用戶登錄並請求時創建、驗證和驗證用戶訪問我們的受保護路線。
除了這個項目的 Node.js,我們還使用 PostgreSQL 創建我們的數據庫;你可以在這裡學習如何做到這一點,Knex.js用於查詢構建,bcrypt.js用於散列我們的密碼,這樣如果我們的數據庫被洩露,黑客就無法獲得用戶密碼。
首先,我們需要安裝此項目所需的 JWT 庫和其他依賴項。為此,我們將運行以下命令:
1npm i jsonwebtoken bcrypt knex postgres --save
然後我們將我們的秘密存儲在我們的 .env 文件中;
1REACT_APP_TOKEN= "jwtsecrettutorial"
我們將創建我們的註冊端點,它將從前端請求接收用戶信息,對密碼進行哈希處理,將信息發送到我們的數據庫,創建我們的 JWT 令牌並使用我們的 JWT 令牌響應前端;
app.post("/register", (req, res, db, bcrypt, jwt) => {
const { email, name, password } = req.body;
if (!email || !name || !password) {
return res
.status(400)
.json(`${console.log(req.body)}incorrect form submission`);
}
//Hashing our password with bcrypt
const hash = bcrypt.hashSync(password);
db.transaction((trx) => {
trx
.insert({
hash: hash,
email: email,
})
//Inserting our user's info into our login and user table
.into("login")
.returning("email")
.then((loginEmail) => {
return trx("users").returning("*").insert({
email: loginEmail[0].email,
name: name,
joined: new Date(),
});
})
//creating the JWT token and responding to the front end with our token
.then((user) => {
const accessToken = jwt.sign({ email }, process.env.REACT_APP_TOKEN, {
expiresIn: "3000s",
});
res.json({ accessToken });
});
})
.then(trx.commit)
.catch(trx.rollback);
});
上圖中使用 Postman 將客戶端的信息發送到服務器。保存客戶端信息後,服務器使用 JWT 令牌響應後續請求。
對於登錄路由,我們將創建端點以接收來自前端請求的用戶信息,驗證用戶是否存在於我們的數據庫中,如果用戶存在,則創建一個 JWT 令牌並將其發送到客戶端; 此令牌將用於後續 API 請求。
app.post("/signin", (req, res, db, bcrypt, jwt) => {
const { email, password } = req.body;
if (!email || !password) {
return res.status(400).json("incorrect form submission");
}
//Getting the user info from the database
db.select("email", "hash")
.from("login")
.where("email", "=", email)
.then((data) => {
//comparing the password rech the one in the database using bcrypt
const isValid = bcrypt.compareSync(password, data[0].hash);
if (isValid) {
return db
.select("*")
.from("users")
.where("email", "=", email)
.then((user) => {
const accessToken = jwt.sign(
{ email },
process.env.REACT_APP_TOKEN,
{ expiresIn: "3000s" }
);
res.json({ accessToken });
})
.catch((err) => res.status(400).json(`${err}wrong credentials`));
} else {
res.status(400).json(`${err}wrong credentials`);
}
})
.catch((err) => res.status(400).json(`${err}wrong credentials`));
});
在上圖中,客戶端的信息是使用 Postman 發送到服務器的。在交叉檢查並確認客戶端信息後,服務器以 JWT 令牌響應後續請求。
對於身份驗證,我們將創建一個中間件,只要通過我們的受保護路由發出請求,該中間件就會執行身份驗證。此路由將要求請求標頭中的用戶令牌作為“x-auth-token”進行授權。令牌將從標頭中獲取並由我們的中間件進行驗證。您可以通過此處的請求標頭了解有關 HTTP 授權的更多信息。要創建中間件,請使用以下代碼;
require("dotenv").config();
var jwt = require("jsonwebtoken");
module.exports = {
jwtauth(req, res, next) {
const token = req.header("x-auth-token");
if (!token) {
res.status(401).json("token not found");
}
try {
const user = jwt.verify(token, process.env.REACT_APP_TOKEN);
req.user = user.email;
console.log("middleware is working");
next();
} catch (error) {
res.status(401).json("invalid token");
}
},
};
我們現在可以向我們的服務器添加一個受保護的路由;在授予或拒絕訪問之前,對該路由的請求將首先通過我們的中間件。
const jwtauth = require("./middleware/jwtauth");
app.post("/protected", jwtauth, (req, res) => {
res.status(200).send("Here's the info you requested ");
});
如果在沒有使用標頭中的“x-access-token”提供令牌的情況下發出請求,則會返回一條錯誤消息,提示“找不到令牌”。
在上圖中,請求通過 Postman 發送到服務器,但標頭中沒有令牌,服務器響應錯誤消息,提示找不到令牌。如果標頭中提供了令牌並且該令牌正確,則它允許客戶端訪問受保護的路由,但如果令牌錯誤,它會以錯誤消息響應“無效令牌”。
在上圖中,通過 Postman 向服務器發送了一個請求,請求的標頭中包含不正確的令牌,服務器以錯誤消息進行響應,指出令牌無效。
為此,您需要在我們使用 React.js 創建的前端安裝 Axios:
1npm i axios
在 React.js 的註冊/註冊頁面中,我們希望客戶端在其信息存儲到數據庫後存儲從服務器端接收到的 JWT。這個令牌將用於後續的 API 請求,所以我們將這個函數添加到我們的代碼中;
onSubmitSignUp = () => {
console.log(this.state);
axios
.post("http://localhost:3001/register", {
email: this.state.email,
password: this.state.password,
name: this.state.name,
enteries: this.state.enteries,
})
.then((response) => {
if (response.data.accessToken) {
localStorage.setItem("user", JSON.stringify(response.data));
} else {
console.log("no response");
}
});
};
完成此操作後,令牌將存儲在客戶端的本地存儲中。我們將對登錄頁面執行相同的操作,以便在現有用戶登錄時為後續 API 調用創建令牌。
onSubmitSignIn = () => {
console.log(this.state);
axios
.post("http://localhost:3001/signin", {
email: this.state.email,
password: this.state.password,
})
.then((response) => {
if (response.data.accessToken) {
localStorage.setItem("user", JSON.stringify(response.data));
} else {
console.log("no response");
}
});
};
對於我們的身份驗證路由,我們必須從存儲中檢索已經存儲的令牌,然後將其發送到服務器端進行身份驗證和進一步操作。
export default function authHeader() {
const user = JSON.parse(localStorage.getItem("user"));
if (useraccessToken) {
return { "x-auth-token": user.accessToken };
}
}
axios.post("http://localhost:3001/protected", { header: authHeader() });
完成所有這些後,我們已經成功設置了一個可以與我們的 node.js(後端)一起工作的有效身份驗證系統,創建我們的令牌,並將其發送到我們的 react.js(前端),然後存儲我們的令牌並將其用於對我們受保護路由的後續請求。
到目前為止,我們已經了解了 JWT 身份驗證、JWT 結構、什麼是 JWT 身份驗證、它是如何工作的以及如何將它添加到我們的服務器端 node.js 路由和我們的 React.js 應用程序中。您可以在此處了解有關 JWT 以及使您更輕鬆、更安全地使用 JWT 身份驗證的庫和工具的更多信息。我希望本教程對您有所幫助,享受使用 JSON Web 令牌驗證請求的樂趣。
鏈接:https ://blog.openreplay.com/authentication-with-jwt-for-your-website
#jwt #authentication
1658990713
Depuis l'avènement du développement d'applications Web, de nombreuses informations sensibles sont envoyées via Internet, ce qui rend le concept d'authentification quelque chose que chaque développeur Web devrait comprendre et appliquer dans une application pour sécuriser les informations confiées à l'application par l'utilisateur. Dans cet article, nous examinerons un moyen d'authentification pour les applications Web appelé authentification JWT. Comparée à d'autres, l'authentification JWT est devenue un favori en raison de ses nombreux avantages pour les développeurs.
Avant de plonger dans le codage, nous définirons quelques termes et concepts clés pour nous aider à comprendre le fonctionnement de l'authentification JWT, après quoi nous intégrerons cette forme d'authentification dans un projet qui a un serveur créé avec Node.js, et un front-end a créé avec React.js un framework largement utilisé (en fait mon préféré) pour le développement front-end.
Pour pouvoir suivre le reste de l'article, vous avez besoin des éléments suivants :
JWT signifie JSON Web Token, une norme ouverte utilisée pour partager des informations de sécurité en tant qu'objet JSON entre un client et un serveur. La présence d'un JWT dans une requête au serveur du client signifie que l'information est vérifiée, et sa crédibilité est établie car elle est signée numériquement à l'aide d'un secret écrit avec un algorithme cryptographique pour s'assurer que les revendications ne sont pas altérées après la jeton est émis. Bien qu'aucun intermédiaire ne puisse modifier un JWT, il est recommandé de l'utiliser dans un environnement HTTPS car le JWT n'est pas chiffré.
L'authentification JWT est un mécanisme d'authentification sans état couramment utilisé comme session sans état côté client. Le serveur n'a pas besoin de s'appuyer entièrement sur une base de données pour enregistrer les informations de session. Les informations de session sont stockées côté client ; par conséquent, une recherche dans la base de données n'est pas nécessaire pour vérifier l'identité de l'utilisateur demandeur. Cela fonctionne comme ceci :
Il y a plusieurs avantages :
Cependant, il y a aussi quelques inconvénients :
Pour faire face à ces défis, certaines bibliothèques JWT ajoutent une couche au-dessus de la spécification standard, permettant des mécanismes d'actualisation des jetons et certaines fonctionnalités comme forcer un utilisateur à se ré-authentifier. Voici quelques recommandations pour les développeurs JWT.
Un jeton Web JSON dans sa forme compacte se compose de trois parties séparées par des points, qui sont :
L'en-tête contient deux parties : le type de jeton et l'algorithme de signature. L'algorithme de signature peut être HMAC SHA256 ou RSA. Ce JSON est ensuite encodé en Base64Url pour former la première partie du JWT. Voici un exemple d'en-tête :
{
"alg" : "HS256",
"typ": "JWT"
}
La charge utile contient principalement des réclamations. Les revendications sont des déclarations concernant un élément, dans notre cas, l'utilisateur, et des données supplémentaires. Le serveur utilise généralement ces informations pour vérifier que l'utilisateur est autorisé à effectuer l'action qu'il demande. Par exemple:
{
"iss":" Signin route",
"name": "janet",
"sub":"2"
"admin": true
}
Enfin, la signature est utilisée pour vérifier que le message n'a pas été modifié, et elle est également utilisée pour vérifier que l'expéditeur du JWT est celui qu'il prétend être. La signature est créée en prenant l'en-tête encodé, la charge utile encodée, un secret et l'algorithme spécifié dans l'en-tête et en encodant cela. Par exemple, si vous souhaitez utiliser l'algorithme HMAC SHA256, la signature sera créée de cette manière :
HMAC256(
base64UrlEncode(header) + "." + base64UrlEncode(payload), secret
)
Une fois tout cela fait, nous obtenons trois chaînes Base64Url représentant les trois parties différentes d'un jeton JWT séparées par des points qui peuvent être facilement transmises dans les environnements HTML et HTTP. Voici un exemple de https://token.dev/paseto/ montrant l'en-tête, la charge utile, la signature et nos trois chaînes Base64Url séparées par des points.
Node.js est un environnement d'exécution JavaScript open source, multiplateforme et back-end qui exécute du code JavaScript en dehors d'un navigateur Web. Il a été conçu pour créer des applications réseau évolutives. Pour moi, Node.js est le React du développement web back-end. À l'aide de Node.js, nous allons créer nos routes de connexion, d'enregistrement et d'authentification qui recevront les informations de l'utilisateur depuis le front-end, hacheront les mots de passe si nécessaire, créeront, vérifieront et authentifieront l'utilisateur chaque fois que l'utilisateur se connectera et demandera à accéder à notre route protégée.
Aux côtés de Node.js pour ce projet, nous avons utilisé PostgreSQL pour créer notre base de données ; vous pouvez apprendre à le faire ici , Knex.js pour la création de requêtes et bcrypt.js pour hacher nos mots de passe afin que si notre base de données est compromise, le mot de passe de l'utilisateur ne soit pas disponible pour le pirate.
Tout d'abord, nous devons installer la bibliothèque JWT et les autres dépendances dont nous aurons besoin pour ce projet. Pour ce faire, nous allons exécuter la commande suivante :
1npm i jsonwebtoken bcrypt knex postgres --save
Nous stockerons ensuite notre secret dans notre fichier .env ;
1REACT_APP_TOKEN= "jwtsecrettutorial"
Nous allons créer notre point de terminaison d'enregistrement qui recevra les informations de l'utilisateur à partir de la requête frontale, hachera le mot de passe, enverra les informations à notre base de données, créera notre jeton JWT et répondra au frontal avec notre jeton JWT ;
app.post("/register", (req, res, db, bcrypt, jwt) => {
const { email, name, password } = req.body;
if (!email || !name || !password) {
return res
.status(400)
.json(`${console.log(req.body)}incorrect form submission`);
}
//Hashing our password with bcrypt
const hash = bcrypt.hashSync(password);
db.transaction((trx) => {
trx
.insert({
hash: hash,
email: email,
})
//Inserting our user's info into our login and user table
.into("login")
.returning("email")
.then((loginEmail) => {
return trx("users").returning("*").insert({
email: loginEmail[0].email,
name: name,
joined: new Date(),
});
})
//creating the JWT token and responding to the front end with our token
.then((user) => {
const accessToken = jwt.sign({ email }, process.env.REACT_APP_TOKEN, {
expiresIn: "3000s",
});
res.json({ accessToken });
});
})
.then(trx.commit)
.catch(trx.rollback);
});
Les informations du client ont été envoyées au serveur à l'aide de Postman dans l'image ci-dessus. Après avoir enregistré les informations du client, le serveur répond avec le jeton JWT pour une demande ultérieure.
Pour la route de connexion, nous allons créer notre point de terminaison pour recevoir les informations de l'utilisateur à partir de la demande frontale, vérifier si l'utilisateur existe dans notre base de données, et si l'utilisateur existe, un jeton JWT est créé et envoyé au côté client. ; ce jeton sera utilisé pour une requête API ultérieure.
app.post("/signin", (req, res, db, bcrypt, jwt) => {
const { email, password } = req.body;
if (!email || !password) {
return res.status(400).json("incorrect form submission");
}
//Getting the user info from the database
db.select("email", "hash")
.from("login")
.where("email", "=", email)
.then((data) => {
//comparing the password rech the one in the database using bcrypt
const isValid = bcrypt.compareSync(password, data[0].hash);
if (isValid) {
return db
.select("*")
.from("users")
.where("email", "=", email)
.then((user) => {
const accessToken = jwt.sign(
{ email },
process.env.REACT_APP_TOKEN,
{ expiresIn: "3000s" }
);
res.json({ accessToken });
})
.catch((err) => res.status(400).json(`${err}wrong credentials`));
} else {
res.status(400).json(`${err}wrong credentials`);
}
})
.catch((err) => res.status(400).json(`${err}wrong credentials`));
});
Dans l'image ci-dessus, les informations du client ont été envoyées au serveur à l'aide de Postman. Après vérification et confirmation des informations du client, le serveur a répondu avec le jeton JWT pour les demandes ultérieures.
Pour l'authentification, nous allons créer un middleware qui effectue l'authentification chaque fois qu'une demande est faite via notre route protégée. Cette route nécessitera le jeton d'utilisateur dans l'en-tête de la demande en tant que "x-auth-token" pour l'autorisation. Le jeton sera obtenu à partir de l'en-tête et vérifié par notre middleware. Vous pouvez en savoir plus sur l'autorisation HTTP via un en-tête de requête ici . Pour créer le middleware, utilisez le code ci-dessous ;
require("dotenv").config();
var jwt = require("jsonwebtoken");
module.exports = {
jwtauth(req, res, next) {
const token = req.header("x-auth-token");
if (!token) {
res.status(401).json("token not found");
}
try {
const user = jwt.verify(token, process.env.REACT_APP_TOKEN);
req.user = user.email;
console.log("middleware is working");
next();
} catch (error) {
res.status(401).json("invalid token");
}
},
};
Nous pouvons maintenant ajouter une route protégée à notre serveur ; une demande à cette route passera d'abord par notre middleware avant que l'accès ne soit accordé ou refusé.
const jwtauth = require("./middleware/jwtauth");
app.post("/protected", jwtauth, (req, res) => {
res.status(200).send("Here's the info you requested ");
});
Si une demande est faite sans fournir de jeton en utilisant le 'x-access-token' dans l'en-tête, un message d'erreur sera renvoyé disant « jeton introuvable ».
Dans l'image ci-dessus, une requête est envoyée au serveur via Postman sans le jeton dans l'en-tête, et le serveur répond avec un message d'erreur indiquant que jeton introuvable. Si un jeton est fourni dans l'en-tête et que ce jeton est correct, il permet au client d'accéder à la route protégée, mais si le jeton est erroné, il répond par un message d'erreur disant « jeton invalide ».
Dans l'image ci-dessus, une requête est envoyée au serveur via Postman avec un jeton incorrect dans l'en-tête, et le serveur répond avec un message d'erreur indiquant un jeton invalide.
Pour ce faire, vous auriez besoin d'installer Axios dans notre front-end créé avec React.js en faisant;
1npm i axios
Dans notre page d'enregistrement/d'inscription dans notre React.js, nous voulons que notre côté client stocke le JWT qu'il reçoit du côté serveur après que leurs informations soient stockées dans la base de données. Ce jeton sera utilisé pour les requêtes API ultérieures, nous ajoutons donc cette fonction à notre code ;
onSubmitSignUp = () => {
console.log(this.state);
axios
.post("http://localhost:3001/register", {
email: this.state.email,
password: this.state.password,
name: this.state.name,
enteries: this.state.enteries,
})
.then((response) => {
if (response.data.accessToken) {
localStorage.setItem("user", JSON.stringify(response.data));
} else {
console.log("no response");
}
});
};
Ceci fait, le jeton est stocké dans notre stockage local côté client. Nous ferons la même chose pour notre page de connexion afin qu'un jeton soit créé pour les appels d'API ultérieurs lorsqu'un utilisateur déjà existant se connecte.
onSubmitSignIn = () => {
console.log(this.state);
axios
.post("http://localhost:3001/signin", {
email: this.state.email,
password: this.state.password,
})
.then((response) => {
if (response.data.accessToken) {
localStorage.setItem("user", JSON.stringify(response.data));
} else {
console.log("no response");
}
});
};
Pour notre route d'authentification, nous devons récupérer le jeton déjà stocké de notre stockage qui sera ensuite envoyé côté serveur pour authentification et action ultérieure.
export default function authHeader() {
const user = JSON.parse(localStorage.getItem("user"));
if (useraccessToken) {
return { "x-auth-token": user.accessToken };
}
}
axios.post("http://localhost:3001/protected", { header: authHeader() });
Avec tout cela fait, nous avons mis en place avec succès un système d'authentification fonctionnel qui fonctionne avec notre node.js (back-end), crée notre jeton et l'envoie à notre react.js (front-end), qui stocke ensuite notre jeton et l'utilise pour les requêtes ultérieures vers notre route protégée.
Jusqu'à présent, nous avons examiné l'authentification JWT, la structure JWT, ce qu'est l'authentification JWT, son fonctionnement et comment l'ajouter à nos routes node.js côté serveur et à notre application React.js. Vous pouvez en savoir plus sur JWT et les bibliothèques et outils qui facilitent et sécurisent votre utilisation de l'authentification JWT ici . J'espère que ce tutoriel vous a été utile, amusez-vous à authentifier les demandes avec les jetons Web JSON.
Lien : https://blog.openreplay.com/authentication-with-jwt-for-your-website
#jwt #authentication
1658983382
Since the advent of web application development, a lot of sensitive information is being sent through the internet making the concept of authentication something every web developer should understand and apply in an application to secure the information entrusted to the application by the user. In this article, we’ll look at a means of authentication for web applications known as JWT authentication. Compared to others, JWT authentication has become a favorite due to its many advantages to developers.
Before we dive into coding, we’ll be defining some key terms and concepts to help us understand how JWT authentication works, after which we will be integrating this form of authentication into a project that has a server created with Node.js, and a front-end created with React.js a widely used framework (actually my personal favorite) for front-end development.
To be able to follow through with the rest of the article, you need the following:
See more at: https://blog.openreplay.com/authentication-with-jwt-for-your-website
#jwt #authentication
1658648340
Un « fournisseur de services d'authentification » fait référence à une entité qui fournit des services d'authentification. Le fournisseur d'authentification élimine la complexité de la mise en œuvre manuelle du système d'authentification à partir de zéro afin que vous puissiez vous concentrer sur des tâches plus importantes.
Cet article présente les avantages et les inconvénients de l'utilisation d'un fournisseur d'authentification et compare ceux existants qui prennent en charge l'intégration JWT.
Avant de choisir un fournisseur de services d'authentification, il est essentiel d'évaluer les avantages et les inconvénients de son utilisation.
L'utilisation d'un fournisseur de services d'authentification élimine la complexité de la mise en œuvre du système d'authentification vous-même. La construction d'un tel système est un processus long et complexe nécessitant de nombreuses ressources.
Vous pouvez utiliser une solution existante qui libère ces ressources pour d'autres tâches plus critiques.
Stocker des informations confidentielles sur des personnes n'est pas quelque chose à prendre à la légère. Choisir d'utiliser un fournisseur signifie que vous n'avez pas à vous soucier du stockage des détails des utilisateurs sur vos serveurs.
Vous pouvez activer les connexions sociales avec un minimum d'effort lorsque vous utilisez un fournisseur de services d'authentification. La connexion sociale fait référence à la connexion à l'aide d'un compte de réseau social existant tel que Twitter, GitHub, Google, etc.
La mise en œuvre de chaque fournisseur social individuellement nécessite des efforts et des ressources. Lorsque vous utilisez un fournisseur d'authentification, l'ajout de connexions sociales devient plus facile et plus rapide.
Choisir d'utiliser un fournisseur d'authentification signifie une meilleure sécurité. Un fournisseur d'authentification se concentre entièrement sur l'authentification et l'autorisation. Cela signifie qu'ils sont mieux formés et équipés pour assurer la sécurité des informations des utilisateurs.
Une fois que vous avez choisi un fournisseur de services d'authentification, il peut être difficile de migrer. Passer à un autre fournisseur ou lancer un système propriétaire peut être difficile.
Il est essentiel de décider s'il est judicieux d'utiliser un fournisseur d'authentification ou non. Si vous choisissez de le faire, assurez-vous de choisir le fournisseur qui correspond à vos besoins et exigences.
Un autre inconvénient est que vous pourriez devenir trop dépendant du fournisseur que vous utilisez. Les raisons peuvent être que votre implémentation est trop spécifique à ce fournisseur ou qu'il est presque impossible d'exporter vos données utilisateur actuelles.
La migration vers un autre fournisseur peut devenir trop coûteuse et prendre trop de temps, vous êtes donc bloqué avec le fournisseur actuel.
Au début, les coûts pourraient ne pas être un problème. Cependant, une fois que l'application grandit et compte plus d'utilisateurs, les coûts peuvent devenir un problème.
De nombreux fournisseurs d'authentification facturent en fonction du nombre d'utilisateurs actifs mensuels. Plus vous avez d'utilisateurs, plus la facture augmente.
Devriez-vous utiliser un fournisseur de services d'authentification ou implémenter un système propriétaire ? Il n'y a pas de réponse définitive.
La décision d'utiliser ou non un fournisseur dépend de nombreux facteurs. Pour certains, l'utilisation d'un fournisseur d'authentification est la solution appropriée, alors que pour d'autres, ce n'est pas le cas.
Si vous décidez d'en utiliser un, continuez à lire pour en savoir plus sur les différents fournisseurs de services d'authentification disponibles.
L'article compare les fournisseurs de services d'authentification suivants :
Ces fournisseurs d'authentification sont évalués sur la base de six critères d'évaluation.
Un projet open source présente une poignée d'avantages. Un avantage serait les économies de coûts. Comme ils sont open source, ils ne nécessitent ni licence ni frais d'utilisation.
Un autre avantage est la flexibilité. Si les besoins de l'entreprise changent ou si vous avez besoin de fonctionnalités supplémentaires, vous pouvez modifier et étendre le code vous-même. Vous n'avez pas à demander au fournisseur des modifications ou à le modifier complètement.
Il est également important de mentionner la transparence. Le code est accessible à tous. Étant donné que de nombreux professionnels ont accès au code, ils peuvent améliorer le logiciel et le rendre plus sûr.
L'utilisation d'un fournisseur d'authentification open source présente également d'autres avantages, mais ces avantages enfoncent le clou.
Lors de l'intégration d'un fournisseur de services d'authentification à Hasura, il est important de s'assurer qu'il prend en charge les revendications JWT personnalisées.
Hasura vérifie les revendications JWT personnalisées pour en savoir plus sur le rôle de l'utilisateur à l'origine de la demande. Par conséquent, Hasura peut appliquer les règles d'autorisation appropriées.
{
'x-hasura-default-role': 'user',
'x-hasura-allowed-roles': ['user'],
'x-hasura-user-id': user.user_id
};
L'extrait ci-dessus montre un exemple de revendications JWT personnalisées. Il contient des informations essentielles sur la demande.
Dans les termes les plus simples, SSO fait référence au type d'authentification où l'utilisateur se connecte à plusieurs plates-formes avec un ensemble d'informations d'identification.
Un exemple est le Social SSO, où l'utilisateur utilise un compte de réseau social tel que le compte Google pour se connecter à une application.
Ce ne sont pas toujours les utilisateurs qui font les demandes. Il existe des scénarios où deux machines communiquent entre elles. Il n'y a pas d'utilisateur pour saisir les informations d'identification, de sorte que le client (une autre machine) doit être authentifié d'une autre manière.
L'authentification machine à machine (M2M) fait référence à l'authentification des machines sans intervention de l'utilisateur. Cela est possible en utilisant le flux d'informations d'identification client OAuth 2.0. Les informations d'identification incluent a client_id
et client_secret
, qui sont utilisées pour authentifier le client.
Tous les fournisseurs d'authentification de cet article ont un niveau gratuit. La différence réside dans ce qu'ils offrent dans ce niveau.
Ils mesurent les utilisateurs actifs mensuels (MAU) et facturent en fonction de cela. En conséquence, certains fournisseurs proposent un niveau gratuit avec des milliers de MAU, tandis que d'autres n'offrent que quelques centaines de MAU.
L'intégration d'un fournisseur de services d'authentification dépend de nombreux facteurs. Il est difficile de présenter à quel point il est facile ou difficile d'intégrer un fournisseur.
Cependant, certains points peuvent indiquer le niveau de difficulté de la mise en œuvre, tels que :
L'image illustre une comparaison entre les fournisseurs d'authentification présentés dans cet article.
Auth0 est une solution bien établie et populaire pour les services d'authentification. Il est livré avec un niveau gratuit généreux et prend en charge la plupart des choses dont vous avez besoin.
OPEN SOURCE | NON |
---|---|
SaaS | Oui |
Prise en charge de l'authentification unique | Oui |
Revendications personnalisées JWT | Oui |
Authentification machine à machine | Oui |
Forfait gratuit | Oui - jusqu'à 7000 MAU |
En ce qui concerne la facilité d'intégration, Auth0 n'est ni facile ni difficile à intégrer. Comme il s'agit d'une solution bien établie et largement répandue, de nombreux documents sont disponibles pour vous aider dans l'intégration. La quantité de configuration que vous devez effectuer dépend du type et de la complexité de votre application.
Firebase Authentication est un autre service d'authentification populaire qui vous permet d'ajouter une authentification à vos applications.
Firebase vous permet d'ajouter des méthodes de connexion telles que :
OPEN SOURCE | NON |
---|---|
SaaS | Non |
Prise en charge de l'authentification unique | Oui |
Revendications personnalisées JWT | Oui |
Authentification machine à machine | Oui |
Forfait gratuit | Gratuit sauf pour l'authentification par téléphone |
La quantité de ressources disponibles rend le processus d'intégration plus simple. La communauté Firebase crée de nombreuses ressources open source que vous pouvez utiliser. C'est aussi un fournisseur bien établi, ce qui signifie que vous êtes susceptible de trouver une solution à presque tous les problèmes.
Enfin, il contient une documentation détaillée expliquant comment implémenter Firebase Auth dans les applications Web et mobiles.
Comparé aux autres fournisseurs, Clerk est le plus récent. Clerk vous permet d'implémenter des profils d'inscription, de connexion et d'utilisateur dans vos applications. Selon leur site Web, il s'agit d'une "plate-forme d'identité client complète".
Clerk est également livré avec le support Hasura. Ils ont une section de documentation spéciale qui montre comment intégrer Clerk à Hasura.
OPEN SOURCE | NON |
---|---|
SaaS | Oui |
Prise en charge de l'authentification unique | SSO sociale |
Revendications personnalisées JWT | Oui |
Authentification machine à machine | Non |
Forfait gratuit | Oui - jusqu'à 500 MAU |
Comme il est relativement nouveau, vous pourriez rencontrer des problèmes qui ne sont pas encore documentés/résolus. En dehors de cela, Clerk dispose d'une documentation complète et approfondie.
La configuration nécessaire pour intégrer Clerk à votre application est minime. Vous avez besoin d'un compte Clerk, puis vous pouvez utiliser les SDK et les composants fournis par eux.
Keycloak est un fournisseur de services d'authentification open source populaire. Puisqu'il est open source, vous pouvez l'auto-héberger, ce qui signifie qu'il est gratuit quel que soit le nombre d'utilisateurs actifs mensuels.
Même s'il est open source et ouvert à tous pour contribuer, le projet est maintenu par Red Hat. Cela signifie que vous pouvez faire confiance au projet.
Keycloak prend en charge la plupart des cas d'utilisation de l'authentification, et il est également gratuit, il peut donc être un excellent choix.
OPEN SOURCE | OUI |
---|---|
SaaS | Non |
Prise en charge de l'authentification unique | Oui |
Revendications personnalisées JWT | Oui |
Authentification machine à machine | Oui |
Forfait gratuit | Gratuit pour un nombre illimité d'utilisateurs |
Keycloak a un niveau modéré de difficulté de mise en œuvre. Outre l'intégration de Keycloak dans vos applications, vous devez également vous occuper du déploiement et de la maintenance.
Même si cela peut sembler compliqué à première vue, vous pouvez vous habituer rapidement à Keycloak. Il s'agit également d'un produit établi, ce qui signifie que vous êtes susceptible de trouver des solutions à la plupart de vos problèmes. Enfin, il a une bonne documentation.
Cognito est le produit d'Amazon pour gérer l'authentification. Il vous permet d'implémenter l'authentification dans vos applications Web et mobiles.
Cognito est l'un des fournisseurs d'authentification les plus généreux, vous offrant un forfait gratuit avec jusqu'à 50 000 utilisateurs actifs par mois. Si les coûts sont une préoccupation et que vous souhaitez une solution gérée, Cognito est un excellent choix.
OPEN SOURCE | NON |
---|---|
SaaS | Non |
Prise en charge de l'authentification unique | Oui |
Revendications personnalisées JWT | Oui |
Authentification machine à machine | Oui |
Forfait gratuit | Gratuit jusqu'à 50 000 utilisateurs actifs mensuels (qui se connectent directement aux groupes d'utilisateurs Cognito) |
En ce qui concerne la facilité d'intégration, Amazon Cognito peut être assez difficile à mettre en œuvre par rapport à d'autres fournisseurs. Cognito nécessite une configuration complexe, même pour les applications de base.
Cependant, il existe de nombreux documents officiels et communautaires pour vous aider à intégrer Cognito à votre application. Une poignée de SDK et d'exemples d'applications sont également disponibles pour vous aider et vous inspirer.
Découvrez comment intégrer Cognito à Hasura
SuperTokens est un service relativement nouveau. Il prend en charge presque tout ce dont vous avez besoin, et il est également open source. Cela signifie que vous pouvez l'héberger vous-même et éviter des frais supplémentaires. Si vous choisissez de vous auto-héberger, c'est gratuit pour toujours pour un nombre illimité d'utilisateurs.
SuperTokens est livré avec le support Hasura, avec une section spéciale sur la façon d'intégrer SuperTokens avec Hasura.
OPEN SOURCE | OUI |
---|---|
SaaS | Oui |
Prise en charge de l'authentification unique | Oui |
Revendications personnalisées JWT | Oui |
Authentification machine à machine | Oui |
Forfait gratuit | Libérez pour un nombre illimité d'utilisateurs (Self Hosted) et jusqu'à 5000 MAU (SaaS) |
En ce qui concerne la facilité d'intégration, vous pouvez rencontrer des difficultés lorsque vous essayez de l'intégrer à votre application. La raison en est qu'il s'agit d'un nouveau service et qu'il n'y a pas beaucoup de matériel disponible sur Internet pour le moment.
En ce qui concerne la configuration, il est relativement facile de démarrer avec SuperTokens puisque la documentation fournit tous les paramètres et informations dont vous avez besoin.
SuperTokens propose également des guides sur l'intégration de SuperTokens à Hasura et des exemples d'applications de démonstration SuperTokens + Hasura.
Nhost Authentication est un service d'authentification open source pour Hasura. Avec l'authentification Nhost, les utilisateurs peuvent se connecter avec :
Comme il s'agit d'un projet open source, vous pouvez l'auto-héberger et éviter les frais supplémentaires que vous paieriez lors de l'utilisation d'un service géré.
OPEN SOURCE | OUI |
---|---|
SaaS | Non |
Prise en charge de l'authentification unique | Oui |
Revendications personnalisées JWT | Oui |
Authentification machine à machine | Non |
Forfait gratuit | Gratuit pour un nombre illimité d'utilisateurs |
En ce qui concerne la facilité d'intégration, l'authentification Nhost est assez simple à intégrer aux applications Hasura. Vous pouvez soit créer une application via Nhost, ce qui vous donne un backend prêt à l'emploi avec Hasura, Hasura Auth et Postgres, soit utiliser l'image Nhost Authentication Docker pour l'auto-héberger.
Vous pouvez vérifier l'authentification Nhost ici .
L'évolutivité fait référence à la capacité du service d'authentification à gérer la croissance de vos applications et l'évolution des besoins de l'entreprise. Le service d'authentification doit suivre la croissance de vos utilisateurs et l'évolution des exigences sans affecter votre application.
Si vous décidez d'utiliser une solution auto-hébergée, vous avez l'entière responsabilité en matière de mise à l'échelle. Vous devez gérer la base de données, les serveurs et toute l'infrastructure. Il est de votre responsabilité de vous assurer que tout fonctionne correctement.
Lorsque vous utilisez une solution gérée, le fournisseur d'authentification s'occupe de l'évolution vers le haut et vers le bas. Le fournisseur d'authentification a des limites de débit et des quotas prédéfinis, qu'il utilise pour la mise à l'échelle.
Tous les fournisseurs présentés dans cet article sont d'excellents choix, mais il n'y a pas de réponse universelle. Le choix d'un fournisseur de services d'authentification dépend de ses besoins et de ses exigences.
SuperTokens et Clerk sont deux fournisseurs notables qui prennent officiellement en charge Hasura. "Support" signifie qu'ils ont une section spéciale dans leur documentation illustrant comment les intégrer à Hasura. C'est un plus, et cela aide beaucoup lors de l'intégration de l'un d'entre eux à Hasura.
Il est important de noter qu'il ne s'agit pas d'une liste exhaustive. Il existe d'autres fournisseurs disponibles qui ne sont pas présents dans l'article. Cependant, l'article sera mis à jour occasionnellement et de nouveaux fournisseurs seront ajoutés.
Source : https://hasura.io/blog/top-authentication-providers-building-apps-jwt/
1658647860
Um “Provedor de Serviços de Autenticação” refere-se a uma entidade que fornece serviços de autenticação. O Provedor de Autenticação abstrai a complexidade de implementar o sistema de autenticação manualmente do zero para que você possa se concentrar em tarefas mais importantes.
Este artigo apresenta as vantagens e desvantagens de usar um Provedor de Autenticação e compara os existentes que suportam a integração JWT.
Antes de escolher um provedor de serviços de autenticação, é essencial avaliar as vantagens e desvantagens de usar um.
O uso de um provedor de serviços de autenticação abstrai a complexidade de implementar o sistema de autenticação por conta própria. Construir tal sistema é um processo complexo e demorado que requer muitos recursos.
Você pode usar uma solução existente que libera esses recursos para outras tarefas mais críticas.
Armazenar informações confidenciais sobre as pessoas não é algo que deve ser tomado de ânimo leve. Optar por usar um provedor significa que você não precisa se preocupar em armazenar os detalhes dos usuários em seus servidores.
Você pode habilitar logins sociais com esforço mínimo ao usar um provedor de serviços de autenticação. O login social refere-se ao login usando uma conta de rede social existente, como Twitter, GitHub, Google e assim por diante.
A implementação de cada provedor social individualmente requer esforço e recursos. Ao usar um provedor de autenticação, adicionar logins sociais fica mais fácil e rápido.
Optar por usar um provedor de autenticação significa melhor segurança. Todo o foco de um Auth Provider está na autenticação e autorização. Isso significa que eles estão mais bem treinados e equipados para manter as informações dos usuários seguras.
Depois de escolher um provedor de serviços de autenticação, pode ser difícil migrar. Mudar para outro provedor ou rolar um sistema proprietário pode ser difícil.
É essencial decidir se faz sentido usar um provedor de autenticação ou não. Se você optar por fazê-lo, certifique-se de escolher o provedor que atende às suas necessidades e requisitos.
Outra desvantagem é que você pode se tornar muito dependente do provedor que está usando. Os motivos podem ser que sua implementação é muito específica para esse fornecedor ou é quase impossível exportar seus dados de usuário atuais.
Migrar para outro provedor pode se tornar muito caro e demorado, então você fica bloqueado com o atual.
No início, os custos podem não ser um problema. No entanto, depois que o aplicativo cresce e tem mais usuários, os custos podem se tornar um problema.
Muitos dos provedores de autenticação cobram com base no número de usuários ativos mensais. Quanto mais usuários você tiver, maior será a conta.
Você deve usar um provedor de serviços de autenticação ou implementar um sistema proprietário? Não há uma resposta definitiva.
A decisão de usar ou não um Provedor depende de muitos fatores. Para alguns, usar um Auth Provider é a solução apropriada, enquanto para outros não é.
Caso você decida usar um, continue lendo para conhecer os vários Provedores de Serviços de Autenticação disponíveis.
O artigo compara os seguintes provedores de serviços de autenticação:
Esses provedores de autenticação são avaliados com base em seis critérios de avaliação.
Um projeto de código aberto vem com um punhado de benefícios. Um benefício seria a redução de custos. Por serem de código aberto, não exigem licenciamento ou taxas de uso.
Outro benefício é a flexibilidade. Se os requisitos de negócios mudarem ou você precisar de recursos adicionais, você mesmo poderá modificar e estender o código. Você não precisa pedir alterações ao fornecedor ou alterá-lo completamente.
É importante mencionar a transparência também. O código está disponível para todos verem. Como muitos profissionais têm acesso ao código, eles podem tornar o software melhor e mais seguro.
Há outros benefícios de usar um provedor de autenticação de código aberto também, mas esses benefícios levam o ponto principal.
Ao integrar qualquer provedor de serviços de autenticação ao Hasura, é importante garantir que eles ofereçam suporte a declarações JWT personalizadas.
Hasura verifica as declarações JWT personalizadas para saber mais sobre a função do usuário que faz a solicitação. Como resultado, a Hasura pode aplicar as regras de autorização apropriadas.
{
'x-hasura-default-role': 'user',
'x-hasura-allowed-roles': ['user'],
'x-hasura-user-id': user.user_id
};
O snippet acima mostra um exemplo de declarações JWT personalizadas. Ele contém informações essenciais sobre a solicitação.
Em termos mais simples, SSO se refere ao tipo de autenticação em que o usuário faz login em várias plataformas com um conjunto de credenciais.
Um exemplo é o SSO Social, onde o usuário usa uma conta de rede social, como a conta do Google, para fazer login em um aplicativo.
Nem sempre são os usuários que fazem as solicitações. Existem cenários em que duas máquinas se comunicam entre si. Não há usuário para inserir as credenciais, portanto, o cliente (outra máquina) precisa ser autenticado de outra maneira.
A autenticação máquina a máquina (M2M) refere-se à autenticação de máquinas sem entrada do usuário. Isso é possível usando o fluxo de credenciais do cliente OAuth 2.0. As credenciais incluem um client_id
e client_secret
, que são usados para autenticar o cliente.
Todos os provedores de autenticação deste artigo têm um nível gratuito. A diferença está no que eles oferecem nesse nível.
Eles medem os usuários ativos mensais (MAUs) e cobram com base nisso. Como resultado, alguns provedores oferecem um nível gratuito com milhares de MAUs, enquanto alguns oferecem apenas algumas centenas de MAUs.
A integração de um provedor de serviços de autenticação depende de muitos fatores. É desafiador apresentar como é fácil ou difícil integrar um provedor.
No entanto, existem alguns pontos que podem indicar o nível de dificuldade da implementação, como:
A imagem ilustra uma comparação entre os provedores de autenticação apresentados neste artigo.
Auth0 é uma solução bem estabelecida e popular para serviços de autenticação. Ele vem com um nível gratuito generoso e tem suporte para a maioria das coisas que você precisa.
CÓDIGO ABERTO | NÃO |
---|---|
SaaS | Sim |
Suporte SSO | Sim |
Reivindicações personalizadas de JWT | Sim |
Autenticação máquina a máquina | Sim |
Plano gratuito | Sim - até 7000 MAU |
Quando se trata da facilidade de integração, Auth0 não é fácil nem difícil de integrar. Por se tratar de uma solução bem estabelecida e difundida, uma grande quantidade de material está disponível para ajudá-lo na integração. A quantidade de configuração que você precisa fazer depende do tipo e da complexidade do seu aplicativo.
O Firebase Authentication é outro serviço de autenticação popular que permite adicionar autenticação aos seus aplicativos.
O Firebase permite adicionar métodos de login, como:
CÓDIGO ABERTO | NÃO |
---|---|
SaaS | Não |
Suporte SSO | Sim |
Reivindicações personalizadas de JWT | Sim |
Autenticação máquina a máquina | Sim |
Plano gratuito | Gratuito, exceto para autenticação por telefone |
A quantidade de recursos disponíveis torna o processo de integração mais simples. A comunidade do Firebase cria muitos recursos de código aberto que você pode usar. Também é um provedor bem estabelecido, o que significa que você provavelmente encontrará uma solução para quase qualquer problema.
Por fim, há uma documentação detalhada sobre como implementar o Firebase Auth em aplicativos da Web e de dispositivos móveis.
Comparado aos outros provedores, o Clerk é o mais novo. O Clerk permite que você implemente perfis de inscrição, entrada e usuário em seus aplicativos. De acordo com seu site, eles são uma “Plataforma de Identidade do Cliente completa”.
Clerk também vem com suporte Hasura. Eles têm uma seção de documentação especial que mostra como integrar Clerk com Hasura.
CÓDIGO ABERTO | NÃO |
---|---|
SaaS | Sim |
Suporte SSO | SSO Social |
Reivindicações personalizadas de JWT | Sim |
Autenticação máquina a máquina | Não |
Plano gratuito | Sim - até 500 MAU |
Como é relativamente novo, você pode encontrar problemas que ainda não foram documentados/resolvidos. Fora isso, o Clerk possui uma documentação extensa e detalhada.
A configuração necessária para integrar o Clerk ao seu aplicativo é mínima. Você precisa de uma conta de funcionário e, em seguida, pode usar os SDKs e os componentes fornecidos por eles.
Keycloak é um provedor de serviços de autenticação de código aberto popular. Como é de código aberto, você pode hospedá-lo automaticamente, o que significa que é gratuito, independentemente do número de usuários ativos mensais.
Mesmo sendo de código aberto e aberto a todos para contribuir, o projeto é mantido pela Red Hat. Isso significa que você pode confiar no projeto.
O Keycloak é compatível com a maioria dos casos de uso de autenticação e também é gratuito, por isso pode ser uma ótima opção.
CÓDIGO ABERTO | SIM |
---|---|
SaaS | Não |
Suporte SSO | Sim |
Reivindicações personalizadas de JWT | Sim |
Autenticação máquina a máquina | Sim |
Plano gratuito | Gratuito para usuários ilimitados |
Keycloak tem um nível moderado de dificuldade de implementação. Além de integrar o Keycloak em seus aplicativos, você também precisa cuidar da implantação e manutenção.
Mesmo que possa parecer complicado à primeira vista, você pode se acostumar com o Keycloak rapidamente. Também é um produto estabelecido, o que significa que você provavelmente encontrará soluções para a maioria dos seus problemas. Por último, tem uma boa documentação.
Cognito é o produto da Amazon para lidar com autenticação. Ele permite que você implemente a autenticação em seus aplicativos da Web e móveis.
O Cognito é um dos provedores de autenticação mais generosos, oferecendo um plano gratuito com até 50.000 usuários ativos mensais. Se os custos são uma preocupação e você deseja uma solução gerenciada, o Cognito é uma excelente escolha.
CÓDIGO ABERTO | NÃO |
---|---|
SaaS | Não |
Suporte SSO | Sim |
Reivindicações personalizadas de JWT | Sim |
Autenticação máquina a máquina | Sim |
Plano gratuito | Libere até 50.000 usuários ativos mensais (que fazem login diretamente nos grupos de usuários do Cognito) |
Com relação à facilidade de integração, o Amazon Cognito pode ser bastante desafiador para implementar em comparação com outros provedores. O Cognito requer uma configuração complexa, mesmo para aplicativos básicos.
No entanto, existem muitos materiais oficiais e comunitários para ajudá-lo a integrar o Cognito ao seu aplicativo. Um punhado de SDKs e aplicativos de amostra também estão disponíveis para ajudar e inspirar você.
Saiba como integrar o Cognito ao Hasura
SuperTokens é um serviço relativamente novo. Ele vem com suporte para quase tudo que você precisa e também é de código aberto. Isso significa que você pode auto-hospedá-lo e evitar custos extras. Se você optar por auto-hospedar, é grátis para sempre para usuários ilimitados.
SuperTokens vem com suporte Hasura, tendo uma seção especial sobre como integrar SuperTokens com Hasura.
CÓDIGO ABERTO | SIM |
---|---|
SaaS | Sim |
Suporte SSO | Sim |
Reivindicações personalizadas de JWT | Sim |
Autenticação máquina a máquina | Sim |
Plano gratuito | Gratuito para usuários ilimitados (auto-hospedado) e até 5000 MAUs (SaaS) |
Quando se trata da facilidade de integração, você pode encontrar algumas dificuldades ao tentar integrá-lo ao seu aplicativo. O motivo é que é um serviço novo e não há muito material disponível na internet no momento.
Com relação à configuração, é razoavelmente fácil começar com os SuperTokens, pois a documentação fornece todas as configurações e informações necessárias.
O SuperTokens também possui guias sobre a integração de SuperTokens com Hasura e aplicativos de demonstração SuperTokens + Hasura de amostra.
Nhost Authentication é um serviço de autenticação de código aberto para Hasura. Com Nhost Authentication, as pessoas podem entrar com:
Como é um projeto de código aberto, você pode hospedá-lo por conta própria e evitar as cobranças extras que pagaria ao usar um serviço gerenciado.
CÓDIGO ABERTO | SIM |
---|---|
SaaS | Não |
Suporte SSO | Sim |
Reivindicações personalizadas de JWT | Sim |
Autenticação máquina a máquina | Não |
Plano gratuito | Gratuito para usuários ilimitados |
Quando se trata da facilidade de integração, o Nhost Authentication é bastante simples de integrar com aplicativos Hasura. Você pode criar um aplicativo por meio do Nhost, que oferece um back-end pronto para uso com Hasura, Hasura Auth e Postgres, ou pode usar a imagem do Nhost Authentication Docker para hospedá-lo.
Você pode verificar a autenticação Nhost aqui .
A escalabilidade refere-se à capacidade do serviço de autenticação de lidar com o crescimento do aplicativo e as mudanças nos requisitos de negócios. O serviço de autenticação deve acompanhar o crescimento do usuário e a mudança de requisitos sem afetar seu aplicativo.
Se você decidir usar uma solução auto-hospedada, terá total responsabilidade no que diz respeito ao dimensionamento. Você precisa gerenciar o banco de dados, os servidores e toda a infraestrutura. É sua responsabilidade garantir que tudo funcione bem.
Quando você usa uma solução gerenciada, o provedor de autenticação se encarrega de aumentar e diminuir a escala. O provedor de autenticação tem cotas e limites de taxa predefinidos, que eles usam para dimensionamento.
Todos os provedores apresentados neste artigo são excelentes opções, mas não há uma resposta universal. A escolha de um provedor de serviços de autenticação depende das necessidades e requisitos de cada um.
SuperTokens e Clerk são dois provedores notáveis que suportam oficialmente o Hasura. "Suporte" significa que eles têm uma seção especial em sua documentação ilustrando como integrá-los ao Hasura. Isso é uma vantagem e ajuda muito ao integrar qualquer um deles com o Hasura.
É importante notar que esta não é uma lista exaustiva. Existem outros provedores disponíveis que não estão presentes no artigo. No entanto, o artigo será atualizado ocasionalmente e novos fornecedores serão adicionados.
Fonte: https://hasura.io/blog/top-authentication-providers-building-apps-jwt/
1658644500
「認証サービスプロバイダー」とは、認証サービスを提供するエンティティを指します。認証プロバイダーは、認証システムを最初から手動で実装する複雑さを抽象化するため、より重要なタスクに集中できます。
この記事では、認証プロバイダーを使用することのメリットとデメリットを紹介し、JWT統合をサポートする既存のプロバイダーを比較します。
認証サービスプロバイダーを選択する前に、それを使用することの利点と欠点を評価することが不可欠です。
認証サービスプロバイダーを使用すると、認証システムを自分で実装する複雑さが抽象化されます。このようなシステムの構築は、多くのリソースを必要とする複雑で時間のかかるプロセスです。
これらのリソースを他のより重要なタスクのために解放する既存のソリューションを使用できます。
人に関する機密情報を保存することは、軽視することではありません。プロバイダーの使用を選択すると、サーバーにユーザーの詳細を保存することを心配する必要がなくなります。
Auth Service Providerを使用すると、最小限の労力でソーシャルログインを有効にできます。ソーシャルログインとは、Twitter、GitHub、Googleなどの既存のソーシャルネットワークアカウントを使用してログインすることです。
各ソーシャルプロバイダーを個別に実装するには、労力とリソースが必要です。認証プロバイダーを使用すると、ソーシャルログインの追加がより簡単かつ迅速になります。
認証プロバイダーの使用を選択すると、セキュリティが向上します。認証プロバイダーの全体的な焦点は、認証と承認にあります。つまり、ユーザーの情報を安全に保つためのトレーニングと設備が整っているということです。
認証サービスプロバイダーを選択すると、移行が困難になる可能性があります。別のプロバイダーに変更したり、独自のシステムをローリングしたりするのは難しい場合があります。
認証プロバイダーを使用することが理にかなっているかどうかを判断することが重要です。それを行うことを選択した場合は、ニーズと要件に合ったプロバイダーを選択してください。
もう1つの欠点は、使用しているプロバイダーに依存しすぎる可能性があることです。その理由は、実装がそのベンダーに固有であるか、現在のユーザーデータをエクスポートすることがほぼ不可能であることが原因である可能性があります。
別のプロバイダーへの移行は、コストと時間がかかりすぎる可能性があるため、現在のプロバイダーでロックされます。
最初は、コストは問題ではないかもしれません。ただし、アプリケーションが大きくなり、ユーザー数が増えると、コストが問題になる可能性があります。
認証プロバイダーの多くは、月間アクティブユーザー数に基づいて課金されます。ユーザーが多いほど、請求額は大きくなります。
認証サービスプロバイダーを使用する必要がありますか、それとも独自のシステムを実装する必要がありますか?決定的な答えはありません。
プロバイダーを使用するかどうかの決定は、多くの要因に依存します。一部の人にとっては、認証プロバイダーを使用することが適切なソリューションですが、他の人にとってはそうではありません。
使用する場合は、読み続けて、利用可能なさまざまな認証サービスプロバイダーについて学習してください。
この記事では、次の認証サービスプロバイダーを比較しています。
これらの認証プロバイダーは、6つの評価基準に基づいて評価されます。
オープンソースプロジェクトには、いくつかの利点があります。1つの利点は、コスト削減です。オープンソースであるため、ライセンス料や使用料は必要ありません。
もう1つの利点は柔軟性です。ビジネス要件が変更された場合、または追加機能が必要な場合は、コードを自分で変更および拡張できます。ベンダーに変更を依頼したり、完全に変更したりする必要はありません。
透明性についても言及することが重要です。コードは誰でも見ることができます。非常に多くの専門家がコードにアクセスできるため、ソフトウェアをより良く、より安全にすることができます。
オープンソースの認証プロバイダーを使用することには他にも利点がありますが、これらの利点がポイントを押し上げます。
認証サービスプロバイダーをHasuraと統合するときは、それらがカスタムJWTクレームをサポートしていることを確認することが重要です。
Hasuraは、カスタムJWTクレームをチェックして、リクエストを行うユーザーの役割について学習します。その結果、Hasuraは適切な承認ルールを適用できます。
{ 'x-hasura-default-role': 'user', 'x-hasura-allowed-roles': ['user'], 'x-hasura-user-id': user.user_id};
上記のスニペットは、カスタムJWTクレームの例を示しています。リクエストに関する重要な情報が含まれています。
簡単に言うと、SSOは、ユーザーが1セットの資格情報を使用して複数のプラットフォームにログインする認証の種類を指します。
一例として、ユーザーがGoogleアカウントなどのソーシャルネットワークアカウントを使用してアプリケーションにログインするソーシャルSSOがあります。
リクエストを行うのは必ずしもユーザーではありません。2台のマシンがそれらの間で通信するシナリオがあります。資格情報を入力するユーザーがいないため、クライアント(別のマシン)を別の方法で認証する必要があります。
マシンツーマシン(M2M)認証とは、ユーザー入力なしでマシンを認証することを指します。これは、OAuth2.0クライアント資格情報フローを使用することで可能になります。資格情報には、クライアントの認証に使用されるとがclient_id
含まれます。client_secret
この記事のすべての認証プロバイダーには無料枠があります。違いは、その層で提供されるものにあります。
毎月のアクティブユーザー(MAU)を測定し、それに基づいて課金します。その結果、一部のプロバイダーは数千のMAUを備えた無料枠を提供していますが、一部のプロバイダーは数百のMAUしか提供していません。
認証サービスプロバイダーの統合は、多くの要因に依存します。プロバイダーの統合がいかに簡単か困難かを提示するのは困難です。
ただし、次のように、実装の難易度を示す可能性のあるポイントがいくつかあります。
この画像は、この記事で紹介した認証プロバイダー間の比較を示しています。
Auth0は、認証サービスのための定評のある人気のあるソリューションです。それは寛大な無料利用枠が付属しており、あなたが必要とするほとんどのものをサポートしています。
オープンソース | いいえ |
---|---|
SaaS | はい |
SSOサポート | はい |
JWTカスタムクレーム | はい |
マシンツーマシン認証 | はい |
無料プラン | はい-最大7000MAU |
統合のしやすさに関して言えば、Auth0は統合が簡単でも難しいものでもありません。これは確立された広範なソリューションであるため、統合に役立つ大量の資料を利用できます。実行する必要のある構成の量は、アプリケーションのタイプと複雑さによって異なります。
Firebase Authenticationは、アプリケーションに認証を追加できるもう1つの人気のある認証サービスです。
Firebaseでは、次のようなサインインメソッドを追加できます。
オープンソース | いいえ |
---|---|
SaaS | いいえ |
SSOサポート | はい |
JWTカスタムクレーム | はい |
マシンツーマシン認証 | はい |
無料プラン | 電話認証以外は無料 |
利用可能なリソースの量により、統合プロセスがより簡単になります。Firebaseコミュニティは、使用できる多くのオープンソースリソースを作成します。また、定評のあるプロバイダーでもあります。つまり、ほとんどすべての問題の解決策を見つける可能性があります。
最後に、FirebaseAuthをウェブアプリケーションとモバイルアプリケーションの両方に実装する方法をカバーする詳細なドキュメントがあります。
他のプロバイダーと比較して、店員は最新のものです。Clerkを使用すると、サインアップ、サインイン、およびユーザープロファイルをアプリケーションに実装できます。彼らのウェブサイトによると、彼らは「完全な顧客アイデンティティプラットフォーム」です。
店員さんにはハスラのサポートも付いています。彼らには、ClerkをHasuraと統合する方法を紹介する特別なドキュメントセクションがあります。
オープンソース | いいえ |
---|---|
SaaS | はい |
SSOサポート | ソーシャルSSO |
JWTカスタムクレーム | はい |
マシンツーマシン認証 | いいえ |
無料プラン | はい-最大500MAU |
比較的新しいため、まだ文書化/解決されていない問題が発生する可能性があります。それ以外に、店員は広範囲にわたる詳細なドキュメントを持っています。
Clerkをアプリケーションと統合するために必要な構成は最小限です。Clerkアカウントが必要です。そうすれば、SDKとそれらが提供するコンポーネントを使用できます。
Keycloakは、人気のあるオープンソースの認証サービスプロバイダーです。オープンソースなので、セルフホストできます。つまり、月間アクティブユーザー数に関係なく無料です。
オープンソースであり、誰もが貢献できるようになっていますが、プロジェクトはRedHatによって管理されています。つまり、プロジェクトを信頼できるということです。
Keycloakはほとんどの認証のユースケースをサポートしており、無料でもあるため、優れた選択肢となる可能性があります。
オープンソース | はい |
---|---|
SaaS | いいえ |
SSOサポート | はい |
JWTカスタムクレーム | はい |
マシンツーマシン認証 | はい |
無料プラン | 無制限のユーザーは無料 |
Keycloakには、中程度の実装の難しさがあります。Keycloakをアプリケーションに統合するだけでなく、デプロイメントとメンテナンスにも注意を払う必要があります。
一見複雑に見えるかもしれませんが、Keycloakにすぐに慣れることができます。また、確立された製品であるため、ほとんどの問題の解決策が見つかる可能性があります。最後に、優れたドキュメントがあります。
Cognitoは、認証を処理するためのAmazonの製品です。これにより、Webおよびモバイルアプリケーションに認証を実装できます。
Cognitoは最も寛大な認証プロバイダーの1つであり、月間最大50,000人のアクティブユーザーがいる無料プランを提供します。コストが懸念され、マネージドソリューションが必要な場合は、Cognitoが最適です。
オープンソース | いいえ |
---|---|
SaaS | いいえ |
SSOサポート | はい |
JWTカスタムクレーム | はい |
マシンツーマシン認証 | はい |
無料プラン | 最大50000の月間アクティブユーザー(Cognitoユーザープールに直接サインインする)を無料で利用できます |
統合の容易さに関して、Amazon Cognitoは、他のプロバイダーと比較して実装が非常に困難になる可能性があります。Cognitoは、基本的なアプリケーションであっても、複雑なセットアップを必要とします。
ただし、Cognitoをアプリケーションに統合するのに役立つ公式およびコミュニティの資料はたくさんあります。いくつかのSDKとサンプルアプリも利用可能で、あなたを助け、刺激を与えます。
SuperTokensは比較的新しいサービスです。必要なほとんどすべてのサポートが付属しており、オープンソースでもあります。つまり、セルフホストして追加料金を回避できます。セルフホストを選択した場合、無制限のユーザーは永久に無料です。
SuperTokensにはHasuraのサポートが付属しており、SuperTokensをHasuraと統合する方法に関する特別なセクションがあります。
オープンソース | はい |
---|---|
SaaS | はい |
SSOサポート | はい |
JWTカスタムクレーム | はい |
マシンツーマシン認証 | はい |
無料プラン | 無制限のユーザー(セルフホスト)と最大5000 MAU(SaaS)を無料で利用できます |
統合のしやすさに関しては、アプリケーションと統合しようとすると、いくつかの問題が発生する可能性があります。その理由は、これは新しいサービスであり、現在インターネット上で利用できる資料があまりないためです。
構成に関しては、ドキュメントに必要なすべての設定と情報が記載されているため、SuperTokenの使用を開始するのはかなり簡単です。
SuperTokensには、SuperTokensをHasuraと統合するためのガイド、およびサンプルのSuperTokens+Hasuraデモアプリケーションもあります。
Nhost Authenticationは、Hasuraのオープンソース認証サービスです。Nhost認証を使用すると、次の方法でサインインできます。
これはオープンソースプロジェクトであるため、セルフホストして、マネージドサービスを使用するときに支払う追加料金を回避できます。
オープンソース | はい |
---|---|
SaaS | いいえ |
SSOサポート | はい |
JWTカスタムクレーム | はい |
マシンツーマシン認証 | いいえ |
無料プラン | 無制限のユーザーは無料 |
統合の容易さに関して言えば、Nhost認証はHasuraアプリケーションと統合するのがかなり簡単です。Hasura、Hasura Auth、Postgresを備えたすぐに使えるバックエンドを提供するNhostを介してアプリケーションを作成するか、NhostAuthenticationDockerイメージを使用してアプリケーションをセルフホストすることができます。
ここでNhost認証を確認できます。
スケーラビリティとは、アプリケーションの成長とビジネス要件の変化を処理する認証サービスの機能を指します。認証サービスは、アプリケーションに影響を与えることなく、ユーザーの成長と要件の変化に対応する必要があります。
セルフホストソリューションを使用する場合は、スケーリングに関して全責任を負います。データベース、サーバー、およびインフラストラクチャ全体を管理する必要があります。すべてがスムーズに機能することを確認するのはあなたの責任です。
マネージドソリューションを使用する場合、認証プロバイダーがスケールアップとスケールダウンを処理します。認証プロバイダーには、スケーリングに使用する事前定義されたレート制限とクォータがあります。
この記事で紹介するすべてのプロバイダーは優れた選択肢ですが、普遍的な答えは1つではありません。認証サービスプロバイダーの選択は、ニーズと要件によって異なります。
SuperTokensとClerkは、Hasuraを公式にサポートする2つの注目すべきプロバイダーです。「サポート」とは、ドキュメントにHasuraとの統合方法を示す特別なセクションがあることを意味します。これはプラスであり、Hasuraと統合するときに非常に役立ちます。
これは完全なリストではないことに注意することが重要です。記事に存在しない利用可能な他のプロバイダーがあります。ただし、記事は随時更新され、新しいプロバイダーが追加されます。
ソース:https ://hasura.io/blog/top-authentication-providers-building-apps-jwt/
1658644200
Un "Proveedor de servicios de autenticación" se refiere a una entidad que brinda servicios de autenticación. El proveedor de autenticación abstrae la complejidad de implementar el sistema de autenticación manualmente desde cero para que pueda concentrarse en tareas más importantes.
Este artículo presenta las ventajas y desventajas de usar un proveedor de autenticación y compara los existentes que admiten la integración de JWT.
Antes de elegir un proveedor de servicios de autenticación, es fundamental evaluar las ventajas y desventajas de utilizar uno.
El uso de un proveedor de servicios de autenticación abstrae la complejidad de implementar el sistema de autenticación usted mismo. La construcción de un sistema de este tipo es un proceso largo y complejo que requiere muchos recursos.
Puede usar una solución existente que libera esos recursos para otras tareas más críticas.
Almacenar información confidencial sobre personas no es algo que deba tomarse a la ligera. Optar por usar un proveedor significa que no tiene que preocuparse por almacenar los detalles de los usuarios en sus servidores.
Puede habilitar los inicios de sesión sociales con un esfuerzo mínimo cuando utiliza un proveedor de servicios de autenticación. El inicio de sesión social se refiere a iniciar sesión utilizando una cuenta de red social existente, como Twitter, GitHub, Google, etc.
Implementar cada proveedor social individualmente requiere esfuerzo y recursos. Al usar un proveedor de autenticación, agregar inicios de sesión sociales se vuelve más fácil y rápido.
Optar por utilizar un proveedor de autenticación significa una mayor seguridad. Todo el enfoque de un proveedor de autenticación está en la autenticación y la autorización. Eso significa que están mejor capacitados y equipados para mantener segura la información de los usuarios.
Una vez que elige un proveedor de servicios de autenticación, puede ser difícil migrar. Cambiar a otro proveedor o implementar un sistema propietario puede ser difícil.
Es esencial decidir si tiene sentido usar un proveedor de autenticación o no. Si decide hacerlo, asegúrese de elegir el proveedor que se ajuste a sus necesidades y requisitos.
Otro inconveniente es que puede volverse demasiado dependiente del proveedor que está utilizando. Los motivos pueden ser que su implementación sea demasiado específica para ese proveedor o que sea casi imposible exportar sus datos de usuario actuales.
La migración a otro proveedor puede volverse demasiado costosa y llevar mucho tiempo, por lo que está bloqueado con el actual.
Al principio, los costos podrían no ser un problema. Sin embargo, una vez que la aplicación crece y tiene más usuarios, los costos pueden convertirse en un problema.
Muchos de los proveedores de autenticación cobran según la cantidad de usuarios activos mensuales. Cuantos más usuarios tenga, mayor será la factura.
¿Debe utilizar un proveedor de servicios de autenticación o implementar un sistema propietario? No hay una respuesta definitiva.
La decisión de usar un Proveedor o no depende de muchos factores. Para algunos, usar un proveedor de autenticación es la solución adecuada, mientras que para otros no lo es.
En caso de que decida usar uno, siga leyendo para conocer los distintos proveedores de servicios de autenticación disponibles.
El artículo compara los siguientes proveedores de servicios de autenticación:
Estos proveedores de autenticación se evalúan en función de seis criterios de evaluación.
Un proyecto de código abierto viene con un puñado de beneficios. Un beneficio sería el ahorro de costos. Dado que son de código abierto, no requieren licencias ni tarifas de uso.
Otro beneficio es la flexibilidad. Si los requisitos comerciales cambian o necesita funciones adicionales, puede modificar y ampliar el código usted mismo. No tiene que pedir cambios al proveedor o cambiarlo por completo.
Es importante mencionar la transparencia también. El código está disponible para que todos lo vean. Dado que tantos profesionales tienen acceso al código, pueden mejorar el software y hacerlo más seguro.
También hay otros beneficios de usar un proveedor de autenticación de código abierto, pero estos beneficios llevan el punto a casa.
Al integrar cualquier proveedor de servicios de autenticación con Hasura, es importante asegurarse de que admitan notificaciones JWT personalizadas.
Hasura comprueba las reclamaciones JWT personalizadas para conocer la función del usuario que realiza la solicitud. Como resultado, Hasura puede aplicar las reglas de autorización apropiadas.
{
'x-hasura-default-role': 'user',
'x-hasura-allowed-roles': ['user'],
'x-hasura-user-id': user.user_id
};
El fragmento anterior muestra un ejemplo de reclamaciones JWT personalizadas. Contiene información esencial sobre la solicitud.
En los términos más simples, SSO se refiere al tipo de autenticación donde el usuario inicia sesión en múltiples plataformas con un conjunto de credenciales.
Un ejemplo es el SSO social, donde el usuario utiliza una cuenta de red social como la cuenta de Google para iniciar sesión en una aplicación.
No siempre son los usuarios quienes realizan las solicitudes. Hay escenarios donde dos máquinas se comunican entre ellas. No hay ningún usuario que ingrese las credenciales, por lo que el cliente (otra máquina) debe autenticarse de otra manera.
La autenticación de máquina a máquina (M2M) se refiere a la autenticación de máquinas sin intervención del usuario. Eso es posible mediante el flujo de credenciales de cliente de OAuth 2.0. Las credenciales incluyen un client_id
y client_secret
, que se utilizan para autenticar al cliente.
Todos los proveedores de autenticación de este artículo tienen un nivel gratuito. La diferencia radica en lo que ofrecen en ese nivel.
Miden los usuarios activos mensuales (MAU) y cobran en función de eso. Como resultado, algunos proveedores ofrecen un nivel gratuito con miles de MAU, mientras que otros ofrecen solo un par de cientos de MAU.
La integración de un proveedor de servicios de autenticación depende de muchos factores. Es desafiante presentar cuán fácil o difícil es integrar un proveedor.
Sin embargo, hay algunos puntos que pueden indicar el nivel de dificultad de la implementación, tales como:
La imagen ilustra una comparación entre los proveedores de autenticación presentados en este artículo.
Auth0 es una solución bien establecida y popular para los servicios de autenticación. Viene con un generoso nivel gratuito y tiene soporte para la mayoría de las cosas que necesita.
FUENTE ABIERTA | NO |
---|---|
SaaS | Sí |
Soporte de inicio de sesión único | Sí |
Reclamaciones personalizadas de JWT | Sí |
Autenticación de máquina a máquina | Sí |
Plan Gratis | Sí - hasta 7000 MAU |
Cuando se trata de la facilidad de integración, Auth0 no es ni fácil ni difícil de integrar. Dado que es una solución bien establecida y extendida, hay una gran cantidad de material disponible para ayudarlo con la integración. La cantidad de configuración que necesita hacer depende del tipo y la complejidad de su aplicación.
Firebase Authentication es otro servicio de autenticación popular que le permite agregar autenticación a sus aplicaciones.
Firebase le permite agregar métodos de inicio de sesión como:
FUENTE ABIERTA | NO |
---|---|
SaaS | No |
Soporte de inicio de sesión único | Sí |
Reclamaciones personalizadas de JWT | Sí |
Autenticación de máquina a máquina | Sí |
Plan Gratis | Gratis excepto para la autenticación telefónica |
La cantidad de recursos disponibles hace que el proceso de integración sea más sencillo. La comunidad de Firebase crea muchos recursos de código abierto que puede usar. También es un proveedor bien establecido, lo que significa que es probable que encuentre una solución a casi cualquier problema.
Por último, tiene documentación detallada que cubre cómo implementar Firebase Auth en aplicaciones web y móviles.
Comparado con los otros proveedores, Clerk es el más nuevo. Clerk le permite implementar registros, inicios de sesión y perfiles de usuario en sus aplicaciones. Según su sitio web, son una "Plataforma de identidad del cliente completa".
Clerk también viene con el soporte de Hasura. Tienen una sección de documentación especial que muestra cómo integrar Clerk con Hasura.
FUENTE ABIERTA | NO |
---|---|
SaaS | Sí |
Soporte de inicio de sesión único | Inicio de sesión único social |
Reclamaciones personalizadas de JWT | Sí |
Autenticación de máquina a máquina | No |
Plan Gratis | Sí, hasta 500 MAU |
Dado que es relativamente nuevo, es posible que se encuentre con problemas que aún no están documentados o resueltos. Aparte de eso, Clerk tiene una documentación extensa y detallada.
La configuración necesaria para integrar Clerk con su aplicación es mínima. Necesita una cuenta de Clerk y luego puede usar los SDK y los componentes proporcionados por ellos.
Keycloak es un popular proveedor de servicios de autenticación de código abierto. Dado que es de código abierto, puede alojarlo usted mismo, lo que significa que es gratuito independientemente de la cantidad de usuarios activos mensuales.
Aunque es de código abierto y está abierto a que todos contribuyan, Red Hat mantiene el proyecto. Eso significa que puedes confiar en el proyecto.
Keycloak es compatible con la mayoría de los casos de uso de autenticación y también es gratuito, por lo que puede ser una excelente opción.
FUENTE ABIERTA | SÍ |
---|---|
SaaS | No |
Soporte de inicio de sesión único | Sí |
Reclamaciones personalizadas de JWT | Sí |
Autenticación de máquina a máquina | Sí |
Plan Gratis | Gratis para usuarios ilimitados |
Keycloak tiene un nivel moderado de dificultad de implementación. Además de integrar Keycloak en sus aplicaciones, también debe encargarse de la implementación y el mantenimiento.
Aunque a primera vista pueda parecer complicado, puedes acostumbrarte a Keycloak rápidamente. También es un producto establecido, lo que significa que es probable que encuentre soluciones a la mayoría de sus problemas. Por último, tiene buena documentación.
Cognito es el producto de Amazon para gestionar la autenticación. Le permite implementar la autenticación en sus aplicaciones web y móviles.
Cognito es uno de los proveedores de autenticación más generosos y le brinda un plan gratuito con hasta 50 000 usuarios activos mensuales. Si los costos son una preocupación y desea una solución administrada, Cognito es una excelente opción.
FUENTE ABIERTA | NO |
---|---|
SaaS | No |
Soporte de inicio de sesión único | Sí |
Reclamaciones personalizadas de JWT | Sí |
Autenticación de máquina a máquina | Sí |
Plan Gratis | Libere hasta 50 000 usuarios activos mensuales (que inician sesión directamente en los grupos de usuarios de Cognito) |
En cuanto a la facilidad de integración, Amazon Cognito puede resultar bastante complicado de implementar en comparación con otros proveedores. Cognito requiere una configuración compleja, incluso para aplicaciones básicas.
Sin embargo, hay muchos materiales oficiales y de la comunidad para ayudarlo a integrar Cognito con su aplicación. Un puñado de SDK y aplicaciones de muestra también están disponibles para ayudarlo e inspirarlo.
Aprende a integrar Cognito con Hasura
SuperTokens es un servicio relativamente nuevo. Viene con soporte para casi todo lo que necesitas, y también es de código abierto. Eso significa que puede alojarlo usted mismo y evitar cargos adicionales. Si elige autohospedarse, es gratis para siempre para usuarios ilimitados.
SuperTokens viene con soporte Hasura, con una sección especial sobre cómo integrar SuperTokens con Hasura.
FUENTE ABIERTA | SÍ |
---|---|
SaaS | Sí |
Soporte de inicio de sesión único | Sí |
Reclamaciones personalizadas de JWT | Sí |
Autenticación de máquina a máquina | Sí |
Plan Gratis | Libere para usuarios ilimitados (autohospedados) y hasta 5000 MAU (SaaS) |
Cuando se trata de la facilidad de integración, es posible que encuentre algunas dificultades al intentar integrarlo con su aplicación. La razón es que es un servicio nuevo y no hay mucho material disponible en Internet en este momento.
Con respecto a la configuración, es razonablemente fácil comenzar con SuperTokens ya que la documentación proporciona todas las configuraciones y la información que necesita.
SuperTokens también tiene guías sobre la integración de SuperTokens con Hasura y muestras de aplicaciones de demostración de SuperTokens + Hasura.
Nhost Authentication es un servicio de autenticación de código abierto para Hasura. Con la autenticación Nhost, las personas pueden iniciar sesión con:
Dado que es un proyecto de código abierto, puede alojarlo usted mismo y evitar los cargos adicionales que pagaría al usar un servicio administrado.
FUENTE ABIERTA | SÍ |
---|---|
SaaS | No |
Soporte de inicio de sesión único | Sí |
Reclamaciones personalizadas de JWT | Sí |
Autenticación de máquina a máquina | No |
Plan Gratis | Gratis para usuarios ilimitados |
Cuando se trata de la facilidad de integración, Nhost Authentication es bastante sencillo de integrar con las aplicaciones de Hasura. Puede crear una aplicación a través de Nhost, que le brinda un back-end listo para usar con Hasura, Hasura Auth y Postgres, o puede usar la imagen de Docker de autenticación de Nhost para autoalojarla.
Puede comprobar la autenticación de Nhost aquí .
La escalabilidad se refiere a la capacidad del servicio de autenticación para manejar el crecimiento de su aplicación y los cambios en los requisitos comerciales. El servicio de autenticación debe mantenerse al día con el crecimiento de sus usuarios y los cambios en los requisitos sin afectar su aplicación.
Si decide utilizar una solución autohospedada, tiene toda la responsabilidad cuando se trata de escalar. Debe administrar la base de datos, los servidores y toda la infraestructura. Es su responsabilidad asegurarse de que todo funcione sin problemas.
Cuando usa una solución administrada, el proveedor de autenticación se encarga de escalar hacia arriba y hacia abajo. El proveedor de autenticación tiene límites de velocidad y cuotas predefinidos, que utilizan para escalar.
Todos los proveedores presentados en este artículo son excelentes opciones, pero no existe una respuesta universal. La elección de un proveedor de servicios de autenticación depende de las necesidades y requisitos de cada uno.
SuperTokens y Clerk son dos proveedores notables que admiten oficialmente a Hasura. "Soporte" significa que tienen una sección especial en su documentación que ilustra cómo integrarlos con Hasura. Eso es una ventaja y ayuda mucho al integrar cualquiera de ellos con Hasura.
Es importante tener en cuenta que esta no es una lista exhaustiva. Hay otros proveedores disponibles que no están presentes en el artículo. Sin embargo, el artículo se actualizará ocasionalmente y se agregarán nuevos proveedores.
Fuente: https://hasura.io/blog/top-authentication-providers-building-apps-jwt/
1658640600
“Nhà cung cấp dịch vụ xác thực” đề cập đến một tổ chức cung cấp dịch vụ xác thực. Nhà cung cấp xác thực tóm tắt sự phức tạp của việc triển khai hệ thống xác thực theo cách thủ công từ đầu để bạn có thể tập trung vào các tác vụ quan trọng hơn.
Bài viết này trình bày những lợi ích và hạn chế của việc sử dụng Nhà cung cấp xác thực và so sánh những nhà cung cấp hiện có hỗ trợ tích hợp JWT.
Trước khi chọn Nhà cung cấp dịch vụ xác thực, điều cần thiết là phải đánh giá những lợi ích và hạn chế của việc sử dụng một Nhà cung cấp dịch vụ xác thực.
Việc sử dụng Nhà cung cấp dịch vụ xác thực sẽ tóm tắt sự phức tạp của việc tự triển khai hệ thống xác thực. Xây dựng một hệ thống như vậy là một quá trình phức tạp, kéo dài, đòi hỏi nhiều nguồn lực.
Bạn có thể sử dụng một giải pháp hiện có để giải phóng các tài nguyên đó cho các nhiệm vụ khác, quan trọng hơn.
Lưu trữ thông tin bí mật về mọi người không phải là điều gì đó xem nhẹ. Chọn sử dụng một nhà cung cấp có nghĩa là bạn không phải lo lắng về việc lưu trữ thông tin chi tiết của người dùng trên máy chủ của mình.
Bạn có thể kích hoạt đăng nhập xã hội với nỗ lực tối thiểu khi sử dụng Nhà cung cấp dịch vụ xác thực. Đăng nhập mạng xã hội đề cập đến việc đăng nhập bằng tài khoản mạng xã hội hiện có như Twitter, GitHub, Google, v.v.
Việc thực hiện từng nhà cung cấp xã hội riêng lẻ đòi hỏi nỗ lực và nguồn lực. Khi sử dụng Nhà cung cấp xác thực, việc thêm thông tin đăng nhập trên mạng xã hội trở nên dễ dàng và nhanh chóng hơn.
Chọn sử dụng Nhà cung cấp xác thực có nghĩa là bảo mật tốt hơn. Toàn bộ trọng tâm của Nhà cung cấp xác thực là xác thực và ủy quyền. Điều đó có nghĩa là họ được đào tạo và trang bị tốt hơn để bảo mật thông tin của người dùng.
Sau khi bạn chọn Nhà cung cấp dịch vụ xác thực, có thể khó di chuyển. Việc thay đổi sang nhà cung cấp khác hoặc chuyển sang sử dụng một hệ thống độc quyền có thể khó khăn.
Điều cần thiết là phải quyết định xem việc sử dụng Nhà cung cấp xác thực có hợp lý hay không. Nếu bạn chọn làm điều đó, hãy chắc chắn rằng bạn chọn nhà cung cấp phù hợp với nhu cầu và yêu cầu của bạn.
Một nhược điểm khác là bạn có thể trở nên quá phụ thuộc vào nhà cung cấp bạn đang sử dụng. Lý do có thể là việc triển khai của bạn quá cụ thể đối với nhà cung cấp đó hoặc gần như không thể xuất dữ liệu người dùng hiện tại của bạn.
Việc di chuyển sang nhà cung cấp khác có thể trở nên quá tốn kém và mất thời gian, vì vậy bạn bị khóa với nhà cung cấp hiện tại.
Ban đầu, chi phí có thể không phải là vấn đề. Tuy nhiên, sau khi ứng dụng phát triển lớn hơn và có nhiều người dùng hơn, chi phí có thể trở thành một vấn đề.
Nhiều Nhà cung cấp xác thực tính phí dựa trên số lượng người dùng hoạt động hàng tháng. Bạn càng có nhiều người dùng, hóa đơn càng lớn.
Bạn nên sử dụng Nhà cung cấp dịch vụ xác thực hay triển khai hệ thống độc quyền? Không có câu trả lời dứt khoát.
Quyết định sử dụng Nhà cung cấp hay không phụ thuộc vào nhiều yếu tố. Đối với một số người, sử dụng Nhà cung cấp xác thực là giải pháp thích hợp, trong khi đối với những người khác thì không.
Trong trường hợp bạn quyết định sử dụng, hãy tiếp tục đọc để tìm hiểu về các Nhà cung cấp Dịch vụ Xác thực khác nhau hiện có.
Bài viết so sánh các Nhà cung cấp Dịch vụ Xác thực sau:
Các nhà cung cấp xác thực này được đánh giá dựa trên sáu tiêu chí đánh giá.
Một dự án mã nguồn mở đi kèm với một số lợi ích. Một lợi ích sẽ là tiết kiệm chi phí. Vì chúng là mã nguồn mở nên chúng không yêu cầu phí cấp phép hoặc phí sử dụng.
Một lợi ích khác là tính linh hoạt. Nếu các yêu cầu kinh doanh thay đổi hoặc bạn cần các tính năng bổ sung, bạn có thể tự sửa đổi và mở rộng mã. Bạn không cần phải yêu cầu nhà cung cấp thay đổi hoặc thay đổi hoàn toàn.
Điều quan trọng là phải đề cập đến tính minh bạch. Mã có sẵn cho mọi người xem. Vì rất nhiều chuyên gia có quyền truy cập vào mã, họ có thể làm cho phần mềm tốt hơn và an toàn hơn.
Có những lợi ích khác của việc sử dụng nhà cung cấp xác thực nguồn mở, nhưng những lợi ích này thúc đẩy điểm về nhà.
Khi tích hợp bất kỳ Nhà cung cấp dịch vụ xác thực nào với Hasura, điều quan trọng là phải đảm bảo họ hỗ trợ các xác nhận quyền sở hữu JWT tùy chỉnh.
Hasura kiểm tra các tuyên bố JWT tùy chỉnh để tìm hiểu về vai trò của người dùng đưa ra yêu cầu. Do đó, Hasura có thể áp dụng các quy tắc ủy quyền phù hợp.
{
'x-hasura-default-role': 'user',
'x-hasura-allowed-roles': ['user'],
'x-hasura-user-id': user.user_id
};
Đoạn mã trên cho thấy một ví dụ về xác nhận quyền sở hữu JWT tùy chỉnh. Nó chứa thông tin cần thiết về yêu cầu.
Theo thuật ngữ đơn giản nhất, SSO đề cập đến loại xác thực trong đó người dùng đăng nhập vào nhiều nền tảng bằng một bộ thông tin xác thực.
Một ví dụ là SSO xã hội, trong đó người dùng sử dụng tài khoản mạng xã hội như tài khoản Google để đăng nhập vào ứng dụng.
Không phải lúc nào người dùng cũng đưa ra yêu cầu. Có những tình huống mà hai máy giao tiếp giữa chúng. Không có người dùng để nhập thông tin đăng nhập, vì vậy máy khách (máy khác) cần được xác thực theo cách khác.
Xác thực máy với máy (M2M) đề cập đến việc xác thực máy mà không cần người dùng nhập. Điều đó có thể thực hiện được bằng cách sử dụng Luồng thông tin xác thực ứng dụng khách OAuth 2.0. Thông tin xác thực bao gồm dấu client_id
và client_secret
, được sử dụng để xác thực khách hàng.
Tất cả các nhà cung cấp xác thực từ bài viết này đều có một cấp miễn phí. Sự khác biệt nằm ở những gì họ cung cấp trong cấp đó.
Họ đo lường người dùng hoạt động hàng tháng (MAU) và tính phí dựa trên đó. Do đó, một số nhà cung cấp cung cấp cấp miễn phí với hàng nghìn MAU, trong khi một số nhà cung cấp chỉ cung cấp vài trăm MAU.
Việc tích hợp nhà cung cấp dịch vụ xác thực phụ thuộc vào nhiều yếu tố. Thật khó để trình bày mức độ dễ dàng hay khó khăn khi tích hợp một nhà cung cấp.
Tuy nhiên, có một số điểm có thể chỉ ra mức độ khó khăn của việc triển khai, chẳng hạn như:
Hình ảnh minh họa sự so sánh giữa các Nhà cung cấp xác thực được trình bày trong bài viết này.
Auth0 là một giải pháp được thiết lập tốt và phổ biến cho các dịch vụ xác thực. Nó đi kèm với một cấp miễn phí phong phú và có hỗ trợ cho hầu hết những thứ bạn cần.
MÃ NGUỒN MỞ | KHÔNG |
---|---|
SaaS | Đúng |
Hỗ trợ SSO | Đúng |
Tuyên bố tùy chỉnh JWT | Đúng |
Xác thực máy với máy | Đúng |
Gói miễn phí | Có - lên đến 7000 MAU |
Khi nói đến sự dễ dàng tích hợp, Auth0 không dễ cũng không khó để tích hợp. Vì đây là một giải pháp được thiết lập tốt và phổ biến, nên rất nhiều tài liệu có sẵn để giúp bạn tích hợp. Số lượng cấu hình bạn cần thực hiện tùy thuộc vào loại và độ phức tạp của ứng dụng của bạn.
Xác thực Firebase là một dịch vụ xác thực phổ biến khác cho phép bạn thêm xác thực vào các ứng dụng của mình.
Firebase cho phép bạn thêm các phương thức đăng nhập như:
MÃ NGUỒN MỞ | KHÔNG |
---|---|
SaaS | Không |
Hỗ trợ SSO | Đúng |
Tuyên bố tùy chỉnh JWT | Đúng |
Xác thực máy với máy | Đúng |
Gói miễn phí | Miễn phí ngoại trừ Xác thực Điện thoại |
Số lượng tài nguyên có sẵn làm cho quá trình tích hợp trở nên đơn giản hơn. Cộng đồng Firebase tạo ra nhiều tài nguyên mã nguồn mở mà bạn có thể sử dụng. Đây cũng là một nhà cung cấp có uy tín lâu năm, có nghĩa là bạn có khả năng tìm ra giải pháp cho hầu hết mọi vấn đề.
Cuối cùng, nó có tài liệu chuyên sâu về cách triển khai Firebase Auth trong cả ứng dụng web và ứng dụng di động.
So với các nhà cung cấp khác, Clerk là nhà cung cấp mới nhất. Thư ký cho phép bạn triển khai đăng ký, đăng nhập và hồ sơ người dùng vào các ứng dụng của mình. Theo trang web của họ, họ là một "nền tảng nhận dạng khách hàng hoàn chỉnh".
Thư ký cũng đi kèm với sự hỗ trợ của Hasura. Họ có một phần tài liệu đặc biệt giới thiệu cách tích hợp Clerk với Hasura.
MÃ NGUỒN MỞ | KHÔNG |
---|---|
SaaS | Đúng |
Hỗ trợ SSO | SSO xã hội |
Tuyên bố tùy chỉnh JWT | Đúng |
Xác thực máy với máy | Không |
Gói miễn phí | Có - lên đến 500 MAU |
Vì nó tương đối mới, bạn có thể gặp phải các vấn đề chưa được ghi chép / giải quyết. Ngoài ra, Clerk có tài liệu chuyên sâu, phong phú.
Cấu hình cần thiết để tích hợp Clerk với ứng dụng của bạn là tối thiểu. Bạn cần có tài khoản Thư ký và sau đó bạn có thể sử dụng SDK và các thành phần do họ cung cấp.
Keycloak là một nhà cung cấp dịch vụ xác thực mã nguồn mở phổ biến. Vì nó là mã nguồn mở, bạn có thể tự lưu trữ nó, có nghĩa là nó miễn phí bất kể số lượng người dùng hoạt động hàng tháng.
Mặc dù nó là mã nguồn mở và mở cho tất cả mọi người đóng góp, dự án vẫn được duy trì bởi Red Hat. Điều đó có nghĩa là bạn có thể tin tưởng vào dự án.
Keycloak hỗ trợ hầu hết các trường hợp sử dụng xác thực và nó cũng miễn phí, vì vậy nó có thể là một lựa chọn tuyệt vời.
MÃ NGUỒN MỞ | VÂNG |
---|---|
SaaS | Không |
Hỗ trợ SSO | Đúng |
Tuyên bố tùy chỉnh JWT | Đúng |
Xác thực máy với máy | Đúng |
Gói miễn phí | Miễn phí cho người dùng không giới hạn |
Keycloak có mức độ khó triển khai vừa phải. Bên cạnh việc tích hợp Keycloak vào các ứng dụng của bạn, bạn cũng phải quan tâm đến việc triển khai và bảo trì.
Mặc dù nó có thể trông phức tạp ngay từ cái nhìn đầu tiên, nhưng bạn có thể nhanh chóng làm quen với Keycloak. Nó cũng là một sản phẩm đã được thành lập, có nghĩa là bạn có khả năng tìm ra giải pháp cho hầu hết các vấn đề của mình. Cuối cùng, nó có tài liệu tốt.
Cognito là sản phẩm của Amazon để xử lý xác thực. Nó cho phép bạn triển khai xác thực vào các ứng dụng web và di động của mình.
Cognito là một trong những nhà cung cấp xác thực hào phóng nhất, cung cấp cho bạn gói miễn phí với tối đa 50.000 người dùng hoạt động hàng tháng. Nếu chi phí là một mối quan tâm và bạn muốn một giải pháp được quản lý, Cognito là một lựa chọn tuyệt vời.
MÃ NGUỒN MỞ | KHÔNG |
---|---|
SaaS | Không |
Hỗ trợ SSO | Đúng |
Tuyên bố tùy chỉnh JWT | Đúng |
Xác thực máy với máy | Đúng |
Gói miễn phí | Miễn phí tới 50000 người dùng hoạt động hàng tháng (những người đăng nhập trực tiếp vào Cognito User Pools) |
Về tính dễ dàng tích hợp, Amazon Cognito có thể gặp khá nhiều khó khăn để triển khai so với các nhà cung cấp khác. Cognito yêu cầu một thiết lập phức tạp, ngay cả đối với các ứng dụng cơ bản.
Tuy nhiên, có nhiều tài liệu chính thức và cộng đồng để giúp bạn tích hợp Cognito với ứng dụng của mình. Một số SDK và ứng dụng mẫu cũng có sẵn để trợ giúp và truyền cảm hứng cho bạn.
Tìm hiểu cách tích hợp Cognito với Hasura
SuperTokens là một dịch vụ tương đối mới. Nó đi kèm với sự hỗ trợ cho hầu hết mọi thứ bạn cần và nó cũng là mã nguồn mở. Điều đó có nghĩa là bạn có thể tự lưu trữ nó và tránh phải trả thêm phí. Nếu bạn chọn tự lưu trữ, nó miễn phí vĩnh viễn cho người dùng không giới hạn.
SuperTokens đi kèm với hỗ trợ Hasura, có một phần đặc biệt về cách tích hợp SuperTokens với Hasura.
MÃ NGUỒN MỞ | VÂNG |
---|---|
SaaS | Đúng |
Hỗ trợ SSO | Đúng |
Tuyên bố tùy chỉnh JWT | Đúng |
Xác thực máy với máy | Đúng |
Gói miễn phí | Giải phóng cho người dùng không giới hạn (Tự lưu trữ) và lên đến 5000 MAU (SaaS) |
Khi nói đến sự dễ dàng tích hợp, bạn có thể gặp một số khó khăn khi cố gắng tích hợp nó với ứng dụng của mình. Lý do là vì đó là một dịch vụ mới và không có nhiều tài liệu có sẵn trên internet vào lúc này.
Về cấu hình, thật dễ dàng để bắt đầu với SuperTokens vì tài liệu cung cấp tất cả các cài đặt và thông tin bạn cần.
SuperTokens cũng có hướng dẫn về việc tích hợp SuperTokens với Hasura và các ứng dụng demo SuperTokens + Hasura mẫu.
Nhost Authentication là một dịch vụ xác thực mã nguồn mở cho Hasura. Với Xác thực Nhỏ, mọi người có thể đăng nhập bằng:
Vì đây là một dự án mã nguồn mở, bạn có thể tự lưu trữ nó và tránh phải trả thêm phí khi sử dụng dịch vụ được quản lý.
MÃ NGUỒN MỞ | VÂNG |
---|---|
SaaS | Không |
Hỗ trợ SSO | Đúng |
Tuyên bố tùy chỉnh JWT | Đúng |
Xác thực máy với máy | Không |
Gói miễn phí | Miễn phí cho người dùng không giới hạn |
Khi nói đến sự dễ dàng tích hợp, Nhost Authentication khá dễ dàng để tích hợp với các ứng dụng Hasura. Bạn có thể tạo một ứng dụng thông qua Nhost, ứng dụng này cung cấp cho bạn một chương trình phụ trợ độc lập với Hasura, Hasura Auth và Postgres hoặc bạn có thể sử dụng hình ảnh Nhost Authentication Docker để tự lưu trữ nó.
Bạn có thể kiểm tra Xác thực Nhost tại đây .
Khả năng mở rộng đề cập đến khả năng của dịch vụ xác thực trong việc xử lý sự phát triển ứng dụng của bạn và những thay đổi trong yêu cầu kinh doanh. Dịch vụ xác thực phải theo kịp với sự phát triển của người dùng và các yêu cầu thay đổi mà không ảnh hưởng đến ứng dụng của bạn.
Nếu bạn quyết định sử dụng giải pháp tự lưu trữ, bạn có toàn bộ trách nhiệm khi nói đến việc mở rộng quy mô. Bạn cần quản lý cơ sở dữ liệu, máy chủ và toàn bộ cơ sở hạ tầng. Bạn có trách nhiệm đảm bảo mọi thứ hoạt động trơn tru.
Khi bạn sử dụng giải pháp được quản lý, nhà cung cấp xác thực sẽ quan tâm đến việc tăng và giảm quy mô. Nhà cung cấp xác thực có các giới hạn và hạn ngạch tỷ lệ được xác định trước, họ sử dụng để mở rộng quy mô.
Tất cả các nhà cung cấp được trình bày trong bài viết này đều là những lựa chọn tuyệt vời, nhưng không có một câu trả lời chung nào. Việc chọn Nhà cung cấp dịch vụ xác thực phụ thuộc vào nhu cầu và yêu cầu của mỗi người.
SuperTokens và Clerk là hai nhà cung cấp đáng chú ý hỗ trợ Hasura chính thức. “Hỗ trợ” có nghĩa là họ có một phần đặc biệt trong tài liệu minh họa cách tích hợp chúng với Hasura. Đó là một điểm cộng và nó sẽ giúp ích rất nhiều khi tích hợp bất kỳ mục nào trong số chúng với Hasura.
Điều quan trọng cần lưu ý là đây không phải là một danh sách đầy đủ. Có những nhà cung cấp khác có sẵn mà không có trong bài viết. Tuy nhiên, bài báo sẽ được cập nhật đôi khi và các nhà cung cấp mới sẽ được thêm vào.
Nguồn: https://hasura.io/blog/top-authentication-providers-building-apps-jwt/