Ejemplo n.º 1
0
        public static IServiceCollection ConfigureAuth0(this IServiceCollection services, IConfiguration configuration)
        {
            services
            .AddAuthentication(options =>
            {
                options.DefaultAuthenticateScheme = CookieAuthenticationDefaults.AuthenticationScheme;
                options.DefaultSignInScheme       = CookieAuthenticationDefaults.AuthenticationScheme;
                options.DefaultChallengeScheme    = CookieAuthenticationDefaults.AuthenticationScheme;
            })
            .AddCookie()
            .AddOpenIdConnect("Auth0", options =>
            {
                var auth0 = new Auth0();

                configuration.Bind("Auth0", auth0);

                options.Authority    = $"https://{auth0.Domain}";
                options.CallbackPath = new PathString("/callback");
                options.ClaimsIssuer = "Auth0";
                options.ClientId     = auth0.ClientId;
                options.ClientSecret = auth0.ClientSecret;
                options.Events       = new OpenIdConnectEvents
                {
                    OnRedirectToIdentityProviderForSignOut = context =>
                    {
                        var logoutUri = $"https://{auth0.Domain}/v2/logout?client_id={auth0.ClientId}";

                        var postLogoutUri = context.Properties.RedirectUri;

                        if (!string.IsNullOrWhiteSpace(postLogoutUri))
                        {
                            if (postLogoutUri.StartsWith("/"))
                            {
                                HttpRequest request = context.Request;

                                postLogoutUri = $"{request.Scheme}://{request.Host}{request.PathBase}{postLogoutUri}";
                            }

                            logoutUri += $"&returnTo={Uri.EscapeDataString(postLogoutUri)}";
                        }

                        context.Response.Redirect(logoutUri);
                        context.HandleResponse();

                        return(Task.CompletedTask);
                    }
                };
                options.ResponseType = "code";
                options.Scope.Clear();
                options.Scope.Add("openid");
            });

            return(services);
        }
Ejemplo n.º 2
0
        private void Authenticate()
        {
            Auth0
            .LoginAsync(this)
            .ContinueWith(t =>
            {
                if (this.ProgressDialog.IsShowing)
                {
                    this.ProgressDialog.Hide();
                }

                User = t.Result;
                if (User != null)
                {
                    JObject p = User.Profile;
                    Profile   = (p == null) ? null : p.ToObject <Auth0Profile>();
                    RunOnUiThread(() =>
                    {
                        TextUsername.Text = Profile.Email;
                        TextNickname.Text = Profile.Given_name;
                    });
                }
            });
        }
Ejemplo n.º 3
0
 public TokenController(IOptions <ExeroSettings> settings, IUserRepository userRepository, ILogger <TokenController> logger)
 {
     _auth0          = settings.Value.Auth0;
     _userRepository = userRepository;
     _logger         = logger;
 }
        protected virtual PickerEntity GetPickerEntity(Auth0.User auth0User, string claimEntityType)
        {
            PickerEntity pe = CreatePickerEntity();
            SPClaim claim = null;

            if (claimEntityType == SPClaimEntityTypes.User)
            {
                claim = new SPClaim(
                    this.identifierClaimType,
                    string.IsNullOrEmpty(this.auth0Config.IdentifierUserField) || this.auth0Config.IdentifierUserField == "Email" ?
                        auth0User.UniqueEmail() :
                        Utils.GetPropValue(auth0User, this.auth0Config.IdentifierUserField).ToString(),
                    Microsoft.IdentityModel.Claims.ClaimValueTypes.String,
                    SPOriginalIssuers.Format(SPOriginalIssuerType.TrustedProvider, this.associatedSPTrustedLoginProvider.Name));

                var displayText = !string.IsNullOrEmpty(auth0User.FamilyName) && !string.IsNullOrEmpty(auth0User.GivenName) ?
                    string.Format("{0} {1}", auth0User.GivenName, auth0User.FamilyName) : auth0User.Name;

                pe.DisplayText =
                    !string.IsNullOrEmpty(displayText) ?
                        string.Format("{0} ({1})", displayText, auth0User.Email) :
                        auth0User.Email;

                pe.Description = string.Format(
                    "Email: {0}; Name: {1}",
                    auth0User.Email,
                    auth0User.Name);

                pe.EntityType = SPClaimEntityTypes.User;
                pe.EntityData[PeopleEditorEntityDataKeys.DisplayName] = displayText;
                pe.EntityData[PeopleEditorEntityDataKeys.Email] = auth0User.Email;
                pe.EntityData["Picture"] = auth0User.Picture;
            }
            else if (claimEntityType == SPClaimEntityTypes.FormsRole)
            {
                claim = new SPClaim(
                    ConnectionClaimType,
                    auth0User.Identities.First().Connection,
                    Microsoft.IdentityModel.Claims.ClaimValueTypes.String,
                    SPOriginalIssuers.Format(SPOriginalIssuerType.TrustedProvider, this.associatedSPTrustedLoginProvider.Name));

                pe.DisplayText = string.Format(
                    "All Users ({0})",
                    auth0User.Identities.First().Connection);

                pe.Description = string.Format(
                    "[{0}] All Users from '{1}'",
                    ProviderInternalName,
                    auth0User.Identities.First().Connection);

                pe.EntityType = SPClaimEntityTypes.FormsRole;
            }

            pe.Claim = claim;
            pe.IsResolved = true;
            pe.EntityGroupName = this.pickerEntityGroupName;

            return pe;
        }
 public ActionResult Index(Auth0.ProvisioningTicket ticket)
 {
     return Json(auth0Client.CreateConnection(ticket));
 }