Top 11 Authentication Mistakes & How to Fix Them

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:

1. Displaying specific error messages
2. Integrating session IDs into a URL
3. Incorrect form validation
4. Low-form sanitization
5. Weak password strategy
6. Failure to use Two-Factor Authentication (2FA)
7. Improper Password Reset
8. Insecure Logout
9. Brute Force Attack
10. Using Weak Security Questions
11. Failure to Safeguard the Route

See more at: https://blog.openreplay.com/

#authentication 

11 основных ошибок аутентификации и способы их исправления

Безопасность аутентификации — важный аспект разработки веб-приложений, который часто упускается из виду при создании продукта. Однако, если вы собираетесь подать заявку онлайн, это является главным приоритетом. В этой статье я объясню некоторые из этих ошибок и как их исправить. Обратите внимание, что это не основные проблемы безопасности, которые рекомендует OWASP ; вместо этого это легко устраняемые проблемы, которые я часто вижу.

Что такое аутентификация?

Аутентификация — это процесс подтверждения личности пользователя или процесса. При нарушении аутентификации злоумышленники могут получить доступ к данным или информации пользователя, нанеся ущерб вашему приложению. Аутентификация — это один из способов, которым злоумышленники могут получить доступ к данным пользователя и вашему приложению.

Когда дело доходит до аутентификации, вот одиннадцать распространенных ошибок, которых следует избегать:

1. Отображение конкретных сообщений об ошибках
2. Интеграция идентификаторов сеанса в URL-адрес
3. Неправильная проверка формы
4. Санитарная обработка низкой формы
5. Стратегия слабого пароля
6. Неиспользование двухфакторной аутентификации (2FA)
7. Неверный сброс пароля
8. Небезопасный выход
9. Атака грубой силы
10. Использование слабых контрольных вопросов
11. Неспособность защитить маршрут

Отображение определенных сообщений об ошибках

Отображение определенного сообщения об ошибке опасно, потому что это может позволить злоумышленнику использовать автоматизированный метод проб и ошибок для определения имени пользователя или пароля пользователя.

Вот пример схемы отображения определенного сообщения об ошибке. 

При аутентификации формы в вашем веб-приложении вы должны быть осторожны, чтобы не отображать только одно сообщение об ошибке, когда пользователь вводит неверные данные, например «Ваш пароль неверен». Если вы покажете такое конкретное сообщение об ошибке, злоумышленник поймет, что адрес электронной почты или идентификатор пользователя реальны, но пароль неверный. Это позволит злоумышленнику предложить пароль для этого пользователя.

Как исправить этот недостаток

• Никогда не показывать конкретное сообщение об ошибке на странице аутентификации. Это позволяет злоумышленнику узнать, какая информация отсутствует, и позволяет ему использовать атаку грубой силы, чтобы угадать, какая информация отсутствует.
• Отображение сообщений об ошибках, таких как «неправильные данные».

Интеграция идентификаторов сеанса в URL-адрес

Идентификатор сеанса — это число, которое сервер веб-сайта присваивает одному пользователю на время посещения этого пользователя. Вероятность того, что злоумышленник получит токен сеанса и злоупотребит им, увеличивается, если он размещен непосредственно в URL-адресе. Хотя риск при использовании HTTPS для подключения к веб-серверу ниже, опасность все же существует. Несмотря на то, что URL-адреса HTTPS шифруются при передаче, они часто сохраняются в журналах сервера.

Вот пример схемы интеграции идентификаторов сеансов в URL-адреса.

Как исправить этот недостаток

• Проверка идентификатора сеанса на стороне сервера
• Чтобы создать токен, убедитесь, что вы используете достаточно безопасный генератор случайных чисел.
• Используйте фильтр, чтобы удалить идентификатор сеанса из URL-адреса.

Неверная проверка формы.

Атаки с внедрением, утечки памяти и скомпрометированные системы могут произойти, если данные, предоставленные во входных данных формы, не проверены или не отформатированы должным образом. Пользователи часто отправляют, не заполнив всю необходимую информацию, поэтому необходимо проверить вашу форму, чтобы убедиться, что вся необходимая информация была соблюдена, прежде чем отправлять ее на сервер.

Как исправить этот недостаток

• Убедитесь, что письмо имеет форматирование адреса электронной почты.
• Перед отправкой убедитесь, что пользователь соответствует критериям формы.
• Проверяйте форму из бэкэнда и внешнего интерфейса, используя обновленную библиотеку или фреймворк.

Некоторые из предлагаемых библиотек, которые я рекомендую для проверки формы:

• Валидатор
• Просто подтвердите
• Нетронутый

Все перечисленные библиотеки хороши для проверки вашей формы.

Санитарная обработка низкой формы 

Процесс поддержания чистоты, фильтрации и очистки ввода формы от вредоносного агента называется очисткой формы. Дезинфекция вашего ввода является обязательной, потому что она предотвращает ошибки инъекций. Хорошо продезинфицированная форма ввода может предотвратить следующие атаки:

Межсайтовый скриптинг (XSS): это тип уязвимости системы безопасности, который часто встречается в веб-приложениях. Эта уязвимость позволяет злоумышленникам вставлять клиентские скрипты в просматриваемые пользователями веб-страницы. Эта атака может нанести значительный ущерб безопасности пользователя, например перенаправить его на вредоносный веб-сайт, заставить его загрузить вредоносное приложение и украсть данные пользователя.

Внедрение SQL: Злоумышленники могут вмешиваться в данные, отправленные в его базу данных через ввод формы. 

Дезинфицируя ввод формы, вы должны защитить свой код и данные пользователя от этого вредоносного агента и всех перечисленных уязвимостей. Я лично использую DOM Purify , библиотеку очистки для HTML и строк, и она может фильтровать все, что содержит грязный HTML, и предотвращать атаки XSS.

Как исправить этот недостаток

• Значительно проще и безопаснее использовать белый список для четко определенных входных данных, таких как числа, даты или почтовые индексы. В связи с этим вы можете явно указать, какие значения разрешены, а какие нет.
• Используйте предопределенную логику списка разрешенных во встроенных определениях типов данных с проверкой формы HTML5.

Стратегия слабого пароля

Нередко можно встретить веб-сайт, на котором нет надежного плана паролей. Недавно я попробовал приложение, которое требовало минимальной длины пароля из пяти символов. Поскольку разработчики пытаются найти правильный баланс между безопасностью и удобством использования, этот недостаток становится все более распространенным. При работе с паролями убедитесь, что пароль, который вы предлагаете пользователю, или пароль, который создает пользователь, представляет собой смесь символов, цифр и букв смешанного регистра. Избегайте слабых планов паролей.

Как исправить этот недостаток

• Требовать от пользователя ввести минимум 12 или 8 символов или больше.
• Из соображений безопасности и удобства использования следует избегать паролей, включающих имена пользователей или названия компаний.
• Буквы верхнего и нижнего регистра следует смешивать.
• Используйте библиотеку для расчета надежности пароля, будьте осторожны при выборе и проверяйте минимальные зависимости и ремонтопригодность.
• Если у человека есть общедоступный профиль, используйте другое отображаемое имя и избегайте использования адреса электронной почты пользователя в качестве отображаемого имени, поскольку это способствует спаму.

Неиспользование двухфакторной аутентификации

Еще одна распространенная ошибка, которую я вижу в механизмах веб-аутентификации, заключается в том, что они не имеют никаких дополнительных мер безопасности. Двухфакторная аутентификация редко используется разработчиками, особенно для топовых аккаунтов. Двухфакторная аутентификация помогает добавить второй уровень защиты к вашему приложению. Двухфакторная аутентификация имеет решающее значение для веб-безопасности, поскольку она сразу устраняет опасность скомпрометированных учетных данных. Когда пароль взломан, угадан или даже заражен вредоносным ПО, уже недостаточно предоставить доступ злоумышленнику без одобрения на втором факторе аутентификации.

Двухфакторная аутентификация — это дополнительный уровень безопасности, добавляемый к странице аутентификации. Примерами этой двухфакторной аутентификации являются SMS, электронная почта и OTP.

Вот пример схемы двухфакторной аутентификации 

Как реализовать двухфакторную аутентификацию

Существует множество способов использования шифрования 2FA. Токены RSA, генераторы кодов, такие как Google Authenticator и Duo, и отправка SMS-сообщений с одноразовыми кодами — все это варианты реализации технологии 2FA.

Неверный сброс пароля

Это не так часто, но время от времени я вижу веб-приложение, в котором эта возможность реализована неправильно. Часто это происходит из-за того, что пароль пользователя был отправлен ему по электронной почте, или токен, использованный для сброса пароля, был недостаточно надежным. Отправка открытого текста пароля обратно конечному пользователю — еще одна проблема, влияющая на сброс пароля. Это ужасно по разным причинам, одна из которых заключается в том, что пароль был отправлен по электронной почте, что считается небезопасным. Это может означать, что пароль был сохранен в базе данных без достаточного хеширования или в формате, который можно было бы изменить, например base64.

Хэширование  — это метод, используемый для проверки или подтверждения качества различных видов входных данных. В системах аутентификации он в основном используется для предотвращения хранения незашифрованных паролей, а хэширование делает невероятно сложным для злоумышленников расшифровку сохраненных паролей.

Base64: Base64 — это метод преобразования двоичных данных в текст. Этот метод часто используется для отправки информации на основе контента через Интернет.

Как исправить этот недостаток

• Всегда шифруйте пароли пользователей перед их сохранением, не храните их в необработанном виде.
• Отправляйте транзакционные электронные письма только после проверки и проверки адресов электронной почты путем проверки допустимых символов и отправки ссылки для подтверждения с токеном.

Небезопасный выход

Это еще одна уязвимость, которая может серьезно повредить приложение. Также важно предоставить вашим пользователям безопасный способ выхода из системы, чтобы их сеансы не могли быть перехвачены. Если вы сохраняете идентификатор сеанса на стороне сервера, метод выхода из системы должен сделать его недействительным и стереть файл cookie сеанса в браузере. Это не позволяет злоумышленникам украсть файлы cookie сеанса, а затем использовать их для запуска нового сеанса.

Как исправить этот недостаток

• Когда пользователь выходит из системы, очистите файл cookie сеанса браузера и сделайте недействительным идентификатор сеанса, если он хранится на сервере.
• Во время выхода сеансы пользователей и токены аутентификации должны быть правильно аннулированы.

Атака грубой силы

Брутфорс — это метод взлома, используемый для получения учетных данных пользователя путем перебора различных возможных учетных данных. В этой атаке хакеры пытаются угадать пароли, чтобы пройти аутентификацию для одной учетной записи. Используя сценарии, которые пробуют многие часто используемые пароли из словаря и миллионы утекших паролей из предыдущих утечек данных, эти попытки имеют больше шансов на успех.

Как исправить этот недостаток

• Ограничьте попытки входа в систему определенным IP-адресом или диапазоном, заблокировав доступ к URL-адресу аутентификации.
• Не используйте термины из словарей на любом языке. Вместо слов предпочтительнее использовать случайные строки символов.
• Блокируйте вредоносные IP-адреса с помощью CAPTCHAS.
• Отслеживайте неудачные попытки входа пользователя и блокируйте учетную запись.

Использование недостаточного количества контрольных вопросов

Контрольный вопрос или запоминающееся слово также могут помочь в защите от автоматизированных атак. Я столкнулся с ненадежными секретными вопросами, ответы на которые предсказуемы, что позволяет злоумышленнику предлагать или угадывать ответы и получать доступ к данным пользователя.

Вот некоторые из популярных вопросов безопасности, с которыми я столкнулся:

• В каком городе ты родился?
• Какая твоя дата рождения?
• В какой средней школе вы учились?
• Какая девичья фамилия вашей матери?

Избегайте всех этих вопросов, потому что хакеры могут угадать их из-за некоторой нашей информации в нашем Google или других онлайн-профилях.

Как исправить этот недостаток

• Рекомендовать вопросы, которые легко запомнить пользователю, но которые сложно предложить злоумышленникам.
• Сохраняйте ответы, используя безопасный алгоритм хеширования, такой как Bcrypt. Bcrypt — это алгоритм, используемый для хеширования и проверки паролей. Это помогает снизить вероятность атаки киберпреступников на ваше приложение через пароль.

Неспособность защитить маршруты

Еще одна ошибка, которую я видел у разработчиков, когда дело доходит до аутентификации, — это «неспособность защитить маршрут». Крайне важно защитить определенные маршруты в вашем приложении от пользователей, не прошедших проверку подлинности, так как это предотвратит доступ неизвестных пользователей к некоторым личным данным вашего приложения.

Как исправить этот недостаток

• Защитите маршрут, к которому должны получить доступ пользователи, не прошедшие проверку подлинности.
• Если пользователь пытается получить доступ к определенному маршруту, перенаправьте его на страницу входа/регистрации, если он не прошел проверку подлинности.

Вывод

При внедрении аутентификации на своем веб-сайте вы как разработчик должны проявлять крайнюю осторожность, поскольку некоторые методы могут нанести серьезный ущерб вашей программе и дать злоумышленникам возможность захватить контроль над данными пользователей и приложением. Надеюсь, в этой статье были выделены такие ошибки и даны советы по их устранению.

Ссылка: https://blog.openreplay.com/11-authentication-mistakes-and-how-to-fix-them

#authentication

前 11 個身份驗證錯誤以及如何修復它們

身份驗證安全性是 Web 應用程序開發的一個重要方面，在創建產品時經常被忽視。但是，如果您打算在線提交申請，這是當務之急。在本文中，我將解釋其中一些錯誤以及如何修復它們。請注意，這些不是OWASP推薦的主要安全問題；相反，它們是我經常看到的易於修復的問題。

什麼是身份驗證？

身份驗證是確認用戶或進程身份的過程。當身份驗證被破壞時，攻擊者可以訪問用戶的數據或信息，從而對您的應用程序造成損害。身份驗證是攻擊者可以訪問用戶數據和您的應用程序的方式之一。

在進行身份驗證時，以下是要避免的 11 個常見錯誤：

1. 顯示特定的錯誤消息
2. 將會話 ID 集成到 URL 中
3. 表單驗證不正確
4. 低形式消毒
5. 弱密碼策略
6. 未能使用雙重身份驗證 (2FA)
7. 密碼重置不當
8. 不安全的註銷
9. 蠻力攻擊
10. 使用弱安全問題
11. 未能保護路線

顯示特定錯誤信息

顯示特定錯誤消息是危險的，因為它可能讓攻擊者使用自動試錯法來確定用戶的用戶名或密碼。

這是顯示特定錯誤消息的圖表示例。 

在您的 Web 應用程序上驗證表單時，您必須注意不要在用戶鍵入不正確的詳細信息時只顯示一條錯誤消息——例如“您的密碼不正確”。如果您顯示這樣的特定錯誤消息，攻擊者將意識到電子郵件地址或用戶 ID 是真實的，但密碼是錯誤的。這將使攻擊者建議該用戶的密碼。

如何修復這個缺陷

• 永遠不要在身份驗證頁面上顯示特定的錯誤消息。這讓攻擊者知道丟失了哪些信息，並讓他們使用暴力攻擊來猜測丟失了哪些信息。
• 顯示錯誤消息，例如“不正確的詳細信息”。

將會話 ID 集成到 URL

會話 ID 是網站服務器在該用戶訪問期間向單個用戶提供的數字。如果將會話令牌直接放在 URL 中，則攻擊者獲取和濫用會話令牌的機會會增加。雖然使用 HTTPS 連接 Web 服務器的風險較低，但仍然存在危險。即使 HTTPS URL 在傳輸過程中被加密，它們也經常保存在服務器日誌中。

這是將會話 ID 集成到 URL 中的圖表示例。

如何修復這個缺陷

• 在服務器端驗證會話 ID
• 要創建令牌，請確保使用足夠安全的隨機生成器。
• 使用過濾器從 URL 中刪除會話 ID。

表單驗證不正確。

如果表單輸入中提供的數據未正確檢查或格式化，則可能發生注入攻擊、內存洩漏和系統受損。用戶通常在提交時沒有填寫所有需要的信息，因此有必要驗證您的表單以確保在將其提交到服務器之前已滿足所有必需的信息。

如何修復這個缺陷

• 確保電子郵件具有電子郵件地址格式。
• 確保用戶在提交之前滿足表單的條件
• 使用更新的庫或框架從後端和前端驗證表單。

我推薦的一些用於表單驗證的建議庫是：

• 驗證器
• 剛剛驗證
• 質樸

所有列出的庫都適用於驗證您的表單。

低形式消毒 

保持表單輸入乾淨、過濾和清除惡意代理的過程稱為表單清除。清理您的輸入是必須的，因為它可以防止注入缺陷。經過良好清理的輸入表單可以防止以下攻擊：

跨站腳本 (XSS)：這是一種常見於 Web 應用程序中的安全漏洞。此漏洞允許攻擊者將客戶端腳本插入用戶查看的網頁中。這種攻擊會對用戶造成很大的安全危害，例如將用戶重定向到惡意網站、強制用戶下載惡意應用程序以及竊取用戶數據。

SQL 注入：攻擊者可以通過表單輸入乾擾發送到其數據庫的數據。 

通過清理表單輸入，您必須保護您的代碼和用戶數據免受此惡意代理和所有列出的漏洞的影響。我個人使用DOM Purify，這是一個用於 HTML 和字符串的淨化庫，它可以過濾任何包含臟 HTML 並防止 XSS 攻擊的內容。

如何修復這個缺陷

• 將許可列表用於數字、日期或郵政編碼等明確定義的輸入會更加容易和安全。在這方面，您可以明確說明允許的值和不允許的值。
• 在 HTML5 表單驗證的內置數據類型定義中使用預定義的白名單邏輯。

弱密碼策略

遇到沒有按順序設置強密碼計劃的網站並不罕見。我最近嘗試了一個需要五個字符的最小密碼長度的應用程序。隨著開發人員試圖在安全性和可用性之間找到適當的平衡，這個缺陷變得越來越普遍。使用密碼時，請確保您向用戶建議的密碼或用戶創建的密碼是符號、數字和大小寫混合字母的混合。避免使用弱密碼計劃。

如何修復這個缺陷

• 要求用戶輸入至少 12 或 8 個字符或更長的字符。
• 為了安全性和可用性，應避免使用包含用戶名或公司名稱的密碼。
• 大小寫字母應混用。
• 使用庫來計算密碼的強度，在選擇時要小心，並檢查最小的依賴性和可維護性。
• 當某人擁有公開個人資料時，請使用不同的顯示名稱，並避免使用用戶的電子郵件地址作為顯示名稱，因為這會招致垃圾郵件。

未能使用雙重身份驗證

我看到的 Web 身份驗證機制的另一個常見錯誤是它們沒有任何額外的安全措施。開發人員很少使用雙因素身份驗證，尤其是對於頂級帳戶。雙因素身份驗證有助於為您的應用程序添加第二層保護。雙重身份驗證對於 Web 安全至關重要，因為它可以立即消除憑據洩露的危害。當密碼被破解、猜到，甚至被惡意軟件感染時，在沒有第二個身份驗證因素批准的情況下授予入侵者訪問權限已不再足夠。

雙因素身份驗證是添加到身份驗證頁面的額外安全層。這種雙因素身份驗證的示例是 SMS、電子郵件和 OTP。

這是兩因素身份驗證的圖表示例 

如何實現雙重身份驗證

有多種方法可以使用 2FA 加密。RSA 令牌、Google Authenticator 和 Duo 等代碼生成器以及一次性代碼的 SMS 文本發送都是實施 2FA 技術的選項。

密碼重置不當

這種情況並不常見，但時不時地，我會看到一個 Web 應用程序錯誤地實現了此功能。這通常是因為用戶的密碼是通過電子郵件發送給他們的，或者用於重置密碼的令牌不夠強。將明文密碼發送回最終用戶是影響密碼重置的另一個問題。這很糟糕，原因有很多，其中之一是密碼是通過電子郵件發送的，這被認為是不安全的。這可能意味著密碼存儲在數據庫中沒有足夠的散列或可以反轉的格式，如 base64。

散列 是一種用於驗證或驗證各種輸入質量的技術。在身份驗證系統中，它主要用於防止存儲明文密碼，而哈希使攻擊者難以破譯已存儲的密碼。

Base64： Base64 是一種將二進制數據轉換為文本的方法。該方法經常用於通過 Internet 發送基於內容的信息。

如何修復這個缺陷

• 始終在存儲用戶密碼之前對其進行加密，不要以原始形式存儲它們。
• 僅在通過檢查有效字符並發送帶有令牌的驗證鏈接來驗證和驗證電子郵件地址後發送交易電子郵件。

不安全的註銷

這是另一個可能對應用程序造成嚴重破壞的漏洞。為您的用戶提供一種安全的註銷方式也很重要，這樣他們的會話就不會被接管。如果您將會話標識符存儲在服務器端，則註銷方法應使其無效並清除瀏覽器中的會話 cookie。這使攻擊者無法竊取會話 cookie，然後使用它們來啟動新會話。

如何修復這個缺陷

• 當用戶註銷時，清除瀏覽器的會話 cookie 並使會話標識符無效（如果它存儲在服務器上）。
• 在註銷期間，用戶會話和身份驗證令牌應正確失效。

蠻力攻擊

蠻力是一種黑客技術，用於通過嘗試各種可能的憑據來找出用戶的憑據。在這種攻擊中，黑客試圖猜測密碼以通過單個帳戶的身份驗證。使用從字典中嘗試許多常用密碼的腳本以及從以前的數據洩露中洩露的數百萬個密碼，這些嘗試更有可能成功。

如何修復這個缺陷

• 通過阻止對身份驗證 URL 的訪問，將登錄嘗試限制在定義的 IP 地址或範圍內。
• 不使用任何語言的字典中的術語。與其使用單詞，不如使用隨機字符串。
• 使用驗證碼阻止惡意 IP 地址。
• 跟踪用戶的失敗登錄嘗試並鎖定帳戶。

使用不足的安全問題

安全問題或令人難忘的單詞也可以幫助防範自動攻擊。我遇到過具有可預測響應的弱安全問題，允許攻擊者建議或猜測答案並獲得對用戶數據的訪問權限。

以下是我遇到的一些流行的安全問題：

• 你出生於哪個城市？
• 你的生日是幾號？
• 你讀的是哪所高中？
• 你媽媽的娘家姓什麼？

避免所有這些問題，因為黑客可以通過我們在 Google 或其他在線個人資料中的一些信息來猜測它們。

如何修復這個缺陷

• 推薦用戶容易記住但攻擊者難以提出的問題
• 使用安全散列算法（例如 Bcrypt）存儲答案。Bcrypt是一種用於散列和驗證密碼的算法。它有助於減少網絡犯罪分子通過密碼攻擊您的應用程序的機會。

未能保護路線

我看到開發人員在身份驗證方面犯的另一個錯誤是“未能保護路由”。確保應用程序中的特定路由免受未經身份驗證的用戶的訪問至關重要，因為這將防止未知用戶訪問您應用程序的某些私有數據。

如何修復這個缺陷

• 保護您希望未經身份驗證的用戶訪問的路由。
• 如果用戶嘗試訪問特定路由，如果他們未通過身份驗證，則將他們重定向到登錄/註冊頁面

結論

在您的網站上實施身份驗證時，作為開發人員，您必須格外小心，因為某些方法可能會對您的程序造成極大的破壞，並為攻擊者奪取用戶數據和應用程序的控制權打開了大門。希望本文突出了此類錯誤並提供了有關如何修復它們的建議。

鏈接：https ://blog.openreplay.com/11-authentication-mistakes-and-how-to-fix-them

#authentication

11 Sai Lầm Xác Thực Hàng đầu Và Cách Khắc Phục Chúng

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à gì?

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:

1. Hiển thị thông báo lỗi cụ thể
2. Tích hợp ID phiên vào một URL
3. Xác thực biểu mẫu không chính xác
4. Vệ sinh dạng thấp
5. Chiến lược mật khẩu yếu
6. Không thể sử dụng Xác thực hai yếu tố (2FA)
7. Đặt lại mật khẩu không đúng
8. Đăng xuất không an toàn
9. Tấn công vũ phu
10. Sử dụng câu hỏi bảo mật yếu
11. Không bảo vệ được tuyến đường

Hiển thị thông báo lỗi cụ thể

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

• Không bao giờ hiển thị thông báo lỗi cụ thể trên trang xác thực. Điều này cho phép kẻ tấn công biết thông tin nào bị thiếu và cho phép chúng sử dụng một cuộc tấn công bạo lực để đoán thông tin bị thiếu.
• Hiển thị các thông báo lỗi như “chi tiết không chính xác”.

Tích hợp ID phiên vào một URL

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

• Xác thực ID phiên ở phía máy chủ
• Để tạo mã thông báo, hãy đảm bảo bạn sử dụng trình tạo ngẫu nhiên đủ an toàn.
• Sử dụng bộ lọc để xóa ID phiên khỏi URL.

Xác thực biểu mẫu không chính xác.

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 bảo rằng email có định dạng địa chỉ email.
• Đảm bảo người dùng đã đáp ứng các tiêu chí cho biểu mẫu trước khi gửi
• Xác thực biểu mẫu từ phụ trợ và giao diện người dùng bằng cách sử dụng thư viện hoặc khuôn khổ được cập nhật.

Một số thư viện được đề xuất mà tôi đề xuất để xác thực biểu mẫu là:

• Trình xác thực
• Chỉ cần xác thực
• Nguyên sơ

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.

Vệ sinh dạng thấp 

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

• Sẽ dễ dàng và an toàn hơn đáng kể khi sử dụng danh sách cho phép cho các đầu vào được xác định rõ ràng như số, ngày tháng hoặc mã bưu điện. Về vấn đề đó, bạn có thể nêu rõ ràng những giá trị nào được phép và những giá trị nào không.
• Sử dụng logic cho phép được xác định trước trong định nghĩa kiểu dữ liệu tích hợp với xác thực biểu mẫu HTML5.

Chiến lược mật khẩu yếu

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

• Yêu cầu người dùng nhập tối thiểu 12 hoặc 8 ký tự hoặc dài hơn.
• Nên tránh sử dụng mật khẩu kết hợp tên người dùng hoặc tên công ty để bảo mật và khả năng sử dụng.
• Chữ hoa và chữ thường nên được trộn lẫn.
• Sử dụng thư viện để tính toán độ mạnh của mật khẩu, thận trọng khi chọn và kiểm tra các phụ thuộc và khả năng bảo trì tối thiểu.
• Khi một người có hồ sơ công khai, hãy sử dụng tên hiển thị khác và tránh sử dụng địa chỉ email của người dùng làm tên hiển thị vì điều này mời spam.

Không thể sử dụng Xác thực hai yếu tố

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.

Đặt lại mật khẩu không đúng

Đ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

• Luôn mã hóa mật khẩu người dùng trước khi lưu trữ, không lưu trữ ở dạng thô.
• Chỉ gửi email giao dịch sau khi xác thực và xác minh địa chỉ email bằng cách kiểm tra các ký tự hợp lệ và gửi liên kết xác minh có mã thông báo.

Đăng xuất không an toàn

Đâ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

• Khi người dùng đăng xuất, hãy xóa cookie phiên của trình duyệt và làm mất hiệu lực nhận dạng phiên nếu nó đang được lưu trữ trên máy chủ.
• Trong quá trình đăng xuất, phiên người dùng và mã thông báo xác thực phải được vô hiệu hóa một cách chính xác.

Tấn công vũ phu

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

• Hạn chế các nỗ lực đăng nhập vào một địa chỉ hoặc dải IP xác định bằng cách chặn quyền truy cập vào URL xác thực.
• Không sử dụng thuật ngữ nào từ từ điển bằng bất kỳ ngôn ngữ nào. Thay vì sử dụng các từ, tốt hơn là sử dụng các chuỗi ký tự ngẫu nhiên.
• Chặn các địa chỉ IP độc hại bằng CAPTCHAS.
• Theo dõi các lần đăng nhập thất bại của người dùng và khóa tài khoản.

Sử dụng câu hỏi bảo mật không đầ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:

• Bạn sinh ra ở thành phố nào?
• Ngày sinh của bạn là gì?
• bạn đã học trường trung học phổ thông nào?
• Tên thời con gái của mẹ bạn là gì?

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

• Đề xuất những câu hỏi người dùng dễ nhớ nhưng kẻ tấn công khó đề xuất
• Lưu trữ câu trả lời bằng thuật toán băm an toàn như Bcrypt. Bcrypt là một thuật toán được sử dụng để băm và xác minh mật khẩu. Nó giúp giảm nguy cơ tội phạm mạng tấn công ứng dụng của bạn thông qua mật khẩu.

Không bảo vệ các tuyến đường

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

• Bảo vệ tuyến đường bạn muốn người dùng chưa xác thực truy cập.
• Nếu người dùng đang cố gắng truy cập vào một tuyến đường cụ thể, hãy chuyển hướng họ đến trang đăng nhập / đăng ký nếu chúng chưa được xác thực

Sự kết luận

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

A Dart/Flutter Package for Authorization & Authentication

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.

Full SMART on FHIR

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.

Setup

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.

Android Setup

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.

1. Your minSdkVersion needs at least 18, and preferably something like 21 or 23.
2. "your.application.id" is usually a reverse of a typicaly url format, so could be something like: "dev.fhirfli.application". This is also going to be your callback, although it should be something like: dev.fhirfli.application://callback (or in the case of google, sometimes they only allow a single slash, i.e. dev.fhirfli.application:/callback).
3. While it may not be completely necessary, I add the 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>

iOS Setup

You must set the platform in ios/Podfile

platform :ios, '11.0'

Basic Example Setup

SmartClient

  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),
  );

Workflow

  await client.login();
  final request1 = FhirRequest.create(
    base: client.fhirUri!.value!,
    resource: _newPatient,
    fhirClient: client,
  );
  final response = await request1.request();

Api.dart

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';
}

Mobile Auth by Provider

Google's Healthcare API

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).

1. Go through the APIs & Services -> OAuth consent screen (fill in everything, including support email, and your authorized domains as your GCP domain)
2. Your sensitive scopes - Cloud Healthcare API
3. APIs & Services -> Credentials -> Create OAuth client ID
4. Package name should be (assuming API file above): com.myshiny.newapp
5. You do need the SHA-1 certificate for this (ALWAYS remember to update this, I always forget and then spend at least an hour cursing at myself for why it's not working when I didn't change anything - and I forgot I changed computers, or reformatted, or something, and now my SHA-1 certificate is different)
6. From the same menu, Create an OAuth client ID but select web application
7. Identity Platform -> Add a Provider -> Select Google
8. Web Client ID (from the above web app) and Web Client Secret (from the above web app)
9. Alright, I can't tell if you need to include the ClientId or not for this. Sometimes it seems to work without it and sometimes it doesn't. You may need to try it both ways. Either way, you DO need to have registered the mobile client.

Aidbox

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.

1. Start by going to https://aidbox.app/
2. Create a new box called whatever you want, select your FHIR Version and Zone
3. Create your client

  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

1. Create User (can be found more detail here)

data:
  name: Grey Faulkenberry
  roles:
    - Administrator
    - Doctor
email: user@mail.com
password: password
id: user1
resourceType: User

1. Create AccessPolicy for user (for true production apps, you will need to consider how you actually want this to be done, what kind of access you need, etc. For now, we are giving all the permissions for the 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

1. The mobileauthdemo should now be ready to connect to Aidbox.

Interopland and MELD

1. This is a relatively typical HAPI server
2. After you have the server setup, select Apps, then create a new App.
3. App Name and description can be what you'd like, Client Type should generally be Public Client
4. App Launch URI for this is unimportant, because we're not launching from within their portal
5. App redirect (given above API): com.myshiny.newapp://callback
6. You'll need to choose your own scopes, I've gone with: launch patient/Patient.* openid profile offline_access user/Patient.*
7. You'll also need to add some users (Settings -> USERS)

Azure API for FHIR (needs to be updated) - ToDo

  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.

Web Auth by Provider

Redirect

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>

Google's Healthcare API

1. Follow the instructions above to set everything up.
2. Ensure you put the Authorized Origins and Redirect URIs in the webauthdemo Oauth2 client
3. For our demo, since we're running it on a localhost (don't ever do this in real life, and ESPECIALLY never in production), our origin is http://localhost:8888 and our redirect is http://localhost:8888/redirect.html

Aidbox

1. Same setup as above actually, just remember to change your redirect.

Interopland and MELD

1. Same setup as above, but remember that for this one you probably do want to make sure you have the correct launch url (although we're still launching externally) and the new redirect URL

Azure API for FHIR - ToDo

  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.

EHR Launch

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!

Suggestions and Complaints

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®

Use this package as a library

Depend on it

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.

Import it

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'; 

example/example.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

#flutter #authentication 

Cách Xác Thực Với JWT Cho Trang Web Của Bạn

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:

• Kiến thức làm việc về JavaScript
• Hiểu rõ về Node.js và cách sử dụng nó trong việc tạo máy chủ.
• Làm việc hiểu biết về tạo cơ sở dữ liệu.
• Kiến thức cơ bản về React.js
• Postman và kiến ​​thức về cách sử dụng Postman.

JWT là gì và nó hoạt động như thế nào?

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:

• Người dùng đăng nhập vào một trang web hoặc ứng dụng bằng email / tên người dùng và mật khẩu để chứng minh danh tính của mình.
• Máy chủ xác nhận danh tính của người dùng và gửi lại mã thông báo truy cập duy nhất có chứa tham chiếu đến danh tính của anh ta.
• Sau đó, máy khách bao gồm mã thông báo truy cập duy nhất này với mọi yêu cầu đến máy chủ, vì vậy nếu mã thông báo truy cập bị sai / bị thay đổi, máy khách sẽ bị từ chối truy cập.
• Đối với các tuyến đường được bảo vệ, một phần mềm trung gian xác thực được tạo trong máy chủ để xác nhận sự hiện diện của mã thông báo hợp lệ. Máy chủ có thể sử dụng thêm danh tính để triển khai các quyền chi tiết hơn.

Ưu và nhược điểm của Xác thực JWT

Có một số lợi thế:

• Nhỏ gọn hơn: JSON ít dài dòng hơn XML, vì vậy khi nó được mã hóa, JWT nhỏ hơn mã thông báo SAML. Điều này làm cho JWT trở thành một lựa chọn tuyệt vời để được thông qua trong các môi trường HTML và HTTP.
• An toàn hơn: JWT có thể sử dụng cặp khóa công khai / riêng tư làm chứng chỉ X.509 để ký. JWT cũng có thể được ký đối xứng bằng một bí mật được chia sẻ bằng cách sử dụng thuật toán HMAC. Và trong khi các mã thông báo SAML có thể sử dụng các cặp khóa công khai / riêng tư như JWT, việc ký XML bằng Chữ ký số XML mà không có các lỗ hổng bảo mật khó hiểu là rất khó khi so sánh với sự đơn giản của việc ký JSON. Đọc thêm về các thuật toán ký JWT tại đây .
• Phổ biến hơn: Bộ phân tích cú pháp JSON phổ biến trong hầu hết các ngôn ngữ lập trình vì chúng ánh xạ trực tiếp đến các đối tượng. Ngược lại, XML không có ánh xạ tài liệu sang đối tượng tự nhiên, làm cho việc làm việc với JWT dễ dàng hơn so với các xác nhận SAML.
• Dễ dàng xử lý hơn: JWT được sử dụng trên quy mô internet. Điều này có nghĩa là nó dễ dàng hơn để xử lý trên các thiết bị của người dùng, đặc biệt là thiết bị di động.

Tuy nhiên, cũng có một số nhược điểm:

• Nếu một ứng dụng khách cần bị chặn hoặc hủy kích hoạt, ứng dụng sẽ phải đợi mã thông báo hết hạn để khóa có hiệu lực hoàn toàn.
• Nếu khách hàng cần thay đổi mật khẩu của họ và xác thực đã được thực hiện trước đó, mã thông báo được tạo bằng mật khẩu trước đó sẽ vẫn có giá trị cho đến khi hết hạn.
• Việc triển khai tiêu chuẩn chỉ định không có mã thông báo "làm mới". Khi hết hạn, khách hàng sẽ phải xác thực lại.
• Không thể phá hủy mã thông báo mà không vi phạm khía cạnh “không trạng thái” của mã thông báo JWT: Ngay cả khi mã thông báo bị xóa khỏi trình duyệt, nó vẫn có giá trị cho đến khi hết hạn, vì vậy không thể đăng xuất thực sự.

Để đố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.

Cấu trúc JWT là gì?

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 đề
• Khối hàng
• Chữ ký

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.

Tích hợp Xác thực JWT vào back end

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.

Tạo lộ trình đăng ký của chúng tôi

Đầ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.

Tạo lộ trình Đăng nhập / Đăng nhập của chúng tôi

Đố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.

Tạo lộ trình xác thực của chúng tôi

Để 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ệ.

Tích hợp Xác thực JWT vào giao diện người dùng

Để 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.

Sự kết luận

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

Как пройти аутентификацию с помощью JWT для вашего сайта

С момента появления разработки веб-приложений через Интернет отправляется много конфиденциальной информации, что делает концепцию аутентификации тем, что каждый веб-разработчик должен понимать и применять в приложении для защиты информации, доверенной приложению пользователем. В этой статье мы рассмотрим средство аутентификации для веб-приложений, известное как аутентификация JWT. По сравнению с другими аутентификация JWT стала фаворитом благодаря своим многочисленным преимуществам для разработчиков.

Прежде чем мы углубимся в программирование, мы определим некоторые ключевые термины и понятия, которые помогут нам понять, как работает аутентификация JWT, после чего мы интегрируем эту форму аутентификации в проект, в котором есть сервер, созданный с помощью Node.js, и интерфейс, созданный с помощью React.js, широко используемого фреймворка (на самом деле, моего личного фаворита) для разработки интерфейса.

Чтобы иметь возможность следовать остальной части статьи, вам необходимо следующее:

• Знание JavaScript на рабочем уровне
• Хорошее понимание Node.js и способов его использования при создании сервера.
• Рабочее понимание создания базы данных.
• Базовые знания React.js
• Почтальон и знания о том, как использовать Postman.

Что такое JWT и как это работает?

JWT означает JSON Web Token, открытый стандарт, используемый для обмена информацией о безопасности в виде объекта JSON между клиентом и сервером. Наличие JWT в запросе к серверу от клиента означает, что информация проверена, и ее достоверность установлена, поскольку она снабжена цифровой подписью с использованием секрета, записанного с помощью криптографического алгоритма, чтобы гарантировать, что утверждения не будут изменены после выдается токен. Хотя ни один посредник не может изменить JWT, рекомендуется использовать его в среде HTTPS, поскольку JWT не зашифрован.

Аутентификация JWT — это механизм аутентификации без сохранения состояния, обычно используемый в качестве сеанса без сохранения состояния на стороне клиента. Серверу не нужно полностью полагаться на базу данных для сохранения информации о сеансе. Информация о сеансе хранится на стороне клиента; поэтому поиск в базе данных не требуется для проверки личности запрашивающего пользователя. Это работает следующим образом:

• Пользователь входит на веб-сайт или в приложение, используя адрес электронной почты/имя пользователя и пароль, чтобы подтвердить свою личность.
• Сервер подтверждает личность пользователя и отправляет обратно уникальный токен доступа, содержащий ссылку на его личность.
• Затем клиент включает этот уникальный токен доступа с каждым запросом к серверу, поэтому, если токен доступа неправильный/измененный, клиенту будет отказано в доступе.
• Для защищенных маршрутов на сервере создается промежуточное ПО проверки подлинности, подтверждающее наличие действительного токена. Сервер может дополнительно использовать удостоверение для реализации более детальных разрешений.

Плюсы и минусы аутентификации JWT

Есть несколько преимуществ:

• Более компактный: JSON менее подробен, чем XML, поэтому при кодировании JWT меньше токена SAML. Это делает JWT отличным выбором для передачи в средах HTML и HTTP.
• Более безопасный: JWT могут использовать пару открытого/закрытого ключа в качестве сертификата X.509 для подписи. JWT также может быть симметрично подписан общим секретом с использованием алгоритма HMAC. И хотя токены SAML могут использовать пары открытого и закрытого ключей, такие как JWT, подписание XML с помощью цифровой подписи XML без создания неясных брешей в безопасности очень сложно по сравнению с простотой подписания JSON. Подробнее об алгоритмах подписи JWT читайте здесь .
• Более распространено: синтаксические анализаторы JSON распространены в большинстве языков программирования, поскольку они напрямую сопоставляются с объектами. И наоборот, XML не имеет естественного сопоставления документа с объектом, что упрощает работу с JWT, чем с утверждениями SAML.
• Проще обрабатывать: JWT используется в масштабах Интернета. Это означает, что его легче обрабатывать на устройствах пользователей, особенно мобильных.

Однако есть и некоторые недостатки:

• Если клиент необходимо заблокировать или деактивировать, приложению придется дождаться истечения срока действия токена, чтобы блокировка вступила в силу.
• Если клиенту необходимо изменить свой пароль, а аутентификация была выполнена заранее, токен, созданный с использованием предыдущего пароля, будет действителен до истечения срока действия.
• Стандартная реализация не указывает токена «обновления». Поэтому по истечении срока действия клиент должен будет пройти повторную аутентификацию.
• Невозможно уничтожить токен, не нарушив аспект «без сохранения состояния» токенов 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, разделенные точками.

Интеграция аутентификации JWT в серверную часть

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 с неверным токеном в заголовке, а сервер отвечает сообщением об ошибке, говорящим о недопустимом токене.

Интеграция аутентификации JWT во внешний интерфейс

Для этого вам нужно будет установить 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

如何使用 JWT 為您的網站進行身份驗證

自從 Web 應用程序開發出現以來，許多敏感信息都通過 Internet 發送，這使得身份驗證的概念成為每個 Web 開發人員都應該理解並在應用程序中應用以保護用戶委託給應用程序的信息。在本文中，我們將介紹一種稱為 JWT 身份驗證的 Web 應用程序身份驗證方法。與其他人相比，JWT 身份驗證因其對開發人員的諸多優勢而成為人們的最愛。

在深入編碼之前，我們將定義一些關鍵術語和概念以幫助我們了解 JWT 身份驗證的工作原理，之後我們會將這種形式的身份驗證集成到一個項目中，該項目有一個使用 Node.js 創建的服務器，以及一個使用 React.js 創建的前端是一個廣泛使用的前端開發框架（實際上是我個人最喜歡的）。

為了能夠繼續閱讀本文的其餘部分，您需要以下內容：

• JavaScript的工作知識
• 對 Node.js 以及如何在創建服務器時使用它有很好的理解。
• 對數據庫創建的工作理解。
• React.js 基礎知識
• 郵遞員和如何使用郵遞員的知識。

什麼是 JWT，它是如何工作的？

JWT 代表 JSON Web Token，這是一種開放標準，用於在客戶端和服務器之間以 JSON 對象的形式共享安全信息。客戶端向服務器發出的請求中存在 JWT 表示該信息已經過驗證，並且它的可信度已經建立，因為它是使用用加密算法編寫的秘密進行數字簽名的，以確保聲明之後不會被更改發出令牌。雖然沒有中間人可以修改 JWT，但建議在 HTTPS 環境中使用它，因為 JWT 未加密。

JWT 身份驗證是一種無狀態身份驗證機制，通常用作客戶端無狀態會話。服務器不必完全依賴數據庫來保存會話信息。會話信息存儲在客戶端；因此，不需要數據庫查找來驗證請求用戶的身份。它是這樣工作的：

• 用戶使用電子郵件/用戶名和密碼登錄網站或應用程序以證明其身份。
• 服務器確認用戶的身份並發回一個唯一的訪問令牌，其中包含對其身份的引用。
• 然後，客戶端在對服務器的每個請求中都包含這個唯一的訪問令牌，因此如果訪問令牌錯誤/更改，客戶端將被拒絕訪問。
• 對於受保護的路由，在服務器中創建一個身份驗證中間件來斷言有效令牌的存在。服務器可以進一步使用身份來實現更細粒度的權限。

JWT 身份驗證的優缺點

有幾個優點：

• 更緊湊：JSON 比 XML 更簡潔，因此在對其進行編碼時，JWT 小於 SAML 令牌。這使得 JWT 成為在 HTML 和 HTTP 環境中傳遞的絕佳選擇。
• 更安全：JWT 可以使用公鑰/私鑰對作為 X.509 證書進行簽名。JWT 也可以使用 HMAC 算法通過共享密鑰進行對稱簽名。雖然 SAML 令牌可以使用 JWT 等公鑰/私鑰對，但與簽署 JSON 的簡單性相比，使用 XML 數字簽名簽署 XML 而不引入晦澀的安全漏洞是非常困難的。在此處閱讀有關 JWT 簽名算法的更多信息。
• 更常見：JSON 解析器在大多數編程語言中都很常見，因為它們直接映射到對象。相反，XML 沒有自然的文檔到對象映射，這使得使用 JWT 比使用 SAML 斷言更容易。
• 更容易處理：JWT 用於互聯網規模。這意味著更容易在用戶的設備上進行處理，尤其是移動設備。

但是，也有一些缺點：

• 如果需要阻止或停用客戶端，應用程序將必須等待令牌過期才能使鎖定完全生效。
• 如果客戶端需要更改密碼，並且事先已經執行了身份驗證，則使用之前的密碼生成的令牌在到期之前仍然有效。
• 標準實現沒有指定“刷新”令牌。因此，在到期時，客戶端將不得不重新進行身份驗證。
• 不破壞 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 字符串。

將 JWT 身份驗證集成到後端

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 向服務器發送了一個請求，請求的標頭中包含不正確的令牌，服務器以錯誤消息進行響應，指出令牌無效。

將 JWT 身份驗證集成到前端

為此，您需要在我們使用 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

Comment S'authentifier Avec JWT Pour Votre Site Web

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 :

• Connaissance pratique de JavaScript
• Une bonne compréhension de Node.js et de son utilisation dans la création d'un serveur.
• Compréhension pratique de la création de bases de données.
• Connaissance de base de React.js
• Postman et connaissances sur l'utilisation de Postman.

Qu'est-ce que JWT et comment ça marche ?

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 :

• Un utilisateur se connecte à un site Web ou à une application avec un e-mail/nom d'utilisateur et un mot de passe pour prouver son identité.
• Le serveur confirme l'identité de l'utilisateur et renvoie un jeton d'accès unique contenant une référence à son identité.
• Le client inclut ensuite ce jeton d'accès unique avec chaque demande au serveur, donc si le jeton d'accès est erroné/modifié, l'accès est refusé au client.
• Pour les routes protégées, un middleware d'authentification est créé dans le serveur pour affirmer la présence d'un jeton valide. Le serveur peut en outre utiliser l'identité pour implémenter des autorisations plus granulaires.

Avantages et inconvénients de l'authentification JWT

Il y a plusieurs avantages :

• Plus compact : JSON est moins verbeux que XML, donc lorsqu'il est encodé, un JWT est plus petit qu'un jeton SAML. Cela fait de JWT un excellent choix à transmettre dans les environnements HTML et HTTP.
• Plus sécurisé : les JWT peuvent utiliser une paire de clés publique/privée comme certificat X.509 pour la signature. Un JWT peut également être signé symétriquement par un secret partagé à l'aide de l'algorithme HMAC. Et tandis que les jetons SAML peuvent utiliser des paires de clés publiques/privées comme JWT, signer XML avec XML Digital Signature sans introduire de failles de sécurité obscures est très difficile par rapport à la simplicité de signature JSON. En savoir plus sur les algorithmes de signature JWT ici .
• Plus courant : les analyseurs JSON sont courants dans la plupart des langages de programmation, car ils correspondent directement aux objets. Inversement, XML n'a pas de mappage naturel de document à objet, ce qui facilite le travail avec JWT par rapport aux assertions SAML.
• Plus facile à traiter : JWT est utilisé à l'échelle d'Internet. Cela signifie qu'il est plus facile à traiter sur les appareils des utilisateurs, en particulier les mobiles.

Cependant, il y a aussi quelques inconvénients :

• Si un client doit être bloqué ou désactivé, l'application devra attendre l'expiration du jeton pour que le verrouillage soit pleinement effectif.
• Si un client a besoin de changer son mot de passe, et qu'une authentification a été effectuée au préalable, un jeton généré avec le mot de passe précédent sera toujours valide jusqu'à expiration.
• L'implémentation standard ne spécifie aucun jeton « d'actualisation ». A l'expiration, le client devra donc se ré-authentifier.
• Il est impossible de détruire un token sans violer l'aspect "stateless" des tokens JWT : Même si le token est supprimé du navigateur, il reste valide jusqu'à expiration, donc aucune véritable déconnexion n'est possible.

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.

Qu'est-ce que la structure JWT ?

Un jeton Web JSON dans sa forme compacte se compose de trois parties séparées par des points, qui sont :

• Entête
• Charge utile
• Signature

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.

Intégration de l'authentification JWT dans le back-end

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.

Création de notre route d'inscription

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.

Création de notre route de connexion/connexion

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.

Création de notre route d'authentification

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.

Intégration de l'authentification JWT dans le frontal

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.

Conclusion

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

How to Authenticate with JWT for Your Website

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:

• Working knowledge of JavaScript
• A good understanding of Node.js and how to use it in creating a server.
• Working understanding of database creation.
• Basic knowledge of React.js
• Postman and knowledge on how to use Postman.

See more at: https://blog.openreplay.com/authentication-with-jwt-for-your-website

#jwt #authentication 

Des Fournisseurs D'authentification Pour La Création D'applications

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.

Avantages et inconvénients des fournisseurs d'authentification

Avant de choisir un fournisseur de services d'authentification, il est essentiel d'évaluer les avantages et les inconvénients de son utilisation.

Pour : Complexité des résumés

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.

Pour : Aucun stockage des informations utilisateur

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.

Pro : Tirez parti des connexions sociales

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.

Pour : une meilleure sécurité

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.

Inconvénients : Difficile à migrer

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.

Inconvénients : verrouillage du fournisseur

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.

Inconvénients : Coûts

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.

Conclusion

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.

Choisir un fournisseur d'authentification

L'article compare les fournisseurs de services d'authentification suivants :

• Auth0
• Authentification Firebase
• Employé de bureau
• CléManteau
• Cognito
• SuperTokens
• Nhôte

Ces fournisseurs d'authentification sont évalués sur la base de six critères d'évaluation.

1. Source ouverte

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.

2. Revendications JWT personnalisées

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.

3. Prise en charge de l'authentification unique (SSO)

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.

4. Authentification machine à machine

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_idet client_secret, qui sont utilisées pour authentifier le client.

5. Niveaux gratuits

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.

6. Facilité d'intégration

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 :

• la qualité des documents
• SDK disponibles
• la quantité de configuration requise
• le matériel disponible

Comparaison des fournisseurs

L'image illustre une comparaison entre les fournisseurs d'authentification présentés dans cet article.

Auth0

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.

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.

Authentification Firebase

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 :

• fournisseurs d'identité tels que Google, Facebook et autres
• email et mot de passe
• téléphoner

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.

Employé de bureau

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.

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.

Cape de clé

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.

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

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.

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

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.

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.

Authentification Nhost

Nhost Authentication est un service d'authentification open source pour Hasura. Avec l'authentification Nhost, les utilisateurs peuvent se connecter avec :

• E-mail et mot de passe
• Fournisseurs OAuth tels que GitHub, Google, Apple, Facebook, Twitter, LinkedIn et autres
• Liens magiques
• SMS

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é.

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 .

Une note sur l'évolutivité

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.

Conclusion

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/

  #jwt #authentication #hasura 

Os 7 Principais Provedores De Autenticação Para Criar Aplicativos

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.

Prós e contras dos provedores de autenticação

Antes de escolher um provedor de serviços de autenticação, é essencial avaliar as vantagens e desvantagens de usar um.

Pró: Complexidade de Resumos

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.

Pro: Sem armazenamento de informações do usuário

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.

Pró: aproveite os logins sociais

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.

Pró: melhor segurança

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.

Contras: Difícil de migrar

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.

Contras: Bloqueio do provedor

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.

Contras: Custos

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.

Conclusão

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.

Escolhendo um provedor de autenticação

O artigo compara os seguintes provedores de serviços de autenticação:

• Aut0
• Autenticação do Firebase
• Atendente
• KeyCloak
• Cognito
• SuperTokens
• Nhost

Esses provedores de autenticação são avaliados com base em seis critérios de avaliação.

1. Código Aberto

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.

2. Reivindicações de JWT personalizadas

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.

3. Suporte de Logon Único (SSO)

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.

4. Autenticação máquina a máquina

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_ide client_secret, que são usados ​​para autenticar o cliente.

5. Níveis Gratuitos

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.

6. Facilidade de Integração

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 qualidade da documentação
• SDKs disponíveis
• a quantidade de configuração necessária
• o material disponível

Comparação de provedores

A imagem ilustra uma comparação entre os provedores de autenticação apresentados neste artigo.

Aut0

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.

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.

Autenticação do Firebase

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:

• provedores de identidade, como Google, Facebook e outros
• e-mail e senha
• 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.

Atendente

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.

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.

Manto-chave

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.

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

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.

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

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.

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.

Autenticação Nhost

Nhost Authentication é um serviço de autenticação de código aberto para Hasura. Com Nhost Authentication, as pessoas podem entrar com:

• E-mail e senha
• Provedores OAuth como GitHub, Google, Apple, Facebook, Twitter, LinkedIn e outros
• Links mágicos
• SMS

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.

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 .

Uma nota sobre escalabilidade

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.

Conclusão

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/

#jwt #authentication #hasura 

JWTを使用してアプリを構築するための上位7つの認証プロバイダー（2022）

「認証サービスプロバイダー」とは、認証サービスを提供するエンティティを指します。認証プロバイダーは、認証システムを最初から手動で実装する複雑さを抽象化するため、より重要なタスクに集中できます。

この記事では、認証プロバイダーを使用することのメリットとデメリットを紹介し、JWT統合をサポートする既存のプロバイダーを比較します。

認証プロバイダーの長所と短所

認証サービスプロバイダーを選択する前に、それを使用することの利点と欠点を評価することが不可欠です。

プロ：複雑さを抽象化

認証サービスプロバイダーを使用すると、認証システムを自分で実装する複雑さが抽象化されます。このようなシステムの構築は、多くのリソースを必要とする複雑で時間のかかるプロセスです。

これらのリソースを他のより重要なタスクのために解放する既存のソリューションを使用できます。

プロ：ユーザー情報の保存なし

人に関する機密情報を保存することは、軽視することではありません。プロバイダーの使用を選択すると、サーバーにユーザーの詳細を保存することを心配する必要がなくなります。

プロ：ソーシャルログインを活用する

Auth Service Providerを使用すると、最小限の労力でソーシャルログインを有効にできます。ソーシャルログインとは、Twitter、GitHub、Googleなどの既存のソーシャルネットワークアカウントを使用してログインすることです。

各ソーシャルプロバイダーを個別に実装するには、労力とリソースが必要です。認証プロバイダーを使用すると、ソーシャルログインの追加がより簡単かつ迅速になります。

プロ：セキュリティの向上

認証プロバイダーの使用を選択すると、セキュリティが向上します。認証プロバイダーの全体的な焦点は、認証と承認にあります。つまり、ユーザーの情報を安全に保つためのトレーニングと設備が整っているということです。

短所：移行が難しい

認証サービスプロバイダーを選択すると、移行が困難になる可能性があります。別のプロバイダーに変更したり、独自のシステムをローリングしたりするのは難しい場合があります。

認証プロバイダーを使用することが理にかなっているかどうかを判断することが重要です。それを行うことを選択した場合は、ニーズと要件に合ったプロバイダーを選択してください。

短所：プロバイダーのロックイン

もう1つの欠点は、使用しているプロバイダーに依存しすぎる可能性があることです。その理由は、実装がそのベンダーに固有であるか、現在のユーザーデータをエクスポートすることがほぼ不可能であることが原因である可能性があります。

別のプロバイダーへの移行は、コストと時間がかかりすぎる可能性があるため、現在のプロバイダーでロックされます。

短所：コスト

最初は、コストは問題ではないかもしれません。ただし、アプリケーションが大きくなり、ユーザー数が増えると、コストが問題になる可能性があります。

認証プロバイダーの多くは、月間アクティブユーザー数に基づいて課金されます。ユーザーが多いほど、請求額は大きくなります。

結論

認証サービスプロバイダーを使用する必要がありますか、それとも独自のシステムを実装する必要がありますか？決定的な答えはありません。

プロバイダーを使用するかどうかの決定は、多くの要因に依存します。一部の人にとっては、認証プロバイダーを使用することが適切なソリューションですが、他の人にとってはそうではありません。

使用する場合は、読み続けて、利用可能なさまざまな認証サービスプロバイダーについて学習してください。

認証プロバイダーの選択

この記事では、次の認証サービスプロバイダーを比較しています。

• auth0
• FirebaseAuth
• 店員
• KeyCloak
• 学んだこと
• スーパートークン
• Nhost

これらの認証プロバイダーは、6つの評価基準に基づいて評価されます。

1.オープンソース

オープンソースプロジェクトには、いくつかの利点があります。1つの利点は、コスト削減です。オープンソースであるため、ライセンス料や使用料は必要ありません。

もう1つの利点は柔軟性です。ビジネス要件が変更された場合、または追加機能が必要な場合は、コードを自分で変更および拡張できます。ベンダーに変更を依頼したり、完全に変更したりする必要はありません。

透明性についても言及することが重要です。コードは誰でも見ることができます。非常に多くの専門家がコードにアクセスできるため、ソフトウェアをより良く、より安全にすることができます。

オープンソースの認証プロバイダーを使用することには他にも利点がありますが、これらの利点がポイントを押し上げます。

2.カスタムJWTクレーム

認証サービスプロバイダーをHasuraと統合するときは、それらがカスタムJWTクレームをサポートしていることを確認することが重要です。

Hasuraは、カスタムJWTクレームをチェックして、リクエストを行うユーザーの役割について学習します。その結果、Hasuraは適切な承認ルールを適用できます。

{    'x-hasura-default-role': 'user',    'x-hasura-allowed-roles': ['user'],    'x-hasura-user-id': user.user_id};

上記のスニペットは、カスタムJWTクレームの例を示しています。リクエストに関する重要な情報が含まれています。

3.シングルサインオン（SSO）のサポート

簡単に言うと、SSOは、ユーザーが1セットの資格情報を使用して複数のプラットフォームにログインする認証の種類を指します。

一例として、ユーザーがGoogleアカウントなどのソーシャルネットワークアカウントを使用してアプリケーションにログインするソーシャルSSOがあります。

4.マシン間認証

リクエストを行うのは必ずしもユーザーではありません。2台のマシンがそれらの間で通信するシナリオがあります。資格情報を入力するユーザーがいないため、クライアント（別のマシン）を別の方法で認証する必要があります。

マシンツーマシン（M2M）認証とは、ユーザー入力なしでマシンを認証することを指します。これは、OAuth2.0クライアント資格情報フローを使用することで可能になります。資格情報には、クライアントの認証に使用されるとがclient_id含まれます。client_secret

5.無料利用枠

この記事のすべての認証プロバイダーには無料枠があります。違いは、その層で提供されるものにあります。

毎月のアクティブユーザー（MAU）を測定し、それに基づいて課金します。その結果、一部のプロバイダーは数千のMAUを備えた無料枠を提供していますが、一部のプロバイダーは数百のMAUしか提供していません。

6.統合のしやすさ

認証サービスプロバイダーの統合は、多くの要因に依存します。プロバイダーの統合がいかに簡単か困難かを提示するのは困難です。

ただし、次のように、実装の難易度を示す可能性のあるポイントがいくつかあります。

• ドキュメントの品質
• 利用可能なSDK
• 必要な構成の量
• 利用可能な資料

プロバイダーの比較

この画像は、この記事で紹介した認証プロバイダー間の比較を示しています。

auth0

Auth0は、認証サービスのための定評のある人気のあるソリューションです。それは寛大な無料利用枠が付属しており、あなたが必要とするほとんどのものをサポートしています。

統合のしやすさに関して言えば、Auth0は統合が簡単でも難しいものでもありません。これは確立された広範なソリューションであるため、統合に役立つ大量の資料を利用できます。実行する必要のある構成の量は、アプリケーションのタイプと複雑さによって異なります。

Firebase認証

Firebase Authenticationは、アプリケーションに認証を追加できるもう1つの人気のある認証サービスです。

Firebaseでは、次のようなサインインメソッドを追加できます。

• Google、FacebookなどのIDプロバイダー
• メールアドレスとパスワード
• 電話

利用可能なリソースの量により、統合プロセスがより簡単になります。Firebaseコミュニティは、使用できる多くのオープンソースリソースを作成します。また、定評のあるプロバイダーでもあります。つまり、ほとんどすべての問題の解決策を見つける可能性があります。

最後に、FirebaseAuthをウェブアプリケーションとモバイルアプリケーションの両方に実装する方法をカバーする詳細なドキュメントがあります。

店員

他のプロバイダーと比較して、店員は最新のものです。Clerkを使用すると、サインアップ、サインイン、およびユーザープロファイルをアプリケーションに実装できます。彼らのウェブサイトによると、彼らは「完全な顧客アイデンティティプラットフォーム」です。

店員さんにはハスラのサポートも付いています。彼らには、ClerkをHasuraと統合する方法を紹介する特別なドキュメントセクションがあります。

比較的新しいため、まだ文書化/解決されていない問題が発生する可能性があります。それ以外に、店員は広範囲にわたる詳細なドキュメントを持っています。

Clerkをアプリケーションと統合するために必要な構成は最小限です。Clerkアカウントが必要です。そうすれば、SDKとそれらが提供するコンポーネントを使用できます。

キークローク

Keycloakは、人気のあるオープンソースの認証サービスプロバイダーです。オープンソースなので、セルフホストできます。つまり、月間アクティブユーザー数に関係なく無料です。

オープンソースであり、誰もが貢献できるようになっていますが、プロジェクトはRedHatによって管理されています。つまり、プロジェクトを信頼できるということです。

Keycloakはほとんどの認証のユースケースをサポートしており、無料でもあるため、優れた選択肢となる可能性があります。

Keycloakには、中程度の実装の難しさがあります。Keycloakをアプリケーションに統合するだけでなく、デプロイメントとメンテナンスにも注意を払う必要があります。

一見複雑に見えるかもしれませんが、Keycloakにすぐに慣れることができます。また、確立された製品であるため、ほとんどの問題の解決策が見つかる可能性があります。最後に、優れたドキュメントがあります。

学んだこと

Cognitoは、認証を処理するためのAmazonの製品です。これにより、Webおよびモバイルアプリケーションに認証を実装できます。

Cognitoは最も寛大な認証プロバイダーの1つであり、月間最大50,000人のアクティブユーザーがいる無料プランを提供します。コストが懸念され、マネージドソリューションが必要な場合は、Cognitoが最適です。

統合の容易さに関して、Amazon Cognitoは、他のプロバイダーと比較して実装が非常に困難になる可能性があります。Cognitoは、基本的なアプリケーションであっても、複雑なセットアップを必要とします。

ただし、Cognitoをアプリケーションに統合するのに役立つ公式およびコミュニティの資料はたくさんあります。いくつかのSDKとサンプルアプリも利用可能で、あなたを助け、刺激を与えます。

CognitoをHasuraと統合する方法を学ぶ

スーパートークン

SuperTokensは比較的新しいサービスです。必要なほとんどすべてのサポートが付属しており、オープンソースでもあります。つまり、セルフホストして追加料金を回避できます。セルフホストを選択した場合、無制限のユーザーは永久に無料です。

SuperTokensにはHasuraのサポートが付属しており、SuperTokensをHasuraと統合する方法に関する特別なセクションがあります。

統合のしやすさに関しては、アプリケーションと統合しようとすると、いくつかの問題が発生する可能性があります。その理由は、これは新しいサービスであり、現在インターネット上で利用できる資料があまりないためです。

構成に関しては、ドキュメントに必要なすべての設定と情報が記載されているため、SuperTokenの使用を開始するのはかなり簡単です。

SuperTokensには、SuperTokensをHasuraと統合するためのガイド、およびサンプルのSuperTokens+Hasuraデモアプリケーションもあります。

Nhost認証

Nhost Authenticationは、Hasuraのオープンソース認証サービスです。Nhost認証を使用すると、次の方法でサインインできます。

• メールアドレスとパスワード
• GitHub、Google、Apple、Facebook、Twitter、LinkedInなどのOAuthプロバイダー
• マジックリンク
• SMS

これはオープンソースプロジェクトであるため、セルフホストして、マネージドサービスを使用するときに支払う追加料金を回避できます。

統合の容易さに関して言えば、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/

#jwt #authentication #hasura 

Los 7 Principales Proveedores De Autenticación Para Crear Aplicaciones

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.

Pros y contras de los proveedores de autenticación

Antes de elegir un proveedor de servicios de autenticación, es fundamental evaluar las ventajas y desventajas de utilizar uno.

Pro: Complejidad de los resúmenes

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.

Pro: Sin almacenamiento de información de usuario

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.

Pro: Aproveche los inicios de sesión sociales

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.

Ventaja: mejor seguridad

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.

Desventajas: Difícil de migrar

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.

Desventajas: Bloqueo de proveedor

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.

Desventajas: Costos

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.

Conclusión

¿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.

Elegir un proveedor de autenticación

El artículo compara los siguientes proveedores de servicios de autenticación:

• Autor0
• Autenticación de base de fuego
• Empleado
• capa clave
• cognito
• supertokens
• anfitrión

Estos proveedores de autenticación se evalúan en función de seis criterios de evaluación.

1. Código abierto

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.

2. Reclamaciones JWT personalizadas

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.

3. Soporte de inicio de sesión único (SSO)

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.

4. Autenticación de máquina a máquina

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_idy client_secret, que se utilizan para autenticar al cliente.

5. Niveles gratuitos

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.

6. Facilidad de integración

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 calidad de la documentacion
• SDK disponibles
• la cantidad de configuración requerida
• el material disponible

Comparación de proveedores

La imagen ilustra una comparación entre los proveedores de autenticación presentados en este artículo.

Autor0

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.

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.

Autenticación de base de fuego

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:

• proveedores de identidad como Google, Facebook y otros
• correo electrónico y contraseña
• teléfono

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.

Empleado

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.

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.

Capa de llaves

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.

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

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.

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

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.

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.

Autenticación Nhost

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:

• Correo electrónico y contraseña
• Proveedores de OAuth como GitHub, Google, Apple, Facebook, Twitter, LinkedIn y otros
• Enlaces mágicos
• SMS

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.

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í .

Una nota sobre la escalabilidad

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.

Conclusión

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/

  #jwt #authentication #hasura 

7 Nhà Cung Cấp Xác Thực Hàng Đầu Để Xây Dựng ứng Dụng Với JWT (2022)

“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.

Ưu và nhược điểm của nhà cung cấp xác thực

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.

Chuyên nghiệp: Độ phức tạp trừu tượng

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.

Chuyên nghiệp: Không có bộ nhớ thông tin người dùng

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.

Pro: Tận dụng Đăng nhập xã hội

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.

Pro: Bảo mật tốt 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.

Nhược điểm: Khó di chuyển

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.

Nhược điểm: Khóa nhà cung cấp

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.

Nhược điểm: Chi phí

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.

Sự kết luậ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ó.

Chọn nhà cung cấp xác thực

Bài viết so sánh các Nhà cung cấp Dịch vụ Xác thực sau:

• auth0
• Xác thực Firebase
• Nhân viên văn phòng
• KeyCloak
• Đã học
• SuperTokens
• Nhost

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á.

1. Nguồn mở

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à.

2. Tuyên bố JWT tùy chỉ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.

3. Hỗ trợ Đăng nhập Một lần (SSO)

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.

4. Xác thực máy với máy

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_idvà client_secret, được sử dụng để xác thực khách hàng.

5. Bậc miễn phí

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.

6. Dễ dàng hội nhập

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ư:

• chất lượng của tài liệu
• SDK có sẵn
• số lượng cấu hình yêu cầu
• vật liệu có sẵn

So sánh nhà cung cấp

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

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.

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

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ư:

• các nhà cung cấp danh tính như Google, Facebook và các nhà cung cấp khác
• email và mật khẩu
• đ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.

Nhân viên văn phò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.

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.

Móc khóa

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.

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.

Đã học

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.

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

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.

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.

Xác thực nhỏ

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:

• Email và mật khẩu
• Các nhà cung cấp OAuth như GitHub, Google, Apple, Facebook, Twitter, LinkedIn và các nhà cung cấp khác
• Liên kết ma thuật
• tin nhắn

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ý.

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 .

Lưu ý về khả năng mở rộng

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ô.

Sự kết luận

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/

  #jwt #authentication #hasura