Вход в личный кабинет Add login using the implicit flow with form post
You can add login to your single-page application (SPA) using the Implicit Flow with Form Post. To learn how the flow works and why you should use it, read Implicit Flow with Form Post.
Use the Implicit Flow with Form Post for login-only use cases; if you need to request access tokens while logging the user in so you can call your API, use the Authorization Code Flow with PKCE. To learn more, read Authorization Code Flow with Proof Key for Code Exchange (PKCE).
To implement the Implicit Flow with Form Post, you can use the following resources:
Following a successful login, your application will have access to the user’s ID token. The ID token will contain basic user profile information.
Register your app with Auth0. To learn more, read Register Single Page Applications.
Request the user’s authorization and redirect back to your app. To begin the flow, you’ll need to get the user’s authorization. This step may include one or more of the following processes:
To authorize the user, your app must send the user to the authorization URL.
| Parameter Name | Description |
|---|---|
response_type | Denotes the kind of credential that Auth0 will return (code or token). For the Implicit Flow, the value can be id_token, token, or id_token token. Specifically, id_token returns an ID Token, and token returns an Access Token. |
response_mode | Specifies the method with which response parameters should be returned. For security purposes, the value should be form_post. In this mode, response parameters will be encoded as HTML form values that are transmitted via the HTTP POST method and encoded in the body using the application/x-www-form-urlencoded format. |
client_id | Your application’s Client ID. You can find this value at your Application’s Settings. |
redirect_uri | The URL to which Auth0 will redirect the browser after authorization has been granted by the user. You must specify this URL as a valid callback URL in your Application Settings. Warning: Per the OAuth 2.0 Specification, Auth0 removes everything after the hash and does not honor any fragments. |
scope | Specifies the scopes for which you want to request authorization, which dictate which claims (or user attributes) you want returned. These must be separated by a space. You can request any of the standard OpenID Connect (OIDC) scopes about users, such as profile and email, custom claims conforming to a namespaced format, or any scopes supported by the target API (for example, read:contacts). |
state | (recommended) An opaque arbitrary alphanumeric string that your app adds to the initial request and Auth0 includes when redirecting back to your application. To see how to use this value to prevent cross-site request forgery (CSRF) attacks, see Mitigate CSRF Attacks With State Parameters. |
nonce | (required for response_type containing id_token token, otherwise recommended) A cryptographically random string that your app adds to the initial request and Auth0 includes inside the ID Token, used to prevent token replay attacks. |
connection | (optional) Forces the user to sign in with a specific connection. For example, you can pass a value of github to send the user directly to GitHub to log in with their GitHub account. When not specified, the user sees the Auth0 Lock screen with all configured connections. You can see a list of your configured connections on the Connections tab of your application. |
organization | (optional) ID of the organization to use when authenticating a user. When not provided, if your application is configured to Display Organization Prompt, the user will be able to enter the organization name when authenticating. |
invitation | (optional) Ticket ID of the organization invitation. When inviting a member to an Organization, your application should handle invitation acceptance by forwarding the invitation and organization key-value pairs when the user accepts the invitation. |
As an example, your HTML snippet for your authorization URL when adding login to your app might look like:
If all goes well, you’ll receive an HTTP 302 response. The requested credentials are encoded in the body:
Note that the returned values depend on what you requested as a response_type.
Auth0 will also return any state value you included in your call to the authorization URL.
ID tokens contain user information that must be decoded and extracted.
This example shows the most basic request you can make when authorizing the user in step 1. It displays the Auth0 login screen and allows the user to sign in with any of your configured connections:
This will return an ID token, which you can parse from your redirect URL.
In addition to the usual user authentication, this example shows how to request additional user details, such as name and picture.
To request the user’s name and picture, you need to add the appropriate scopes when authorizing the user:
Now, your ID token will contain the requested name and picture claims. When you decode the ID token, it will look similar to:
In addition to the usual user authentication, this example shows how to send users directly to a social identity provider, such as GitHub. For this example to work, you need to go to Auth0 Dashboard > Authentication > Social and configure the appropriate connection. Get the connection name from the Settings tab.
To send users directly to the GitHub login screen, you need to pass the connection parameter and set its value to the connection name (in this case, github) when authorizing the user:
Now, your ID Token will contain a sub claim with the user’s unique ID returned from GitHub. When you decode the ID Token, it will look similar to:
Claims upgrade custom flow steps
Step 1-3: Client application authentication
Hybrid flow
The Hybrid flow is covered in Section 3.3 of the OIDC spec. In this flow, some tokens are returned from the authorization endpoint (/authorize) and others are returned from the token endpoint (/token).
Hybrid flow steps
Step 1. – Authorize request
Implicit flow
The Implicit flow is covered in Section 3.2 of the OIDC spec. Essentially, access and ID tokens are returned directly from the /authorization endpoint. The /token endpoint is not used.
This is a suitable approach when working with a client (such as a Single Page Application or mobile application) that you want to interact with the OIDC OP directly.
Here’s an example of how this flow gets started using Okta:
It’s almost identical to the authorization code flow, except that the response_type is either id_token, token or id_token token.
Below, we cover exactly what’s in these tokens and how it’s driven, but remember: an id_token encodes identity information and an access_token (returned if token is specified) is a bearer token used to access resources.
Here’s this flow in the browser:
You are redirected back to the redirect_uri originally specified (with the returned tokens and original state):
Implicit flow | jetbrains space
A space separated list of rights required to access specific resources in Space.
The rights are grouped in four categories: Global, Profile, Team, Project. Use the following syntax to specify the rights (shown here in BNF notation):
<SCOPE> ::= <ALL> | <TOKEN_LIST>
<ALL> ::= ‘**’
<TOKEN_LIST> ::= <TOKEN> (‘ ‘ <TOKEN&>)*
<TOKEN> ::= <GLOBAL_PERMISSIONS_TOKEN> | <ENTITY_PERMISSIONS_TOKEN>
<GLOBAL_PERMISSIONS_TOKEN> ::= <PERMISSIONS>
<ENTITY_PERMISSIONS_TOKEN> ::= <ENTITY> ‘:’ <PERMISSIONS>
<ENTITY> ::= ‘Team’ | ‘Project’ | ‘Profile’ | ‘etc.’
<PERMISSIONS> ::= <ALL_PERMISSIONS> | <PERMISSION_LIST>
<ALL_PERMISSIONS> ::= ‘*’
<PERMISSION_LIST> ::= <PERMISSION> (‘,’ <PERMISSION>)*
Wildcards are accepted. For global rights, category is omitted.
Example:
AddNewProfile,AddNewTeam Team:EditTeam Profile:EditAbsences,EditLanguages Project:*
The rights you specify in scope should be first added to the list of requested rights and authorized for your application in Space.
Oauth 2.0
OAuth 2.0 is a standard that apps use to provide client applications with access. If you would like to grant access to your application data in a secure way, then you want to use the OAuth 2.0 protocol.
The OAuth 2.0 spec has four important roles:
Other important terms:
Note: See Token lifetime for more information on hard-coded and configurable token lifetimes.
The usual OAuth 2.0 grant flow looks like this:
Oauth 2.0 vs openid connect
There are two main types of authentication that you can perform with Okta:
Openid connect
OpenID Connect is an authentication standard built on top of OAuth 2.0. It adds an additional token called an ID token. OpenID Connect also standardizes areas that OAuth 2.0 leaves up to choice, such as scopes, endpoint discovery, and dynamic registration of clients.
Okta is OpenID Certified(opens new window).
Although OpenID Connect is built on top of OAuth 2.0, the OpenID Connect specification(opens new window) uses slightly different terms for the roles in the flows:
Request access token
Example token request using credentials (client_id and client secret) in body
POST /token
code=<code>&grant_type=authorization_code&client_id=<client_id>&client_secret=<secret>
An alternative authentication method is sending a JWT token with X509 certifcate in client_assertion parameter accompanied by
client_assertion_type, see private_key_jwt in OpenID Connect specs.
In this method the thumbprint of a certificate added to the header of JWT token has to be stored as client secret in IDS and
be of Type X509Thumbprint. client_id & client_secret should not be passed in this case.
What kind of client are you building?
The type of OAuth 2.0 flow depends on what kind of client that you are building. This flowchart can quickly help you decide which flow to use.
Which flow to use?
When choosing the authentication flow to use, it is important to understand:
Recommended flow by application type
The table shows you which OAuth 2.0 flow to use for the type of application that you are building.
Загрузка...