public void ShouldRequestTokenWithCustomDirectoryResolver(string username)
        {
            var appHost   = TestServer.Current;
            var directory = new ApplicationRegistration
            {
                ClientId      = "custom-clientid",
                ClientSecret  = "custom-clientsecret",
                DirectoryName = "custom-foodomain.com"
            };
            var auth = new Authenticate {
                UserName = username
            };

            var subject = new AzureAuthenticationProvider(new TestAzureGraphService())
            {
                ApplicationDirectoryResolver = (serviceBase, registryService, s) => directory,
            };

            var session = new AuthUserSession
            {
                State    = "D79E5777-702E-4260-9A62-37F75FF22CCE",
                UserName = auth.UserName
            };

            subject.CallbackUrl = "http://localhost/myapp/";
            var request = new MockHttpRequest("myapp", "GET", "text", "/myapp", new NameValueCollection
            {
                {
                    "code",
                    "AwABAAAAvPM1KaPlrEqdFSBzjqfTGBCmLdgfSTLEMPGYuNHSUYBrqqf_ZT_p5uEAEJJ_nZ3UmphWygRNy2C3jJ239gV_DBnZ2syeg95Ki-374WHUP-i3yIhv5i-7KU2CEoPXwURQp6IVYMw-DjAOzn7C3JCu5wpngXmbZKtJdWmiBzHpcO2aICJPu1KvJrDLDP20chJBXzVYJtkfjviLNNW7l7Y3ydcHDsBRKZc3GuMQanmcghXPyoDg41g8XbwPudVh7uCmUponBQpIhbuffFP_tbV8SNzsPoFz9CLpBCZagJVXeqWoYMPe2dSsPiLO9Alf_YIe5zpi-zY4C3aLw5g9at35eZTfNd0gBRpR5ojkMIcZZ6IgAA"
                },
                { "session_state", "7B29111D-C220-4263-99AB-6F6E135D75EF" },
                { "state", "D79E5777-702E-4260-9A62-37F75FF22CCE" }
            }, Stream.Null, new NameValueCollection());

            var mockAuthService = MockAuthService(request, appHost);
            var response        = (IHttpResult)subject.Authenticate(mockAuthService.Object, session, auth);

            Assert.True(session.IsAuthenticated);
            var tokens = session.GetAuthTokens("ms-graph");

            Assert.NotNull(tokens);
            Assert.Equal("ms-graph", tokens.Provider);
            Assert.Equal(tokens.AccessTokenSecret, TokenHelper.AccessToken);
            Assert.NotNull(tokens.RefreshTokenExpiry);
            Assert.Equal(tokens.RefreshToken, TokenHelper.RefreshToken);

            // Regardless of what is entered up front, Azure will determine what the identity values are
            Assert.Equal("d542096aa0b94e2195856b57e43257e4", tokens.UserId); // oid
            Assert.Equal("*****@*****.**", tokens.UserName);
            Assert.Equal("Some User", tokens.DisplayName);
            Assert.Equal(session.UserName, tokens.UserName);
            Assert.Equal(session.LastName, tokens.LastName);
            Assert.Equal(session.FirstName, tokens.FirstName);
            Assert.Equal(session.DisplayName, tokens.DisplayName);

            var result = (IHttpResult)response;

            Assert.StartsWith("http://localhost#s=1", result.Headers["Location"]);
        }
Esempio n. 2
0
        public void Initialize()
        {
            IApplicationRegistration applicationRegistration = new ApplicationRegistration("Security Tester");

            applicationRegistration
            .RegisterComponent(
                (new ComponentRegistration <Authentication>("Authentication Component", applicationRegistration))
                .RegisterObservableEvent("Validation", authentication => new Func <bool>(authentication.Verify))
                .RegisterObservableParameter("Is Administrator", authentication => authentication.AdministratorAccess)
                .RegisterObservableParameter("Access Rights", authentication => authentication.AccessRights)
                )
            .RegisterComponent(
                (new ComponentRegistration <SecurityCredential>("Security Credential Component", applicationRegistration))
                .RegisterObservableEvent("Credential Setup", securityCredential => new Action <string, string>(securityCredential.SetCredentials))
                .RegisterObservableEvent("Credential Input Validation", securityCredential => new Func <bool>(securityCredential.ValidateCredentialInput))

                );

            ISystemRegistration systemRegistration = new SystemRegistration("Security System");

            systemRegistration
            .RegisterApplication(applicationRegistration)
            .RegisterApplication(new ApplicationRegistration("Dummy Application"));


            ActivityManager.GetInstance().RegisterSystem(systemRegistration);
        }
Esempio n. 3
0
        void PerformRegistrations()
        {
            IApplicationRegistration applicationRegistration = new ApplicationRegistration("Security Tester");

            applicationRegistration
            .RegisterComponent(
                (new ComponentRegistration <Authentication>(AUTHENTICATION_COMPONENT_NAME, applicationRegistration))
                .RegisterObservableEvent(AUTHENTICATION_EVENT_NAME, authentication => new Func <bool>(authentication.Verify))
                .RegisterObservableParameter(_isAdminVar.Name, authentication => authentication.AdministratorAccess)
                .RegisterObservableParameter(_accessRightsVar.Name, authentication => authentication.AccessRights)
                )
            .RegisterComponent(
                (new ComponentRegistration <SecurityCredential>("Security Credential Component", applicationRegistration))
                .RegisterObservableEvent("Credential Setup", securityCredential => new Action <string, string>(securityCredential.SetCredentials))
                .RegisterObservableEvent("Credential Input Validation", securityCredential => new Func <bool>(securityCredential.ValidateCredentialInput))

                );

            ISystemRegistration systemRegistration = new SystemRegistration("Security System");

            systemRegistration
            .RegisterApplication(applicationRegistration)
            .RegisterApplication(new ApplicationRegistration("Dummy Application"));


            ActivityManager.GetInstance().RegisterSystem(systemRegistration);
        }
Esempio n. 4
0
        public ApplicationRegistration RegisterUpns(ApplicationRegistration registration, IEnumerable <string> upns)
        {
            if (registration == null)
            {
                throw new ArgumentException($"Cannot update null or empty {nameof(ApplicationRegistration)}.");
            }

            var utcNow   = DateTimeOffset.UtcNow;
            var existing = registration.Upns?.Select(x => x.Suffix.ToLower());
            var unique   = upns.Where(x => !string.IsNullOrWhiteSpace(x) &&
                                      !existing.Contains(x))
                           .Select(x => new DirectoryUpn
            {
                ApplicationRegistrationId = registration.Id,
                DateCreatedUtc            = utcNow,
                Suffix = x.ToLower()
            });

            using (var db = _connectionFactory.OpenDbConnection())
            {
                db.InsertAll(unique);

                _cacheClient.RemoveAll(existing.Select(x => UrnId.Create(typeof(DirectoryRegistrationLookup), x)));
                _cacheClient.Remove(UrnId.Create(typeof(ApplicationRegistration), registration.Id.ToString()));

                // Return uncached version to avoid possible race returning invalid cached data.
                var q = db.From <ApplicationRegistration>()
                        .Where(x => x.Id == registration.Id);
                return(db.LoadSelect(q).FirstOrDefault());
            }
        }
Esempio n. 5
0
 public App()
 {
     try
     {
         var    args            = Environment.GetCommandLineArgs();
         string extension       = "m2d";
         string applicationName = "Map2D";
         string icon            = "icon.ico";
         string description     = "Map2D map file";
         if (args.Any(x => x.Equals("/register", StringComparison.OrdinalIgnoreCase)))
         {
             ApplicationRegistration registration = new ApplicationRegistration();
             registration.RegisterApplication(extension, applicationName,
                                              AppDomain.CurrentDomain.BaseDirectory + applicationName + ".exe",
                                              AppDomain.CurrentDomain.BaseDirectory + icon, description);
             Environment.Exit(0);
         }
         if (args.Any(x => x.Equals("/unregister", StringComparison.OrdinalIgnoreCase)))
         {
             ApplicationRegistration registration = new ApplicationRegistration();
             registration.UnregisterApplication(extension, applicationName);
             Environment.Exit(0);
         }
     }
     catch (Exception e)
     {
         Console.Write(e.Message);
         Console.ReadLine();
     }
 }
 public CodeFirstApplicationRegistryService(string applicationId, string publicKey, string directoryName)
 {
     _registration = new ApplicationRegistration
     {
         ClientId      = applicationId,
         DirectoryName = directoryName,
         ClientSecret  = publicKey
     };
 }
Esempio n. 7
0
        public static void RegisterDevelopment(IServiceCollection services)
        {
            if (services == null)
            {
                throw new ArgumentNullException(nameof(services));
            }

            ApplicationRegistration.RegisterDevelopment(services);
        }
 public SingleTenantApplicationRegistryService(MicrosoftGraphDirectorySettings settings)
 {
     _upns         = new HashSet <string>(new [] { settings.DirectoryName.ToLower() });
     _registration = new ApplicationRegistration
     {
         ClientId     = settings.ClientId,
         ClientSecret = settings.ClientSecret
     };
 }
 public SingleTenantApplicationRegistryService(AzureDirectorySettings settings)
 {
     _registration = new ApplicationRegistration
     {
         ClientId      = settings.ClientId,
         DirectoryName = settings.DirectoryName,
         ClientSecret  = settings.ClientSecret
     };
 }
Esempio n. 10
0
 public AppSettingsApplicationRegistryService(IAppSettings settings)
 {
     _registration = new ApplicationRegistration
     {
         ClientId      = settings.GetString(ConfigSettings.GetClientIdKey()),
         DirectoryName = settings.GetString(ConfigSettings.GetDirectoryNameKey()),
         ClientSecret  = settings.GetString(ConfigSettings.GetClientSecretKey())
     };
 }
        public ApplicationRegistration RegisterApplication(ApplicationRegistration registration)
        {
            if (registration == null)
            {
                throw new ArgumentException($"Cannot register null or empty {nameof(ApplicationRegistration)}.");
            }

            return(RegisterApplication(registration.ClientId, registration.ClientSecret, registration.DirectoryName,
                                       registration.RefId, registration.RefIdStr));
        }
        private object RequestCode(IServiceBase authService, Authenticate request, IAuthSession session,
                                   AuthUserSession userSession, IAuthTokens tokens, ApplicationRegistration registration = null, bool isConsentRequest = false)
        {
            var appDirectory = GetDirectoryNameFromUsername(request.UserName ?? session.UserName);

            if (string.IsNullOrWhiteSpace(session.UserName))
            {
                session.UserName = request.UserName;
            }

            if (registration == null)
            {
                var appRegistry = authService.TryResolve <IApplicationRegistryService>();
                if (appRegistry == null)
                {
                    throw new InvalidOperationException(
                              $"No {nameof(IApplicationRegistryService)} found registered in AppHost.");
                }

                registration = appRegistry.GetApplicationByDirectoryName(appDirectory);
                if (registration == null)
                {
                    throw new UnauthorizedAccessException($"Authorization for directory @{appDirectory} failed.");
                }
            }

            var codeRequest = new AuthCodeRequest
            {
                CallbackUrl  = CallbackUrl,
                Registration = registration,
                Scopes       = Scopes,
                UserName     = request.UserName,
                Upn          = appDirectory
            };
            var codeRequestData = (isConsentRequest)
                ? _graphService.RequestConsentCode(codeRequest)
                : _graphService.RequestAuthCode(codeRequest);

            if (!tokens.Items.ContainsKey("ClientId"))
            {
                tokens.Items.Add("ClientId", registration.ClientId);
            }

            if (string.IsNullOrWhiteSpace(userSession.UserName))
            {
                userSession.UserName = request.UserName;
            }

            userSession.State = codeRequestData.State;
            authService.SaveSession(session, SessionExpiry);
            return(authService.Redirect(PreAuthUrlFilter(this, codeRequestData.AuthCodeRequestUrl)));
        }
        public ApplicationRegistration RegisterUpns(ApplicationRegistration registration, IEnumerable <string> upns)
        {
            var distinct = upns.Where(x => !_registration.Upns?.Select(y => y.Suffix).Contains(x) == true)
                           .Select(x => new DirectoryUpn
            {
                ApplicationRegistrationId = _registration.Id,
                DateCreatedUtc            = DateTimeOffset.UtcNow,
                Suffix = x
            });

            _registration.Upns.AddRange(distinct);
            return(_registration);
        }
        public void ShouldNotRegisterNewApplicationAtRuntime()
        {
            var registration = new ApplicationRegistration
            {
                ClientId      = Guid.NewGuid().ToString(),
                DirectoryName = Guid.NewGuid().ToString("N"),
                ClientSecret  = Guid.NewGuid().ToString("N")
            };

            Action tryRegister = () => Service.RegisterApplication(registration);

            tryRegister.ShouldThrow <NotImplementedException>();
        }
Esempio n. 15
0
        public ApplicationRegistration RegisterApplication(ApplicationRegistration registration)
        {
            if (registration == null)
            {
                throw new ArgumentException($"Cannot register null or empty {nameof(ApplicationRegistration)}.");
            }

            if (string.IsNullOrWhiteSpace(registration.ClientId))
            {
                throw new ArgumentException("Parameter cannot be empty.", nameof(registration.ClientId));
            }

            if (string.IsNullOrWhiteSpace(registration.ClientSecret))
            {
                throw new ArgumentException("Parameter cannot be empty.", nameof(registration.ClientSecret));
            }

            if (registration.Upns?.Any() == false)
            {
                throw new ArgumentException("At least one upn must be specified to register an application.");
            }

            var duplicates = new List <string>();

            registration.Upns.Each(upn =>
            {
                upn.Suffix         = upn.Suffix.ToLower();
                upn.DateCreatedUtc = registration.DateCreatedUtc;
                duplicates.Add(upn.Suffix);
            });

            long id;

            using (var db = _connectionFactory.OpenDbConnection())
            {
                var existing = db.Select <DirectoryUpn>(x => duplicates.Contains(x.Suffix));
                if (existing.Any())
                {
                    throw new InvalidOperationException($"Specified suffix(es) already registered: {string.Join(",", existing)}");
                }

                db.Save(registration, true);
                id = registration.Id;
            }

            _cacheClient.RemoveAll(registration.Upns.Where(x => !string.IsNullOrWhiteSpace(x.Suffix))
                                   .Select(x => x.Suffix.ToLower()));

            return(ApplicationById(id));
        }
Esempio n. 16
0
        public void ShouldNotRegisterNewApplicationAtRuntime()
        {
            var registration = new ApplicationRegistration
            {
                ClientId      = Guid.NewGuid().ToString(),
                DirectoryName = Guid.NewGuid().ToString("N"),
                ClientSecret  = Guid.NewGuid().ToString("N")
            };

            var    service     = new SingleTenantApplicationRegistryService(_directorySettings);
            Action tryRegister = () => service.RegisterApplication(registration);

            Assert.Throws <NotImplementedException>(tryRegister);
        }
        public ClientCredentialsRequest(ApplicationRegistration applicationRegistration, [Optional] HttpClient httpClient)
        {
            if (httpClient == null)
            {
                _httpClient = new HttpClient();
            }
            else
            {
                _httpClient = httpClient;
            }

            this.ClientId     = applicationRegistration.ClientId;
            this.ClientSecret = applicationRegistration.ClientSecret;
            this.Scope        = applicationRegistration.Scopes;
        }
        public void ShouldRequestCodeWithCustomDirectoryResolver(string clientId, string clientSecret
                                                                 , string directoryName, string username)
        {
            var appHost   = TestServer.Current;
            var directory = new ApplicationRegistration
            {
                ClientId      = clientId,
                ClientSecret  = clientSecret,
                DirectoryName = directoryName
            };

            var subject = new AzureAuthenticationProvider(new TestAzureGraphService())
            {
                ApplicationDirectoryResolver = (serviceBase, registryService, session) => directory
            };

            var auth = new Authenticate()
            {
                UserName = username
            };

            var authService = MockAuthService(appHost: appHost);
            var response    = subject.Authenticate(authService.Object, new AuthUserSession(), auth);

            var result = (IHttpResult)response;

            if (string.IsNullOrWhiteSpace(username))
            {
                Assert.StartsWith($"https://login.microsoftonline.com/common/oauth2/v2.0/authorize?client_id={clientId}&response_type=code&redirect_uri=http%3a%2f%2flocalhost%2f&scope=https%3a%2f%2fgraph.microsoft.com%2fUser.Read+offline%5faccess+openid+profile", result.Headers["Location"]);
            }
            else
            {
                Assert.StartsWith($"https://login.microsoftonline.com/common/oauth2/v2.0/authorize?client_id={clientId}&response_type=code&redirect_uri=http%3a%2f%2flocalhost%2f&domain_hint={username}&scope=https%3a%2f%2fgraph.microsoft.com%2fUser.Read+offline%5faccess+openid+profile", result.Headers["Location"]);
            }

            var codeRequest = new Uri(result.Headers["Location"]);
            var query       = new NameValueCollection();

            Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(codeRequest.Query)
            .ForEach((key, values) => query.Add(key, values.ToString()));
            if (!string.IsNullOrWhiteSpace(username))
            {
                Assert.Equal(username, query["domain_hint"]);
            }
            Assert.Equal("code", query["response_type"]);
            Assert.Equal(query["client_id"], clientId);
            Assert.Equal(query["redirect_uri"].UrlDecode(), subject.CallbackUrl);
        }
Esempio n. 19
0
        public RefreshTokenRequest(ApplicationRegistration applicationRegistration, string refreshToken, [Optional] HttpClient httpClient)
        {
            if (httpClient == null)
            {
                _httpClient = new HttpClient();
            }
            else
            {
                _httpClient = httpClient;
            }

            this.ClientId     = applicationRegistration.ClientId;
            this.ClientSecret = applicationRegistration.ClientSecret;
            this.RefreshToken = refreshToken;
            this.RedirectUri  = applicationRegistration.RedirectUri;
        }
Esempio n. 20
0
        public async Task OnGetAsync()
        {
            var queryString = this.Request.QueryString.ToString();
            AuthorizationResponse authorizationResponse = AuthorizationResponse.Parse(queryString);

            ApplicationRegistration applicationRegistration = new ApplicationRegistration()
            {
                ClientId     = config["v2Endpoint:clientId"],
                ClientSecret = config["v2Endpoint:clientSecret"],
                RedirectUri  = config["v2Endpoint:redirectUri"],
                Scopes       = config["v2Endpoint:scopes"]
            };

            TokenRequest tokenRequest = new TokenRequest(applicationRegistration, authorizationResponse);

            this.TokenResponse = await tokenRequest.RequestToken();
        }
Esempio n. 21
0
        public Guid RegisterApplication(ApplicationRegistration applicationRegistration)
        {
            var client = dbContext.Clients.FirstOrDefault(c => c.ClientGuid == applicationRegistration.ClientId);

            if (client == null)
            {
                throw new Exception("Unable to find clientId " + applicationRegistration.ClientId);
            }

            var application = new Application()
            {
                ClientId        = client.ClientId,
                ApplicationName = applicationRegistration.ApplicationName
            };

            dbContext.Applications.Add(application);
            dbContext.SaveChanges();

            return(application.ApplicationGuid);
        }
Esempio n. 22
0
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            ApplicationRegistration.AddRegistration(app);

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseHttpsRedirection();

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }
Esempio n. 23
0
        private bool SetAppRegistration(ApplicationRegistration req, bool registration)
        {
            byte[] array = new byte[128];
            array[0] = 1;
            array[1] = 16;
            switch (req)
            {
            case ApplicationRegistration.AP01_QuickButton0:
            {
                array[8] = 9;
                break;
            }

            case ApplicationRegistration.AP02_Reserved:
            {
                array[8] = 10;
                break;
            }

            default:
            {
                if (req != ApplicationRegistration.AP07_DebugConsole)
                {
                    return(false);
                }
                array[8] = 15;
                break;
            }
            }
            array[9]  = 3;
            array[10] = 0;
            if (registration)
            {
                array[16] = 1;
            }
            else
            {
                array[16] = 0;
            }
            return(WriteWMIACPI_IO(array));
        }
Esempio n. 24
0
        public void OnGet()
        {
            ApplicationRegistration applicationRegistration = new ApplicationRegistration()
            {
                ClientId     = config["v2Endpoint:clientId"],
                ClientSecret = config["v2Endpoint:clientSecret"],
                RedirectUri  = config["v2Endpoint:redirectUri"],
                Scopes       = config["v2Endpoint:scopes"]
            };

            AuthorizationRequest authorizationRequest = new AuthorizationRequest(applicationRegistration)
            {
                Prompt = "consent"
            };

            AuthorizationUri = authorizationRequest.GenerateAuthorizationUri();

            TokenTools.Microsoft.AdminConsent.AdminConsentRequest adminConsentRequest =
                new TokenTools.Microsoft.AdminConsent.AdminConsentRequest(applicationRegistration.ClientId, "http://localhost:64191/AdminConsent");
            AdminConsentUri = adminConsentRequest.GenerateAuthorizationUri();
        }
Esempio n. 25
0
        public static void Register(
            [NotNull] IServiceCollection services,
            [NotNull] IConfiguration configuration,
            [NotNull] IHostingEnvironment hostingEnvironment)
        {
            if (services == null)
            {
                throw new ArgumentNullException(nameof(services));
            }
            if (configuration == null)
            {
                throw new ArgumentNullException(nameof(configuration));
            }
            if (hostingEnvironment == null)
            {
                throw new ArgumentNullException(nameof(hostingEnvironment));
            }

            var photoStoreRoot = GetPhotoStoreRoot(configuration, hostingEnvironment);
            var photoStoreType = GetPhotoStoreType(configuration);

            SharedKernelRegistrations.RegisterServices(services);
            ApplicationRegistration.RegisterServices(services);
            InterfaceAdaptersRegistration.RegisterServices(services);

            PhotoStorageRegistration.RegisterServices(services, photoStoreRoot, photoStoreType);
            ApplicationInsightsRegistration.RegisterServices(services);
            ImageSharpRegistrations.RegisterServices(services);
            SmtpEmailRegistrations.RegisterServices(services);
            DataAccessServices.RegisterServices(services);

            services.AddSingleton <IActionContextAccessor, ActionContextAccessor>();
            services.AddSingleton <IAbsoluteUrlGenerator, MvcAbsoluteUrlGenerator>();
            services.AddSingleton <IRelativeUrlGenerator, MvcRelativeUrlGenerator>();
            services.AddSingleton <ILogbookDetailsUrlGenerator, MvcLogbookDetailsUrlGenerator>();
            services.AddSingleton <IAvatarPathProvider, AvatarPathProvider>();
            services.AddTransient <ITextFormattingHelper, TextFormattingHelper>();
            services.AddSingleton(new TokenConfiguration(GetTokenSecurityKey(configuration)));
            services.AddTransient <ITokenGenerator, TokenGenerator>();
        }
Esempio n. 26
0
        public async Task <IActionResult> OnGetRefreshAsync(string id)
        {
            if (!ModelState.IsValid)
            {
                return(Page());
            }


            ApplicationRegistration applicationRegistration = new ApplicationRegistration()
            {
                ClientId     = config["v2Endpoint:clientId"],
                ClientSecret = config["v2Endpoint:clientSecret"],
                RedirectUri  = config["v2Endpoint:redirectUri"],
                Scopes       = config["v2Endpoint:scopes"]
            };

            RefreshTokenRequest refreshTokenRequest = new RefreshTokenRequest(applicationRegistration, id);

            this.TokenResponse = await refreshTokenRequest.Refresh();

            return(Page());
        }
        public MainPage()
        {
            InitializeComponent();
            _viewModel = App.MainViewModel;

            try
            {
                _translationService = new TranslationService();
                _conversationService = new ConversationService();

                // Get the instance of LyncClient and subscribe to outgoing/incoming conversation events
                _lyncClient = LyncClient.GetClient();
                _lyncClient.StateChanged += new EventHandler<ClientStateChangedEventArgs>(LyncClient_StateChanged);

                _conversation = (Conversation)Microsoft.Lync.Model.LyncClient.GetHostingConversation();

                // Perform run-time registration using the ApplicationRegistration class.
                _myApplicationRegistration = _lyncClient.CreateApplicationRegistration(App.AppId, App.AppName);
                this._myApplicationRegistration.AddRegistration();
            }
            catch (ClientNotFoundException) { Console.WriteLine("Lync client was not found on startup"); }
            catch (LyncClientException lce) { MessageBox.Show("Lyncclientexception: " + lce.Message); }
        }
        public MainPage()
        {
            InitializeComponent();
            _viewModel = App.MainViewModel;

            try
            {
                _translationService  = new TranslationService();
                _conversationService = new ConversationService();

                // Get the instance of LyncClient and subscribe to outgoing/incoming conversation events
                _lyncClient = LyncClient.GetClient();
                _lyncClient.StateChanged += new EventHandler <ClientStateChangedEventArgs>(LyncClient_StateChanged);

                _conversation = (Conversation)Microsoft.Lync.Model.LyncClient.GetHostingConversation();

                // Perform run-time registration using the ApplicationRegistration class.
                _myApplicationRegistration = _lyncClient.CreateApplicationRegistration(App.AppId, App.AppName);
                this._myApplicationRegistration.AddRegistration();
            }
            catch (ClientNotFoundException) { Console.WriteLine("Lync client was not found on startup"); }
            catch (LyncClientException lce) { MessageBox.Show("Lyncclientexception: " + lce.Message); }
        }
Esempio n. 29
0
        public TokenRequest(ApplicationRegistration applicationRegistration, AuthorizationResponse authorizationResponse, [Optional] HttpClient httpClient)
        {
            if (authorizationResponse.HasErrors)
            {
                throw new HttpRequestException($"{authorizationResponse.Error} : {authorizationResponse.ErrorDescription}");
            }

            if (httpClient == null)
            {
                _httpClient = new HttpClient();
            }
            else
            {
                _httpClient = httpClient;
            }

            _authorizationResponse = authorizationResponse;

            this.ClientId          = applicationRegistration.ClientId;
            this.ClientSecret      = applicationRegistration.ClientSecret;
            this.RedirectUri       = applicationRegistration.RedirectUri;
            this.AuthorizationCode = authorizationResponse.Code;
        }
Esempio n. 30
0
 public AuthorizationRequest(ApplicationRegistration applicationRegistration)
 {
     this.ClientId    = applicationRegistration.ClientId;
     this.RedirectUri = applicationRegistration.RedirectUri;
 }
        public async Task <List <ApplicationRegistration> > GetApplications()
        {
            // Get Applications For Current Tenant
            var applicationsJson = await GetFromGraph("/applications");

            var graphObject  = JsonConvert.DeserializeObject <GraphApplicationsResult>(applicationsJson);
            var applications = graphObject.Applications.ToList();

            while (!string.IsNullOrEmpty(graphObject.OdataNextLink))
            {
                var nextResult = await GetFromGraph(graphObject.OdataNextLink.Replace("https://graph.microsoft.com/beta", ""));

                graphObject = JsonConvert.DeserializeObject <GraphApplicationsResult>(nextResult);
                applications.AddRange(graphObject.Applications);
            }

            if (applications == null)
            {
                throw new InvalidOperationException("No Applications Found in your tenant");
            }

            var principleCache           = new List <ServicePrinciple>();
            var applicationRegistrations = new List <ApplicationRegistration>();

            foreach (var app in applications)
            {
                var application = new ApplicationRegistration
                {
                    Id          = app.AppId,
                    DisplayName = app.DisplayName
                };

                if (app.PasswordCredentials.Any())
                {
                    application.Secrets = app.PasswordCredentials.Select(s => $"{s.DisplayName} - Expires on: {s.EndDateTime.ToString("MM-dd-yyyy")}").ToList();
                }

                if (app.KeyCredentials.Any())
                {
                    application.Certificates = app.KeyCredentials.Select(x => $"{x.CustomKeyIdentifier} - Expires on: {x.EndDateTime.ToString("MM-dd-yyyy")}").ToList();
                }

                var ownersJson = await GetFromGraph($"/applications/{app.Id}/owners");

                var owners = JsonConvert.DeserializeObject <GraphOwnerResult>(ownersJson).Value;
                application.Owners = owners.Select(x => x.UserPrincipalName).ToList();

                foreach (var requiredAccess in app.RequiredResourceAccess)
                {
                    // Retrieve the service principle form cache or when not found from the graph api
                    ServicePrinciple currentPrinciple = null;
                    if (principleCache.Any(x => x.AppId == requiredAccess.ResourceAppId))
                    {
                        currentPrinciple = principleCache.First(x => x.AppId == requiredAccess.ResourceAppId);
                    }
                    else
                    {
                        var getServicePrinciple = $"/servicePrincipals?filter=appId eq '{requiredAccess.ResourceAppId}'";
                        var principleFromGraph  = await GetFromGraph(getServicePrinciple);

                        currentPrinciple = JsonConvert.DeserializeObject <ServicePrinciplesGraphResult>(principleFromGraph).ServicePrinciples?.FirstOrDefault();

                        if (currentPrinciple == null)
                        {
                            continue;
                        }

                        principleCache.Add(currentPrinciple);
                    }

                    // Approles -> Application Permissions
                    // PermissionScopes -> Delegated Permissions

                    var applicationRegistrationServices = new ApplicationRegistrationServices
                    {
                        DisplayName          = currentPrinciple.AppDisplayName,
                        DelegatedPermissions = currentPrinciple.PublishedPermissionScopes
                                               .Where(x => requiredAccess.ResourceAccess.Any(r => r.Id == x.Id))
                                               .Select(s => new DelegatedPermission
                        {
                            DisplayName = s.UserConsentDisplayName,
                            Id          = s.Id,
                            Permission  = s.Value
                        }),
                        ApplicationPermissions = currentPrinciple.AppRoles
                                                 .Where(x => requiredAccess.ResourceAccess.Any(r => r.Id == x.Id))
                                                 .Select(s => new ApplicationPermission
                        {
                            DisplayName = s.DisplayName,
                            Id          = s.Id,
                            Permission  = s.Value
                        })
                    };
                    application.Services.Add(applicationRegistrationServices);
                }
                applicationRegistrations.Add(application);
            }

            return(applicationRegistrations);
        }
Esempio n. 32
0
        void InitializeClient()
        {
            _conversationManager = _lyncClient.ConversationManager;

            _applicationRegistration =
                _lyncClient.CreateApplicationRegistration(
                    _applicationGuid,
                    _applicationName);

            _applicationRegistration.AddRegistration();

            this._conversationManager.ConversationAdded +=
                new EventHandler<Microsoft.Lync.Model.Conversation.ConversationManagerEventArgs>(ConversationManager_ConversationAdded);
        }