/// <summary> /// Constructs a JwtAssertionTokenClient with specified options /// </summary> /// <param name="options">Token client options</param> public JwtAssertionTokenClient(TokenClientOptions options) { ValidateOptions(options); _cache = options.Cache ?? DefaultTokenCache.Value; _internalClient = new PrivateKeyJwtClientCredentialsTokenClient(options); _partialCacheKey = string.Join("|", options.TokenEndpointUrl, options.ClientId, options.Certificate.Thumbprint); }
/// <summary> /// Constructs a JwtAssertionTokenClient with default (in-memory) cache /// </summary> /// <param name="tokenEndpointUrl">Authorization Server token endpoint</param> /// <param name="clientId">OAuth2 client_id</param> /// <param name="certificate">Certificate used for signing JWT client assertion (must have private key)</param> /// <param name="cache">Token cache</param> public JwtAssertionTokenClient(string tokenEndpointUrl, string clientId, X509Certificate2 certificate, ITokenCache cache) : this(new TokenClientOptions() { TokenEndpointUrl = tokenEndpointUrl, ClientId = clientId, Certificate = certificate, Cache = cache }) { }
/// <summary> /// Initializes a new instance of the <see cref="MSALPerUserMemoryTokenCache"/> class. /// </summary> /// <param name="tokenCache">The client's instance of the token cache.</param> /// <param name="user">The signed-in user for whom the cache needs to be established.</param> public MSALPerUserMemoryTokenCache(ITokenCache tokenCache, ClaimsPrincipal user) { this.Initialize(tokenCache, user); }
public void Bind(ITokenCache tokenCache) { tokenCache.SetBeforeAccess(BeforeAccessNotification); tokenCache.SetAfterAccess(AfterAccessNotification); }
public RefreshTokenRetriever(ITokenCache tokenCache) { tokenCache.SetAfterAccess(AfterAccessHandler); }
public MSALPerUserSessionTokenCache(ITokenCache tokenCache, HttpContextBase httpcontext, ClaimsPrincipal user) { this.Initialize(tokenCache, httpcontext, user); }
public void RegisterCallbacks(ITokenCache cache) { _ = cache ?? throw new ArgumentNullException(nameof(cache)); cache.SetBeforeAccess(OnSetBeforeAccess); cache.SetAfterAccess(OnSetAfterAccess); }
private void Persist(string key, ITokenCache tokenCache) { _cache.Set(key, tokenCache.SerializeMsalV3(), DateTimeOffset.Now.AddHours(12)); }
/// <summary> /// Initializes a new instance of the <see cref="MSALMemoryTokenCache"/> class. /// </summary> /// <param name="tokenCache">The client's instance of the token cache.</param> public MSALMemoryTokenCache(ITokenCache tokenCache) { Initialize(tokenCache); }
public static void Initialize(ITokenCache tokenCache) { tokenCache.SetBeforeAccessAsync(BeforeAccessAsync); tokenCache.SetAfterAccessAsync(AfterAccessAsync); }
/// <summary>Initializes a new instance of the <see cref="OAuthTokenService" /> class.</summary> /// <param name="client">The client.</param> /// <param name="tokenCache">The token cache.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="client"/> or <paramref name="tokenCache"/> is null. /// </exception> public OAuthTokenService(IOAuthClient client, ITokenCache <OAuthOptions, Token> tokenCache) { _client = client ?? throw new ArgumentNullException(nameof(client)); _tokenCache = tokenCache ?? throw new ArgumentNullException(nameof(tokenCache)); }
protected override void Given() { _tokenCache = ApplicationContext.Container.Resolve <ITokenCache>(); }
internal TokenCacheHelper(ITokenCache tokenCache, string fileName) { CacheFilePath = fileName; tokenCache.SetBeforeAccess(BeforeAccessNotification); tokenCache.SetAfterAccess(AfterAccessNotification); }
private static IObservable <TokenCacheNotificationArgs> WriteStorage(this ITokenCache tokenCache, Func <IObjectSpace> objectSpaceFactory, Guid userId) => tokenCache.AfterAccess().Select(args => {
private static IObservable <TokenCacheNotificationArgs> WriteStorage(this ITokenCache tokenCache, string cacheFilePath) => tokenCache.AfterAccess() .Select(args => { var bytes = ProtectedData.Protect(args.TokenCache.SerializeMsalV3(), null, DataProtectionScope.CurrentUser); File.WriteAllBytes(cacheFilePath, bytes); return(args); });
public void EnableSerialization(ITokenCache tokenCache) { Ensure.ParamNotNull(tokenCache, nameof(tokenCache)); tokenCache.SetBeforeAccess(BeforeAccessNotification); tokenCache.SetAfterAccess(AfterAccessNotification); }
public void Initialize(ITokenCache tokenCache) { tokenCache.SetBeforeAccess(BeforeAccessNotification); tokenCache.SetAfterAccess(AfterAccessNotification); tokenCache.SetBeforeWrite(BeforeWriteNotification); }
/// <summary>Initializes the cache instance</summary> /// <param name="tokenCache">The ITokenCache passed through the constructor</param> private void Initialize(ITokenCache tokenCache) { tokenCache.SetBeforeAccess(TokenCacheBeforeAccessNotification); tokenCache.SetAfterAccess(TokenCacheAfterAccessNotification); }
private void Load(string key, ITokenCache tokenCache) { var data = (byte[])_cache.Get(key); tokenCache.DeserializeMsalV3(data); }
/// <summary> /// Unregisters a token cache so it no longer synchronizes with on disk storage. /// </summary> /// <param name="tokenCache"></param> public virtual void UnregisterCache(ITokenCache tokenCache) { _helper.UnregisterCache(tokenCache); }
public static void Initialize(string key, IDistributedCache distributedCache, ITokenCache tokenCache) { _key = key; _cache = distributedCache; _tokenCache = tokenCache; _tokenCache.SetBeforeAccessAsync(OnBeforeAccessHandler); _tokenCache.SetAfterAccessAsync(OnAfterAccessHandler); }
/// <summary>Initializes this instance of TokenCacheProvider with essentials to initialize themselves.</summary> /// <param name="tokenCache">The token cache instance of MSAL application.</param> /// <param name="httpcontext">The Httpcontext whose Session will be used for caching.This is required by some providers.</param> public void Initialize(ITokenCache tokenCache, HttpContext httpcontext) { tokenCache.SetBeforeAccess(this.AppTokenCacheBeforeAccessNotification); tokenCache.SetAfterAccess(this.AppTokenCacheAfterAccessNotification); tokenCache.SetBeforeWrite(this.AppTokenCacheBeforeWriteNotification); }
//public static implicit operator ITokenCache(TokenCacheBase b) //{ // return b.GetCacheInstance(); //} public void SetCacheInstance(ITokenCache cache) { this.cache = cache; GetCacheInstance(); }
/// <summary> /// Initializes the token cache serialization. /// </summary> /// <param name="tokenCache">Token cache to serialize/deserialize.</param> /// <returns>A <see cref="Task"/> that represents a completed initialization operation.</returns> public Task InitializeAsync(ITokenCache tokenCache) { Initialize(tokenCache); return(Task.CompletedTask); }
/// <summary>Initializes this instance of TokenCacheProvider with essentials to initialize themselves.</summary> /// <param name="tokenCache">The token cache instance of MSAL application</param> /// <param name="httpcontext">The Httpcontext whose Session will be used for caching.This is required by some providers.</param> /// <param name="user">The signed-in user for whom the cache needs to be established. Not needed by all providers.</param> public void Initialize(ITokenCache tokenCache, HttpContext httpcontext, ClaimsPrincipal user) { tokenCache.SetBeforeAccess(this.UserTokenCacheBeforeAccessNotification); tokenCache.SetAfterAccess(this.UserTokenCacheAfterAccessNotification); tokenCache.SetBeforeWrite(this.UserTokenCacheBeforeWriteNotification); }
public ForgeHandler(IOptions <ForgeConfiguration> configuration) { this.configuration = configuration ?? throw new ArgumentNullException(nameof(configuration)); this.TokenCache = new TokenCache(); this.resiliencyPolicies = GetResiliencyPolicies(GetDefaultTimeout()); }
/// <summary> /// Initializes a new instance of the <see cref="MSALPerUserMemoryTokenCache"/> class. /// </summary> /// <param name="tokenCache">The client's instance of the token cache.</param> public MSALPerUserMemoryTokenCache(ITokenCache tokenCache) { this.Initialize(tokenCache, ClaimsPrincipal.Current); }
/// <summary>Initializes this instance of TokenCacheProvider with essentials to initialize themselves.</summary> /// <param name="tokenCache">The token cache instance of MSAL application</param> public async Task InitializeAsync(ITokenCache tokenCache) { await InitializeAsync(tokenCache, true).ConfigureAwait(false); }
public void EnableSerialization(ITokenCache tokenCache) { tokenCache.SetBeforeAccess(BeforeAccessNotification); tokenCache.SetAfterAccess(AfterAccessNotification); }
/// <summary> /// Constructor with Parameter cacheFilePath /// </summary> /// <param name="cacheFilePath"></param> /// <param name="tokenCache"></param> public CdsServiceClientTokenCache(ITokenCache tokenCache, string cacheFilePath) { logEntry = new CdsTraceLogger(); //If cacheFilePath is provided if (!string.IsNullOrEmpty(cacheFilePath)) { _cacheFilePath = cacheFilePath; // Register MSAL event handlers. tokenCache.SetBeforeAccess(BeforeAccessNotification); tokenCache.SetAfterAccess(AfterAccessNotification); // Need to revist this for adding support for other cache providers: // https://docs.microsoft.com/en-us/azure/active-directory/develop/msal-net-token-cache-serialization // // Try to encrypt some data to test if Protect is available. // try // { //#pragma warning disable CS0618 // Type or member is obsolete // ProtectedData.Protect(this.Serialize(), null, DataProtectionScope.CurrentUser); //#pragma warning restore CS0618 // Type or member is obsolete // } // catch (Exception ex) // { // _UseLocalFileEncryption = false; // logEntry.Log("Encryption System not available in this environment", TraceEventType.Warning, ex); // } // Create token cache file if one does not already exist. if (!File.Exists(_cacheFilePath)) { string directoryName = Path.GetDirectoryName(_cacheFilePath); if (!Directory.Exists(directoryName)) { Directory.CreateDirectory(directoryName); } //File.Create(string) returns an instance of the FileStream class. You need to use Close() method //in order to close it and release resources which are using try { File.Create(_cacheFilePath).Close(); // Encrypt the file try { // user is using a specified file directory... encrypt file to user using Machine / FS Locking. // this will lock / prevent users other then the current user from accessing this file. FileInfo fi = new FileInfo(_cacheFilePath); if (_UseLocalFileEncryption) { fi.Encrypt(); } } catch (IOException) { // This can happen when a certificate system on the host has failed. // usually this can be fixed with the steps in this article : http://support.microsoft.com/kb/937536 //logEntry.Log(string.Format("{0}\r\nException Details : {1}", "Failed to Encrypt Configuration File!", encrEX), TraceEventType.Error); //logEntry.Log("This problem may be related to a domain certificate in windows being out of sync with the domain, please read http://support.microsoft.com/kb/937536"); } catch (Exception) { //logEntry.Log(string.Format("Failed to Encrypt Configuration File!", genEX), TraceEventType.Error); } } catch (Exception exception) { logEntry.Log(string.Format("{0}\r\nException Details : {1}", "Error occurred in CdsServiceClientTokenCache.CdsServiceClientTokenCache(). ", exception), TraceEventType.Error); } } //// Register ADAL event handlers. //this.AfterAccess = AfterAccessNotification; //this.BeforeAccess = BeforeAccessNotification; // lock (_fileLocker) // { // try // { // // Read token from the persistent store and supply it to ADAL's in memory cache. // if (_UseLocalFileEncryption) //#pragma warning disable CS0618 // Type or member is obsolete // this.Deserialize(File.Exists(_cacheFilePath) && File.ReadAllBytes(_cacheFilePath).Length != 0 // ? ProtectedData.Unprotect(File.ReadAllBytes(_cacheFilePath), null, DataProtectionScope.CurrentUser) // : null); //#pragma warning restore CS0618 // Type or member is obsolete // else //#pragma warning disable CS0618 // Type or member is obsolete // this.Deserialize(File.Exists(_cacheFilePath) && File.ReadAllBytes(_cacheFilePath).Length != 0 // ? File.ReadAllBytes(_cacheFilePath) : null); //#pragma warning restore CS0618 // Type or member is obsolete // } // catch (Exception ex) // { // // Failed to access Local token cache file.. // // Delete it. // logEntry.Log("Failed to access token cache file, resetting the token cache file", TraceEventType.Warning, ex); // Clear(_cacheFilePath); // } // } } }
public MSALAppTokenMemoryCache(ITokenCache appTokenCache) { appTokenCache.SetBeforeAccess(AppTokenCacheBeforeAccessNotification); appTokenCache.SetAfterAccess(AppTokenCacheAfterAccessNotification); }
public static IObservable <TokenCacheNotificationArgs> SynchStorage(this ITokenCache tokenCache, string cacheFilePath) => tokenCache.ReadStorage(cacheFilePath).Merge(tokenCache.WriteStorage(cacheFilePath));